Auto merge of #28748 - nikomatsakis:universal-mir, r=pnkfelix

I had to fix a few things. Notable changes:

1. I removed the MIR support for constants, instead falling back to the existing `ConstVal`. I still think we ought to reform how we handle constants, but it's not clear to me that the approach I was taking is correct, and anyway I think we ought to do it separately.
2. I adjusted how we handle bindings in matches: we now *declare* all the bindings up front, rather than doing it as we encounter them. This is not only simpler, since we don't have to check if a binding has already been declared, it avoids ICEs if any of the arms turn out to be unreachable.
3. I do MIR construction *after* `check_match`, because it detects various broken cases. I'd like for `check_match` to be subsumed by MIR construction, but we can do that as a separate PR (if indeed it makes sense).

I did a crater run and found no regressions in the wild: https://gist.github.com/nikomatsakis/0038f90e10c8ad00f2f8

Author: bors

src/librustc/middle/const_eval.rs

@@ -38,6 +38,7 @@ use std::borrow::{Cow, IntoCow};
 use std::num::wrapping::OverflowingOps;
 use std::cmp::Ordering;
 use std::collections::hash_map::Entry::Vacant;
+use std::mem::transmute;
 use std::{i8, i16, i32, i64, u8, u16, u32, u64};
 use std::rc::Rc;
 
@@ -242,7 +243,7 @@ pub fn lookup_const_fn_by_id<'tcx>(tcx: &ty::ctxt<'tcx>, def_id: DefId)
     }
 }
 
