rustc: re-complicate the TyLayout API and use better names.

Author: eddyb

src/librustc/ty/layout.rs

@@ -227,12 +227,6 @@ impl<'a> HasDataLayout for &'a TargetDataLayout {
     }
 }
 
-impl<'a, 'tcx> HasDataLayout for TyCtxt<'a, 'tcx, 'tcx> {
-    fn data_layout(&self) -> &TargetDataLayout {
-        &self.data_layout
-    }
-}
-
 /// Endianness of the target, which must match cfg(target-endian).
 #[derive(Copy, Clone)]
 pub enum Endian {
@@ -2089,80 +2083,85 @@ impl<'a, 'tcx> SizeSkeleton<'tcx> {
     }
 }
 
-/// A pair of a type and its layout. Implements various
-/// type traversal APIs (e.g. recursing into fields).
+/// The details of the layout of a type, alongside the type itself.
+/// Provides various type traversal APIs (e.g. recursing into fields).
+///
+/// Note that the details are NOT guaranteed to always be identical
+/// to those obtained from `layout_of(ty)`, as we need to produce
+/// layouts for which Rust types do not exist, such as enum variants
+/// or synthetic fields of enums (i.e. discriminants) and fat pointers.
 #[derive(Copy, Clone, Debug)]
-pub struct TyLayout<'tcx> {
+pub struct FullLayout<'tcx> {
     pub ty: Ty<'tcx>,
-    pub layout: &'tcx Layout,
     pub variant_index: Option<usize>,
+    pub layout: &'tcx Layout,
 }
 
-impl<'tcx> Deref for TyLayout<'tcx> {
+impl<'tcx> Deref for FullLayout<'tcx> {
     type Target = Layout;
     fn deref(&self) -> &Layout {
         self.layout
     }
 }
 
-pub trait LayoutTyper<'tcx>: HasDataLayout {
-    type TyLayout;
-
+pub trait HasTyCtxt<'tcx>: HasDataLayout {
     fn tcx<'a>(&'a self) -> TyCtxt<'a, 'tcx, 'tcx>;
-    fn layout_of(self, ty: Ty<'tcx>) -> Self::TyLayout;
-    fn normalize_projections(self, ty: Ty<'tcx>) -> Ty<'tcx>;
 }
 
-/// Combines a tcx with the parameter environment so that you can
-/// compute layout operations.
-#[derive(Copy, Clone)]
-pub struct LayoutCx<'a, 'tcx: 'a> {
-    tcx: TyCtxt<'a, 'tcx, 'tcx>,
-    param_env: ty::ParamEnv<'tcx>,
+impl<'a, 'gcx, 'tcx> HasDataLayout for TyCtxt<'a, 'gcx, 'tcx> {
+    fn data_layout(&self) -> &TargetDataLayout {
+        &self.data_layout
+    }
 }
 
-impl<'a, 'tcx> LayoutCx<'a, 'tcx> {
-    pub fn new(tcx: TyCtxt<'a, 'tcx, 'tcx>, param_env: ty::ParamEnv<'tcx>) -> Self {
-        LayoutCx { tcx, param_env }
+impl<'a, 'gcx, 'tcx> HasTyCtxt<'gcx> for TyCtxt<'a, 'gcx, 'tcx> {
+    fn tcx<'b>(&'b self) -> TyCtxt<'b, 'gcx, 'gcx> {
+        self.global_tcx()
     }
 }
 
-impl<'a, 'tcx> HasDataLayout for LayoutCx<'a, 'tcx> {
+impl<'a, 'gcx, 'tcx, T: Copy> HasDataLayout for (TyCtxt<'a, 'gcx, 'tcx>, T) {
     fn data_layout(&self) -> &TargetDataLayout {
-        &self.tcx.data_layout
+        self.0.data_layout()
     }
 }
 
