1 // Copyright 2014 The Rust Project Developers. See the COPYRIGHT
2 // file at the top-level directory of this distribution and at
3 // http://rust-lang.org/COPYRIGHT.
5 // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
6 // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
7 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
8 // option. This file may not be copied, modified, or distributed
9 // except according to those terms.
11 use hir::def_id::DefId;
12 use util::nodemap::NodeMap;
14 use syntax::ext::base::MacroKind;
18 #[derive(Clone, Copy, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)]
20 /// Constructor function automatically created by a tuple struct/variant.
22 /// Constructor constant automatically created by a unit struct/variant.
24 /// Unusable name in value namespace created by a struct variant.
28 #[derive(Clone, Copy, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)]
32 Struct(DefId), // DefId refers to NodeId of the struct itself
41 SelfTy(Option<DefId> /* trait */, Option<DefId> /* impl */),
46 Static(DefId, bool /* is_mutbl */),
47 StructCtor(DefId, CtorKind), // DefId refers to NodeId of the struct's constructor
48 VariantCtor(DefId, CtorKind),
50 AssociatedConst(DefId),
53 Upvar(ast::NodeId, // node id of closed over local
54 usize, // index in the freevars list of the closure
55 ast::NodeId), // expr node that creates the closure
59 Macro(DefId, MacroKind),
67 /// The result of resolving a path before lowering to HIR.
68 /// `base_def` is definition of resolved part of the
69 /// path, `unresolved_segments` is the number of unresolved
71 /// module::Type::AssocX::AssocY::MethodOrAssocType
72 /// ^~~~~~~~~~~~ ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
73 /// base_def unresolved_segments = 3
75 /// <T as Trait>::AssocX::AssocY::MethodOrAssocType
76 /// ^~~~~~~~~~~~~~ ^~~~~~~~~~~~~~~~~~~~~~~~~
77 /// base_def unresolved_segments = 2
78 #[derive(Copy, Clone, Debug)]
79 pub struct PathResolution {
81 unresolved_segments: usize,
85 pub fn new(def: Def) -> Self {
86 PathResolution { base_def: def, unresolved_segments: 0 }
89 pub fn with_unresolved_segments(def: Def, mut unresolved_segments: usize) -> Self {
90 if def == Def::Err { unresolved_segments = 0 }
91 PathResolution { base_def: def, unresolved_segments: unresolved_segments }
95 pub fn base_def(&self) -> Def {
100 pub fn unresolved_segments(&self) -> usize {
101 self.unresolved_segments
104 pub fn kind_name(&self) -> &'static str {
105 if self.unresolved_segments != 0 {
108 self.base_def.kind_name()
113 /// Definition mapping
114 pub type DefMap = NodeMap<PathResolution>;
116 /// This is the replacement export map. It maps a module to all of the exports
118 pub type ExportMap = NodeMap<Vec<Export>>;
120 #[derive(Copy, Clone, Debug, RustcEncodable, RustcDecodable)]
122 /// The name of the target.
123 pub ident: ast::Ident,
124 /// The definition of the target.
126 /// The span of the target definition.
131 pub fn from_ast(vdata: &ast::VariantData) -> CtorKind {
133 ast::VariantData::Tuple(..) => CtorKind::Fn,
134 ast::VariantData::Unit(..) => CtorKind::Const,
135 ast::VariantData::Struct(..) => CtorKind::Fictive,
138 pub fn from_hir(vdata: &hir::VariantData) -> CtorKind {
140 hir::VariantData::Tuple(..) => CtorKind::Fn,
141 hir::VariantData::Unit(..) => CtorKind::Const,
142 hir::VariantData::Struct(..) => CtorKind::Fictive,
148 pub fn def_id(&self) -> DefId {
150 Def::Fn(id) | Def::Mod(id) | Def::Static(id, _) |
151 Def::Variant(id) | Def::VariantCtor(id, ..) | Def::Enum(id) | Def::TyAlias(id) |
152 Def::AssociatedTy(id) | Def::TyParam(id) | Def::Struct(id) | Def::StructCtor(id, ..) |
153 Def::Union(id) | Def::Trait(id) | Def::Method(id) | Def::Const(id) |
154 Def::AssociatedConst(id) | Def::Macro(id, ..) |
155 Def::GlobalAsm(id) => {
165 bug!("attempted .def_id() on invalid def: {:?}", self)
170 /// A human readable kind name
171 pub fn kind_name(&self) -> &'static str {
173 Def::Fn(..) => "function",
174 Def::Mod(..) => "module",
175 Def::Static(..) => "static",
176 Def::Variant(..) => "variant",
177 Def::VariantCtor(.., CtorKind::Fn) => "tuple variant",
178 Def::VariantCtor(.., CtorKind::Const) => "unit variant",
179 Def::VariantCtor(.., CtorKind::Fictive) => "struct variant",
180 Def::Enum(..) => "enum",
181 Def::TyAlias(..) => "type alias",
182 Def::AssociatedTy(..) => "associated type",
183 Def::Struct(..) => "struct",
184 Def::StructCtor(.., CtorKind::Fn) => "tuple struct",
185 Def::StructCtor(.., CtorKind::Const) => "unit struct",
186 Def::StructCtor(.., CtorKind::Fictive) => bug!("impossible struct constructor"),
187 Def::Union(..) => "union",
188 Def::Trait(..) => "trait",
189 Def::Method(..) => "method",
190 Def::Const(..) => "constant",
191 Def::AssociatedConst(..) => "associated constant",
192 Def::TyParam(..) => "type parameter",
193 Def::PrimTy(..) => "builtin type",
194 Def::Local(..) => "local variable",
195 Def::Upvar(..) => "closure capture",
196 Def::Label(..) => "label",
197 Def::SelfTy(..) => "self type",
198 Def::Macro(..) => "macro",
199 Def::GlobalAsm(..) => "global asm",
200 Def::Err => "unresolved item",