Auto merge of #46925 - arielb1:make-the-trains-run-on-time, r=arielb1

Bounce out the layout refactor from beta

@eddyb's #45225 was supposed to get into get into 1.24, but due to an ordering mistake, it had snuck into 1.23.

That wide-effect translation-changing PR had poked LLVM's weak corners and caused many regressions (3 of them have fixes I include here, but also #46897, #46845, #46449, #46371). I don't think it is a good idea to land it in the beta (1.23) because there are bound to be some regressions we didn't patch.

Therefore, I am reverting it in time for stable, along with its related regression fixes.

r? @michaelwoerister (I think)

src/liballoc/boxed.rs

@@ -151,7 +151,7 @@ impl<T> Place<T> for IntermediateBox<T> {
 unsafe fn finalize<T>(b: IntermediateBox<T>) -> Box<T> {
     let p = b.ptr as *mut T;
     mem::forget(b);
-    Box::from_raw(p)
+    mem::transmute(p)
 }
 
 fn make_place<T>() -> IntermediateBox<T> {
@@ -300,10 +300,7 @@ impl<T: ?Sized> Box<T> {
                issue = "27730")]
     #[inline]
     pub unsafe fn from_unique(u: Unique<T>) -> Self {
-        #[cfg(stage0)]
-        return mem::transmute(u);
-        #[cfg(not(stage0))]
-        return Box(u);
+        mem::transmute(u)
     }
 
     /// Consumes the `Box`, returning the wrapped raw pointer.
@@ -365,14 +362,7 @@ impl<T: ?Sized> Box<T> {
                issue = "27730")]
     #[inline]
     pub fn into_unique(b: Box<T>) -> Unique<T> {
-        #[cfg(stage0)]
-        return unsafe { mem::transmute(b) };
-        #[cfg(not(stage0))]
-        return {
-            let unique = b.0;
-            mem::forget(b);
-            unique
-        };
+        unsafe { mem::transmute(b) }
     }
 }
 
@@ -637,7 +627,7 @@ impl Box<Any + Send> {
     pub fn downcast<T: Any>(self) -> Result<Box<T>, Box<Any + Send>> {
         <Box<Any>>::downcast(self).map_err(|s| unsafe {
             // reapply the Send marker
-            Box::from_raw(Box::into_raw(s) as *mut (Any + Send))
+            mem::transmute::<Box<Any>, Box<Any + Send>>(s)
         })
     }
 }

src/librustc/lib.rs

@@ -46,13 +46,11 @@
 #![feature(const_fn)]
 #![feature(core_intrinsics)]
 #![feature(drain_filter)]
-#![feature(i128)]
 #![feature(i128_type)]
-#![feature(inclusive_range)]
+#![feature(match_default_bindings)]
 #![feature(inclusive_range_syntax)]
 #![cfg_attr(windows, feature(libc))]
 #![feature(macro_vis_matcher)]
-#![feature(match_default_bindings)]
 #![feature(never_type)]
 #![feature(nonzero)]
 #![feature(quote)]

src/librustc/lint/context.rs

@@ -34,8 +34,7 @@ use middle::privacy::AccessLevels;
 use rustc_serialize::{Decoder, Decodable, Encoder, Encodable};
 use session::{config, early_error, Session};
 use traits::Reveal;
-use ty::{self, TyCtxt, Ty};
-use ty::layout::{LayoutError, LayoutOf, TyLayout};
+use ty::{self, TyCtxt};
 use util::nodemap::FxHashMap;
 
 use std::default::Default as StdDefault;
@@ -627,14 +626,6 @@ impl<'a, 'tcx> LateContext<'a, 'tcx> {
     }
 }
 
-impl<'a, 'tcx> LayoutOf<Ty<'tcx>> for &'a LateContext<'a, 'tcx> {
-    type TyLayout = Result<TyLayout<'tcx>, LayoutError<'tcx>>;
-
-    fn layout_of(self, ty: Ty<'tcx>) -> Self::TyLayout {
-        (self.tcx, self.param_env.reveal_all()).layout_of(ty)
-    }
-}
-
 impl<'a, 'tcx> hir_visit::Visitor<'tcx> for LateContext<'a, 'tcx> {
     /// Because lints are scoped lexically, we want to walk nested
     /// items in the context of the outer item, so enable

src/librustc/middle/mem_categorization.rs

@@ -210,7 +210,7 @@ impl<'tcx> cmt_<'tcx> {
                 adt_def.variant_with_id(variant_did)
             }
             _ => {
-                assert_eq!(adt_def.variants.len(), 1);
+                assert!(adt_def.is_univariant());
                 &adt_def.variants[0]
             }
         };
@@ -1096,7 +1096,7 @@ impl<'a, 'gcx, 'tcx> MemCategorizationContext<'a, 'gcx, 'tcx> {
                                               -> cmt<'tcx> {
         // univariant enums do not need downcasts
         let base_did = self.tcx.parent_def_id(variant_did).unwrap();
-        if self.tcx.adt_def(base_did).variants.len() != 1 {
+        if !self.tcx.adt_def(base_did).is_univariant() {
             let base_ty = base_cmt.ty;
             let ret = Rc::new(cmt_ {
                 id: node.id(),

src/librustc/ty/context.rs

@@ -41,7 +41,7 @@ use ty::{PolyFnSig, InferTy, ParamTy, ProjectionTy, ExistentialPredicate, Predic
 use ty::RegionKind;
 use ty::{TyVar, TyVid, IntVar, IntVid, FloatVar, FloatVid};
 use ty::TypeVariants::*;
-use ty::layout::{LayoutDetails, TargetDataLayout};
+use ty::layout::{Layout, TargetDataLayout};
 use ty::maps;
 use ty::steal::Steal;
 use ty::BindingMode;
@@ -78,7 +78,7 @@ use hir;
 /// Internal storage
 pub struct GlobalArenas<'tcx> {
     // internings
-    layout: TypedArena<LayoutDetails>,
+    layout: TypedArena<Layout>,
 
     // references
     generics: TypedArena<ty::Generics>,
@@ -918,7 +918,7 @@ pub struct GlobalCtxt<'tcx> {
 
     stability_interner: RefCell<FxHashSet<&'tcx attr::Stability>>,
 
-    layout_interner: RefCell<FxHashSet<&'tcx LayoutDetails>>,
+    layout_interner: RefCell<FxHashSet<&'tcx Layout>>,
 
     /// A vector of every trait accessible in the whole crate
     /// (i.e. including those from subcrates). This is used only for
@@ -1016,7 +1016,7 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> {
         interned
     }
 
-    pub fn intern_layout(self, layout: LayoutDetails) -> &'gcx LayoutDetails {
+    pub fn intern_layout(self, layout: Layout) -> &'gcx Layout {
         if let Some(layout) = self.layout_interner.borrow().get(&layout) {
             return layout;
         }