-impl<'a, 'tcx> LayoutTyper<'tcx> for LayoutCx<'a, 'tcx> {
-    type TyLayout = Result<TyLayout<'tcx>, LayoutError<'tcx>>;
-
-    fn tcx<'b>(&'b self) -> TyCtxt<'b, 'tcx, 'tcx> {
-        self.tcx
+impl<'a, 'gcx, 'tcx, T: Copy> HasTyCtxt<'gcx> for (TyCtxt<'a, 'gcx, 'tcx>, T) {
+    fn tcx<'b>(&'b self) -> TyCtxt<'b, 'gcx, 'gcx> {
+        self.0.tcx()
     }
+}
+
+pub trait LayoutOf<T> {
+    type FullLayout;
+
+    fn layout_of(self, ty: T) -> Self::FullLayout;
+}
+
+impl<'a, 'tcx> LayoutOf<Ty<'tcx>> for (TyCtxt<'a, 'tcx, 'tcx>, ty::ParamEnv<'tcx>) {
+    type FullLayout = Result<FullLayout<'tcx>, LayoutError<'tcx>>;
 
-    fn layout_of(self, ty: Ty<'tcx>) -> Self::TyLayout {
-        let ty = self.normalize_projections(ty);
+    fn layout_of(self, ty: Ty<'tcx>) -> Self::FullLayout {
+        let (tcx, param_env) = self;
 
-        Ok(TyLayout {
+        let ty = tcx.normalize_associated_type_in_env(&ty, param_env);
+
+        Ok(FullLayout {
             ty,
-            layout: ty.layout(self.tcx, self.param_env)?,
-            variant_index: None
+            variant_index: None,
+            layout: ty.layout(tcx, param_env)?,
         })
     }
-
-    fn normalize_projections(self, ty: Ty<'tcx>) -> Ty<'tcx> {
-        self.tcx.normalize_associated_type_in_env(&ty, self.param_env)
-    }
 }
 
-impl<'a, 'tcx> TyLayout<'tcx> {
+impl<'a, 'tcx> FullLayout<'tcx> {
     pub fn for_variant(&self, variant_index: usize) -> Self {
         let is_enum = match self.ty.sty {
             ty::TyAdt(def, _) => def.is_enum(),
             _ => false
         };
         assert!(is_enum);
-        TyLayout {
+        FullLayout {
             variant_index: Some(variant_index),
             ..*self
         }
@@ -2199,7 +2198,7 @@ impl<'a, 'tcx> TyLayout<'tcx> {
 
         match *self.layout {
             Scalar { .. } => {
-                bug!("TyLayout::field_count({:?}): not applicable", self)
+                bug!("FullLayout::field_count({:?}): not applicable", self)
             }
 
             // Handled above (the TyAdt case).
@@ -2222,9 +2221,7 @@ impl<'a, 'tcx> TyLayout<'tcx> {
         }
     }
 
-    fn field_type_unnormalized<C: LayoutTyper<'tcx>>(&self, cx: C, i: usize) -> Ty<'tcx> {
-        let tcx = cx.tcx();
-
+    fn field_type_unnormalized(&self, tcx: TyCtxt<'a, 'tcx, 'tcx>, i: usize) -> Ty<'tcx> {
         let ptr_field_type = |pointee: Ty<'tcx>| {
             assert!(i < 2);
             let slice = |element: Ty<'tcx>| {
@@ -2238,7 +2235,7 @@ impl<'a, 'tcx> TyLayout<'tcx> {
                 ty::TySlice(element) => slice(element),
                 ty::TyStr => slice(tcx.types.u8),
                 ty::TyDynamic(..) => tcx.mk_mut_ptr(tcx.mk_nil()),
-                _ => bug!("TyLayout::field_type({:?}): not applicable", self)
+                _ => bug!("FullLayout::field_type({:?}): not applicable", self)
             }
         };
 
@@ -2253,7 +2250,7 @@ impl<'a, 'tcx> TyLayout<'tcx> {
             ty::TyFnDef(..) |
             ty::TyDynamic(..) |
             ty::TyForeign(..) => {
-                bug!("TyLayout::field_type({:?}): not applicable", self)
+                bug!("FullLayout::field_type({:?}): not applicable", self)
             }
 
             // Potentially-fat pointers.
@@ -2311,20 +2308,16 @@ impl<'a, 'tcx> TyLayout<'tcx> {
 
             ty::TyProjection(_) | ty::TyAnon(..) | ty::TyParam(_) |
             ty::TyInfer(_) | ty::TyError => {
-                bug!("TyLayout::field_type: unexpected type `{}`", self.ty)
+                bug!("FullLayout::field_type: unexpected type `{}`", self.ty)
             }
         }
     }
 
-    pub fn field_type<C: LayoutTyper<'tcx>>(&self, cx: C, i: usize) -> Ty<'tcx> {
-        cx.normalize_projections(self.field_type_unnormalized(cx, i))
-    }
-
-    pub fn field<C: LayoutTyper<'tcx>>(&self,
-                                       cx: C,
-                                       i: usize)
-                                       -> C::TyLayout {
-        cx.layout_of(self.field_type(cx, i))
+    pub fn field<C: LayoutOf<Ty<'tcx>> + HasTyCtxt<'tcx>>(&self,
+                                                          cx: C,
+                                                          i: usize)
+                                                          -> C::FullLayout {
+        cx.layout_of(self.field_type_unnormalized(cx.tcx(), i))
     }
 }
 

src/librustc_trans/abi.rs

@@ -35,8 +35,8 @@ use type_::Type;
 
 use rustc::hir;
 use rustc::ty::{self, Ty};
-use rustc::ty::layout::{self, Align, Layout, Size, TyLayout};
-use rustc::ty::layout::{HasDataLayout, LayoutTyper};
+use rustc::ty::layout::{self, Align, Layout, Size, FullLayout};
+use rustc::ty::layout::{HasDataLayout, LayoutOf};
 use rustc_back::PanicStrategy;
 
 use libc::c_uint;
@@ -274,7 +274,7 @@ pub trait LayoutExt<'tcx> {
     fn homogeneous_aggregate<'a>(&self, ccx: &CrateContext<'a, 'tcx>) -> Option<Reg>;
 }
 
-impl<'tcx> LayoutExt<'tcx> for TyLayout<'tcx> {
+impl<'tcx> LayoutExt<'tcx> for FullLayout<'tcx> {
     fn is_aggregate(&self) -> bool {
         match *self.layout {
             Layout::Scalar { .. } |
@@ -471,7 +471,7 @@ impl CastTarget {
 #[derive(Clone, Copy, Debug)]
 pub struct ArgType<'tcx> {
     kind: ArgKind,
-    pub layout: TyLayout<'tcx>,
+    pub layout: FullLayout<'tcx>,
     /// Cast target, either a single uniform or a pair of registers.
     pub cast: Option<CastTarget>,
     /// Dummy argument, which is emitted before the real argument.
@@ -481,7 +481,7 @@ pub struct ArgType<'tcx> {
 }
 
 impl<'a, 'tcx> ArgType<'tcx> {
-    fn new(layout: TyLayout<'tcx>) -> ArgType<'tcx> {
+    fn new(layout: FullLayout<'tcx>) -> ArgType<'tcx> {
         ArgType {
             kind: ArgKind::Direct,
             layout,

src/librustc_trans/adt.rs

@@ -42,7 +42,7 @@
 //!   taken to it, implementing them for Rust seems difficult.
 
 use rustc::ty::{self, Ty};
-use rustc::ty::layout::{self, Align, HasDataLayout, LayoutTyper, Size, TyLayout};
+use rustc::ty::layout::{self, Align, HasDataLayout, LayoutOf, Size, FullLayout};
 
 use context::CrateContext;
 use type_::Type;
@@ -207,7 +207,7 @@ pub fn memory_index_to_gep(index: u64) -> u64 {
 }
 
 pub fn struct_llfields<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>,
-                                 layout: TyLayout<'tcx>,
+                                 layout: FullLayout<'tcx>,
                                  variant: &layout::Struct) -> Vec<Type> {
     let field_count = layout.field_count();
     debug!("struct_llfields: variant: {:?}", variant);

src/librustc_trans/cabi_s390x.rs

@@ -14,7 +14,7 @@
 use abi::{FnType, ArgType, LayoutExt, Reg};
 use context::CrateContext;
 
-use rustc::ty::layout::{self, Layout, TyLayout};
+use rustc::ty::layout::{self, Layout, FullLayout};
 
 fn classify_ret_ty<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, ret: &mut ArgType<'tcx>) {
     if !ret.layout.is_aggregate() && ret.layout.size(ccx).bits() <= 64 {
@@ -25,7 +25,7 @@ fn classify_ret_ty<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, ret: &mut ArgType<'tc
 }
 
 fn is_single_fp_element<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>,
-                                  layout: TyLayout<'tcx>) -> bool {
+                                  layout: FullLayout<'tcx>) -> bool {
     match *layout {
         Layout::Scalar { value: layout::F32, .. } |
         Layout::Scalar { value: layout::F64, .. } => true,

src/librustc_trans/cabi_x86.rs

@@ -11,7 +11,7 @@
 use abi::{ArgAttribute, FnType, LayoutExt, Reg, RegKind};
 use common::CrateContext;
 
-use rustc::ty::layout::{self, Layout, TyLayout};
+use rustc::ty::layout::{self, Layout, FullLayout};
 
 #[derive(PartialEq)]
 pub enum Flavor {
@@ -20,7 +20,7 @@ pub enum Flavor {
 }
 
 fn is_single_fp_element<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>,
-                                  layout: TyLayout<'tcx>) -> bool {
+                                  layout: FullLayout<'tcx>) -> bool {
     match *layout {
         Layout::Scalar { value: layout::F32, .. } |
         Layout::Scalar { value: layout::F64, .. } => true,

src/librustc_trans/cabi_x86_64.rs

@@ -14,7 +14,7 @@
 use abi::{ArgType, ArgAttribute, CastTarget, FnType, LayoutExt, Reg, RegKind};
 use context::CrateContext;
 
-use rustc::ty::layout::{self, Layout, TyLayout, Size};
+use rustc::ty::layout::{self, Layout, FullLayout, Size};
 
 #[derive(Clone, Copy, PartialEq, Debug)]
 enum Class {
@@ -53,7 +53,7 @@ fn classify_arg<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, arg: &ArgType<'tcx>)
     }
 
     fn classify<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>,
-                          layout: TyLayout<'tcx>,
+                          layout: FullLayout<'tcx>,
                           cls: &mut [Class],
                           off: Size)
                           -> Result<(), Memory> {

src/librustc_trans/common.rs

@@ -27,7 +27,7 @@ use type_::Type;
 use value::Value;
 use rustc::traits;
 use rustc::ty::{self, Ty, TyCtxt};
-use rustc::ty::layout::{HasDataLayout, Layout, LayoutTyper};
+use rustc::ty::layout::{HasDataLayout, Layout, LayoutOf};
 use rustc::ty::subst::{Kind, Subst, Substs};
 use rustc::hir;
 
@@ -81,8 +81,8 @@ pub fn type_is_imm_pair<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, ty: Ty<'tcx>)
             }
 
             // The two fields must be both immediates.
-            type_is_immediate(ccx, layout.field_type(ccx, 0)) &&
-            type_is_immediate(ccx, layout.field_type(ccx, 1))
+            type_is_immediate(ccx, layout.field(ccx, 0).ty) &&
+            type_is_immediate(ccx, layout.field(ccx, 1).ty)
         }
         _ => false
     }