it works!

Ariel Ben-Yehuda · Ariel Ben-Yehuda · commit 63be9d766267 · 2015-08-05T21:33:56.000+03:00
diff --git a/src/librustc/metadata/decoder.rs b/src/librustc/metadata/decoder.rs
@@ -466,12 +466,31 @@ pub fn get_adt_def<'tcx>(intr: &IdentInterner,
     // this needs to be done *after* the variant is interned,
     // to support recursive structures
     for variant in &adt.variants {
-        for field in &variant.fields {
-            debug!("evaluating the type of {:?}::{:?}", variant.name, field.name);
-            let ty = get_type(cdata, field.did.node, tcx).ty;
-            field.fulfill_ty(ty);
-            debug!("evaluating the type of {:?}::{:?}: {:?}",
-                   variant.name, field.name, ty);
+        if variant.kind() == ty::VariantKind::Tuple &&
+            adt.adt_kind() == ty::ADTKind::Enum {
+            // tuple-like enum variant fields aren't real items - get the types
+            // from the ctor.
+            debug!("evaluating the ctor-type of {:?}",
+                   variant.name);
+            let ctor_ty = get_type(cdata, variant.did.node, tcx).ty;
+            debug!("evaluating the ctor-type of {:?}.. {:?}",
+                   variant.name,
+                   ctor_ty);
+            let field_tys = match ctor_ty.sty {
+                ty::TyBareFn(_, ref f) => &f.sig.skip_binder().inputs,
+                _ => tcx.sess.bug("tuple-variant ctor is not an ADT")
+            };
+            for (field, &ty) in variant.fields.iter().zip(field_tys.iter()) {
+                field.fulfill_ty(ty);
+            }
+        } else {
+            for field in &variant.fields {
+                debug!("evaluating the type of {:?}::{:?}", variant.name, field.name);
+                let ty = get_type(cdata, field.did.node, tcx).ty;
+                field.fulfill_ty(ty);
+                debug!("evaluating the type of {:?}::{:?}: {:?}",
+                       variant.name, field.name, ty);
+            }
         }
     }
 
diff --git a/src/librustc/metadata/encoder.rs b/src/librustc/metadata/encoder.rs
@@ -319,9 +319,11 @@ fn encode_enum_variant_info(ecx: &EncodeContext,
                                              rbml_w,
                                              &variant.fields,
                                              index);
-            encode_struct_fields(rbml_w, &variant.fields, vid);
             encode_index(rbml_w, idx, write_i64);
         }
