Separate Def::StructCtor/Def::VariantCtor from Def::Struct/Def::Variant

Author: petrochenkov

src/librustc/hir/def.rs

@@ -13,6 +13,16 @@ use util::nodemap::NodeMap;
 use syntax::ast;
 use hir;
 
+#[derive(Clone, Copy, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)]
+pub enum CtorKind {
+    // Constructor function automatically created by a tuple struct/variant.
+    Fn,
+    // Constructor constant automatically created by a unit struct/variant.
+    Const,
+    // Unusable name in value namespace created by a struct variant.
+    Fictive,
+}
+
 #[derive(Clone, Copy, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)]
 pub enum Def {
     Fn(DefId),
@@ -23,21 +33,18 @@ pub enum Def {
     AssociatedConst(DefId),
     Local(DefId),
     Variant(DefId),
+    VariantCtor(DefId, CtorKind),
     Enum(DefId),
     TyAlias(DefId),
     AssociatedTy(DefId),
     Trait(DefId),
     PrimTy(hir::PrimTy),
     TyParam(DefId),
     Upvar(DefId,        // def id of closed over local
-             usize,        // index in the freevars list of the closure
-             ast::NodeId), // expr node that creates the closure
-
-    // If Def::Struct lives in type namespace it denotes a struct item and its DefId refers
-    // to NodeId of the struct itself.
-    // If Def::Struct lives in value namespace (e.g. tuple struct, unit struct expressions)
-    // it denotes a constructor and its DefId refers to NodeId of the struct's constructor.
-    Struct(DefId),
+          usize,        // index in the freevars list of the closure
+          ast::NodeId), // expr node that creates the closure
+    Struct(DefId), // DefId refers to NodeId of the struct itself
+    StructCtor(DefId, CtorKind), // DefId refers to NodeId of the struct's constructor
     Union(DefId),
     Label(ast::NodeId),
     Method(DefId),
@@ -97,14 +104,24 @@ pub struct Export {
     pub def_id: DefId, // The definition of the target.
 }
 
+impl CtorKind {
+    pub fn from_vdata(vdata: &ast::VariantData) -> CtorKind {
+        match *vdata {
+            ast::VariantData::Tuple(..) => CtorKind::Fn,
+            ast::VariantData::Unit(..) => CtorKind::Const,
+            ast::VariantData::Struct(..) => CtorKind::Fictive,
+        }
+    }
+}
+
 impl Def {
     pub fn def_id(&self) -> DefId {
         match *self {
             Def::Fn(id) | Def::Mod(id) | Def::Static(id, _) |
-            Def::Variant(id) | Def::Enum(id) | Def::TyAlias(id) | Def::AssociatedTy(id) |
-            Def::TyParam(id) | Def::Struct(id) | Def::Union(id) | Def::Trait(id) |
-            Def::Method(id) | Def::Const(id) | Def::AssociatedConst(id) |
-            Def::Local(id) | Def::Upvar(id, ..) => {
+            Def::Variant(id) | Def::VariantCtor(id, ..) | Def::Enum(id) | Def::TyAlias(id) |
+            Def::AssociatedTy(id) | Def::TyParam(id) | Def::Struct(id) | Def::StructCtor(id, ..) |
+            Def::Union(id) | Def::Trait(id) | Def::Method(id) | Def::Const(id) |
+            Def::AssociatedConst(id) | Def::Local(id) | Def::Upvar(id, ..) => {
                 id
             }
 
@@ -123,10 +140,12 @@ impl Def {
             Def::Mod(..) => "module",
             Def::Static(..) => "static",
             Def::Variant(..) => "variant",
+            Def::VariantCtor(..) => "variant",
             Def::Enum(..) => "enum",
             Def::TyAlias(..) => "type",
             Def::AssociatedTy(..) => "associated type",
             Def::Struct(..) => "struct",
+            Def::StructCtor(..) => "struct",
             Def::Union(..) => "union",
             Def::Trait(..) => "trait",
             Def::Method(..) => "method",

src/librustc/hir/pat_util.rs

@@ -174,7 +174,8 @@ pub fn necessary_variants(dm: &DefMap, pat: &hir::Pat) -> Vec<DefId> {
             PatKind::Path(..) |
             PatKind::Struct(..) => {
                 match dm.get(&p.id) {
-                    Some(&PathResolution { base_def: Def::Variant(id), .. }) => {
+                    Some(&PathResolution { base_def: Def::Variant(id), .. }) |
+                    Some(&PathResolution { base_def: Def::VariantCtor(id, ..), .. }) => {
                         variants.push(id);
                     }
                     _ => ()

src/librustc/middle/dead.rs

@@ -108,7 +108,7 @@ impl<'a, 'tcx> MarkSymbolVisitor<'a, 'tcx> {
             _ if self.ignore_non_const_paths => (),
             Def::PrimTy(_) => (),
             Def::SelfTy(..) => (),
-            Def::Variant(variant_id) => {
+            Def::Variant(variant_id) | Def::VariantCtor(variant_id, ..) => {
                 if let Some(enum_id) = self.tcx.parent_def_id(variant_id) {
                     self.check_def_id(enum_id);
                 }

src/librustc/middle/expr_use_visitor.rs

@@ -1003,7 +1003,8 @@ impl<'a, 'gcx, 'tcx> ExprUseVisitor<'a, 'gcx, 'tcx> {
         // the leaves of the pattern tree structure.
         return_if_err!(mc.cat_pattern(cmt_discr, pat, |mc, cmt_pat, pat| {
             match tcx.expect_def_or_none(pat.id) {
-                Some(Def::Variant(variant_did)) => {
+                Some(Def::Variant(variant_did)) |
+                Some(Def::VariantCtor(variant_did, ..)) => {
                     let enum_did = tcx.parent_def_id(variant_did).unwrap();
                     let downcast_cmt = if tcx.lookup_adt_def(enum_did).is_univariant() {
                         cmt_pat
@@ -1015,7 +1016,7 @@ impl<'a, 'gcx, 'tcx> ExprUseVisitor<'a, 'gcx, 'tcx> {
                     debug!("variant downcast_cmt={:?} pat={:?}", downcast_cmt, pat);
                     delegate.matched_pat(pat, downcast_cmt, match_mode);
                 }
-                Some(Def::Struct(..)) | Some(Def::Union(..)) |
+                Some(Def::Struct(..)) | Some(Def::StructCtor(..)) | Some(Def::Union(..)) |
                 Some(Def::TyAlias(..)) | Some(Def::AssociatedTy(..)) => {
                     debug!("struct cmt_pat={:?} pat={:?}", cmt_pat, pat);
                     delegate.matched_pat(pat, cmt_pat, match_mode);

src/librustc/middle/mem_categorization.rs

@@ -524,7 +524,7 @@ impl<'a, 'gcx, 'tcx> MemCategorizationContext<'a, 'gcx, 'tcx> {
                id, expr_ty, def);
 
         match def {
-          Def::Struct(..) | Def::Union(..) | Def::Variant(..) | Def::Const(..) |
+          Def::StructCtor(..) | Def::Union(..) | Def::VariantCtor(..) | Def::Const(..) |
           Def::AssociatedConst(..) | Def::Fn(..) | Def::Method(..) => {
                 Ok(self.cat_rvalue_node(id, span, expr_ty))
           }
@@ -533,6 +533,8 @@ impl<'a, 'gcx, 'tcx> MemCategorizationContext<'a, 'gcx, 'tcx> {
           Def::Trait(_) | Def::Enum(..) | Def::TyAlias(..) | Def::PrimTy(_) |
           Def::TyParam(..) |
           Def::Label(_) | Def::SelfTy(..) |
+          Def::Variant(..) |
+          Def::Struct(..) |
           Def::AssociatedTy(..) => {
               span_bug!(span, "Unexpected definition in \
                                memory categorization: {:?}", def);
@@ -1077,7 +1079,8 @@ impl<'a, 'gcx, 'tcx> MemCategorizationContext<'a, 'gcx, 'tcx> {
         // alone) because PatKind::Struct can also refer to variants.
         let cmt = match self.tcx().expect_def_or_none(pat.id) {
             Some(Def::Err) => return Err(()),
-            Some(Def::Variant(variant_did)) => {
+            Some(Def::Variant(variant_did)) |
+            Some(Def::VariantCtor(variant_did, ..)) => {
                 // univariant enums do not need downcasts
                 let enum_did = self.tcx().parent_def_id(variant_did).unwrap();
                 if !self.tcx().lookup_adt_def(enum_did).is_univariant() {
@@ -1092,11 +1095,11 @@ impl<'a, 'gcx, 'tcx> MemCategorizationContext<'a, 'gcx, 'tcx> {
         match pat.node {
           PatKind::TupleStruct(_, ref subpats, ddpos) => {
             let expected_len = match self.tcx().expect_def(pat.id) {
-                Def::Variant(def_id) => {
+                Def::VariantCtor(def_id, ..) => {
                     let enum_def = self.tcx().parent_def_id(def_id).unwrap();
                     self.tcx().lookup_adt_def(enum_def).variant_with_id(def_id).fields.len()
                 }
-                Def::Struct(..) => {
+                Def::StructCtor(..) => {
                     match self.pat_ty(&pat)?.sty {
                         ty::TyAdt(adt_def, _) => {
                             adt_def.struct_variant().fields.len()

src/librustc/ty/mod.rs

@@ -20,7 +20,7 @@ pub use self::fold::TypeFoldable;
 use dep_graph::{self, DepNode};
 use hir::map as ast_map;
 use middle;
-use hir::def::{Def, PathResolution, ExportMap};
+use hir::def::{Def, CtorKind, PathResolution, ExportMap};
 use hir::def_id::{CrateNum, DefId, CRATE_DEF_INDEX, LOCAL_CRATE};
 use middle::lang_items::{FnTraitLangItem, FnMutTraitLangItem, FnOnceTraitLangItem};
 use middle::region::{CodeExtent, ROOT_CODE_EXTENT};
@@ -1496,6 +1496,13 @@ impl VariantKind {
             hir::VariantData::Unit(..) => VariantKind::Unit,
         }
     }
+    pub fn ctor_kind(self) -> CtorKind {
+        match self {
+            VariantKind::Tuple => CtorKind::Fn,
+            VariantKind::Unit => CtorKind::Const,
+            VariantKind::Struct => CtorKind::Fictive,
+        }
+    }
 }
 
 impl<'a, 'gcx, 'tcx, 'container> AdtDefData<'gcx, 'container> {
@@ -1673,8 +1680,8 @@ impl<'a, 'gcx, 'tcx, 'container> AdtDefData<'gcx, 'container> {
 
     pub fn variant_of_def(&self, def: Def) -> &VariantDefData<'gcx, 'container> {
         match def {
-            Def::Variant(vid) => self.variant_with_id(vid),
-            Def::Struct(..) | Def::Union(..) |
+            Def::Variant(vid) | Def::VariantCtor(vid, ..) => self.variant_with_id(vid),
+            Def::Struct(..) | Def::StructCtor(..) | Def::Union(..) |
             Def::TyAlias(..) | Def::AssociatedTy(..) => self.struct_variant(),
             _ => bug!("unexpected def {:?} in variant_of_def", def)
         }
@@ -2332,11 +2339,11 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> {
     // or variant or their constructors, panics otherwise.
     pub fn expect_variant_def(self, def: Def) -> VariantDef<'tcx> {
         match def {
-            Def::Variant(did) => {
+            Def::Variant(did) | Def::VariantCtor(did, ..) => {
                 let enum_did = self.parent_def_id(did).unwrap();
                 self.lookup_adt_def(enum_did).variant_with_id(did)
             }
-            Def::Struct(did) | Def::Union(did) => {
+            Def::Struct(did) | Def::StructCtor(did, ..) | Def::Union(did) => {
                 self.lookup_adt_def(did).struct_variant()
             }
             _ => bug!("expect_variant_def used with unexpected def {:?}", def)

src/librustc_const_eval/check_match.rs

@@ -801,8 +801,8 @@ fn pat_constructors(cx: &MatchCheckCtxt, p: &Pat,
     match pat.node {
         PatKind::Struct(..) | PatKind::TupleStruct(..) | PatKind::Path(..) =>
             match cx.tcx.expect_def(pat.id) {
-                Def::Variant(id) => vec![Variant(id)],
-                Def::Struct(..) | Def::Union(..) |
+                Def::Variant(id) | Def::VariantCtor(id, ..) => vec![Variant(id)],
+                Def::Struct(..) | Def::StructCtor(..) | Def::Union(..) |
                 Def::TyAlias(..) | Def::AssociatedTy(..) => vec![Single],
                 Def::Const(..) | Def::AssociatedConst(..) =>
                     span_bug!(pat.span, "const pattern should've been rewritten"),
@@ -913,8 +913,8 @@ pub fn specialize<'a, 'b, 'tcx>(
                 Def::Const(..) | Def::AssociatedConst(..) =>
                     span_bug!(pat_span, "const pattern should've \
                                          been rewritten"),
-                Def::Variant(id) if *constructor != Variant(id) => None,
-                Def::Variant(..) | Def::Struct(..) => Some(Vec::new()),
+                Def::VariantCtor(id, ..) if *constructor != Variant(id) => None,
+                Def::VariantCtor(..) | Def::StructCtor(..) => Some(Vec::new()),
                 def => span_bug!(pat_span, "specialize: unexpected \
                                           definition {:?}", def),
             }
@@ -925,8 +925,8 @@ pub fn specialize<'a, 'b, 'tcx>(
                 Def::Const(..) | Def::AssociatedConst(..) =>
                     span_bug!(pat_span, "const pattern should've \
                                          been rewritten"),
-                Def::Variant(id) if *constructor != Variant(id) => None,
-                Def::Variant(..) | Def::Struct(..) => {
+                Def::VariantCtor(id, ..) if *constructor != Variant(id) => None,
+                Def::VariantCtor(..) | Def::StructCtor(..) => {
                     match ddpos {
                         Some(ddpos) => {
                             let mut pats: Vec<_> = args[..ddpos].iter().map(|p| {

src/librustc_const_eval/eval.rs

@@ -287,8 +287,8 @@ pub fn const_expr_to_pat<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
                entry.insert(PathResolution::new(def));
             }
             let path = match def {
-                Def::Struct(def_id) => def_to_path(tcx, def_id),
-                Def::Variant(variant_did) => def_to_path(tcx, variant_did),
+                Def::StructCtor(def_id, ..) => def_to_path(tcx, def_id),
+                Def::VariantCtor(variant_did, ..) => def_to_path(tcx, variant_did),
                 Def::Fn(..) | Def::Method(..) => return Ok(P(hir::Pat {
                     id: expr.id,
                     node: PatKind::Lit(P(expr.clone())),
@@ -326,7 +326,7 @@ pub fn const_expr_to_pat<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
 
         hir::ExprPath(_, ref path) => {
             match tcx.expect_def(expr.id) {
-                Def::Struct(..) | Def::Variant(..) => PatKind::Path(None, path.clone()),
+                Def::StructCtor(..) | Def::VariantCtor(..) => PatKind::Path(None, path.clone()),
                 Def::Const(def_id) | Def::AssociatedConst(def_id) => {
                     let substs = Some(tcx.node_id_item_substs(expr.id).substs);
                     let (expr, _ty) = lookup_const_by_id(tcx, def_id, substs).unwrap();
@@ -807,7 +807,7 @@ pub fn eval_const_expr_partial<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
                       signal!(e, NonConstPath);
                   }
               },
-              Def::Variant(variant_def) => {
+              Def::VariantCtor(variant_def, ..) => {
                   if let Some(const_expr) = lookup_variant_by_id(tcx, variant_def) {
                       match eval_const_expr_partial(tcx, const_expr, ty_hint, None) {
                           Ok(val) => val,
@@ -820,7 +820,7 @@ pub fn eval_const_expr_partial<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
                       signal!(e, UnimplementedConstVal("enum variants"));
                   }
               }
-              Def::Struct(..) => {
+              Def::StructCtor(..) => {
                   ConstVal::Struct(e.id)
               }
               Def::Local(def_id) => {

src/librustc_incremental/calculate_svh/svh_visitor.rs

@@ -611,11 +611,13 @@ impl<'a, 'hash, 'tcx> StrictVersionHashVisitor<'a, 'hash, 'tcx> {
             Def::Mod(..) |
             Def::Static(..) |
             Def::Variant(..) |
+            Def::VariantCtor(..) |
             Def::Enum(..) |
             Def::TyAlias(..) |
             Def::AssociatedTy(..) |
             Def::TyParam(..) |
             Def::Struct(..) |
+            Def::StructCtor(..) |
             Def::Union(..) |
             Def::Trait(..) |
             Def::Method(..) |

src/librustc_mir/hair/cx/expr.rs

@@ -15,7 +15,7 @@ use hair::cx::Cx;
 use hair::cx::block;
 use hair::cx::to_ref::ToRef;
 use rustc::hir::map;
-use rustc::hir::def::Def;
+use rustc::hir::def::{Def, CtorKind};
 use rustc::middle::const_val::ConstVal;
 use rustc_const_eval as const_eval;
 use rustc::middle::region::CodeExtent;
@@ -271,10 +271,10 @@ fn make_mirror_unadjusted<'a, 'gcx, 'tcx>(cx: &mut Cx<'a, 'gcx, 'tcx>,
                     // Tuple-like ADTs are represented as ExprCall. We convert them here.
                     expr_ty.ty_adt_def().and_then(|adt_def|{
                         match cx.tcx.expect_def(fun.id) {
-                            Def::Variant(variant_id) => {
+                            Def::VariantCtor(variant_id, ..) => {
                                 Some((adt_def, adt_def.variant_index_with_id(variant_id)))
                             },
-                            Def::Struct(..) => {
+                            Def::StructCtor(..) => {
                                 Some((adt_def, 0))
                             },
                             _ => None
@@ -672,10 +672,9 @@ fn convert_path_expr<'a, 'gcx, 'tcx>(cx: &mut Cx<'a, 'gcx, 'tcx>,
     let def_id = match def {
         // A regular function.
         Def::Fn(def_id) | Def::Method(def_id) => def_id,
-        Def::Struct(def_id) => match cx.tcx.node_id_to_type(expr.id).sty {
-            // A tuple-struct constructor. Should only be reached if not called in the same
-            // expression.
-            ty::TyFnDef(..) => def_id,
+        Def::StructCtor(def_id, CtorKind::Fn) |
+        Def::VariantCtor(def_id, CtorKind::Fn) => def_id,
+        Def::StructCtor(_, CtorKind::Const) => match cx.tcx.node_id_to_type(expr.id).sty {
             // A unit struct which is used as a value. We return a completely different ExprKind
             // here to account for this special case.
             ty::TyAdt(adt_def, substs) => return ExprKind::Adt {
@@ -687,13 +686,10 @@ fn convert_path_expr<'a, 'gcx, 'tcx>(cx: &mut Cx<'a, 'gcx, 'tcx>,
             },
             ref sty => bug!("unexpected sty: {:?}", sty)
         },
-        Def::Variant(variant_id) => match cx.tcx.node_id_to_type(expr.id).sty {
-            // A variant constructor. Should only be reached if not called in the same
-            // expression.
-            ty::TyFnDef(..) => variant_id,
+        Def::VariantCtor(def_id, CtorKind::Const) => match cx.tcx.node_id_to_type(expr.id).sty {
             // A unit variant, similar special case to the struct case above.
             ty::TyAdt(adt_def, substs) => {
-                let index = adt_def.variant_index_with_id(variant_id);
+                let index = adt_def.variant_index_with_id(def_id);
                 return ExprKind::Adt {
                     adt_def: adt_def,
                     substs: substs,