Remove Unknown state in favor of Value(Top)

compiler/rustc_mir_dataflow/src/value_analysis.rs

@@ -183,15 +183,15 @@ fn super_rvalue(
                 .map()
                 .find(place.as_ref())
                 .map(ValueOrPlaceOrRef::Ref)
-                .unwrap_or(ValueOrPlaceOrRef::Unknown),
+                .unwrap_or(ValueOrPlaceOrRef::top()),
             Rvalue::Ref(_, _, place) | Rvalue::AddressOf(_, place) => {
                 state.flood(place.as_ref(), self.map());
-                ValueOrPlaceOrRef::Unknown
+                ValueOrPlaceOrRef::top()
             }
             Rvalue::CopyForDeref(place) => {
                 self.handle_operand(&Operand::Copy(*place), state).into()
             }
-            _ => ValueOrPlaceOrRef::Unknown,
+            _ => ValueOrPlaceOrRef::top(),
         }
     }
 
@@ -218,7 +218,7 @@ fn super_operand(
                 self.map()
                     .find(place.as_ref())
                     .map(ValueOrPlace::Place)
-                    .unwrap_or(ValueOrPlace::Unknown)
+                    .unwrap_or(ValueOrPlace::top())
             }
         }
     }
@@ -511,9 +511,6 @@ pub fn assign_idx(&mut self, target: PlaceIndex, result: ValueOrPlaceOrRef<V>, m
                     self.assign_place_idx(target_deref, source, map);
                 }
             }
-            ValueOrPlaceOrRef::Unknown => {
-                self.flood_idx(target, map);
-            }
         }
     }
 
@@ -756,27 +753,35 @@ fn next(&mut self) -> Option<Self::Item> {
         }
     }
 }
-
-// FIXME: See if we can get rid of `Unknown`.
 pub enum ValueOrPlace<V> {
     Value(V),
     Place(PlaceIndex),
-    Unknown,
+}
+
+impl<V: HasTop> ValueOrPlace<V> {
+    pub fn top() -> Self {
+        ValueOrPlace::Value(V::top())
+    }
 }
 
 pub enum ValueOrPlaceOrRef<V> {
     Value(V),
     Place(PlaceIndex),
-    Ref(PlaceIndex),
-    Unknown,
+    Ref(PlaceIndex)
 }
 
+impl<V: HasTop> ValueOrPlaceOrRef<V> {
+    pub fn top() -> Self {
+        ValueOrPlaceOrRef::Value(V::top())
+    }
+}
+
+
 impl<V> From<ValueOrPlace<V>> for ValueOrPlaceOrRef<V> {
     fn from(x: ValueOrPlace<V>) -> Self {
         match x {
             ValueOrPlace::Value(value) => ValueOrPlaceOrRef::Value(value),
             ValueOrPlace::Place(place) => ValueOrPlaceOrRef::Place(place),
-            ValueOrPlace::Unknown => ValueOrPlaceOrRef::Unknown,
         }
     }
 }

compiler/rustc_mir_transform/src/dataflow_const_prop.rs

@@ -105,8 +105,8 @@ fn handle_rvalue(
                         .ecx
                         .misc_cast(&operand, *ty)
                         .map(|result| ValueOrPlaceOrRef::Value(self.wrap_immediate(result, *ty)))
-                        .unwrap_or(ValueOrPlaceOrRef::Unknown),
-                    _ => ValueOrPlaceOrRef::Unknown,
+                        .unwrap_or(ValueOrPlaceOrRef::top()),
+                    _ => ValueOrPlaceOrRef::top(),
                 }
             }
             Rvalue::BinaryOp(op, box (left, right)) => {
@@ -156,7 +156,6 @@ fn handle_switch_int(
                     let value = match self.handle_operand(discr, state) {
                         ValueOrPlace::Value(value) => value,
                         ValueOrPlace::Place(place) => state.get_idx(place, self.map()),
-                        ValueOrPlace::Unknown => FlatSet::Top,
                     };
                     let result = match value {
                         FlatSet::Top => FlatSet::Top,
@@ -241,7 +240,6 @@ fn eval_operand(
         let value = match self.handle_operand(op, state) {
             ValueOrPlace::Value(value) => value,
             ValueOrPlace::Place(place) => state.get_idx(place, &self.map),
-            ValueOrPlace::Unknown => FlatSet::Top,
         };
         match value {
             FlatSet::Top => FlatSet::Top,
@@ -384,9 +382,7 @@ fn visit_operand(&mut self, operand: &Operand<'tcx>, location: Location) {
                     FlatSet::Elem(value) => {
                         self.visitor.before_effect.insert((location, *place), value);
                     }
-                    FlatSet::Bottom => {
-                        // This only happens if this location is unreachable.
-                    }
+                    FlatSet::Bottom => (),
                 }
             }
             _ => (),