Auto merge of #27338 - alexcrichton:remove-morestack, r=brson

[rust.git] / src / librustc_typeck / variance.rs

diff --git a/src/librustc_typeck/variance.rs b/src/librustc_typeck/variance.rs
index 1f4e13436512179f729084b162d2d566b81e2a33..69e2141b17b07807c2907eb3660b2001418b6fae 100644 (file)
--- a/src/librustc_typeck/variance.rs
+++ b/src/librustc_typeck/variance.rs
@@ -485,7 +485,7 @@ fn add_inferred(&mut self,
                 param_id={}, \
                 inf_index={:?}, \
                 initial_variance={:?})",
-               ty::item_path_str(self.tcx, ast_util::local_def(item_id)),
+               self.tcx.item_path_str(ast_util::local_def(item_id)),
                item_id, kind, space, index, param_id, inf_index,
                initial_variance);
     }
@@ -602,8 +602,8 @@ fn visit_item(&mut self, item: &ast::Item) {
         debug!("visit_item item={}", tcx.map.node_to_string(item.id));
 
         match item.node {
-            ast::ItemEnum(ref enum_definition, _) => {
-                let scheme = ty::lookup_item_type(tcx, did);
+            ast::ItemEnum(..) | ast::ItemStruct(..) => {
+                let scheme = tcx.lookup_item_type(did);
 
                 // Not entirely obvious: constraints on structs/enums do not
                 // affect the variance of their type parameters. See discussion
@@ -611,46 +611,14 @@ fn visit_item(&mut self, item: &ast::Item) {
                 //
                 // self.add_constraints_from_generics(&scheme.generics);
 
-                // Hack: If we directly call `ty::enum_variants`, it
-                // annoyingly takes it upon itself to run off and
-                // evaluate the discriminants eagerly (*grumpy* that's
-                // not the typical pattern). This results in double
-                // error messages because typeck goes off and does
-                // this at a later time. All we really care about is
-                // the types of the variant arguments, so we just call
-                // `ty::VariantInfo::from_ast_variant()` ourselves
-                // here, mainly so as to mask the differences between
-                // struct-like enums and so forth.
-                for ast_variant in &enum_definition.variants {
-                    let variant =
-                        ty::VariantInfo::from_ast_variant(tcx,
-                                                          &**ast_variant,
-                                                          /*discriminant*/ 0);
-                    for arg_ty in &variant.args {
-                        self.add_constraints_from_ty(&scheme.generics, *arg_ty, self.covariant);
-                    }
-                }
-            }
-
-            ast::ItemStruct(..) => {
-                let scheme = ty::lookup_item_type(tcx, did);
-
-                // Not entirely obvious: constraints on structs/enums do not
-                // affect the variance of their type parameters. See discussion
-                // in comment at top of module.
-                //
-                // self.add_constraints_from_generics(&scheme.generics);
-
-                let struct_fields = ty::lookup_struct_fields(tcx, did);
-                for field_info in &struct_fields {
-                    assert_eq!(field_info.id.krate, ast::LOCAL_CRATE);
-                    let field_ty = ty::node_id_to_type(tcx, field_info.id.node);
-                    self.add_constraints_from_ty(&scheme.generics, field_ty, self.covariant);
+                for field in tcx.lookup_adt_def(did).all_fields() {
+                    self.add_constraints_from_ty(&scheme.generics,
+                                                 field.unsubst_ty(),
+                                                 self.covariant);
                 }
             }
-
             ast::ItemTrait(..) => {
-                let trait_def = ty::lookup_trait_def(tcx, did);
+                let trait_def = tcx.lookup_trait_def(did);
                 self.add_constraints_from_trait_ref(&trait_def.generics,
                                                     trait_def.trait_ref,
                                                     self.invariant);
@@ -781,7 +749,7 @@ fn declared_variance(&self,
         } else {
             // Parameter on an item defined within another crate:
             // variance already inferred, just look it up.
-            let variances = ty::item_variances(self.tcx(), item_def_id);
+            let variances = self.tcx().item_variances(item_def_id);
             let variance = match kind {
                 TypeParam => *variances.types.get(space, index),
                 RegionParam => *variances.regions.get(space, index),
@@ -848,7 +816,7 @@ fn add_constraints_from_trait_ref(&mut self,
                trait_ref,
                variance);
 
-        let trait_def = ty::lookup_trait_def(self.tcx(), trait_ref.def_id);
+        let trait_def = self.tcx().lookup_trait_def(trait_ref.def_id);
 
         self.add_constraints_from_substs(
             generics,
@@ -902,9 +870,9 @@ fn add_constraints_from_ty(&mut self,
                 }
             }
 
-            ty::TyEnum(def_id, substs) |
-            ty::TyStruct(def_id, substs) => {
-                let item_type = ty::lookup_item_type(self.tcx(), def_id);
+            ty::TyEnum(def, substs) |
+            ty::TyStruct(def, substs) => {
+                let item_type = self.tcx().lookup_item_type(def.did);
 
                 // All type parameters on enums and structs should be
                 // in the TypeSpace.
@@ -915,7 +883,7 @@ fn add_constraints_from_ty(&mut self,
 
                 self.add_constraints_from_substs(
                     generics,
-                    def_id,
+                    def.did,
                     item_type.generics.types.get_slice(subst::TypeSpace),
                     item_type.generics.regions.get_slice(subst::TypeSpace),
                     substs,
@@ -924,7 +892,7 @@ fn add_constraints_from_ty(&mut self,
 
             ty::TyProjection(ref data) => {
                 let trait_ref = &data.trait_ref;
-                let trait_def = ty::lookup_trait_def(self.tcx(), trait_ref.def_id);
+                let trait_def = self.tcx().lookup_trait_def(trait_ref.def_id);
                 self.add_constraints_from_substs(
                     generics,
                     trait_ref.def_id,
@@ -1074,7 +1042,7 @@ fn add_constraints_from_region(&mut self,
     /// appearing in a context with ambient variance `variance`
     fn add_constraints_from_mt(&mut self,
                                generics: &ty::Generics<'tcx>,
-                               mt: &ty::mt<'tcx>,
+                               mt: &ty::TypeAndMut<'tcx>,
                                variance: VarianceTermPtr<'a>) {
         match mt.mutbl {
             ast::MutMutable => {
@@ -1200,7 +1168,7 @@ fn write(&self) {
 
             // For unit testing: check for a special "rustc_variance"
             // attribute and report an error with various results if found.
-            if ty::has_attr(tcx, item_def_id, "rustc_variance") {
+            if tcx.has_attr(item_def_id, "rustc_variance") {
                 span_err!(tcx.sess, tcx.map.span(item_id), E0208, "{:?}", item_variances);
             }