rustc: remove Ty::layout and move everything to layout_of.

eddyb · eddyb · commit 8c4d5af52b7f · 2017-11-19T02:14:29.000+02:00
diff --git a/src/librustc/lint/context.rs b/src/librustc/lint/context.rs
@@ -34,7 +34,8 @@ use middle::privacy::AccessLevels;
 use rustc_serialize::{Decoder, Decodable, Encoder, Encodable};
 use session::{config, early_error, Session};
 use traits::Reveal;
-use ty::{self, TyCtxt};
+use ty::{self, TyCtxt, Ty};
+use ty::layout::{FullLayout, LayoutError, LayoutOf};
 use util::nodemap::FxHashMap;
 
 use std::default::Default as StdDefault;
@@ -626,6 +627,14 @@ impl<'a, 'tcx> LateContext<'a, 'tcx> {
     }
 }
 
+impl<'a, 'tcx> LayoutOf<Ty<'tcx>> for &'a LateContext<'a, 'tcx> {
+    type FullLayout = Result<FullLayout<'tcx>, LayoutError<'tcx>>;
+
+    fn layout_of(self, ty: Ty<'tcx>) -> Self::FullLayout {
+        (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
diff --git a/src/librustc/ty/layout.rs b/src/librustc/ty/layout.rs
diff --git a/src/librustc/ty/mod.rs b/src/librustc/ty/mod.rs
@@ -2617,9 +2617,10 @@ fn original_crate_name<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
 }
 
 pub fn provide(providers: &mut ty::maps::Providers) {
-    util::provide(providers);
     context::provide(providers);
     erase_regions::provide(providers);
+    layout::provide(providers);
+    util::provide(providers);
     *providers = ty::maps::Providers {
         associated_item,
         associated_item_def_ids,
diff --git a/src/librustc/ty/util.rs b/src/librustc/ty/util.rs
@@ -19,7 +19,6 @@ use middle::const_val::ConstVal;
 use traits::{self, Reveal};
 use ty::{self, Ty, TyCtxt, TypeFoldable};
 use ty::fold::TypeVisitor;
-use ty::layout::{Layout, LayoutError};
 use ty::subst::{Subst, Kind};
 use ty::TypeVariants::*;
 use util::common::ErrorReported;
@@ -852,30 +851,6 @@ impl<'a, 'tcx> ty::TyS<'tcx> {
         tcx.needs_drop_raw(param_env.and(self))
     }
 
-    /// Computes the layout of a type. Note that this implicitly
-    /// executes in "reveal all" mode.
-    #[inline]
-    pub fn layout<'lcx>(&'tcx self,
-                        tcx: TyCtxt<'a, 'tcx, 'tcx>,
-                        param_env: ty::ParamEnv<'tcx>)
-                        -> Result<&'tcx Layout, LayoutError<'tcx>> {
-        let ty = tcx.erase_regions(&self);
-        let layout = tcx.layout_raw(param_env.reveal_all().and(ty));
-
-        // NB: This recording is normally disabled; when enabled, it
-        // can however trigger recursive invocations of `layout()`.
-        // Therefore, we execute it *after* the main query has
-        // completed, to avoid problems around recursive structures
-        // and the like. (Admitedly, I wasn't able to reproduce a problem
-        // here, but it seems like the right thing to do. -nmatsakis)
-        if let Ok(l) = layout {
-            Layout::record_layout_for_printing(tcx, ty, param_env, l);
-        }
-
-        layout
-    }
-
-
     /// Check whether a type is representable. This means it cannot contain unboxed
     /// structural recursion. This check is needed for structs and enums.
     pub fn is_representable(&'tcx self,
@@ -1184,26 +1159,6 @@ fn needs_drop_raw<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
     }
 }
 
-fn layout_raw<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
-                        query: ty::ParamEnvAnd<'tcx, Ty<'tcx>>)
-                        -> Result<&'tcx Layout, LayoutError<'tcx>>
-{
-    let (param_env, ty) = query.into_parts();
-
-    let rec_limit = tcx.sess.recursion_limit.get();
-    let depth = tcx.layout_depth.get();
-    if depth > rec_limit {
-        tcx.sess.fatal(
-            &format!("overflow representing the type `{}`", ty));
-    }
-
-    tcx.layout_depth.set(depth+1);
-    let layout = Layout::compute_uncached(tcx, param_env, ty);
-    tcx.layout_depth.set(depth);
-
-    layout
-}
-
 pub enum ExplicitSelf<'tcx> {
     ByValue,
     ByReference(ty::Region<'tcx>, hir::Mutability),
@@ -1262,7 +1217,6 @@ pub fn provide(providers: &mut ty::maps::Providers) {
         is_sized_raw,
         is_freeze_raw,
         needs_drop_raw,
-        layout_raw,
         ..*providers
     };
 }
diff --git a/src/librustc_lint/types.rs b/src/librustc_lint/types.rs
@@ -13,7 +13,7 @@
 use rustc::hir::def_id::DefId;
 use rustc::ty::subst::Substs;
 use rustc::ty::{self, AdtKind, Ty, TyCtxt};
-use rustc::ty::layout::{Layout, Primitive};
+use rustc::ty::layout::{Layout, LayoutOf, Primitive};
 use middle::const_val::ConstVal;
 use rustc_const_eval::ConstContext;
 use util::nodemap::FxHashSet;
@@ -748,9 +748,8 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for VariantSizeDifferences {
                 // sizes only make sense for non-generic types
                 let item_def_id = cx.tcx.hir.local_def_id(it.id);
                 let t = cx.tcx.type_of(item_def_id);
-                let param_env = cx.param_env.reveal_all();
                 let ty = cx.tcx.erase_regions(&t);
-                let layout = ty.layout(cx.tcx, param_env).unwrap_or_else(|e| {
+                let layout = cx.layout_of(ty).unwrap_or_else(|e| {
                     bug!("failed to get layout for `{}`: {}", t, e)
                 });
 
diff --git a/src/librustc_mir/transform/inline.rs b/src/librustc_mir/transform/inline.rs
@@ -19,6 +19,7 @@ use rustc_data_structures::indexed_vec::{Idx, IndexVec};
 use rustc::mir::*;
 use rustc::mir::visit::*;
 use rustc::ty::{self, Instance, Ty, TyCtxt, TypeFoldable};
+use rustc::ty::layout::LayoutOf;
 use rustc::ty::subst::{Subst,Substs};
 
 use std::collections::VecDeque;
@@ -625,9 +626,7 @@ impl<'a, 'tcx> Inliner<'a, 'tcx> {
 fn type_size_of<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
                           param_env: ty::ParamEnv<'tcx>,
                           ty: Ty<'tcx>) -> Option<u64> {
-    ty.layout(tcx, param_env).ok().map(|layout| {
-        layout.size(&tcx.data_layout).bytes()
-    })
+    (tcx, param_env).layout_of(ty).ok().map(|layout| layout.size(tcx).bytes())
 }
 
 fn subst_and_normalize<'a, 'tcx: 'a>(
diff --git a/src/librustc_trans/abi.rs b/src/librustc_trans/abi.rs
@@ -330,7 +330,7 @@ impl<'tcx> LayoutExt<'tcx> for FullLayout<'tcx> {
                 }
             }
 
-            Layout::Univariant { ref variant, .. } => {
+            Layout::Univariant(ref variant) => {
                 let mut unaligned_offset = Size::from_bytes(0);
                 let mut result = None;
 
diff --git a/src/librustc_trans/adt.rs b/src/librustc_trans/adt.rs
@@ -74,7 +74,7 @@ pub fn finish_type_of<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>,
         layout::Univariant { ..}
         | layout::StructWrappedNullablePointer { .. } => {
             let (variant_layout, variant) = match *l {
-                layout::Univariant { ref variant, .. } => {
+                layout::Univariant(ref variant) => {
                     let is_enum = if let ty::TyAdt(def, _) = t.sty {
                         def.is_enum()
                     } else {
@@ -123,7 +123,7 @@ fn generic_type_of<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>,
                 }
             }
         }
-        layout::Univariant { ref variant, .. } => {
+        layout::Univariant(ref variant) => {
             match name {
                 None => {
                     Type::struct_(cx, &struct_llfields(cx, l, &variant),
@@ -134,16 +134,16 @@ fn generic_type_of<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>,
                 }
             }
         }
-        layout::UntaggedUnion { ref variants, .. }=> {
+        layout::UntaggedUnion(ref un) => {
             // Use alignment-sized ints to fill all the union storage.
-            let fill = union_fill(cx, variants.stride(), variants.align);
+            let fill = union_fill(cx, un.stride(), un.align);
             match name {
                 None => {
-                    Type::struct_(cx, &[fill], variants.packed)
+                    Type::struct_(cx, &[fill], un.packed)
                 }
                 Some(name) => {
                     let mut llty = Type::named_struct(cx, name);
-                    llty.set_struct_body(&[fill], variants.packed);
+                    llty.set_struct_body(&[fill], un.packed);
                     llty
                 }
             }
diff --git a/src/librustc_trans/cabi_x86_64.rs b/src/librustc_trans/cabi_x86_64.rs
@@ -101,7 +101,7 @@ fn classify_arg<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, arg: &ArgType<'tcx>)
                 }
             }
 
-            Layout::Univariant { ref variant, .. } => {
+            Layout::Univariant(ref variant) => {
                 for i in 0..layout.field_count() {
                     let field_off = off + variant.offsets[i];
                     classify(ccx, layout.field(ccx, i), cls, field_off)?;
diff --git a/src/librustc_trans/common.rs b/src/librustc_trans/common.rs
@@ -74,7 +74,7 @@ pub fn type_is_imm_pair<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, ty: Ty<'tcx>)
     let layout = ccx.layout_of(ty);
     match *layout {
         Layout::FatPointer { .. } => true,
-        Layout::Univariant { ref variant, .. } => {
+        Layout::Univariant(ref variant) => {
             // There must be only 2 fields.
             if variant.offsets.len() != 2 {
                 return false;
diff --git a/src/librustc_trans/debuginfo/metadata.rs b/src/librustc_trans/debuginfo/metadata.rs
@@ -942,7 +942,7 @@ impl<'tcx> StructMemberDescriptionFactory<'tcx> {
 
         let tmp;
         let offsets = match *layout {
-            layout::Univariant { ref variant, .. } => &variant.offsets,
+            layout::Univariant(ref variant) => &variant.offsets,
             layout::Vector { element, count } => {
                 let element_size = element.size(cx).bytes();
                 tmp = (0..count).
@@ -1022,7 +1022,7 @@ impl<'tcx> TupleMemberDescriptionFactory<'tcx> {
     fn create_member_descriptions<'a>(&self, cx: &CrateContext<'a, 'tcx>)
                                       -> Vec<MemberDescription> {
         let layout = cx.layout_of(self.ty);
-        let offsets = if let layout::Univariant { ref variant, .. } = *layout {
+        let offsets = if let layout::Univariant(ref variant) = *layout {
             &variant.offsets
         } else {
             bug!("{} is not a tuple", self.ty);
@@ -1184,7 +1184,7 @@ impl<'tcx> EnumMemberDescriptionFactory<'tcx> {
                         }
                     }).collect()
             },
-            layout::Univariant{ ref variant, .. } => {
+            layout::Univariant(ref variant) => {
                 assert!(adt.variants.len() <= 1);
 
                 if adt.variants.is_empty() {
diff --git a/src/librustc_trans/glue.rs b/src/librustc_trans/glue.rs
@@ -59,7 +59,7 @@ pub fn size_and_align_of_dst<'a, 'tcx>(bcx: &Builder<'a, 'tcx>, t: Ty<'tcx>, inf
             debug!("DST {} layout: {:?}", t, layout);
 
             let (sized_size, sized_align) = match *layout {
-                ty::layout::Layout::Univariant { ref variant, .. } => {
+                ty::layout::Layout::Univariant(ref variant) => {
                     (variant.offsets.last().map_or(0, |o| o.bytes()), variant.align.abi())
                 }
                 _ => {
diff --git a/src/librustc_trans/mir/constant.rs b/src/librustc_trans/mir/constant.rs
@@ -1111,16 +1111,16 @@ fn trans_const_adt<'a, 'tcx>(
             build_const_struct(ccx, l, &variant, vals,
                 Some(Const::new(lldiscr, d.to_ty(ccx.tcx(), false))))
         }
-        layout::UntaggedUnion { ref variants, .. }=> {
+        layout::UntaggedUnion(ref un) => {
             assert_eq!(variant_index, 0);
             let contents = [
                 vals[0].llval,
-                padding(ccx, variants.stride() - ccx.size_of(vals[0].ty))
+                padding(ccx, un.stride() - ccx.size_of(vals[0].ty))
             ];
 
-            Const::new(C_struct(ccx, &contents, variants.packed), t)
+            Const::new(C_struct(ccx, &contents, un.packed), t)
         }
-        layout::Univariant { ref variant, .. } => {
+        layout::Univariant(ref variant) => {
             assert_eq!(variant_index, 0);
             build_const_struct(ccx, l, &variant, vals, None)
         }
diff --git a/src/librustc_trans/mir/lvalue.rs b/src/librustc_trans/mir/lvalue.rs
@@ -58,8 +58,8 @@ impl ops::BitOr for Alignment {
 impl<'a> From<&'a Layout> for Alignment {
     fn from(layout: &Layout) -> Self {
         let (packed, align) = match *layout {
-            Layout::UntaggedUnion { ref variants } => (variants.packed, variants.align),
-            Layout::Univariant { ref variant, .. } => (variant.packed, variant.align),
+            Layout::UntaggedUnion(ref un) => (un.packed, un.align),
+            Layout::Univariant(ref variant) => (variant.packed, variant.align),
             _ => return Alignment::AbiAligned
         };
         if packed {
@@ -250,7 +250,7 @@ impl<'a, 'tcx> LvalueRef<'tcx> {
 
         // Check whether the variant being used is packed, if applicable.
         let is_packed = match (&*l, l.variant_index) {
-            (&layout::Univariant { ref variant, .. }, _) => variant.packed,
+            (&layout::Univariant(ref variant), _) => variant.packed,
             (&layout::StructWrappedNullablePointer { ref nonnull, .. }, _) => nonnull.packed,
             (&layout::General { ref variants, .. }, Some(v)) => variants[v].packed,
             _ => return simple()
diff --git a/src/librustc_trans/mir/mod.rs b/src/librustc_trans/mir/mod.rs
@@ -577,7 +577,7 @@ fn arg_local_refs<'a, 'tcx>(bcx: &Builder<'a, 'tcx>,
 
             let layout = bcx.ccx.layout_of(closure_ty);
             let offsets = match *layout {
-                layout::Univariant { ref variant, .. } => &variant.offsets[..],
+                layout::Univariant(ref variant) => &variant.offsets[..],
                 _ => bug!("Closures are only supposed to be Univariant")
             };
 
diff --git a/src/librustc_trans/type_of.rs b/src/librustc_trans/type_of.rs
@@ -254,7 +254,7 @@ impl<'tcx> LayoutLlvmExt for FullLayout<'tcx> {
                 adt::memory_index_to_gep(index as u64)
             }
 
-            Layout::Univariant { ref variant, .. } => {
+            Layout::Univariant(ref variant) => {
                 adt::memory_index_to_gep(variant.memory_index[index] as u64)
             }
 
diff --git a/src/test/compile-fail/issue-26548.rs b/src/test/compile-fail/issue-26548.rs
@@ -8,7 +8,10 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// error-pattern: overflow representing the type
+// error-pattern: unsupported cyclic reference between types/traits detected
+// note-pattern: the cycle begins when computing layout of
+// note-pattern: ...which then requires computing layout of
+// note-pattern: ...which then again requires computing layout of
 
 
 trait Mirror { type It: ?Sized; }
diff --git a/src/test/ui/issue-26548.stderr b/src/test/ui/issue-26548.stderr
diff --git a/src/tools/toolstate.toml b/src/tools/toolstate.toml
@@ -26,7 +26,7 @@
 miri = "Broken"
 
 # ping @Manishearth @llogiq @mcarton @oli-obk
-clippy = "Testing"
+clippy = "Broken"
 
 # ping @nrc
 rls = "Testing"

Original file line number	Diff line number	Diff line change
`@@ -330,7 +330,7 @@ impl<'tcx> LayoutExt<'tcx> for FullLayout<'tcx> {`
`330`	`330`	`}`
`331`	`331`	`}`
`332`	`332`
`333`		`- Layout::Univariant { ref variant, .. } => {`
	`333`	`+ Layout::Univariant(ref variant) => {`
`334`	`334`	`let mut unaligned_offset = Size::from_bytes(0);`
`335`	`335`	`let mut result = None;`
`336`	`336`
Original file line number	Diff line number	Diff line change
`@@ -74,7 +74,7 @@ pub fn finish_type_of<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>,`
`74`	`74`	`layout::Univariant { ..}`
`75`	`75`	`\| layout::StructWrappedNullablePointer { .. } => {`
`76`	`76`	`let (variant_layout, variant) = match *l {`
`77`		`- layout::Univariant { ref variant, .. } => {`
	`77`	`+ layout::Univariant(ref variant) => {`
`78`	`78`	`let is_enum = if let ty::TyAdt(def, _) = t.sty {`
`79`	`79`	`def.is_enum()`
`80`	`80`	`} else {`
`@@ -123,7 +123,7 @@ fn generic_type_of<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>,`
`123`	`123`	`}`
`124`	`124`	`}`
`125`	`125`	`}`
`126`		`- layout::Univariant { ref variant, .. } => {`
	`126`	`+ layout::Univariant(ref variant) => {`
`127`	`127`	`match name {`
`128`	`128`	`None => {`
`129`	`129`	`Type::struct_(cx, &struct_llfields(cx, l, &variant),`
`@@ -134,16 +134,16 @@ fn generic_type_of<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>,`
`134`	`134`	`}`
`135`	`135`	`}`
`136`	`136`	`}`
`137`		`- layout::UntaggedUnion { ref variants, .. }=> {`
	`137`	`+ layout::UntaggedUnion(ref un) => {`
`138`	`138`	`// Use alignment-sized ints to fill all the union storage.`
`139`		`- let fill = union_fill(cx, variants.stride(), variants.align);`
	`139`	`+ let fill = union_fill(cx, un.stride(), un.align);`
`140`	`140`	`match name {`
`141`	`141`	`None => {`
`142`		`- Type::struct_(cx, &[fill], variants.packed)`
	`142`	`+ Type::struct_(cx, &[fill], un.packed)`
`143`	`143`	`}`
`144`	`144`	`Some(name) => {`
`145`	`145`	`let mut llty = Type::named_struct(cx, name);`
`146`		`- llty.set_struct_body(&[fill], variants.packed);`
	`146`	`+ llty.set_struct_body(&[fill], un.packed);`
`147`	`147`	`llty`
`148`	`148`	`}`
`149`	`149`	`}`
Original file line number	Diff line number	Diff line change
`@@ -101,7 +101,7 @@ fn classify_arg<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, arg: &ArgType<'tcx>)`
`101`	`101`	`}`
`102`	`102`	`}`
`103`	`103`
`104`		`- Layout::Univariant { ref variant, .. } => {`
	`104`	`+ Layout::Univariant(ref variant) => {`
`105`	`105`	`for i in 0..layout.field_count() {`
`106`	`106`	`let field_off = off + variant.offsets[i];`
`107`	`107`	`classify(ccx, layout.field(ccx, i), cls, field_off)?;`