Introduce new dataflow implementation for available locals, use in existing pass

compiler/rustc_middle/src/mir/mod.rs

@@ -1485,6 +1485,13 @@ pub enum StatementKind<'tcx> {
 }
 
 impl<'tcx> StatementKind<'tcx> {
+    pub fn as_assign(&self) -> Option<&(Place<'tcx>, Rvalue<'tcx>)> {
+        match self {
+            StatementKind::Assign(x) => Some(x),
+            _ => None,
+        }
+    }
+
     pub fn as_assign_mut(&mut self) -> Option<&mut Box<(Place<'tcx>, Rvalue<'tcx>)>> {
         match self {
             StatementKind::Assign(x) => Some(x),
@@ -1736,6 +1743,7 @@ impl<'tcx> Place<'tcx> {
         self.as_ref().as_local()
     }
 
+    #[inline]
     pub fn as_ref(&self) -> PlaceRef<'tcx> {
         PlaceRef { local: self.local, projection: &self.projection }
     }
@@ -2395,7 +2403,7 @@ impl<'tcx> UserTypeProjections {
 
 /// Encodes the effect of a user-supplied type annotation on the
 /// subcomponents of a pattern. The effect is determined by applying the
-/// given list of proejctions to some underlying base type. Often,
+/// given list of projections to some underlying base type. Often,
 /// the projection element list `projs` is empty, in which case this
 /// directly encodes a type in `base`. But in the case of complex patterns with
 /// subpatterns and bindings, we want to apply only a *part* of the type to a variable,

compiler/rustc_mir/src/dataflow/framework/mod.rs

@@ -412,6 +412,9 @@ pub trait GenKill<T> {
             self.kill(elem);
         }
     }
+
+    /// Returns whether `elem` is alive
+    fn is_alive(&self, elem: T) -> bool;
 }
 
 /// Stores a transfer function for a gen/kill problem.
@@ -450,6 +453,10 @@ impl<T: Idx> GenKill<T> for GenKillSet<T> {
         self.kill.insert(elem);
         self.gen.remove(elem);
     }
+
+    fn is_alive(&self, elem: T) -> bool {
+        self.gen.contains(elem) && !self.kill.contains(elem)
+    }
 }
 
 impl<T: Idx> GenKill<T> for BitSet<T> {
@@ -460,6 +467,10 @@ impl<T: Idx> GenKill<T> for BitSet<T> {
     fn kill(&mut self, elem: T) {
         self.remove(elem);
     }
+
+    fn is_alive(&self, elem: T) -> bool {
+        self.contains(elem)
+    }
 }
 
 impl<T: Idx> GenKill<T> for lattice::Dual<BitSet<T>> {
@@ -470,6 +481,10 @@ impl<T: Idx> GenKill<T> for lattice::Dual<BitSet<T>> {
     fn kill(&mut self, elem: T) {
         self.0.remove(elem);
     }
+
+    fn is_alive(&self, elem: T) -> bool {
+        self.0.contains(elem)
+    }
 }
 
 // NOTE: DO NOT CHANGE VARIANT ORDER. The derived `Ord` impls rely on the current order.