diff options
Diffstat (limited to 'crates/hir_def/src/item_tree')
-rw-r--r-- | crates/hir_def/src/item_tree/lower.rs | 705 | ||||
-rw-r--r-- | crates/hir_def/src/item_tree/tests.rs | 439 |
2 files changed, 1144 insertions, 0 deletions
diff --git a/crates/hir_def/src/item_tree/lower.rs b/crates/hir_def/src/item_tree/lower.rs new file mode 100644 index 000000000..391ab5d39 --- /dev/null +++ b/crates/hir_def/src/item_tree/lower.rs | |||
@@ -0,0 +1,705 @@ | |||
1 | //! AST -> `ItemTree` lowering code. | ||
2 | |||
3 | use std::{collections::hash_map::Entry, mem, sync::Arc}; | ||
4 | |||
5 | use arena::map::ArenaMap; | ||
6 | use hir_expand::{ast_id_map::AstIdMap, hygiene::Hygiene, HirFileId}; | ||
7 | use smallvec::SmallVec; | ||
8 | use syntax::{ | ||
9 | ast::{self, ModuleItemOwner}, | ||
10 | SyntaxNode, | ||
11 | }; | ||
12 | |||
13 | use crate::{ | ||
14 | attr::Attrs, | ||
15 | generics::{GenericParams, TypeParamData, TypeParamProvenance}, | ||
16 | }; | ||
17 | |||
18 | use super::*; | ||
19 | |||
20 | fn id<N: ItemTreeNode>(index: Idx<N>) -> FileItemTreeId<N> { | ||
21 | FileItemTreeId { index, _p: PhantomData } | ||
22 | } | ||
23 | |||
24 | struct ModItems(SmallVec<[ModItem; 1]>); | ||
25 | |||
26 | impl<T> From<T> for ModItems | ||
27 | where | ||
28 | T: Into<ModItem>, | ||
29 | { | ||
30 | fn from(t: T) -> Self { | ||
31 | ModItems(SmallVec::from_buf([t.into(); 1])) | ||
32 | } | ||
33 | } | ||
34 | |||
35 | pub(super) struct Ctx { | ||
36 | tree: ItemTree, | ||
37 | hygiene: Hygiene, | ||
38 | file: HirFileId, | ||
39 | source_ast_id_map: Arc<AstIdMap>, | ||
40 | body_ctx: crate::body::LowerCtx, | ||
41 | inner_items: Vec<ModItem>, | ||
42 | forced_visibility: Option<RawVisibilityId>, | ||
43 | } | ||
44 | |||
45 | impl Ctx { | ||
46 | pub(super) fn new(db: &dyn DefDatabase, hygiene: Hygiene, file: HirFileId) -> Self { | ||
47 | Self { | ||
48 | tree: ItemTree::empty(), | ||
49 | hygiene, | ||
50 | file, | ||
51 | source_ast_id_map: db.ast_id_map(file), | ||
52 | body_ctx: crate::body::LowerCtx::new(db, file), | ||
53 | inner_items: Vec::new(), | ||
54 | forced_visibility: None, | ||
55 | } | ||
56 | } | ||
57 | |||
58 | pub(super) fn lower_module_items(mut self, item_owner: &dyn ModuleItemOwner) -> ItemTree { | ||
59 | self.tree.top_level = item_owner | ||
60 | .items() | ||
61 | .flat_map(|item| self.lower_mod_item(&item, false)) | ||
62 | .flat_map(|items| items.0) | ||
63 | .collect(); | ||
64 | self.tree | ||
65 | } | ||
66 | |||
67 | pub(super) fn lower_inner_items(mut self, within: &SyntaxNode) -> ItemTree { | ||
68 | self.collect_inner_items(within); | ||
69 | self.tree | ||
70 | } | ||
71 | |||
72 | fn data(&mut self) -> &mut ItemTreeData { | ||
73 | self.tree.data_mut() | ||
74 | } | ||
75 | |||
76 | fn lower_mod_item(&mut self, item: &ast::Item, inner: bool) -> Option<ModItems> { | ||
77 | assert!(inner || self.inner_items.is_empty()); | ||
78 | |||
79 | // Collect inner items for 1-to-1-lowered items. | ||
80 | match item { | ||
81 | ast::Item::Struct(_) | ||
82 | | ast::Item::Union(_) | ||
83 | | ast::Item::Enum(_) | ||
84 | | ast::Item::Fn(_) | ||
85 | | ast::Item::TypeAlias(_) | ||
86 | | ast::Item::Const(_) | ||
87 | | ast::Item::Static(_) | ||
88 | | ast::Item::MacroCall(_) => { | ||
89 | // Skip this if we're already collecting inner items. We'll descend into all nodes | ||
90 | // already. | ||
91 | if !inner { | ||
92 | self.collect_inner_items(item.syntax()); | ||
93 | } | ||
94 | } | ||
95 | |||
96 | // These are handled in their respective `lower_X` method (since we can't just blindly | ||
97 | // walk them). | ||
98 | ast::Item::Trait(_) | ast::Item::Impl(_) | ast::Item::ExternBlock(_) => {} | ||
99 | |||
100 | // These don't have inner items. | ||
101 | ast::Item::Module(_) | ast::Item::ExternCrate(_) | ast::Item::Use(_) => {} | ||
102 | }; | ||
103 | |||
104 | let attrs = Attrs::new(item, &self.hygiene); | ||
105 | let items = match item { | ||
106 | ast::Item::Struct(ast) => self.lower_struct(ast).map(Into::into), | ||
107 | ast::Item::Union(ast) => self.lower_union(ast).map(Into::into), | ||
108 | ast::Item::Enum(ast) => self.lower_enum(ast).map(Into::into), | ||
109 | ast::Item::Fn(ast) => self.lower_function(ast).map(Into::into), | ||
110 | ast::Item::TypeAlias(ast) => self.lower_type_alias(ast).map(Into::into), | ||
111 | ast::Item::Static(ast) => self.lower_static(ast).map(Into::into), | ||
112 | ast::Item::Const(ast) => Some(self.lower_const(ast).into()), | ||
113 | ast::Item::Module(ast) => self.lower_module(ast).map(Into::into), | ||
114 | ast::Item::Trait(ast) => self.lower_trait(ast).map(Into::into), | ||
115 | ast::Item::Impl(ast) => self.lower_impl(ast).map(Into::into), | ||
116 | ast::Item::Use(ast) => Some(ModItems( | ||
117 | self.lower_use(ast).into_iter().map(Into::into).collect::<SmallVec<_>>(), | ||
118 | )), | ||
119 | ast::Item::ExternCrate(ast) => self.lower_extern_crate(ast).map(Into::into), | ||
120 | ast::Item::MacroCall(ast) => self.lower_macro_call(ast).map(Into::into), | ||
121 | ast::Item::ExternBlock(ast) => { | ||
122 | Some(ModItems(self.lower_extern_block(ast).into_iter().collect::<SmallVec<_>>())) | ||
123 | } | ||
124 | }; | ||
125 | |||
126 | if !attrs.is_empty() { | ||
127 | for item in items.iter().flat_map(|items| &items.0) { | ||
128 | self.add_attrs((*item).into(), attrs.clone()); | ||
129 | } | ||
130 | } | ||
131 | |||
132 | items | ||
133 | } | ||
134 | |||
135 | fn add_attrs(&mut self, item: AttrOwner, attrs: Attrs) { | ||
136 | match self.tree.attrs.entry(item) { | ||
137 | Entry::Occupied(mut entry) => { | ||
138 | *entry.get_mut() = entry.get().merge(attrs); | ||
139 | } | ||
140 | Entry::Vacant(entry) => { | ||
141 | entry.insert(attrs); | ||
142 | } | ||
143 | } | ||
144 | } | ||
145 | |||
146 | fn collect_inner_items(&mut self, container: &SyntaxNode) { | ||
147 | let forced_vis = self.forced_visibility.take(); | ||
148 | let mut inner_items = mem::take(&mut self.tree.inner_items); | ||
149 | inner_items.extend(container.descendants().skip(1).filter_map(ast::Item::cast).filter_map( | ||
150 | |item| { | ||
151 | let ast_id = self.source_ast_id_map.ast_id(&item); | ||
152 | Some((ast_id, self.lower_mod_item(&item, true)?.0)) | ||
153 | }, | ||
154 | )); | ||
155 | self.tree.inner_items = inner_items; | ||
156 | self.forced_visibility = forced_vis; | ||
157 | } | ||
158 | |||
159 | fn lower_assoc_item(&mut self, item: &ast::AssocItem) -> Option<AssocItem> { | ||
160 | match item { | ||
161 | ast::AssocItem::Fn(ast) => self.lower_function(ast).map(Into::into), | ||
162 | ast::AssocItem::TypeAlias(ast) => self.lower_type_alias(ast).map(Into::into), | ||
163 | ast::AssocItem::Const(ast) => Some(self.lower_const(ast).into()), | ||
164 | ast::AssocItem::MacroCall(ast) => self.lower_macro_call(ast).map(Into::into), | ||
165 | } | ||
166 | } | ||
167 | |||
168 | fn lower_struct(&mut self, strukt: &ast::Struct) -> Option<FileItemTreeId<Struct>> { | ||
169 | let visibility = self.lower_visibility(strukt); | ||
170 | let name = strukt.name()?.as_name(); | ||
171 | let generic_params = self.lower_generic_params(GenericsOwner::Struct, strukt); | ||
172 | let fields = self.lower_fields(&strukt.kind()); | ||
173 | let ast_id = self.source_ast_id_map.ast_id(strukt); | ||
174 | let kind = match strukt.kind() { | ||
175 | ast::StructKind::Record(_) => StructDefKind::Record, | ||
176 | ast::StructKind::Tuple(_) => StructDefKind::Tuple, | ||
177 | ast::StructKind::Unit => StructDefKind::Unit, | ||
178 | }; | ||
179 | let res = Struct { name, visibility, generic_params, fields, ast_id, kind }; | ||
180 | Some(id(self.data().structs.alloc(res))) | ||
181 | } | ||
182 | |||
183 | fn lower_fields(&mut self, strukt_kind: &ast::StructKind) -> Fields { | ||
184 | match strukt_kind { | ||
185 | ast::StructKind::Record(it) => { | ||
186 | let range = self.lower_record_fields(it); | ||
187 | Fields::Record(range) | ||
188 | } | ||
189 | ast::StructKind::Tuple(it) => { | ||
190 | let range = self.lower_tuple_fields(it); | ||
191 | Fields::Tuple(range) | ||
192 | } | ||
193 | ast::StructKind::Unit => Fields::Unit, | ||
194 | } | ||
195 | } | ||
196 | |||
197 | fn lower_record_fields(&mut self, fields: &ast::RecordFieldList) -> IdRange<Field> { | ||
198 | let start = self.next_field_idx(); | ||
199 | for field in fields.fields() { | ||
200 | if let Some(data) = self.lower_record_field(&field) { | ||
201 | let idx = self.data().fields.alloc(data); | ||
202 | self.add_attrs(idx.into(), Attrs::new(&field, &self.hygiene)); | ||
203 | } | ||
204 | } | ||
205 | let end = self.next_field_idx(); | ||
206 | IdRange::new(start..end) | ||
207 | } | ||
208 | |||
209 | fn lower_record_field(&mut self, field: &ast::RecordField) -> Option<Field> { | ||
210 | let name = field.name()?.as_name(); | ||
211 | let visibility = self.lower_visibility(field); | ||
212 | let type_ref = self.lower_type_ref_opt(field.ty()); | ||
213 | let res = Field { name, type_ref, visibility }; | ||
214 | Some(res) | ||
215 | } | ||
216 | |||
217 | fn lower_tuple_fields(&mut self, fields: &ast::TupleFieldList) -> IdRange<Field> { | ||
218 | let start = self.next_field_idx(); | ||
219 | for (i, field) in fields.fields().enumerate() { | ||
220 | let data = self.lower_tuple_field(i, &field); | ||
221 | let idx = self.data().fields.alloc(data); | ||
222 | self.add_attrs(idx.into(), Attrs::new(&field, &self.hygiene)); | ||
223 | } | ||
224 | let end = self.next_field_idx(); | ||
225 | IdRange::new(start..end) | ||
226 | } | ||
227 | |||
228 | fn lower_tuple_field(&mut self, idx: usize, field: &ast::TupleField) -> Field { | ||
229 | let name = Name::new_tuple_field(idx); | ||
230 | let visibility = self.lower_visibility(field); | ||
231 | let type_ref = self.lower_type_ref_opt(field.ty()); | ||
232 | let res = Field { name, type_ref, visibility }; | ||
233 | res | ||
234 | } | ||
235 | |||
236 | fn lower_union(&mut self, union: &ast::Union) -> Option<FileItemTreeId<Union>> { | ||
237 | let visibility = self.lower_visibility(union); | ||
238 | let name = union.name()?.as_name(); | ||
239 | let generic_params = self.lower_generic_params(GenericsOwner::Union, union); | ||
240 | let fields = match union.record_field_list() { | ||
241 | Some(record_field_list) => self.lower_fields(&StructKind::Record(record_field_list)), | ||
242 | None => Fields::Record(IdRange::new(self.next_field_idx()..self.next_field_idx())), | ||
243 | }; | ||
244 | let ast_id = self.source_ast_id_map.ast_id(union); | ||
245 | let res = Union { name, visibility, generic_params, fields, ast_id }; | ||
246 | Some(id(self.data().unions.alloc(res))) | ||
247 | } | ||
248 | |||
249 | fn lower_enum(&mut self, enum_: &ast::Enum) -> Option<FileItemTreeId<Enum>> { | ||
250 | let visibility = self.lower_visibility(enum_); | ||
251 | let name = enum_.name()?.as_name(); | ||
252 | let generic_params = self.lower_generic_params(GenericsOwner::Enum, enum_); | ||
253 | let variants = match &enum_.variant_list() { | ||
254 | Some(variant_list) => self.lower_variants(variant_list), | ||
255 | None => IdRange::new(self.next_variant_idx()..self.next_variant_idx()), | ||
256 | }; | ||
257 | let ast_id = self.source_ast_id_map.ast_id(enum_); | ||
258 | let res = Enum { name, visibility, generic_params, variants, ast_id }; | ||
259 | Some(id(self.data().enums.alloc(res))) | ||
260 | } | ||
261 | |||
262 | fn lower_variants(&mut self, variants: &ast::VariantList) -> IdRange<Variant> { | ||
263 | let start = self.next_variant_idx(); | ||
264 | for variant in variants.variants() { | ||
265 | if let Some(data) = self.lower_variant(&variant) { | ||
266 | let idx = self.data().variants.alloc(data); | ||
267 | self.add_attrs(idx.into(), Attrs::new(&variant, &self.hygiene)); | ||
268 | } | ||
269 | } | ||
270 | let end = self.next_variant_idx(); | ||
271 | IdRange::new(start..end) | ||
272 | } | ||
273 | |||
274 | fn lower_variant(&mut self, variant: &ast::Variant) -> Option<Variant> { | ||
275 | let name = variant.name()?.as_name(); | ||
276 | let fields = self.lower_fields(&variant.kind()); | ||
277 | let res = Variant { name, fields }; | ||
278 | Some(res) | ||
279 | } | ||
280 | |||
281 | fn lower_function(&mut self, func: &ast::Fn) -> Option<FileItemTreeId<Function>> { | ||
282 | let visibility = self.lower_visibility(func); | ||
283 | let name = func.name()?.as_name(); | ||
284 | |||
285 | let mut params = Vec::new(); | ||
286 | let mut has_self_param = false; | ||
287 | if let Some(param_list) = func.param_list() { | ||
288 | if let Some(self_param) = param_list.self_param() { | ||
289 | let self_type = match self_param.ty() { | ||
290 | Some(type_ref) => TypeRef::from_ast(&self.body_ctx, type_ref), | ||
291 | None => { | ||
292 | let self_type = TypeRef::Path(name![Self].into()); | ||
293 | match self_param.kind() { | ||
294 | ast::SelfParamKind::Owned => self_type, | ||
295 | ast::SelfParamKind::Ref => { | ||
296 | TypeRef::Reference(Box::new(self_type), Mutability::Shared) | ||
297 | } | ||
298 | ast::SelfParamKind::MutRef => { | ||
299 | TypeRef::Reference(Box::new(self_type), Mutability::Mut) | ||
300 | } | ||
301 | } | ||
302 | } | ||
303 | }; | ||
304 | params.push(self_type); | ||
305 | has_self_param = true; | ||
306 | } | ||
307 | for param in param_list.params() { | ||
308 | let type_ref = TypeRef::from_ast_opt(&self.body_ctx, param.ty()); | ||
309 | params.push(type_ref); | ||
310 | } | ||
311 | } | ||
312 | |||
313 | let mut is_varargs = false; | ||
314 | if let Some(params) = func.param_list() { | ||
315 | if let Some(last) = params.params().last() { | ||
316 | is_varargs = last.dotdotdot_token().is_some(); | ||
317 | } | ||
318 | } | ||
319 | |||
320 | let ret_type = match func.ret_type().and_then(|rt| rt.ty()) { | ||
321 | Some(type_ref) => TypeRef::from_ast(&self.body_ctx, type_ref), | ||
322 | _ => TypeRef::unit(), | ||
323 | }; | ||
324 | |||
325 | let ret_type = if func.async_token().is_some() { | ||
326 | let future_impl = desugar_future_path(ret_type); | ||
327 | let ty_bound = TypeBound::Path(future_impl); | ||
328 | TypeRef::ImplTrait(vec![ty_bound]) | ||
329 | } else { | ||
330 | ret_type | ||
331 | }; | ||
332 | |||
333 | let ast_id = self.source_ast_id_map.ast_id(func); | ||
334 | let mut res = Function { | ||
335 | name, | ||
336 | visibility, | ||
337 | generic_params: GenericParamsId::EMPTY, | ||
338 | has_self_param, | ||
339 | is_unsafe: func.unsafe_token().is_some(), | ||
340 | params: params.into_boxed_slice(), | ||
341 | is_varargs, | ||
342 | ret_type, | ||
343 | ast_id, | ||
344 | }; | ||
345 | res.generic_params = self.lower_generic_params(GenericsOwner::Function(&res), func); | ||
346 | |||
347 | Some(id(self.data().functions.alloc(res))) | ||
348 | } | ||
349 | |||
350 | fn lower_type_alias( | ||
351 | &mut self, | ||
352 | type_alias: &ast::TypeAlias, | ||
353 | ) -> Option<FileItemTreeId<TypeAlias>> { | ||
354 | let name = type_alias.name()?.as_name(); | ||
355 | let type_ref = type_alias.ty().map(|it| self.lower_type_ref(&it)); | ||
356 | let visibility = self.lower_visibility(type_alias); | ||
357 | let bounds = self.lower_type_bounds(type_alias); | ||
358 | let generic_params = self.lower_generic_params(GenericsOwner::TypeAlias, type_alias); | ||
359 | let ast_id = self.source_ast_id_map.ast_id(type_alias); | ||
360 | let res = TypeAlias { | ||
361 | name, | ||
362 | visibility, | ||
363 | bounds: bounds.into_boxed_slice(), | ||
364 | generic_params, | ||
365 | type_ref, | ||
366 | ast_id, | ||
367 | }; | ||
368 | Some(id(self.data().type_aliases.alloc(res))) | ||
369 | } | ||
370 | |||
371 | fn lower_static(&mut self, static_: &ast::Static) -> Option<FileItemTreeId<Static>> { | ||
372 | let name = static_.name()?.as_name(); | ||
373 | let type_ref = self.lower_type_ref_opt(static_.ty()); | ||
374 | let visibility = self.lower_visibility(static_); | ||
375 | let mutable = static_.mut_token().is_some(); | ||
376 | let ast_id = self.source_ast_id_map.ast_id(static_); | ||
377 | let res = Static { name, visibility, mutable, type_ref, ast_id }; | ||
378 | Some(id(self.data().statics.alloc(res))) | ||
379 | } | ||
380 | |||
381 | fn lower_const(&mut self, konst: &ast::Const) -> FileItemTreeId<Const> { | ||
382 | let name = konst.name().map(|it| it.as_name()); | ||
383 | let type_ref = self.lower_type_ref_opt(konst.ty()); | ||
384 | let visibility = self.lower_visibility(konst); | ||
385 | let ast_id = self.source_ast_id_map.ast_id(konst); | ||
386 | let res = Const { name, visibility, type_ref, ast_id }; | ||
387 | id(self.data().consts.alloc(res)) | ||
388 | } | ||
389 | |||
390 | fn lower_module(&mut self, module: &ast::Module) -> Option<FileItemTreeId<Mod>> { | ||
391 | let name = module.name()?.as_name(); | ||
392 | let visibility = self.lower_visibility(module); | ||
393 | let kind = if module.semicolon_token().is_some() { | ||
394 | ModKind::Outline {} | ||
395 | } else { | ||
396 | ModKind::Inline { | ||
397 | items: module | ||
398 | .item_list() | ||
399 | .map(|list| { | ||
400 | list.items() | ||
401 | .flat_map(|item| self.lower_mod_item(&item, false)) | ||
402 | .flat_map(|items| items.0) | ||
403 | .collect() | ||
404 | }) | ||
405 | .unwrap_or_else(|| { | ||
406 | mark::hit!(name_res_works_for_broken_modules); | ||
407 | Box::new([]) as Box<[_]> | ||
408 | }), | ||
409 | } | ||
410 | }; | ||
411 | let ast_id = self.source_ast_id_map.ast_id(module); | ||
412 | let res = Mod { name, visibility, kind, ast_id }; | ||
413 | Some(id(self.data().mods.alloc(res))) | ||
414 | } | ||
415 | |||
416 | fn lower_trait(&mut self, trait_def: &ast::Trait) -> Option<FileItemTreeId<Trait>> { | ||
417 | let name = trait_def.name()?.as_name(); | ||
418 | let visibility = self.lower_visibility(trait_def); | ||
419 | let generic_params = | ||
420 | self.lower_generic_params_and_inner_items(GenericsOwner::Trait(trait_def), trait_def); | ||
421 | let auto = trait_def.auto_token().is_some(); | ||
422 | let items = trait_def.assoc_item_list().map(|list| { | ||
423 | self.with_inherited_visibility(visibility, |this| { | ||
424 | list.assoc_items() | ||
425 | .filter_map(|item| { | ||
426 | let attrs = Attrs::new(&item, &this.hygiene); | ||
427 | this.collect_inner_items(item.syntax()); | ||
428 | this.lower_assoc_item(&item).map(|item| { | ||
429 | this.add_attrs(ModItem::from(item).into(), attrs); | ||
430 | item | ||
431 | }) | ||
432 | }) | ||
433 | .collect() | ||
434 | }) | ||
435 | }); | ||
436 | let ast_id = self.source_ast_id_map.ast_id(trait_def); | ||
437 | let res = Trait { | ||
438 | name, | ||
439 | visibility, | ||
440 | generic_params, | ||
441 | auto, | ||
442 | items: items.unwrap_or_default(), | ||
443 | ast_id, | ||
444 | }; | ||
445 | Some(id(self.data().traits.alloc(res))) | ||
446 | } | ||
447 | |||
448 | fn lower_impl(&mut self, impl_def: &ast::Impl) -> Option<FileItemTreeId<Impl>> { | ||
449 | let generic_params = | ||
450 | self.lower_generic_params_and_inner_items(GenericsOwner::Impl, impl_def); | ||
451 | let target_trait = impl_def.trait_().map(|tr| self.lower_type_ref(&tr)); | ||
452 | let target_type = self.lower_type_ref(&impl_def.self_ty()?); | ||
453 | let is_negative = impl_def.excl_token().is_some(); | ||
454 | |||
455 | // We cannot use `assoc_items()` here as that does not include macro calls. | ||
456 | let items = impl_def | ||
457 | .assoc_item_list() | ||
458 | .into_iter() | ||
459 | .flat_map(|it| it.assoc_items()) | ||
460 | .filter_map(|item| { | ||
461 | self.collect_inner_items(item.syntax()); | ||
462 | let assoc = self.lower_assoc_item(&item)?; | ||
463 | let attrs = Attrs::new(&item, &self.hygiene); | ||
464 | self.add_attrs(ModItem::from(assoc).into(), attrs); | ||
465 | Some(assoc) | ||
466 | }) | ||
467 | .collect(); | ||
468 | let ast_id = self.source_ast_id_map.ast_id(impl_def); | ||
469 | let res = Impl { generic_params, target_trait, target_type, is_negative, items, ast_id }; | ||
470 | Some(id(self.data().impls.alloc(res))) | ||
471 | } | ||
472 | |||
473 | fn lower_use(&mut self, use_item: &ast::Use) -> Vec<FileItemTreeId<Import>> { | ||
474 | // FIXME: cfg_attr | ||
475 | let is_prelude = use_item.has_atom_attr("prelude_import"); | ||
476 | let visibility = self.lower_visibility(use_item); | ||
477 | let ast_id = self.source_ast_id_map.ast_id(use_item); | ||
478 | |||
479 | // Every use item can expand to many `Import`s. | ||
480 | let mut imports = Vec::new(); | ||
481 | let tree = self.tree.data_mut(); | ||
482 | ModPath::expand_use_item( | ||
483 | InFile::new(self.file, use_item.clone()), | ||
484 | &self.hygiene, | ||
485 | |path, _tree, is_glob, alias| { | ||
486 | imports.push(id(tree.imports.alloc(Import { | ||
487 | path, | ||
488 | alias, | ||
489 | visibility, | ||
490 | is_glob, | ||
491 | is_prelude, | ||
492 | ast_id, | ||
493 | }))); | ||
494 | }, | ||
495 | ); | ||
496 | |||
497 | imports | ||
498 | } | ||
499 | |||
500 | fn lower_extern_crate( | ||
501 | &mut self, | ||
502 | extern_crate: &ast::ExternCrate, | ||
503 | ) -> Option<FileItemTreeId<ExternCrate>> { | ||
504 | let path = ModPath::from_name_ref(&extern_crate.name_ref()?); | ||
505 | let alias = extern_crate.rename().map(|a| { | ||
506 | a.name().map(|it| it.as_name()).map_or(ImportAlias::Underscore, ImportAlias::Alias) | ||
507 | }); | ||
508 | let visibility = self.lower_visibility(extern_crate); | ||
509 | let ast_id = self.source_ast_id_map.ast_id(extern_crate); | ||
510 | // FIXME: cfg_attr | ||
511 | let is_macro_use = extern_crate.has_atom_attr("macro_use"); | ||
512 | |||
513 | let res = ExternCrate { path, alias, visibility, is_macro_use, ast_id }; | ||
514 | Some(id(self.data().extern_crates.alloc(res))) | ||
515 | } | ||
516 | |||
517 | fn lower_macro_call(&mut self, m: &ast::MacroCall) -> Option<FileItemTreeId<MacroCall>> { | ||
518 | let name = m.name().map(|it| it.as_name()); | ||
519 | let attrs = Attrs::new(m, &self.hygiene); | ||
520 | let path = ModPath::from_src(m.path()?, &self.hygiene)?; | ||
521 | |||
522 | let ast_id = self.source_ast_id_map.ast_id(m); | ||
523 | |||
524 | // FIXME: cfg_attr | ||
525 | let export_attr = attrs.by_key("macro_export"); | ||
526 | |||
527 | let is_export = export_attr.exists(); | ||
528 | let is_local_inner = if is_export { | ||
529 | export_attr.tt_values().map(|it| &it.token_trees).flatten().any(|it| match it { | ||
530 | tt::TokenTree::Leaf(tt::Leaf::Ident(ident)) => { | ||
531 | ident.text.contains("local_inner_macros") | ||
532 | } | ||
533 | _ => false, | ||
534 | }) | ||
535 | } else { | ||
536 | false | ||
537 | }; | ||
538 | |||
539 | let is_builtin = attrs.by_key("rustc_builtin_macro").exists(); | ||
540 | let res = MacroCall { name, path, is_export, is_builtin, is_local_inner, ast_id }; | ||
541 | Some(id(self.data().macro_calls.alloc(res))) | ||
542 | } | ||
543 | |||
544 | fn lower_extern_block(&mut self, block: &ast::ExternBlock) -> Vec<ModItem> { | ||
545 | block.extern_item_list().map_or(Vec::new(), |list| { | ||
546 | list.extern_items() | ||
547 | .filter_map(|item| { | ||
548 | self.collect_inner_items(item.syntax()); | ||
549 | let attrs = Attrs::new(&item, &self.hygiene); | ||
550 | let id: ModItem = match item { | ||
551 | ast::ExternItem::Fn(ast) => { | ||
552 | let func = self.lower_function(&ast)?; | ||
553 | self.data().functions[func.index].is_unsafe = true; | ||
554 | func.into() | ||
555 | } | ||
556 | ast::ExternItem::Static(ast) => { | ||
557 | let statik = self.lower_static(&ast)?; | ||
558 | statik.into() | ||
559 | } | ||
560 | ast::ExternItem::MacroCall(_) => return None, | ||
561 | }; | ||
562 | self.add_attrs(id.into(), attrs); | ||
563 | Some(id) | ||
564 | }) | ||
565 | .collect() | ||
566 | }) | ||
567 | } | ||
568 | |||
569 | /// Lowers generics defined on `node` and collects inner items defined within. | ||
570 | fn lower_generic_params_and_inner_items( | ||
571 | &mut self, | ||
572 | owner: GenericsOwner<'_>, | ||
573 | node: &impl ast::GenericParamsOwner, | ||
574 | ) -> GenericParamsId { | ||
575 | // Generics are part of item headers and may contain inner items we need to collect. | ||
576 | if let Some(params) = node.generic_param_list() { | ||
577 | self.collect_inner_items(params.syntax()); | ||
578 | } | ||
579 | if let Some(clause) = node.where_clause() { | ||
580 | self.collect_inner_items(clause.syntax()); | ||
581 | } | ||
582 | |||
583 | self.lower_generic_params(owner, node) | ||
584 | } | ||
585 | |||
586 | fn lower_generic_params( | ||
587 | &mut self, | ||
588 | owner: GenericsOwner<'_>, | ||
589 | node: &impl ast::GenericParamsOwner, | ||
590 | ) -> GenericParamsId { | ||
591 | let mut sm = &mut ArenaMap::default(); | ||
592 | let mut generics = GenericParams::default(); | ||
593 | match owner { | ||
594 | GenericsOwner::Function(func) => { | ||
595 | generics.fill(&self.body_ctx, sm, node); | ||
596 | // lower `impl Trait` in arguments | ||
597 | for param in &*func.params { | ||
598 | generics.fill_implicit_impl_trait_args(param); | ||
599 | } | ||
600 | } | ||
601 | GenericsOwner::Struct | ||
602 | | GenericsOwner::Enum | ||
603 | | GenericsOwner::Union | ||
604 | | GenericsOwner::TypeAlias => { | ||
605 | generics.fill(&self.body_ctx, sm, node); | ||
606 | } | ||
607 | GenericsOwner::Trait(trait_def) => { | ||
608 | // traits get the Self type as an implicit first type parameter | ||
609 | let self_param_id = generics.types.alloc(TypeParamData { | ||
610 | name: Some(name![Self]), | ||
611 | default: None, | ||
612 | provenance: TypeParamProvenance::TraitSelf, | ||
613 | }); | ||
614 | sm.insert(self_param_id, Either::Left(trait_def.clone())); | ||
615 | // add super traits as bounds on Self | ||
616 | // i.e., trait Foo: Bar is equivalent to trait Foo where Self: Bar | ||
617 | let self_param = TypeRef::Path(name![Self].into()); | ||
618 | generics.fill_bounds(&self.body_ctx, trait_def, self_param); | ||
619 | |||
620 | generics.fill(&self.body_ctx, &mut sm, node); | ||
621 | } | ||
622 | GenericsOwner::Impl => { | ||
623 | // Note that we don't add `Self` here: in `impl`s, `Self` is not a | ||
624 | // type-parameter, but rather is a type-alias for impl's target | ||
625 | // type, so this is handled by the resolver. | ||
626 | generics.fill(&self.body_ctx, &mut sm, node); | ||
627 | } | ||
628 | } | ||
629 | |||
630 | self.data().generics.alloc(generics) | ||
631 | } | ||
632 | |||
633 | fn lower_type_bounds(&mut self, node: &impl ast::TypeBoundsOwner) -> Vec<TypeBound> { | ||
634 | match node.type_bound_list() { | ||
635 | Some(bound_list) => { | ||
636 | bound_list.bounds().map(|it| TypeBound::from_ast(&self.body_ctx, it)).collect() | ||
637 | } | ||
638 | None => Vec::new(), | ||
639 | } | ||
640 | } | ||
641 | |||
642 | fn lower_visibility(&mut self, item: &impl ast::VisibilityOwner) -> RawVisibilityId { | ||
643 | let vis = match self.forced_visibility { | ||
644 | Some(vis) => return vis, | ||
645 | None => RawVisibility::from_ast_with_hygiene(item.visibility(), &self.hygiene), | ||
646 | }; | ||
647 | |||
648 | self.data().vis.alloc(vis) | ||
649 | } | ||
650 | |||
651 | fn lower_type_ref(&self, type_ref: &ast::Type) -> TypeRef { | ||
652 | TypeRef::from_ast(&self.body_ctx, type_ref.clone()) | ||
653 | } | ||
654 | fn lower_type_ref_opt(&self, type_ref: Option<ast::Type>) -> TypeRef { | ||
655 | type_ref.map(|ty| self.lower_type_ref(&ty)).unwrap_or(TypeRef::Error) | ||
656 | } | ||
657 | |||
658 | /// Forces the visibility `vis` to be used for all items lowered during execution of `f`. | ||
659 | fn with_inherited_visibility<R>( | ||
660 | &mut self, | ||
661 | vis: RawVisibilityId, | ||
662 | f: impl FnOnce(&mut Self) -> R, | ||
663 | ) -> R { | ||
664 | let old = mem::replace(&mut self.forced_visibility, Some(vis)); | ||
665 | let res = f(self); | ||
666 | self.forced_visibility = old; | ||
667 | res | ||
668 | } | ||
669 | |||
670 | fn next_field_idx(&self) -> Idx<Field> { | ||
671 | Idx::from_raw(RawId::from( | ||
672 | self.tree.data.as_ref().map_or(0, |data| data.fields.len() as u32), | ||
673 | )) | ||
674 | } | ||
675 | fn next_variant_idx(&self) -> Idx<Variant> { | ||
676 | Idx::from_raw(RawId::from( | ||
677 | self.tree.data.as_ref().map_or(0, |data| data.variants.len() as u32), | ||
678 | )) | ||
679 | } | ||
680 | } | ||
681 | |||
682 | fn desugar_future_path(orig: TypeRef) -> Path { | ||
683 | let path = path![core::future::Future]; | ||
684 | let mut generic_args: Vec<_> = std::iter::repeat(None).take(path.segments.len() - 1).collect(); | ||
685 | let mut last = GenericArgs::empty(); | ||
686 | let binding = | ||
687 | AssociatedTypeBinding { name: name![Output], type_ref: Some(orig), bounds: Vec::new() }; | ||
688 | last.bindings.push(binding); | ||
689 | generic_args.push(Some(Arc::new(last))); | ||
690 | |||
691 | Path::from_known_path(path, generic_args) | ||
692 | } | ||
693 | |||
694 | enum GenericsOwner<'a> { | ||
695 | /// We need access to the partially-lowered `Function` for lowering `impl Trait` in argument | ||
696 | /// position. | ||
697 | Function(&'a Function), | ||
698 | Struct, | ||
699 | Enum, | ||
700 | Union, | ||
701 | /// The `TraitDef` is needed to fill the source map for the implicit `Self` parameter. | ||
702 | Trait(&'a ast::Trait), | ||
703 | TypeAlias, | ||
704 | Impl, | ||
705 | } | ||
diff --git a/crates/hir_def/src/item_tree/tests.rs b/crates/hir_def/src/item_tree/tests.rs new file mode 100644 index 000000000..9c5bf72bd --- /dev/null +++ b/crates/hir_def/src/item_tree/tests.rs | |||
@@ -0,0 +1,439 @@ | |||
1 | use base_db::fixture::WithFixture; | ||
2 | use expect::{expect, Expect}; | ||
3 | use hir_expand::{db::AstDatabase, HirFileId, InFile}; | ||
4 | use rustc_hash::FxHashSet; | ||
5 | use std::sync::Arc; | ||
6 | use stdx::format_to; | ||
7 | use syntax::{ast, AstNode}; | ||
8 | |||
9 | use crate::{db::DefDatabase, test_db::TestDB}; | ||
10 | |||
11 | use super::{ItemTree, ModItem, ModKind}; | ||
12 | |||
13 | fn test_inner_items(ra_fixture: &str) { | ||
14 | let (db, file_id) = TestDB::with_single_file(ra_fixture); | ||
15 | let file_id = HirFileId::from(file_id); | ||
16 | let tree = db.item_tree(file_id); | ||
17 | let root = db.parse_or_expand(file_id).unwrap(); | ||
18 | let ast_id_map = db.ast_id_map(file_id); | ||
19 | |||
20 | // Traverse the item tree and collect all module/impl/trait-level items as AST nodes. | ||
21 | let mut outer_items = FxHashSet::default(); | ||
22 | let mut worklist = tree.top_level_items().to_vec(); | ||
23 | while let Some(item) = worklist.pop() { | ||
24 | let node: ast::Item = match item { | ||
25 | ModItem::Import(it) => tree.source(&db, InFile::new(file_id, it)).into(), | ||
26 | ModItem::ExternCrate(it) => tree.source(&db, InFile::new(file_id, it)).into(), | ||
27 | ModItem::Function(it) => tree.source(&db, InFile::new(file_id, it)).into(), | ||
28 | ModItem::Struct(it) => tree.source(&db, InFile::new(file_id, it)).into(), | ||
29 | ModItem::Union(it) => tree.source(&db, InFile::new(file_id, it)).into(), | ||
30 | ModItem::Enum(it) => tree.source(&db, InFile::new(file_id, it)).into(), | ||
31 | ModItem::Const(it) => tree.source(&db, InFile::new(file_id, it)).into(), | ||
32 | ModItem::Static(it) => tree.source(&db, InFile::new(file_id, it)).into(), | ||
33 | ModItem::TypeAlias(it) => tree.source(&db, InFile::new(file_id, it)).into(), | ||
34 | ModItem::Mod(it) => { | ||
35 | if let ModKind::Inline { items } = &tree[it].kind { | ||
36 | worklist.extend(&**items); | ||
37 | } | ||
38 | tree.source(&db, InFile::new(file_id, it)).into() | ||
39 | } | ||
40 | ModItem::Trait(it) => { | ||
41 | worklist.extend(tree[it].items.iter().map(|item| ModItem::from(*item))); | ||
42 | tree.source(&db, InFile::new(file_id, it)).into() | ||
43 | } | ||
44 | ModItem::Impl(it) => { | ||
45 | worklist.extend(tree[it].items.iter().map(|item| ModItem::from(*item))); | ||
46 | tree.source(&db, InFile::new(file_id, it)).into() | ||
47 | } | ||
48 | ModItem::MacroCall(_) => continue, | ||
49 | }; | ||
50 | |||
51 | outer_items.insert(node); | ||
52 | } | ||
53 | |||
54 | // Now descend the root node and check that all `ast::ModuleItem`s are either recorded above, or | ||
55 | // registered as inner items. | ||
56 | for item in root.descendants().skip(1).filter_map(ast::Item::cast) { | ||
57 | if outer_items.contains(&item) { | ||
58 | continue; | ||
59 | } | ||
60 | |||
61 | let ast_id = ast_id_map.ast_id(&item); | ||
62 | assert!(!tree.inner_items(ast_id).is_empty()); | ||
63 | } | ||
64 | } | ||
65 | |||
66 | fn item_tree(ra_fixture: &str) -> Arc<ItemTree> { | ||
67 | let (db, file_id) = TestDB::with_single_file(ra_fixture); | ||
68 | db.item_tree(file_id.into()) | ||
69 | } | ||
70 | |||
71 | fn print_item_tree(ra_fixture: &str) -> String { | ||
72 | let tree = item_tree(ra_fixture); | ||
73 | let mut out = String::new(); | ||
74 | |||
75 | format_to!(out, "inner attrs: {:?}\n\n", tree.top_level_attrs()); | ||
76 | format_to!(out, "top-level items:\n"); | ||
77 | for item in tree.top_level_items() { | ||
78 | fmt_mod_item(&mut out, &tree, *item); | ||
79 | format_to!(out, "\n"); | ||
80 | } | ||
81 | |||
82 | if !tree.inner_items.is_empty() { | ||
83 | format_to!(out, "\ninner items:\n\n"); | ||
84 | for (ast_id, items) in &tree.inner_items { | ||
85 | format_to!(out, "for AST {:?}:\n", ast_id); | ||
86 | for inner in items { | ||
87 | fmt_mod_item(&mut out, &tree, *inner); | ||
88 | format_to!(out, "\n\n"); | ||
89 | } | ||
90 | } | ||
91 | } | ||
92 | |||
93 | out | ||
94 | } | ||
95 | |||
96 | fn fmt_mod_item(out: &mut String, tree: &ItemTree, item: ModItem) { | ||
97 | let attrs = tree.attrs(item.into()); | ||
98 | if !attrs.is_empty() { | ||
99 | format_to!(out, "#[{:?}]\n", attrs); | ||
100 | } | ||
101 | |||
102 | let mut children = String::new(); | ||
103 | match item { | ||
104 | ModItem::ExternCrate(it) => { | ||
105 | format_to!(out, "{:?}", tree[it]); | ||
106 | } | ||
107 | ModItem::Import(it) => { | ||
108 | format_to!(out, "{:?}", tree[it]); | ||
109 | } | ||
110 | ModItem::Function(it) => { | ||
111 | format_to!(out, "{:?}", tree[it]); | ||
112 | } | ||
113 | ModItem::Struct(it) => { | ||
114 | format_to!(out, "{:?}", tree[it]); | ||
115 | } | ||
116 | ModItem::Union(it) => { | ||
117 | format_to!(out, "{:?}", tree[it]); | ||
118 | } | ||
119 | ModItem::Enum(it) => { | ||
120 | format_to!(out, "{:?}", tree[it]); | ||
121 | } | ||
122 | ModItem::Const(it) => { | ||
123 | format_to!(out, "{:?}", tree[it]); | ||
124 | } | ||
125 | ModItem::Static(it) => { | ||
126 | format_to!(out, "{:?}", tree[it]); | ||
127 | } | ||
128 | ModItem::Trait(it) => { | ||
129 | format_to!(out, "{:?}", tree[it]); | ||
130 | for item in &*tree[it].items { | ||
131 | fmt_mod_item(&mut children, tree, ModItem::from(*item)); | ||
132 | format_to!(children, "\n"); | ||
133 | } | ||
134 | } | ||
135 | ModItem::Impl(it) => { | ||
136 | format_to!(out, "{:?}", tree[it]); | ||
137 | for item in &*tree[it].items { | ||
138 | fmt_mod_item(&mut children, tree, ModItem::from(*item)); | ||
139 | format_to!(children, "\n"); | ||
140 | } | ||
141 | } | ||
142 | ModItem::TypeAlias(it) => { | ||
143 | format_to!(out, "{:?}", tree[it]); | ||
144 | } | ||
145 | ModItem::Mod(it) => { | ||
146 | format_to!(out, "{:?}", tree[it]); | ||
147 | match &tree[it].kind { | ||
148 | ModKind::Inline { items } => { | ||
149 | for item in &**items { | ||
150 | fmt_mod_item(&mut children, tree, *item); | ||
151 | format_to!(children, "\n"); | ||
152 | } | ||
153 | } | ||
154 | ModKind::Outline {} => {} | ||
155 | } | ||
156 | } | ||
157 | ModItem::MacroCall(it) => { | ||
158 | format_to!(out, "{:?}", tree[it]); | ||
159 | } | ||
160 | } | ||
161 | |||
162 | for line in children.lines() { | ||
163 | format_to!(out, "\n> {}", line); | ||
164 | } | ||
165 | } | ||
166 | |||
167 | fn check(ra_fixture: &str, expect: Expect) { | ||
168 | let actual = print_item_tree(ra_fixture); | ||
169 | expect.assert_eq(&actual); | ||
170 | } | ||
171 | |||
172 | #[test] | ||
173 | fn smoke() { | ||
174 | check( | ||
175 | r" | ||
176 | #![attr] | ||
177 | |||
178 | #[attr_on_use] | ||
179 | use {a, b::*}; | ||
180 | |||
181 | #[ext_crate] | ||
182 | extern crate krate; | ||
183 | |||
184 | #[on_trait] | ||
185 | trait Tr<U> { | ||
186 | #[assoc_ty] | ||
187 | type AssocTy: Tr<()>; | ||
188 | |||
189 | #[assoc_const] | ||
190 | const CONST: u8; | ||
191 | |||
192 | #[assoc_method] | ||
193 | fn method(&self); | ||
194 | |||
195 | #[assoc_dfl_method] | ||
196 | fn dfl_method(&mut self) {} | ||
197 | } | ||
198 | |||
199 | #[struct0] | ||
200 | struct Struct0<T = ()>; | ||
201 | |||
202 | #[struct1] | ||
203 | struct Struct1<T>(#[struct1fld] u8); | ||
204 | |||
205 | #[struct2] | ||
206 | struct Struct2<T> { | ||
207 | #[struct2fld] | ||
208 | fld: (T, ), | ||
209 | } | ||
210 | |||
211 | #[en] | ||
212 | enum En { | ||
213 | #[enum_variant] | ||
214 | Variant { | ||
215 | #[enum_field] | ||
216 | field: u8, | ||
217 | }, | ||
218 | } | ||
219 | |||
220 | #[un] | ||
221 | union Un { | ||
222 | #[union_fld] | ||
223 | fld: u16, | ||
224 | } | ||
225 | ", | ||
226 | expect![[r##" | ||
227 | inner attrs: Attrs { entries: Some([Attr { path: ModPath { kind: Plain, segments: [Name(Text("attr"))] }, input: None }]) } | ||
228 | |||
229 | top-level items: | ||
230 | #[Attrs { entries: Some([Attr { path: ModPath { kind: Plain, segments: [Name(Text("attr_on_use"))] }, input: None }]) }] | ||
231 | Import { path: ModPath { kind: Plain, segments: [Name(Text("a"))] }, alias: None, visibility: RawVisibilityId("pub(self)"), is_glob: false, is_prelude: false, ast_id: FileAstId::<syntax::ast::generated::nodes::Use>(0) } | ||
232 | #[Attrs { entries: Some([Attr { path: ModPath { kind: Plain, segments: [Name(Text("attr_on_use"))] }, input: None }]) }] | ||
233 | Import { path: ModPath { kind: Plain, segments: [Name(Text("b"))] }, alias: None, visibility: RawVisibilityId("pub(self)"), is_glob: true, is_prelude: false, ast_id: FileAstId::<syntax::ast::generated::nodes::Use>(0) } | ||
234 | #[Attrs { entries: Some([Attr { path: ModPath { kind: Plain, segments: [Name(Text("ext_crate"))] }, input: None }]) }] | ||
235 | ExternCrate { path: ModPath { kind: Plain, segments: [Name(Text("krate"))] }, alias: None, visibility: RawVisibilityId("pub(self)"), is_macro_use: false, ast_id: FileAstId::<syntax::ast::generated::nodes::ExternCrate>(1) } | ||
236 | #[Attrs { entries: Some([Attr { path: ModPath { kind: Plain, segments: [Name(Text("on_trait"))] }, input: None }]) }] | ||
237 | Trait { name: Name(Text("Tr")), visibility: RawVisibilityId("pub(self)"), generic_params: GenericParamsId(0), auto: false, items: [TypeAlias(Idx::<TypeAlias>(0)), Const(Idx::<Const>(0)), Function(Idx::<Function>(0)), Function(Idx::<Function>(1))], ast_id: FileAstId::<syntax::ast::generated::nodes::Trait>(2) } | ||
238 | > #[Attrs { entries: Some([Attr { path: ModPath { kind: Plain, segments: [Name(Text("assoc_ty"))] }, input: None }]) }] | ||
239 | > TypeAlias { name: Name(Text("AssocTy")), visibility: RawVisibilityId("pub(self)"), bounds: [Path(Path { type_anchor: None, mod_path: ModPath { kind: Plain, segments: [Name(Text("Tr"))] }, generic_args: [Some(GenericArgs { args: [Type(Tuple([]))], has_self_type: false, bindings: [] })] })], generic_params: GenericParamsId(4294967295), type_ref: None, ast_id: FileAstId::<syntax::ast::generated::nodes::TypeAlias>(8) } | ||
240 | > #[Attrs { entries: Some([Attr { path: ModPath { kind: Plain, segments: [Name(Text("assoc_const"))] }, input: None }]) }] | ||
241 | > Const { name: Some(Name(Text("CONST"))), visibility: RawVisibilityId("pub(self)"), type_ref: Path(Path { type_anchor: None, mod_path: ModPath { kind: Plain, segments: [Name(Text("u8"))] }, generic_args: [None] }), ast_id: FileAstId::<syntax::ast::generated::nodes::Const>(9) } | ||
242 | > #[Attrs { entries: Some([Attr { path: ModPath { kind: Plain, segments: [Name(Text("assoc_method"))] }, input: None }]) }] | ||
243 | > Function { name: Name(Text("method")), visibility: RawVisibilityId("pub(self)"), generic_params: GenericParamsId(4294967295), has_self_param: true, is_unsafe: false, params: [Reference(Path(Path { type_anchor: None, mod_path: ModPath { kind: Plain, segments: [Name(Text("Self"))] }, generic_args: [None] }), Shared)], is_varargs: false, ret_type: Tuple([]), ast_id: FileAstId::<syntax::ast::generated::nodes::Fn>(10) } | ||
244 | > #[Attrs { entries: Some([Attr { path: ModPath { kind: Plain, segments: [Name(Text("assoc_dfl_method"))] }, input: None }]) }] | ||
245 | > Function { name: Name(Text("dfl_method")), visibility: RawVisibilityId("pub(self)"), generic_params: GenericParamsId(4294967295), has_self_param: true, is_unsafe: false, params: [Reference(Path(Path { type_anchor: None, mod_path: ModPath { kind: Plain, segments: [Name(Text("Self"))] }, generic_args: [None] }), Mut)], is_varargs: false, ret_type: Tuple([]), ast_id: FileAstId::<syntax::ast::generated::nodes::Fn>(11) } | ||
246 | #[Attrs { entries: Some([Attr { path: ModPath { kind: Plain, segments: [Name(Text("struct0"))] }, input: None }]) }] | ||
247 | Struct { name: Name(Text("Struct0")), visibility: RawVisibilityId("pub(self)"), generic_params: GenericParamsId(1), fields: Unit, ast_id: FileAstId::<syntax::ast::generated::nodes::Struct>(3), kind: Unit } | ||
248 | #[Attrs { entries: Some([Attr { path: ModPath { kind: Plain, segments: [Name(Text("struct1"))] }, input: None }]) }] | ||
249 | Struct { name: Name(Text("Struct1")), visibility: RawVisibilityId("pub(self)"), generic_params: GenericParamsId(2), fields: Tuple(IdRange::<hir_def::item_tree::Field>(0..1)), ast_id: FileAstId::<syntax::ast::generated::nodes::Struct>(4), kind: Tuple } | ||
250 | #[Attrs { entries: Some([Attr { path: ModPath { kind: Plain, segments: [Name(Text("struct2"))] }, input: None }]) }] | ||
251 | Struct { name: Name(Text("Struct2")), visibility: RawVisibilityId("pub(self)"), generic_params: GenericParamsId(3), fields: Record(IdRange::<hir_def::item_tree::Field>(1..2)), ast_id: FileAstId::<syntax::ast::generated::nodes::Struct>(5), kind: Record } | ||
252 | #[Attrs { entries: Some([Attr { path: ModPath { kind: Plain, segments: [Name(Text("en"))] }, input: None }]) }] | ||
253 | Enum { name: Name(Text("En")), visibility: RawVisibilityId("pub(self)"), generic_params: GenericParamsId(4294967295), variants: IdRange::<hir_def::item_tree::Variant>(0..1), ast_id: FileAstId::<syntax::ast::generated::nodes::Enum>(6) } | ||
254 | #[Attrs { entries: Some([Attr { path: ModPath { kind: Plain, segments: [Name(Text("un"))] }, input: None }]) }] | ||
255 | Union { name: Name(Text("Un")), visibility: RawVisibilityId("pub(self)"), generic_params: GenericParamsId(4294967295), fields: Record(IdRange::<hir_def::item_tree::Field>(3..4)), ast_id: FileAstId::<syntax::ast::generated::nodes::Union>(7) } | ||
256 | "##]], | ||
257 | ); | ||
258 | } | ||
259 | |||
260 | #[test] | ||
261 | fn simple_inner_items() { | ||
262 | check( | ||
263 | r" | ||
264 | impl<T:A> D for Response<T> { | ||
265 | fn foo() { | ||
266 | end(); | ||
267 | fn end<W: Write>() { | ||
268 | let _x: T = loop {}; | ||
269 | } | ||
270 | } | ||
271 | } | ||
272 | ", | ||
273 | expect![[r#" | ||
274 | inner attrs: Attrs { entries: None } | ||
275 | |||
276 | top-level items: | ||
277 | Impl { generic_params: GenericParamsId(0), target_trait: Some(Path(Path { type_anchor: None, mod_path: ModPath { kind: Plain, segments: [Name(Text("D"))] }, generic_args: [None] })), target_type: Path(Path { type_anchor: None, mod_path: ModPath { kind: Plain, segments: [Name(Text("Response"))] }, generic_args: [Some(GenericArgs { args: [Type(Path(Path { type_anchor: None, mod_path: ModPath { kind: Plain, segments: [Name(Text("T"))] }, generic_args: [None] }))], has_self_type: false, bindings: [] })] }), is_negative: false, items: [Function(Idx::<Function>(1))], ast_id: FileAstId::<syntax::ast::generated::nodes::Impl>(0) } | ||
278 | > Function { name: Name(Text("foo")), visibility: RawVisibilityId("pub(self)"), generic_params: GenericParamsId(4294967295), has_self_param: false, is_unsafe: false, params: [], is_varargs: false, ret_type: Tuple([]), ast_id: FileAstId::<syntax::ast::generated::nodes::Fn>(1) } | ||
279 | |||
280 | inner items: | ||
281 | |||
282 | for AST FileAstId::<syntax::ast::generated::nodes::Item>(2): | ||
283 | Function { name: Name(Text("end")), visibility: RawVisibilityId("pub(self)"), generic_params: GenericParamsId(1), has_self_param: false, is_unsafe: false, params: [], is_varargs: false, ret_type: Tuple([]), ast_id: FileAstId::<syntax::ast::generated::nodes::Fn>(2) } | ||
284 | |||
285 | "#]], | ||
286 | ); | ||
287 | } | ||
288 | |||
289 | #[test] | ||
290 | fn extern_attrs() { | ||
291 | check( | ||
292 | r#" | ||
293 | #[block_attr] | ||
294 | extern "C" { | ||
295 | #[attr_a] | ||
296 | fn a() {} | ||
297 | #[attr_b] | ||
298 | fn b() {} | ||
299 | } | ||
300 | "#, | ||
301 | expect![[r##" | ||
302 | inner attrs: Attrs { entries: None } | ||
303 | |||
304 | top-level items: | ||
305 | #[Attrs { entries: Some([Attr { path: ModPath { kind: Plain, segments: [Name(Text("attr_a"))] }, input: None }, Attr { path: ModPath { kind: Plain, segments: [Name(Text("block_attr"))] }, input: None }]) }] | ||
306 | Function { name: Name(Text("a")), visibility: RawVisibilityId("pub(self)"), generic_params: GenericParamsId(4294967295), has_self_param: false, is_unsafe: true, params: [], is_varargs: false, ret_type: Tuple([]), ast_id: FileAstId::<syntax::ast::generated::nodes::Fn>(1) } | ||
307 | #[Attrs { entries: Some([Attr { path: ModPath { kind: Plain, segments: [Name(Text("attr_b"))] }, input: None }, Attr { path: ModPath { kind: Plain, segments: [Name(Text("block_attr"))] }, input: None }]) }] | ||
308 | Function { name: Name(Text("b")), visibility: RawVisibilityId("pub(self)"), generic_params: GenericParamsId(4294967295), has_self_param: false, is_unsafe: true, params: [], is_varargs: false, ret_type: Tuple([]), ast_id: FileAstId::<syntax::ast::generated::nodes::Fn>(2) } | ||
309 | "##]], | ||
310 | ); | ||
311 | } | ||
312 | |||
313 | #[test] | ||
314 | fn trait_attrs() { | ||
315 | check( | ||
316 | r#" | ||
317 | #[trait_attr] | ||
318 | trait Tr { | ||
319 | #[attr_a] | ||
320 | fn a() {} | ||
321 | #[attr_b] | ||
322 | fn b() {} | ||
323 | } | ||
324 | "#, | ||
325 | expect![[r##" | ||
326 | inner attrs: Attrs { entries: None } | ||
327 | |||
328 | top-level items: | ||
329 | #[Attrs { entries: Some([Attr { path: ModPath { kind: Plain, segments: [Name(Text("trait_attr"))] }, input: None }]) }] | ||
330 | Trait { name: Name(Text("Tr")), visibility: RawVisibilityId("pub(self)"), generic_params: GenericParamsId(0), auto: false, items: [Function(Idx::<Function>(0)), Function(Idx::<Function>(1))], ast_id: FileAstId::<syntax::ast::generated::nodes::Trait>(0) } | ||
331 | > #[Attrs { entries: Some([Attr { path: ModPath { kind: Plain, segments: [Name(Text("attr_a"))] }, input: None }]) }] | ||
332 | > Function { name: Name(Text("a")), visibility: RawVisibilityId("pub(self)"), generic_params: GenericParamsId(4294967295), has_self_param: false, is_unsafe: false, params: [], is_varargs: false, ret_type: Tuple([]), ast_id: FileAstId::<syntax::ast::generated::nodes::Fn>(1) } | ||
333 | > #[Attrs { entries: Some([Attr { path: ModPath { kind: Plain, segments: [Name(Text("attr_b"))] }, input: None }]) }] | ||
334 | > Function { name: Name(Text("b")), visibility: RawVisibilityId("pub(self)"), generic_params: GenericParamsId(4294967295), has_self_param: false, is_unsafe: false, params: [], is_varargs: false, ret_type: Tuple([]), ast_id: FileAstId::<syntax::ast::generated::nodes::Fn>(2) } | ||
335 | "##]], | ||
336 | ); | ||
337 | } | ||
338 | |||
339 | #[test] | ||
340 | fn impl_attrs() { | ||
341 | check( | ||
342 | r#" | ||
343 | #[impl_attr] | ||
344 | impl Ty { | ||
345 | #[attr_a] | ||
346 | fn a() {} | ||
347 | #[attr_b] | ||
348 | fn b() {} | ||
349 | } | ||
350 | "#, | ||
351 | expect![[r##" | ||
352 | inner attrs: Attrs { entries: None } | ||
353 | |||
354 | top-level items: | ||
355 | #[Attrs { entries: Some([Attr { path: ModPath { kind: Plain, segments: [Name(Text("impl_attr"))] }, input: None }]) }] | ||
356 | Impl { generic_params: GenericParamsId(4294967295), target_trait: None, target_type: Path(Path { type_anchor: None, mod_path: ModPath { kind: Plain, segments: [Name(Text("Ty"))] }, generic_args: [None] }), is_negative: false, items: [Function(Idx::<Function>(0)), Function(Idx::<Function>(1))], ast_id: FileAstId::<syntax::ast::generated::nodes::Impl>(0) } | ||
357 | > #[Attrs { entries: Some([Attr { path: ModPath { kind: Plain, segments: [Name(Text("attr_a"))] }, input: None }]) }] | ||
358 | > Function { name: Name(Text("a")), visibility: RawVisibilityId("pub(self)"), generic_params: GenericParamsId(4294967295), has_self_param: false, is_unsafe: false, params: [], is_varargs: false, ret_type: Tuple([]), ast_id: FileAstId::<syntax::ast::generated::nodes::Fn>(1) } | ||
359 | > #[Attrs { entries: Some([Attr { path: ModPath { kind: Plain, segments: [Name(Text("attr_b"))] }, input: None }]) }] | ||
360 | > Function { name: Name(Text("b")), visibility: RawVisibilityId("pub(self)"), generic_params: GenericParamsId(4294967295), has_self_param: false, is_unsafe: false, params: [], is_varargs: false, ret_type: Tuple([]), ast_id: FileAstId::<syntax::ast::generated::nodes::Fn>(2) } | ||
361 | "##]], | ||
362 | ); | ||
363 | } | ||
364 | |||
365 | #[test] | ||
366 | fn cursed_inner_items() { | ||
367 | test_inner_items( | ||
368 | r" | ||
369 | struct S<T: Trait = [u8; { fn f() {} 0 }]>(T); | ||
370 | |||
371 | enum En { | ||
372 | Var1 { | ||
373 | t: [(); { trait Inner {} 0 }], | ||
374 | }, | ||
375 | |||
376 | Var2([u16; { enum Inner {} 0 }]), | ||
377 | } | ||
378 | |||
379 | type Ty = [En; { struct Inner; 0 }]; | ||
380 | |||
381 | impl En { | ||
382 | fn assoc() { | ||
383 | trait InnerTrait<T = [u8; { fn f() {} }]> {} | ||
384 | struct InnerStruct<T = [u8; { fn f() {} }]> {} | ||
385 | impl<T = [u8; { fn f() {} }]> InnerTrait for InnerStruct {} | ||
386 | } | ||
387 | } | ||
388 | |||
389 | trait Tr<T = [u8; { fn f() {} }]> { | ||
390 | type AssocTy = [u8; { fn f() {} }]; | ||
391 | |||
392 | const AssocConst: [u8; { fn f() {} }]; | ||
393 | } | ||
394 | ", | ||
395 | ); | ||
396 | } | ||
397 | |||
398 | #[test] | ||
399 | fn inner_item_attrs() { | ||
400 | check( | ||
401 | r" | ||
402 | fn foo() { | ||
403 | #[on_inner] | ||
404 | fn inner() {} | ||
405 | } | ||
406 | ", | ||
407 | expect![[r##" | ||
408 | inner attrs: Attrs { entries: None } | ||
409 | |||
410 | top-level items: | ||
411 | Function { name: Name(Text("foo")), visibility: RawVisibilityId("pub(self)"), generic_params: GenericParamsId(4294967295), has_self_param: false, is_unsafe: false, params: [], is_varargs: false, ret_type: Tuple([]), ast_id: FileAstId::<syntax::ast::generated::nodes::Fn>(0) } | ||
412 | |||
413 | inner items: | ||
414 | |||
415 | for AST FileAstId::<syntax::ast::generated::nodes::Item>(1): | ||
416 | #[Attrs { entries: Some([Attr { path: ModPath { kind: Plain, segments: [Name(Text("on_inner"))] }, input: None }]) }] | ||
417 | Function { name: Name(Text("inner")), visibility: RawVisibilityId("pub(self)"), generic_params: GenericParamsId(4294967295), has_self_param: false, is_unsafe: false, params: [], is_varargs: false, ret_type: Tuple([]), ast_id: FileAstId::<syntax::ast::generated::nodes::Fn>(1) } | ||
418 | |||
419 | "##]], | ||
420 | ); | ||
421 | } | ||
422 | |||
423 | #[test] | ||
424 | fn assoc_item_macros() { | ||
425 | check( | ||
426 | r" | ||
427 | impl S { | ||
428 | items!(); | ||
429 | } | ||
430 | ", | ||
431 | expect![[r#" | ||
432 | inner attrs: Attrs { entries: None } | ||
433 | |||
434 | top-level items: | ||
435 | Impl { generic_params: GenericParamsId(4294967295), target_trait: None, target_type: Path(Path { type_anchor: None, mod_path: ModPath { kind: Plain, segments: [Name(Text("S"))] }, generic_args: [None] }), is_negative: false, items: [MacroCall(Idx::<MacroCall>(0))], ast_id: FileAstId::<syntax::ast::generated::nodes::Impl>(0) } | ||
436 | > MacroCall { name: None, path: ModPath { kind: Plain, segments: [Name(Text("items"))] }, is_export: false, is_local_inner: false, is_builtin: false, ast_id: FileAstId::<syntax::ast::generated::nodes::MacroCall>(1) } | ||
437 | "#]], | ||
438 | ); | ||
439 | } | ||