]>
Commit | Line | Data |
---|---|---|
6a06907d | 1 | use crate::{ImplTraitContext, Resolver}; |
ba9703b0 XL |
2 | use rustc_ast::visit::{self, FnKind}; |
3 | use rustc_ast::walk_list; | |
3dfed10e | 4 | use rustc_ast::*; |
dfeec247 | 5 | use rustc_expand::expand::AstFragment; |
ba9703b0 XL |
6 | use rustc_hir::def_id::LocalDefId; |
7 | use rustc_hir::definitions::*; | |
136023e0 | 8 | use rustc_span::hygiene::LocalExpnId; |
a2a8927a | 9 | use rustc_span::symbol::sym; |
dfeec247 | 10 | use rustc_span::Span; |
3dfed10e | 11 | use tracing::debug; |
a7813a04 | 12 | |
923072b8 | 13 | pub(crate) fn collect_definitions( |
f035d41b | 14 | resolver: &mut Resolver<'_>, |
60c5eb7d | 15 | fragment: &AstFragment, |
136023e0 | 16 | expansion: LocalExpnId, |
60c5eb7d | 17 | ) { |
6a06907d XL |
18 | let (parent_def, impl_trait_context) = resolver.invocation_parents[&expansion]; |
19 | fragment.visit_with(&mut DefCollector { resolver, parent_def, expansion, impl_trait_context }); | |
60c5eb7d XL |
20 | } |
21 | ||
9fa01778 | 22 | /// Creates `DefId`s for nodes in the AST. |
f035d41b XL |
23 | struct DefCollector<'a, 'b> { |
24 | resolver: &'a mut Resolver<'b>, | |
ba9703b0 | 25 | parent_def: LocalDefId, |
6a06907d | 26 | impl_trait_context: ImplTraitContext, |
136023e0 | 27 | expansion: LocalExpnId, |
c30ab7b3 SL |
28 | } |
29 | ||
f035d41b | 30 | impl<'a, 'b> DefCollector<'a, 'b> { |
ba9703b0 | 31 | fn create_def(&mut self, node_id: NodeId, data: DefPathData, span: Span) -> LocalDefId { |
416331ca | 32 | let parent_def = self.parent_def; |
a7813a04 | 33 | debug!("create_def(node_id={:?}, data={:?}, parent_def={:?})", node_id, data, parent_def); |
c295e0f8 XL |
34 | self.resolver.create_def( |
35 | parent_def, | |
36 | node_id, | |
37 | data, | |
38 | self.expansion.to_expn_id(), | |
39 | span.with_parent(None), | |
40 | ) | |
a7813a04 XL |
41 | } |
42 | ||
ba9703b0 | 43 | fn with_parent<F: FnOnce(&mut Self)>(&mut self, parent_def: LocalDefId, f: F) { |
416331ca | 44 | let orig_parent_def = std::mem::replace(&mut self.parent_def, parent_def); |
a7813a04 | 45 | f(self); |
416331ca | 46 | self.parent_def = orig_parent_def; |
a7813a04 XL |
47 | } |
48 | ||
6a06907d XL |
49 | fn with_impl_trait<F: FnOnce(&mut Self)>( |
50 | &mut self, | |
51 | impl_trait_context: ImplTraitContext, | |
52 | f: F, | |
53 | ) { | |
54 | let orig_itc = std::mem::replace(&mut self.impl_trait_context, impl_trait_context); | |
55 | f(self); | |
56 | self.impl_trait_context = orig_itc; | |
57 | } | |
58 | ||
59 | fn collect_field(&mut self, field: &'a FieldDef, index: Option<usize>) { | |
dfeec247 XL |
60 | let index = |this: &Self| { |
61 | index.unwrap_or_else(|| { | |
62 | let node_id = NodeId::placeholder_from_expn_id(this.expansion); | |
f035d41b | 63 | this.resolver.placeholder_field_indices[&node_id] |
dfeec247 XL |
64 | }) |
65 | }; | |
e74abb32 | 66 | |
e1599b0c | 67 | if field.is_placeholder { |
f035d41b XL |
68 | let old_index = self.resolver.placeholder_field_indices.insert(field.id, index(self)); |
69 | assert!(old_index.is_none(), "placeholder field index is reset for a node ID"); | |
e1599b0c XL |
70 | self.visit_macro_invoc(field.id); |
71 | } else { | |
e74abb32 | 72 | let name = field.ident.map_or_else(|| sym::integer(index(self)), |ident| ident.name); |
e1599b0c | 73 | let def = self.create_def(field.id, DefPathData::ValueNs(name), field.span); |
6a06907d | 74 | self.with_parent(def, |this| visit::walk_field_def(this, field)); |
e1599b0c XL |
75 | } |
76 | } | |
77 | ||
e74abb32 | 78 | fn visit_macro_invoc(&mut self, id: NodeId) { |
6a06907d | 79 | let id = id.placeholder_to_expn_id(); |
f035d41b | 80 | let old_parent = |
6a06907d | 81 | self.resolver.invocation_parents.insert(id, (self.parent_def, self.impl_trait_context)); |
f035d41b | 82 | assert!(old_parent.is_none(), "parent `LocalDefId` is reset for an invocation"); |
c30ab7b3 | 83 | } |
a7813a04 XL |
84 | } |
85 | ||
f035d41b | 86 | impl<'a, 'b> visit::Visitor<'a> for DefCollector<'a, 'b> { |
476ff2be | 87 | fn visit_item(&mut self, i: &'a Item) { |
a7813a04 XL |
88 | debug!("visit_item: {:?}", i); |
89 | ||
90 | // Pick the def data. This need not be unique, but the more | |
94b46f34 | 91 | // information we encapsulate into, the better |
60c5eb7d | 92 | let def_data = match &i.kind { |
dfeec247 | 93 | ItemKind::Impl { .. } => DefPathData::Impl, |
a2a8927a | 94 | ItemKind::ForeignMod(..) => DefPathData::ForeignMod, |
dfeec247 XL |
95 | ItemKind::Mod(..) |
96 | | ItemKind::Trait(..) | |
97 | | ItemKind::TraitAlias(..) | |
98 | | ItemKind::Enum(..) | |
99 | | ItemKind::Struct(..) | |
100 | | ItemKind::Union(..) | |
101 | | ItemKind::ExternCrate(..) | |
dfeec247 | 102 | | ItemKind::TyAlias(..) => DefPathData::TypeNs(i.ident.name), |
dfeec247 XL |
103 | ItemKind::Static(..) | ItemKind::Const(..) | ItemKind::Fn(..) => { |
104 | DefPathData::ValueNs(i.ident.name) | |
8faf50e0 | 105 | } |
e74abb32 | 106 | ItemKind::MacroDef(..) => DefPathData::MacroNs(i.ident.name), |
5869c6ff XL |
107 | ItemKind::MacCall(..) => { |
108 | visit::walk_item(self, i); | |
109 | return self.visit_macro_invoc(i.id); | |
110 | } | |
04454e1e | 111 | ItemKind::GlobalAsm(..) => DefPathData::GlobalAsm, |
ff7c6d11 XL |
112 | ItemKind::Use(..) => { |
113 | return visit::walk_item(self, i); | |
476ff2be | 114 | } |
a7813a04 | 115 | }; |
48663c56 | 116 | let def = self.create_def(i.id, def_data, i.span); |
a7813a04 XL |
117 | |
118 | self.with_parent(def, |this| { | |
6a06907d XL |
119 | this.with_impl_trait(ImplTraitContext::Existential, |this| { |
120 | match i.kind { | |
121 | ItemKind::Struct(ref struct_def, _) | ItemKind::Union(ref struct_def, _) => { | |
122 | // If this is a unit or tuple-like struct, register the constructor. | |
123 | if let Some(ctor_hir_id) = struct_def.ctor_id() { | |
124 | this.create_def(ctor_hir_id, DefPathData::Ctor, i.span); | |
125 | } | |
a7813a04 | 126 | } |
6a06907d | 127 | _ => {} |
a7813a04 | 128 | } |
6a06907d XL |
129 | visit::walk_item(this, i); |
130 | }) | |
a7813a04 XL |
131 | }); |
132 | } | |
133 | ||
ba9703b0 | 134 | fn visit_fn(&mut self, fn_kind: FnKind<'a>, span: Span, _: NodeId) { |
04454e1e | 135 | if let FnKind::Fn(_, _, sig, _, generics, body) = fn_kind { |
ba9703b0 | 136 | if let Async::Yes { closure_id, return_impl_trait_id, .. } = sig.header.asyncness { |
04454e1e FG |
137 | self.visit_generics(generics); |
138 | ||
6a06907d XL |
139 | let return_impl_trait_id = |
140 | self.create_def(return_impl_trait_id, DefPathData::ImplTrait, span); | |
ba9703b0 XL |
141 | |
142 | // For async functions, we need to create their inner defs inside of a | |
143 | // closure to match their desugared representation. Besides that, | |
144 | // we must mirror everything that `visit::walk_fn` below does. | |
145 | self.visit_fn_header(&sig.header); | |
6a06907d XL |
146 | for param in &sig.decl.inputs { |
147 | self.visit_param(param); | |
148 | } | |
149 | self.with_parent(return_impl_trait_id, |this| { | |
150 | this.visit_fn_ret_ty(&sig.decl.output) | |
151 | }); | |
ba9703b0 XL |
152 | let closure_def = self.create_def(closure_id, DefPathData::ClosureExpr, span); |
153 | self.with_parent(closure_def, |this| walk_list!(this, visit_block, body)); | |
154 | return; | |
155 | } | |
156 | } | |
157 | ||
158 | visit::walk_fn(self, fn_kind, span); | |
159 | } | |
160 | ||
ff7c6d11 | 161 | fn visit_use_tree(&mut self, use_tree: &'a UseTree, id: NodeId, _nested: bool) { |
04454e1e | 162 | self.create_def(id, DefPathData::Use, use_tree.span); |
6a06907d XL |
163 | match use_tree.kind { |
164 | UseTreeKind::Simple(_, id1, id2) => { | |
04454e1e FG |
165 | self.create_def(id1, DefPathData::Use, use_tree.prefix.span); |
166 | self.create_def(id2, DefPathData::Use, use_tree.prefix.span); | |
6a06907d XL |
167 | } |
168 | UseTreeKind::Glob => (), | |
169 | UseTreeKind::Nested(..) => {} | |
170 | } | |
ff7c6d11 XL |
171 | visit::walk_use_tree(self, use_tree, id); |
172 | } | |
173 | ||
476ff2be | 174 | fn visit_foreign_item(&mut self, foreign_item: &'a ForeignItem) { |
ba9703b0 | 175 | if let ForeignItemKind::MacCall(_) = foreign_item.kind { |
94b46f34 | 176 | return self.visit_macro_invoc(foreign_item.id); |
83c7162d XL |
177 | } |
178 | ||
dfeec247 XL |
179 | let def = self.create_def( |
180 | foreign_item.id, | |
181 | DefPathData::ValueNs(foreign_item.ident.name), | |
182 | foreign_item.span, | |
183 | ); | |
a7813a04 XL |
184 | |
185 | self.with_parent(def, |this| { | |
186 | visit::walk_foreign_item(this, foreign_item); | |
187 | }); | |
188 | } | |
189 | ||
e1599b0c XL |
190 | fn visit_variant(&mut self, v: &'a Variant) { |
191 | if v.is_placeholder { | |
192 | return self.visit_macro_invoc(v.id); | |
193 | } | |
dfeec247 | 194 | let def = self.create_def(v.id, DefPathData::TypeNs(v.ident.name), v.span); |
532ac7d7 | 195 | self.with_parent(def, |this| { |
e1599b0c | 196 | if let Some(ctor_hir_id) = v.data.ctor_id() { |
48663c56 | 197 | this.create_def(ctor_hir_id, DefPathData::Ctor, v.span); |
532ac7d7 | 198 | } |
e1599b0c | 199 | visit::walk_variant(this, v) |
532ac7d7 | 200 | }); |
94b46f34 XL |
201 | } |
202 | ||
e1599b0c XL |
203 | fn visit_variant_data(&mut self, data: &'a VariantData) { |
204 | // The assumption here is that non-`cfg` macro expansion cannot change field indices. | |
205 | // It currently holds because only inert attributes are accepted on fields, | |
206 | // and every such attribute expands into a single field after it's resolved. | |
94b46f34 | 207 | for (index, field) in data.fields().iter().enumerate() { |
e1599b0c | 208 | self.collect_field(field, Some(index)); |
94b46f34 XL |
209 | } |
210 | } | |
211 | ||
ff7c6d11 | 212 | fn visit_generic_param(&mut self, param: &'a GenericParam) { |
e1599b0c XL |
213 | if param.is_placeholder { |
214 | self.visit_macro_invoc(param.id); | |
215 | return; | |
216 | } | |
e74abb32 | 217 | let name = param.ident.name; |
8faf50e0 | 218 | let def_path_data = match param.kind { |
48663c56 XL |
219 | GenericParamKind::Lifetime { .. } => DefPathData::LifetimeNs(name), |
220 | GenericParamKind::Type { .. } => DefPathData::TypeNs(name), | |
221 | GenericParamKind::Const { .. } => DefPathData::ValueNs(name), | |
8faf50e0 | 222 | }; |
48663c56 | 223 | self.create_def(param.id, def_path_data, param.ident.span); |
a7813a04 | 224 | |
6a06907d XL |
225 | // impl-Trait can happen inside generic parameters, like |
226 | // ``` | |
227 | // fn foo<U: Iterator<Item = impl Clone>>() {} | |
228 | // ``` | |
229 | // | |
230 | // In that case, the impl-trait is lowered as an additional generic parameter. | |
231 | self.with_impl_trait(ImplTraitContext::Universal(self.parent_def), |this| { | |
232 | visit::walk_generic_param(this, param) | |
233 | }); | |
a7813a04 XL |
234 | } |
235 | ||
74b04a01 XL |
236 | fn visit_assoc_item(&mut self, i: &'a AssocItem, ctxt: visit::AssocCtxt) { |
237 | let def_data = match &i.kind { | |
74b04a01 XL |
238 | AssocItemKind::Fn(..) | AssocItemKind::Const(..) => DefPathData::ValueNs(i.ident.name), |
239 | AssocItemKind::TyAlias(..) => DefPathData::TypeNs(i.ident.name), | |
ba9703b0 | 240 | AssocItemKind::MacCall(..) => return self.visit_macro_invoc(i.id), |
a7813a04 XL |
241 | }; |
242 | ||
74b04a01 XL |
243 | let def = self.create_def(i.id, def_data, i.span); |
244 | self.with_parent(def, |this| visit::walk_assoc_item(this, i, ctxt)); | |
a7813a04 XL |
245 | } |
246 | ||
476ff2be | 247 | fn visit_pat(&mut self, pat: &'a Pat) { |
e74abb32 | 248 | match pat.kind { |
ba9703b0 | 249 | PatKind::MacCall(..) => self.visit_macro_invoc(pat.id), |
ea8adc8c | 250 | _ => visit::walk_pat(self, pat), |
a7813a04 | 251 | } |
a7813a04 XL |
252 | } |
253 | ||
94b46f34 | 254 | fn visit_anon_const(&mut self, constant: &'a AnonConst) { |
dfeec247 | 255 | let def = self.create_def(constant.id, DefPathData::AnonConst, constant.value.span); |
94b46f34 XL |
256 | self.with_parent(def, |this| visit::walk_anon_const(this, constant)); |
257 | } | |
258 | ||
476ff2be | 259 | fn visit_expr(&mut self, expr: &'a Expr) { |
e74abb32 | 260 | let parent_def = match expr.kind { |
ba9703b0 | 261 | ExprKind::MacCall(..) => return self.visit_macro_invoc(expr.id), |
064997fb | 262 | ExprKind::Closure(_, _, asyncness, ..) => { |
8faf50e0 XL |
263 | // Async closures desugar to closures inside of closures, so |
264 | // we must create two defs. | |
416331ca XL |
265 | let closure_def = self.create_def(expr.id, DefPathData::ClosureExpr, expr.span); |
266 | match asyncness { | |
74b04a01 | 267 | Async::Yes { closure_id, .. } => { |
dfeec247 XL |
268 | self.create_def(closure_id, DefPathData::ClosureExpr, expr.span) |
269 | } | |
74b04a01 | 270 | Async::No => closure_def, |
8faf50e0 XL |
271 | } |
272 | } | |
dfeec247 XL |
273 | ExprKind::Async(_, async_id, _) => { |
274 | self.create_def(async_id, DefPathData::ClosureExpr, expr.span) | |
275 | } | |
416331ca | 276 | _ => self.parent_def, |
8faf50e0 | 277 | }; |
a7813a04 | 278 | |
416331ca | 279 | self.with_parent(parent_def, |this| visit::walk_expr(this, expr)); |
a7813a04 XL |
280 | } |
281 | ||
476ff2be | 282 | fn visit_ty(&mut self, ty: &'a Ty) { |
e74abb32 | 283 | match ty.kind { |
29967ef6 | 284 | TyKind::MacCall(..) => self.visit_macro_invoc(ty.id), |
8faf50e0 | 285 | TyKind::ImplTrait(node_id, _) => { |
6a06907d XL |
286 | let parent_def = match self.impl_trait_context { |
287 | ImplTraitContext::Universal(item_def) => self.resolver.create_def( | |
288 | item_def, | |
289 | node_id, | |
290 | DefPathData::ImplTrait, | |
136023e0 | 291 | self.expansion.to_expn_id(), |
6a06907d XL |
292 | ty.span, |
293 | ), | |
294 | ImplTraitContext::Existential => { | |
295 | self.create_def(node_id, DefPathData::ImplTrait, ty.span) | |
296 | } | |
297 | }; | |
298 | self.with_parent(parent_def, |this| visit::walk_ty(this, ty)) | |
8faf50e0 | 299 | } |
29967ef6 | 300 | _ => visit::walk_ty(self, ty), |
5bcae85e | 301 | } |
a7813a04 XL |
302 | } |
303 | ||
476ff2be | 304 | fn visit_stmt(&mut self, stmt: &'a Stmt) { |
e74abb32 | 305 | match stmt.kind { |
ba9703b0 | 306 | StmtKind::MacCall(..) => self.visit_macro_invoc(stmt.id), |
c30ab7b3 SL |
307 | _ => visit::walk_stmt(self, stmt), |
308 | } | |
309 | } | |
abe05a73 | 310 | |
e1599b0c | 311 | fn visit_arm(&mut self, arm: &'a Arm) { |
dfeec247 | 312 | if arm.is_placeholder { self.visit_macro_invoc(arm.id) } else { visit::walk_arm(self, arm) } |
e1599b0c XL |
313 | } |
314 | ||
6a06907d XL |
315 | fn visit_expr_field(&mut self, f: &'a ExprField) { |
316 | if f.is_placeholder { | |
317 | self.visit_macro_invoc(f.id) | |
318 | } else { | |
319 | visit::walk_expr_field(self, f) | |
320 | } | |
e1599b0c XL |
321 | } |
322 | ||
6a06907d | 323 | fn visit_pat_field(&mut self, fp: &'a PatField) { |
e1599b0c XL |
324 | if fp.is_placeholder { |
325 | self.visit_macro_invoc(fp.id) | |
326 | } else { | |
6a06907d | 327 | visit::walk_pat_field(self, fp) |
e1599b0c XL |
328 | } |
329 | } | |
330 | ||
331 | fn visit_param(&mut self, p: &'a Param) { | |
6a06907d XL |
332 | if p.is_placeholder { |
333 | self.visit_macro_invoc(p.id) | |
334 | } else { | |
335 | self.with_impl_trait(ImplTraitContext::Universal(self.parent_def), |this| { | |
336 | visit::walk_param(this, p) | |
337 | }) | |
338 | } | |
e1599b0c XL |
339 | } |
340 | ||
341 | // This method is called only when we are visiting an individual field | |
342 | // after expanding an attribute on it. | |
6a06907d | 343 | fn visit_field_def(&mut self, field: &'a FieldDef) { |
e1599b0c XL |
344 | self.collect_field(field, None); |
345 | } | |
a2a8927a XL |
346 | |
347 | fn visit_crate(&mut self, krate: &'a Crate) { | |
348 | if krate.is_placeholder { | |
349 | self.visit_macro_invoc(krate.id) | |
350 | } else { | |
351 | visit::walk_crate(self, krate) | |
352 | } | |
353 | } | |
a7813a04 | 354 | } |