Duplicate liveness code for generator liveness analysis

Author: eholk

compiler/rustc_passes/src/liveness.rs

@@ -106,7 +106,7 @@ use std::io::prelude::*;
 use std::iter;
 use std::rc::Rc;
 
-mod rwu_table;
+pub mod rwu_table;
 
 rustc_index::newtype_index! {
     pub struct Variable {
@@ -121,7 +121,7 @@ rustc_index::newtype_index! {
 }
 
 #[derive(Copy, Clone, PartialEq, Debug)]
-enum LiveNodeKind {
+pub enum LiveNodeKind {
     UpvarNode(Span),
     ExprNode(Span, HirId),
     VarDefNode(Span, HirId),
@@ -170,9 +170,9 @@ pub fn provide(providers: &mut Providers) {
 // variable must not be assigned if there is some successor
 // assignment.  And so forth.
 
-struct CaptureInfo {
-    ln: LiveNode,
-    var_hid: HirId,
+pub struct CaptureInfo {
+    pub ln: LiveNode,
+    pub var_hid: HirId,
 }
 
 #[derive(Copy, Clone, Debug)]
@@ -194,16 +194,16 @@ pub enum VarKind {
 }
 
 pub struct IrMaps<'tcx> {
-    tcx: TyCtxt<'tcx>,
-    live_node_map: HirIdMap<LiveNode>,
-    variable_map: HirIdMap<Variable>,
-    capture_info_map: HirIdMap<Rc<Vec<CaptureInfo>>>,
-    var_kinds: IndexVec<Variable, VarKind>,
-    lnks: IndexVec<LiveNode, LiveNodeKind>,
+    pub tcx: TyCtxt<'tcx>,
+    pub live_node_map: HirIdMap<LiveNode>,
+    pub variable_map: HirIdMap<Variable>,
+    pub capture_info_map: HirIdMap<Rc<Vec<CaptureInfo>>>,
+    pub var_kinds: IndexVec<Variable, VarKind>,
+    pub lnks: IndexVec<LiveNode, LiveNodeKind>,
 }
 
 impl IrMaps<'tcx> {
-    fn new(tcx: TyCtxt<'tcx>) -> IrMaps<'tcx> {
+    pub fn new(tcx: TyCtxt<'tcx>) -> IrMaps<'tcx> {
         IrMaps {
             tcx,
             live_node_map: HirIdMap::default(),
@@ -214,7 +214,7 @@ impl IrMaps<'tcx> {
         }
     }
 
-    fn add_live_node(&mut self, lnk: LiveNodeKind) -> LiveNode {
+    pub fn add_live_node(&mut self, lnk: LiveNodeKind) -> LiveNode {
         let ln = self.lnks.push(lnk);
 
         debug!("{:?} is of kind {}", ln, live_node_kind_to_string(lnk, self.tcx));
@@ -246,7 +246,7 @@ impl IrMaps<'tcx> {
         v
     }
 
-    fn variable(&self, hir_id: HirId, span: Span) -> Variable {
+    pub fn variable(&self, hir_id: HirId, span: Span) -> Variable {
         match self.variable_map.get(&hir_id) {
             Some(&var) => var,
             None => {
@@ -255,13 +255,19 @@ impl IrMaps<'tcx> {
         }
     }
 
-    fn variable_name(&self, var: Variable) -> Symbol {
+    pub fn variable_name(&self, var: Variable) -> Symbol {
         match self.var_kinds[var] {
             Local(LocalInfo { name, .. }) | Param(_, name) | Upvar(_, name) => name,
             Temporary(..) => Symbol::intern("[temporary]"),
         }
     }
 
+    pub fn variable_hir_id(&self, var: Variable) -> HirId {
+        match self.var_kinds[var] {
+            Local(LocalInfo { id, .. }) | Param(id, ..) | Upvar(id, ..) | Temporary(id) => id,
+        }
+    }
+
     fn variable_is_shorthand(&self, var: Variable) -> bool {
         match self.var_kinds[var] {
             Local(LocalInfo { is_shorthand, .. }) => is_shorthand,

compiler/rustc_passes/src/liveness/rwu_table.rs

@@ -2,15 +2,15 @@ use crate::liveness::{LiveNode, Variable};
 use std::iter;
 
 #[derive(Clone, Copy)]
-pub(super) struct RWU {
-    pub(super) reader: bool,
-    pub(super) writer: bool,
-    pub(super) used: bool,
+pub struct RWU {
+    pub reader: bool,
+    pub writer: bool,
+    pub used: bool,
 }
 
 /// Conceptually, this is like a `Vec<Vec<RWU>>`. But the number of
 /// RWU`s can get very large, so it uses a more compact representation.
-pub(super) struct RWUTable {
+pub struct RWUTable {
     /// Total number of live nodes.
     live_nodes: usize,
     /// Total number of variables.
@@ -42,7 +42,7 @@ impl RWUTable {
     /// Number of packed RWUs that fit into a single word.
     const WORD_RWU_COUNT: usize = Self::WORD_BITS / Self::RWU_BITS;
 
-    pub(super) fn new(live_nodes: usize, vars: usize) -> RWUTable {
+    pub fn new(live_nodes: usize, vars: usize) -> RWUTable {
         let live_node_words = (vars + Self::WORD_RWU_COUNT - 1) / Self::WORD_RWU_COUNT;
         Self { live_nodes, vars, live_node_words, words: vec![0u8; live_node_words * live_nodes] }
     }
@@ -74,7 +74,7 @@ impl RWUTable {
         }
     }
 
-    pub(super) fn copy(&mut self, dst: LiveNode, src: LiveNode) {
+    pub fn copy(&mut self, dst: LiveNode, src: LiveNode) {
         if dst == src {
             return;
         }
@@ -85,7 +85,7 @@ impl RWUTable {
 
     /// Sets `dst` to the union of `dst` and `src`, returns true if `dst` was
     /// changed.
-    pub(super) fn union(&mut self, dst: LiveNode, src: LiveNode) -> bool {
+    pub fn union(&mut self, dst: LiveNode, src: LiveNode) -> bool {
         if dst == src {
             return false;
         }
@@ -101,22 +101,22 @@ impl RWUTable {
         changed
     }
 
-    pub(super) fn get_reader(&self, ln: LiveNode, var: Variable) -> bool {
+    pub fn get_reader(&self, ln: LiveNode, var: Variable) -> bool {
         let (word, shift) = self.word_and_shift(ln, var);
         (self.words[word] >> shift) & Self::RWU_READER != 0
     }
 
-    pub(super) fn get_writer(&self, ln: LiveNode, var: Variable) -> bool {
+    pub fn get_writer(&self, ln: LiveNode, var: Variable) -> bool {
         let (word, shift) = self.word_and_shift(ln, var);
         (self.words[word] >> shift) & Self::RWU_WRITER != 0
     }
 
-    pub(super) fn get_used(&self, ln: LiveNode, var: Variable) -> bool {
+    pub fn get_used(&self, ln: LiveNode, var: Variable) -> bool {
         let (word, shift) = self.word_and_shift(ln, var);
         (self.words[word] >> shift) & Self::RWU_USED != 0
     }
 
-    pub(super) fn get(&self, ln: LiveNode, var: Variable) -> RWU {
+    pub fn get(&self, ln: LiveNode, var: Variable) -> RWU {
         let (word, shift) = self.word_and_shift(ln, var);
         let rwu_packed = self.words[word] >> shift;
         RWU {
@@ -126,7 +126,7 @@ impl RWUTable {
         }
     }
 
-    pub(super) fn set(&mut self, ln: LiveNode, var: Variable, rwu: RWU) {
+    pub fn set(&mut self, ln: LiveNode, var: Variable, rwu: RWU) {
         let mut packed = 0;
         if rwu.reader {
             packed |= Self::RWU_READER;