Regenerate tests

Author: oli-obk

src/Cargo.lock

@@ -61,10 +61,10 @@ for ty::subst::Kind<'gcx> {
     }
 }
 
-impl<'gcx> HashStable<StableHashingContext<'gcx>>
+impl<'a, 'gcx> HashStable<StableHashingContext<'a>>
 for ty::subst::UnpackedKind<'gcx> {
     fn hash_stable<W: StableHasherResult>(&self,
-                                          hcx: &mut StableHashingContext<'gcx>,
+                                          hcx: &mut StableHashingContext<'a>,
                                           hasher: &mut StableHasher<W>) {
         match self {
             ty::subst::UnpackedKind::Lifetime(lt) => lt.hash_stable(hcx, hasher),

src/librustc/ich/impls_ty.rs

@@ -362,6 +362,7 @@ impl<'sess> OnDiskCache<'sess> {
             cnum_map: cnum_map.as_ref().unwrap(),
             file_index_to_file: &self.file_index_to_file,
             file_index_to_stable_id: &self.file_index_to_stable_id,
+            synthetic_expansion_infos: &self.synthetic_expansion_infos,
             interpret_alloc_cache: FxHashMap::default(),
         };
 

src/librustc/ty/maps/on_disk_cache.rs

@@ -36,7 +36,7 @@ use rustc_typeck as typeck;
 use rustc_privacy;
 use rustc_plugin::registry::Registry;
 use rustc_plugin as plugin;
-use rustc_passes::{self, ast_validation, loops, consts, hir_stats};
+use rustc_passes::{self, ast_validation, loops, rvalue_promotion, hir_stats};
 use super::Compilation;
 
 use serialize::json;

src/librustc_driver/driver.rs

@@ -373,13 +373,17 @@ impl<'a, 'tcx> PatternContext<'a, 'tcx> {
                      PatternKind::Constant { value: hi }) => {
                         use std::cmp::Ordering;
                         match (end, compare_const_vals(&lo.val, &hi.val, ty).unwrap()) {
-                            (RangeEnd::Excluded, Ordering::Less) => {},
-                            (RangeEnd::Excluded, _) => span_err!(
-                                self.tcx.sess,
-                                lo_expr.span,
-                                E0579,
-                                "lower range bound must be less than upper",
-                            ),
+                            (RangeEnd::Excluded, Ordering::Less) =>
+                                PatternKind::Range { lo, hi, end },
+                            (RangeEnd::Excluded, _) => {
+                                span_err!(
+                                    self.tcx.sess,
+                                    lo_expr.span,
+                                    E0579,
+                                    "lower range bound must be less than upper",
+                                );
+                                PatternKind::Wild
+                            },
                             (RangeEnd::Included, Ordering::Greater) => {
                                 let mut err = struct_span_err!(
                                     self.tcx.sess,
@@ -399,10 +403,10 @@ impl<'a, 'tcx> PatternContext<'a, 'tcx> {
                                               to be less than or equal to the end of the range.");
                                 }
                                 err.emit();
+                                PatternKind::Wild
                             },
-                            (RangeEnd::Included, _) => {}
+                            (RangeEnd::Included, _) => PatternKind::Range { lo, hi, end },
                         }
-                        PatternKind::Range { lo, hi, end }
                     }
                     _ => PatternKind::Wild
                 }

src/librustc_mir/hair/pattern/mod.rs

@@ -1090,8 +1090,7 @@ fn collect_miri<'a, 'tcx>(
         let instance = Instance::mono(tcx, did);
         if should_monomorphize_locally(tcx, &instance) {
             trace!("collecting static {:?}", did);
-            let node_id = tcx.hir.as_local_node_id(did).unwrap();
-            output.push(MonoItem::Static(node_id));
+            output.push(MonoItem::Static(did));
         }
     } else if let Some(alloc) = tcx.interpret_interner.get_alloc(alloc_id) {
         trace!("collecting {:?} with {:#?}", alloc_id, alloc);

src/librustc_mir/monomorphize/collector.rs

@@ -203,7 +203,7 @@ impl MirPass for RestoreSubsliceArrayMoveOut {
                         let opt_size = opt_src_place.and_then(|src_place| {
                             let src_ty = src_place.ty(mir, tcx).to_ty(tcx);
                             if let ty::TyArray(_, ref size_o) = src_ty.sty {
-                                size_o.val.to_const_int().and_then(|v| v.to_u64())
+                                size_o.val.to_raw_bits().map(|n| n as u64)
                             } else {
                                 None
                             }

src/librustc_mir/transform/uniform_array_move_out.rs

@@ -32,7 +32,7 @@ use rustc::middle::expr_use_visitor as euv;
 use rustc::middle::mem_categorization as mc;
 use rustc::middle::mem_categorization::Categorization;
 use rustc::ty::{self, Ty, TyCtxt};
-use rustc::ty::maps::{queries, Providers};
+use rustc::ty::maps::Providers;
 use rustc::ty::subst::Substs;
 use rustc::traits::Reveal;
 use rustc::util::nodemap::{ItemLocalSet, NodeSet};
@@ -325,16 +325,7 @@ fn check_expr<'a, 'tcx>(v: &mut CheckCrateVisitor<'a, 'tcx>, e: &hir::Expr, node
                         // Don't peek inside trait associated constants.
                         false
                     } else {
-                        queries::const_is_rvalue_promotable_to_static::try_get(v.tcx, e.span, did)
-                            .unwrap_or_else(|mut err| {
-                                // A cycle between constants ought to be reported elsewhere.
-                                err.cancel();
-                                v.tcx.sess.delay_span_bug(
-                                    e.span,
-                                    &format!("cycle encountered during const qualification: {:?}",
-                                             did));
-                                false
-                            })
+                        v.tcx.at(e.span).const_is_rvalue_promotable_to_static(did)
                     };
 
                     // Just in case the type is more specific than the definition,

src/librustc_passes/rvalue_promotion.rs

@@ -5,7 +5,7 @@ LL | const NEG_NEG_128: i8 = -NEG_128;
    |                         ^^^^^^^^ attempt to negate with overflow
    |
 note: for pattern here
-  --> $DIR/const-eval-overflow-2.rs:27:9
+  --> $DIR/const-eval-overflow-2.rs:26:9
    |
 LL |         NEG_NEG_128 => println!("A"),
    |         ^^^^^^^^^^^

src/test/ui/const-eval-overflow-2.stderr

@@ -1,11 +1,3 @@
-warning: constant evaluation error: attempt to add with overflow
-  --> $DIR/const-eval-overflow-4.rs:23:13
-   |
-LL |     : [u32; (i8::MAX as i8 + 1i8) as usize]
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = note: #[warn(const_err)] on by default
-
 error[E0080]: constant evaluation error
   --> $DIR/const-eval-overflow-4.rs:23:13
    |