-#[derive(Clone, PartialEq)]
+#[derive(Clone, Debug)]
 pub enum ConstVal {
     Float(f64),
     Int(i64),
@@ -254,6 +255,27 @@ pub enum ConstVal {
     Tuple(ast::NodeId),
 }
 
+/// Note that equality for `ConstVal` means that the it is the same
+/// constant, not that the rust values are equal. In particular, `NaN
+/// == NaN` (at least if it's the same NaN; distinct encodings for NaN
+/// are considering unequal).
+impl PartialEq for ConstVal {
+    #[stable(feature = "rust1", since = "1.0.0")]
+    fn eq(&self, other: &ConstVal) -> bool {
+        match (self, other) {
+            (&Float(a), &Float(b)) => unsafe{transmute::<_,u64>(a) == transmute::<_,u64>(b)},
+            (&Int(a), &Int(b)) => a == b,
+            (&Uint(a), &Uint(b)) => a == b,
+            (&Str(ref a), &Str(ref b)) => a == b,
+            (&ByteStr(ref a), &ByteStr(ref b)) => a == b,
+            (&Bool(a), &Bool(b)) => a == b,
+            (&Struct(a), &Struct(b)) => a == b,
+            (&Tuple(a), &Tuple(b)) => a == b,
+            _ => false,
+        }
+    }
+}
+
 impl ConstVal {
     pub fn description(&self) -> &'static str {
         match *self {

src/librustc_driver/driver.rs

@@ -718,9 +718,6 @@ pub fn phase_3_run_analysis_passes<'tcx, F, R>(sess: Session,
         // passes are timed inside typeck
         typeck::check_crate(tcx, trait_map);
 
-        time(time_passes, "MIR dump", ||
-             mir::dump::dump_crate(tcx));
-
         time(time_passes, "const checking", ||
             middle::check_const::check_crate(tcx));
 
@@ -741,6 +738,9 @@ pub fn phase_3_run_analysis_passes<'tcx, F, R>(sess: Session,
         time(time_passes, "match checking", ||
             middle::check_match::check_crate(tcx));
 
+        time(time_passes, "MIR dump", ||
+             mir::dump::dump_crate(tcx));
+
         time(time_passes, "liveness checking", ||
             middle::liveness::check_crate(tcx));
 

src/librustc_mir/build/expr/as_constant.rs

@@ -10,8 +10,6 @@
 
 //! See docs in build/expr/mod.rs
 
-use rustc_data_structures::fnv::FnvHashMap;
-
 use build::{Builder};
 use hair::*;
 use repr::*;
@@ -28,93 +26,16 @@ impl<H:Hair> Builder<H> {
 
     fn expr_as_constant(&mut self, expr: Expr<H>) -> Constant<H> {
         let this = self;
-        let Expr { ty: _, temp_lifetime: _, span, kind } = expr;
-        let kind = match kind {
-            ExprKind::Scope { extent: _, value } => {
-                return this.as_constant(value);
-            }
-            ExprKind::Literal { literal } => {
-                ConstantKind::Literal(literal)
-            }
-            ExprKind::Vec { fields } => {
-                let fields = this.as_constants(fields);
-                ConstantKind::Aggregate(AggregateKind::Vec, fields)
-            }
-            ExprKind::Tuple { fields } => {
-                let fields = this.as_constants(fields);
-                ConstantKind::Aggregate(AggregateKind::Tuple, fields)
-            }
-            ExprKind::Adt { adt_def, variant_index, substs, fields, base: None } => {
-                let field_names = this.hir.fields(adt_def, variant_index);
-                let fields = this.named_field_constants(field_names, fields);
-                ConstantKind::Aggregate(AggregateKind::Adt(adt_def, variant_index, substs), fields)
-            }
-            ExprKind::Repeat { value, count } => {
-                let value = Box::new(this.as_constant(value));
-                let count = Box::new(this.as_constant(count));
-                ConstantKind::Repeat(value, count)
-            }
-            ExprKind::Binary { op, lhs, rhs } => {
-                let lhs = Box::new(this.as_constant(lhs));
-                let rhs = Box::new(this.as_constant(rhs));
-                ConstantKind::BinaryOp(op, lhs, rhs)
-            }
-            ExprKind::Unary { op, arg } => {
-                let arg = Box::new(this.as_constant(arg));
-                ConstantKind::UnaryOp(op, arg)
-            }
-            ExprKind::Field { lhs, name } => {
-                let lhs = this.as_constant(lhs);
-                ConstantKind::Projection(
-                    Box::new(ConstantProjection {
-                        base: lhs,
-                        elem: ProjectionElem::Field(name),
-                    }))
-            }
-            ExprKind::Deref { arg } => {
-                let arg = this.as_constant(arg);
-                ConstantKind::Projection(
-                    Box::new(ConstantProjection {
-                        base: arg,
-                        elem: ProjectionElem::Deref,
-                    }))
-            }
-            ExprKind::Call { fun, args } => {
-                let fun = this.as_constant(fun);
-                let args = this.as_constants(args);
-                ConstantKind::Call(Box::new(fun), args)
-            }
-            _ => {
+        let Expr { ty, temp_lifetime: _, span, kind } = expr;
+        match kind {
+            ExprKind::Scope { extent: _, value } =>
+                this.as_constant(value),
+            ExprKind::Literal { literal } =>
+                Constant { span: span, ty: ty, literal: literal },
+            _ =>
                 this.hir.span_bug(
                     span,
-                    &format!("expression is not a valid constant {:?}", kind));
-            }
-        };
-        Constant { span: span, kind: kind }
-    }
-
-    fn as_constants(&mut self,
-                    exprs: Vec<ExprRef<H>>)
-                    -> Vec<Constant<H>>
-    {
-        exprs.into_iter().map(|expr| self.as_constant(expr)).collect()
-    }
-
-    fn named_field_constants(&mut self,
-                             field_names: Vec<Field<H>>,
-                             field_exprs: Vec<FieldExprRef<H>>)
-                             -> Vec<Constant<H>>
-    {
-        let fields_map: FnvHashMap<_, _> =
-            field_exprs.into_iter()
-                       .map(|f| (f.name, self.as_constant(f.expr)))
-                       .collect();
-
-        let fields: Vec<_> =
-            field_names.into_iter()
-                       .map(|n| fields_map[&n].clone())
-                       .collect();
-
-        fields
+                    &format!("expression is not a valid constant {:?}", kind)),
+        }
     }
 }

src/librustc_mir/build/expr/into.rs

@@ -99,14 +99,16 @@ impl<H:Hair> Builder<H> {
                     true_block, expr_span, destination,
                     Constant {
                         span: expr_span,
-                        kind: ConstantKind::Literal(Literal::Bool { value: true }),
+                        ty: this.hir.bool_ty(),
+                        literal: this.hir.true_literal(),
                     });
 
                 this.cfg.push_assign_constant(
                     false_block, expr_span, destination,
                     Constant {
                         span: expr_span,
-                        kind: ConstantKind::Literal(Literal::Bool { value: false }),
+                        ty: this.hir.bool_ty(),
+                        literal: this.hir.false_literal(),
                     });
 
                 this.cfg.terminate(true_block, Terminator::Goto { target: join_block });