+
+        encode_struct_fields(rbml_w, &variant.fields, vid);
+
         let specified_disr_val = variant.disr_val;
         if specified_disr_val != disr_val {
             encode_disr_val(ecx, rbml_w, specified_disr_val);
diff --git a/src/librustc/middle/cast.rs b/src/librustc/middle/cast.rs
@@ -58,8 +58,7 @@ pub enum CastKind {
 }
 
 impl<'tcx> CastTy<'tcx> {
-    pub fn from_ty(tcx: &ty::ctxt<'tcx>, t: Ty<'tcx>)
-                   -> Option<CastTy<'tcx>> {
+    pub fn from_ty(t: Ty<'tcx>) -> Option<CastTy<'tcx>> {
         match t.sty {
             ty::TyBool => Some(CastTy::Int(IntTy::Bool)),
             ty::TyChar => Some(CastTy::Int(IntTy::Char)),
diff --git a/src/librustc/middle/check_match.rs b/src/librustc/middle/check_match.rs
@@ -898,7 +898,8 @@ pub fn specialize<'a>(cx: &MatchCheckCtxt, r: &[&'a Pat],
             let def = cx.tcx.def_map.borrow().get(&pat_id).unwrap().full_def();
             let adt = cx.tcx.node_id_to_type(pat_id).ty_adt_def().unwrap();
             let variant = adt.variant_of_ctor(constructor);
-            if variant.did == def.def_id() {
+            let def_variant = adt.variant_of_def(def);
+            if variant.did == def_variant.did {
                 Some(variant.fields.iter().map(|sf| {
                     match pattern_fields.iter().find(|f| f.node.ident.name == sf.name) {
                         Some(ref f) => &*f.node.pat,
diff --git a/src/librustc/middle/dead.rs b/src/librustc/middle/dead.rs
@@ -110,8 +110,6 @@ impl<'a, 'tcx> MarkSymbolVisitor<'a, 'tcx> {
     fn handle_tup_field_access(&mut self, lhs: &ast::Expr, idx: usize) {
         if let ty::TyStruct(def, _) = self.tcx.expr_ty_adjusted(lhs).sty {
             self.live_symbols.insert(def.struct_variant().fields[idx].did.node);
-        } else {
-            self.tcx.sess.span_bug(lhs.span, "indexed field access on non-struct")
         }
     }
 
diff --git a/src/librustc/middle/ty.rs b/src/librustc/middle/ty.rs
@@ -3287,6 +3287,8 @@ pub struct VariantDef_<'tcx, 'lt: 'tcx> {
 }
 
 pub struct FieldDef_<'tcx, 'lt: 'tcx> {
+    /// The field's def-id. Be aware that tuple-like enum fields
+    /// are currently not real items (you can't e.g. lookup_item_type them).
     pub did: DefId,
     // special_idents::unnamed_field.name
     // if this is a tuple-like field
@@ -3424,7 +3426,8 @@ impl<'tcx, 'lt> ADTDef_<'tcx, 'lt> {
     }
 
     pub fn is_payloadfree(&self) -> bool {
-        self.variants.iter().all(|v| v.fields.is_empty())
+        !self.variants.is_empty() &&
+            self.variants.iter().all(|v| v.fields.is_empty())
     }
 
     pub fn variant_with_id(&self, vid: DefId) -> &VariantDef_<'tcx, 'lt> {
@@ -3437,11 +3440,8 @@ impl<'tcx, 'lt> ADTDef_<'tcx, 'lt> {
     pub fn variant_of_def(&self, def: def::Def) -> &VariantDef_<'tcx, 'lt> {
         match def {
             def::DefVariant(_, vid, _) => self.variant_with_id(vid),
-            def::DefStruct(..) => self.struct_variant(),
-            _ => {
-                debug!("unexpected def {:?} in variant_of_def", def);
-                unreachable!()
-            }
+            def::DefStruct(..) | def::DefTy(..) => self.struct_variant(),
+            _ => panic!("unexpected def {:?} in variant_of_def", def)
         }
     }
 }
diff --git a/src/librustc_lint/builtin.rs b/src/librustc_lint/builtin.rs
@@ -417,11 +417,13 @@ fn is_repr_nullable_ptr<'tcx>(tcx: &ty::ctxt<'tcx>,
                               substs: &Substs<'tcx>)
                               -> bool {
     if def.variants.len() == 2 {
-        let mut data_idx = 0;
+        let data_idx;
 
         if def.variants[0].fields.is_empty() {
             data_idx = 1;
-        } else if !def.variants[1].fields.is_empty() {
+        } else if def.variants[1].fields.is_empty() {
+            data_idx = 0;
+        } else {
             return false;
         }
 
diff --git a/src/librustc_privacy/lib.rs b/src/librustc_privacy/lib.rs
@@ -913,18 +913,22 @@ impl<'a, 'tcx, 'v> Visitor<'v> for PrivacyVisitor<'a, 'tcx> {
             }
             ast::ExprPath(..) => {
                 if let def::DefStruct(_) = self.tcx.resolve_expr(expr) {
-                    if let ty::TyStruct(def, _) = self.tcx.expr_ty(expr).sty {
-                        let fields = &def.struct_variant().fields;
-                        let any_priv = fields.iter().any(|f| {
-                            f.vis != ast::Public && (
-                                !is_local(f.did) ||
+                    let expr_ty = self.tcx.expr_ty(expr);
+                    let def = match expr_ty.sty {
+                        ty::TyBareFn(_, &ty::BareFnTy { sig: ty::Binder(ty::FnSig {
+                            output: ty::FnConverging(ty), ..
+                        }), ..}) => ty,
+                        _ => expr_ty
+                    }.ty_adt_def().unwrap();
+                    let any_priv = def.struct_variant().fields.iter().any(|f| {
+                        f.vis != ast::Public && (
+                            !is_local(f.did) ||
                                     !self.private_accessible(f.did.node))
                         });
-                        if any_priv {
-                            self.tcx.sess.span_err(expr.span,
-                                                   "cannot invoke tuple struct constructor \
-                                                    with private fields");
-                        }
+                    if any_priv {
+                        self.tcx.sess.span_err(expr.span,
+                                               "cannot invoke tuple struct construcor \
+                                                with private fields");
                     }
                 }
             }
diff --git a/src/librustc_trans/trans/common.rs b/src/librustc_trans/trans/common.rs
@@ -49,6 +49,7 @@ use std::cell::{Cell, RefCell};
 use std::result::Result as StdResult;
 use std::vec::Vec;
 use syntax::ast;
+use syntax::ast_util::local_def;
 use syntax::codemap::{DUMMY_SP, Span};
 use syntax::parse::token::InternedString;
 use syntax::parse::token;
@@ -282,14 +283,14 @@ pub struct VariantInfo<'tcx> {
 impl<'tcx> VariantInfo<'tcx> {
     pub fn from_ty(tcx: &ty::ctxt<'tcx>,
                    ty: Ty<'tcx>,
-                   opt_vid: Option<ast::DefId>)
+                   opt_def: Option<def::Def>)
                    -> Self
     {
         match ty.sty {
             ty::TyStruct(adt, substs) | ty::TyEnum(adt, substs) => {
-                let variant = match opt_vid {
+                let variant = match opt_def {
                     None => adt.struct_variant(),
-                    Some(vid) => adt.variant_with_id(vid)
+                    Some(def) => adt.variant_of_def(def)
                 };
 
                 VariantInfo {
@@ -319,8 +320,8 @@ impl<'tcx> VariantInfo<'tcx> {
 
     /// Return the variant corresponding to a given node (e.g. expr)
     pub fn of_node(tcx: &ty::ctxt<'tcx>, ty: Ty<'tcx>, id: ast::NodeId) -> Self {
-        let vid = tcx.def_map.borrow().get(&id).unwrap().full_def().def_id();
-        Self::from_ty(tcx, ty, Some(vid))
+        let node_def = tcx.def_map.borrow().get(&id).map(|v| v.full_def());
+        Self::from_ty(tcx, ty, node_def)
     }
 
     pub fn field_index(&self, name: ast::Name) -> usize {
@@ -1243,9 +1244,18 @@ pub fn inlined_variant_def<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>,
                                      inlined_vid: ast::NodeId)
                                      -> &'tcx ty::VariantDef<'tcx>
 {
-    let adt_def = ccx.tcx().node_id_to_type(inlined_vid).ty_adt_def().unwrap();
+    let ctor_ty = ccx.tcx().node_id_to_type(inlined_vid);
+    debug!("inlined_variant_def: ctor_ty={:?} inlined_vid={:?}", ctor_ty,
+           inlined_vid);
+    let adt_def = match ctor_ty.sty {
+        ty::TyBareFn(_, &ty::BareFnTy { sig: ty::Binder(ty::FnSig {
+            output: ty::FnConverging(ty), ..
+        }), ..}) => ty,
+        _ => ctor_ty
+    }.ty_adt_def().unwrap();
     adt_def.variants.iter().find(|v| {
-        ccx.external().borrow().get(&v.did) == Some(&Some(inlined_vid))
+        local_def(inlined_vid) == v.did ||
+            ccx.external().borrow().get(&v.did) == Some(&Some(inlined_vid))
     }).unwrap_or_else(|| {
         ccx.sess().bug(&format!("no variant for {:?}::{}", adt_def, inlined_vid))
     })
diff --git a/src/librustc_trans/trans/consts.rs b/src/librustc_trans/trans/consts.rs
@@ -662,8 +662,8 @@ fn const_expr_unadjusted<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>,
                 }
             }
             unsafe { match (
-                CastTy::from_ty(cx.tcx(), t_expr).expect("bad input type for cast"),
-                CastTy::from_ty(cx.tcx(), t_cast).expect("bad output type for cast"),
+                CastTy::from_ty(t_expr).expect("bad input type for cast"),
+                CastTy::from_ty(t_cast).expect("bad output type for cast"),
             ) {
                 (CastTy::Int(IntTy::CEnum), CastTy::Int(_)) => {
                     let repr = adt::represent_type(cx, t_expr);
@@ -747,8 +747,7 @@ fn const_expr_unadjusted<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>,
             };
 
             let VariantInfo { discr, fields } = VariantInfo::of_node(cx.tcx(), ety, e.id);
-
-            let cs = fields.iter().enumerate().map(|(ix, &Field(f_name, f_ty))| {
+            let cs = fields.iter().enumerate().map(|(ix, &Field(f_name, _))| {
                 match (fs.iter().find(|f| f_name == f.ident.node.name), base_val) {
                     (Some(ref f), _) => const_expr(cx, &*f.expr, param_substs, fn_args).0,
                     (_, Some((bv, _))) => adt::const_get_field(cx, &*repr, bv, discr, ix),
diff --git a/src/librustc_trans/trans/debuginfo/metadata.rs b/src/librustc_trans/trans/debuginfo/metadata.rs
@@ -27,7 +27,7 @@ use metadata::csearch;
 use middle::pat_util;
 use middle::subst::{self, Substs};
 use rustc::ast_map;
-use trans::{type_of, adt, machine, monomorphize};
+use trans::{type_of, adt, machine};
 use trans::common::{self, CrateContext, FunctionContext, Block, Field};
 use trans::_match::{BindingInfo, TransBindingMode};
 use trans::type_::Type;
@@ -44,7 +44,7 @@ use std::rc::Rc;
 use syntax::util::interner::Interner;
 use syntax::codemap::Span;
 use syntax::{ast, codemap, ast_util};
-use syntax::parse::token::{self, special_idents};
+use syntax::parse::token;
 
 
 const DW_LANG_RUST: c_uint = 0x9000;
@@ -784,11 +784,9 @@ pub fn type_metadata<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>,
                                    unique_type_id,
                                    usage_site_span).finalize(cx)
         }
-        ty::TyStruct(def, substs) => {
+        ty::TyStruct(..) => {
             prepare_struct_metadata(cx,
                                     t,
-                                    def.did,
-                                    substs,
                                     unique_type_id,
                                     usage_site_span).finalize(cx)
         }
@@ -1145,11 +1143,10 @@ impl<'tcx> StructMemberDescriptionFactory<'tcx> {
 
 fn prepare_struct_metadata<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>,
                                      struct_type: Ty<'tcx>,
-                                     def_id: ast::DefId,
-                                     substs: &subst::Substs<'tcx>,
                                      unique_type_id: UniqueTypeId,
                                      span: Span)
                                      -> RecursiveTypeDescription<'tcx> {
+    let def_id = struct_type.ty_to_def_id().unwrap();
     let struct_name = compute_debuginfo_type_name(cx, struct_type, false);
     let struct_llvm_type = type_of::in_memory_type_of(cx, struct_type);
 
diff --git a/src/librustc_trans/trans/expr.rs b/src/librustc_trans/trans/expr.rs
@@ -68,7 +68,6 @@ use trans::debuginfo::{self, DebugLoc, ToDebugLoc};
 use trans::glue;
 use trans::machine;
 use trans::meth;
-use trans::monomorphize;
 use trans::tvec;
 use trans::type_of;
 use middle::cast::{CastKind, CastTy};
@@ -743,7 +742,7 @@ fn trans_rec_field<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
                                base: &ast::Expr,
                                field: ast::Name)
                                -> DatumBlock<'blk, 'tcx, Expr> {
-    trans_field(bcx, base, |tcx, vinfo| vinfo.field_index(field))
+    trans_field(bcx, base, |_, vinfo| vinfo.field_index(field))
 }
 
 /// Translates `base.<idx>`.
@@ -2049,8 +2048,8 @@ fn trans_imm_cast<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
         }
     }
 
-    let r_t_in = CastTy::from_ty(bcx.tcx(), t_in).expect("bad input type for cast");
-    let r_t_out = CastTy::from_ty(bcx.tcx(), t_out).expect("bad output type for cast");
+    let r_t_in = CastTy::from_ty(t_in).expect("bad input type for cast");
+    let r_t_out = CastTy::from_ty(t_out).expect("bad output type for cast");
 
     let (llexpr, signed) = if let Int(CEnum) = r_t_in {
         let repr = adt::represent_type(ccx, t_in);
diff --git a/src/librustc_trans/trans/monomorphize.rs b/src/librustc_trans/trans/monomorphize.rs
@@ -29,7 +29,6 @@ use middle::ty::{self, HasTypeFlags, Ty};
 
 use syntax::abi;
 use syntax::ast;
-use syntax::ast_util::local_def;
 use syntax::attr;
 use syntax::codemap::DUMMY_SP;
 use std::hash::{Hasher, Hash, SipHasher};
diff --git a/src/librustc_typeck/check/cast.rs b/src/librustc_typeck/check/cast.rs
@@ -224,8 +224,8 @@ impl<'tcx> CastCheck<'tcx> {
         use middle::cast::IntTy::*;
         use middle::cast::CastTy::*;
 
-        let (t_from, t_cast) = match (CastTy::from_ty(fcx.tcx(), self.expr_ty),
-                                      CastTy::from_ty(fcx.tcx(), self.cast_ty)) {
+        let (t_from, t_cast) = match (CastTy::from_ty(self.expr_ty),
+                                      CastTy::from_ty(self.cast_ty)) {
             (Some(t_from), Some(t_cast)) => (t_from, t_cast),
             _ => {
                 return Err(CastError::NonScalar)
diff --git a/src/librustc_typeck/check/mod.rs b/src/librustc_typeck/check/mod.rs
@@ -2965,6 +2965,7 @@ fn check_expr_with_unifier<'a, 'tcx, F>(fcx: &FnCtxt<'a, 'tcx>,
                     ty::TyStruct(base_def, substs) => {
                         if base_def.struct_variant().is_tuple_struct() {
                             debug!("tuple struct named {:?}",  base_t);
+                            tuple_like = true;
                             base_def.struct_variant()
                                     .fields
                                     .get(idx.node)

Original file line number	Diff line number	Diff line change
`@@ -58,8 +58,7 @@ pub enum CastKind {`
`58`	`58`	`}`
`59`	`59`
`60`	`60`	`impl<'tcx> CastTy<'tcx> {`
`61`		`- pub fn from_ty(tcx: &ty::ctxt<'tcx>, t: Ty<'tcx>)`
`62`		`- -> Option<CastTy<'tcx>> {`
	`61`	`+ pub fn from_ty(t: Ty<'tcx>) -> Option<CastTy<'tcx>> {`
`63`	`62`	`match t.sty {`
`64`	`63`	`ty::TyBool => Some(CastTy::Int(IntTy::Bool)),`
`65`	`64`	`ty::TyChar => Some(CastTy::Int(IntTy::Char)),`
Original file line number	Diff line number	Diff line change
`@@ -110,8 +110,6 @@ impl<'a, 'tcx> MarkSymbolVisitor<'a, 'tcx> {`
`110`	`110`	`fn handle_tup_field_access(&mut self, lhs: &ast::Expr, idx: usize) {`
`111`	`111`	`if let ty::TyStruct(def, _) = self.tcx.expr_ty_adjusted(lhs).sty {`
`112`	`112`	`self.live_symbols.insert(def.struct_variant().fields[idx].did.node);`
`113`		`- } else {`
`114`		`- self.tcx.sess.span_bug(lhs.span, "indexed field access on non-struct")`
`115`	`113`	`}`
`116`	`114`	`}`
`117`	`115`
Original file line number	Diff line number	Diff line change
`@@ -3287,6 +3287,8 @@ pub struct VariantDef_<'tcx, 'lt: 'tcx> {`
`3287`	`3287`	`}`
`3288`	`3288`
`3289`	`3289`	`pub struct FieldDef_<'tcx, 'lt: 'tcx> {`
	`3290`	`+ /// The field's def-id. Be aware that tuple-like enum fields`
	`3291`	`+ /// are currently not real items (you can't e.g. lookup_item_type them).`
`3290`	`3292`	`pub did: DefId,`
`3291`	`3293`	`// special_idents::unnamed_field.name`
`3292`	`3294`	`// if this is a tuple-like field`
`@@ -3424,7 +3426,8 @@ impl<'tcx, 'lt> ADTDef_<'tcx, 'lt> {`
`3424`	`3426`	`}`
`3425`	`3427`
`3426`	`3428`	`pub fn is_payloadfree(&self) -> bool {`
`3427`		`- self.variants.iter().all(\|v\| v.fields.is_empty())`
	`3429`	`+ !self.variants.is_empty() &&`
	`3430`	`+ self.variants.iter().all(\|v\| v.fields.is_empty())`
`3428`	`3431`	`}`
`3429`	`3432`
`3430`	`3433`	`pub fn variant_with_id(&self, vid: DefId) -> &VariantDef_<'tcx, 'lt> {`
`@@ -3437,11 +3440,8 @@ impl<'tcx, 'lt> ADTDef_<'tcx, 'lt> {`
`3437`	`3440`	`pub fn variant_of_def(&self, def: def::Def) -> &VariantDef_<'tcx, 'lt> {`
`3438`	`3441`	`match def {`
`3439`	`3442`	`def::DefVariant(_, vid, _) => self.variant_with_id(vid),`
`3440`		`- def::DefStruct(..) => self.struct_variant(),`
`3441`		`- _ => {`
`3442`		`- debug!("unexpected def {:?} in variant_of_def", def);`
`3443`		`- unreachable!()`
`3444`		`- }`
	`3443`	`+ def::DefStruct(..) \| def::DefTy(..) => self.struct_variant(),`
	`3444`	`+ _ => panic!("unexpected def {:?} in variant_of_def", def)`
`3445`	`3445`	`}`
`3446`	`3446`	`}`
`3447`	`3447`	`}`