diff options
Diffstat (limited to 'crates/hir_def/src/item_tree/lower.rs')
-rw-r--r-- | crates/hir_def/src/item_tree/lower.rs | 207 |
1 files changed, 120 insertions, 87 deletions
diff --git a/crates/hir_def/src/item_tree/lower.rs b/crates/hir_def/src/item_tree/lower.rs index 91cf75371..6208facd5 100644 --- a/crates/hir_def/src/item_tree/lower.rs +++ b/crates/hir_def/src/item_tree/lower.rs | |||
@@ -3,7 +3,6 @@ | |||
3 | use std::{collections::hash_map::Entry, mem, sync::Arc}; | 3 | use std::{collections::hash_map::Entry, mem, sync::Arc}; |
4 | 4 | ||
5 | use hir_expand::{ast_id_map::AstIdMap, hygiene::Hygiene, name::known, HirFileId}; | 5 | use hir_expand::{ast_id_map::AstIdMap, hygiene::Hygiene, name::known, HirFileId}; |
6 | use smallvec::SmallVec; | ||
7 | use syntax::{ | 6 | use syntax::{ |
8 | ast::{self, ModuleItemOwner}, | 7 | ast::{self, ModuleItemOwner}, |
9 | SyntaxNode, WalkEvent, | 8 | SyntaxNode, WalkEvent, |
@@ -20,22 +19,10 @@ fn id<N: ItemTreeNode>(index: Idx<N>) -> FileItemTreeId<N> { | |||
20 | FileItemTreeId { index, _p: PhantomData } | 19 | FileItemTreeId { index, _p: PhantomData } |
21 | } | 20 | } |
22 | 21 | ||
23 | struct ModItems(SmallVec<[ModItem; 1]>); | ||
24 | |||
25 | impl<T> From<T> for ModItems | ||
26 | where | ||
27 | T: Into<ModItem>, | ||
28 | { | ||
29 | fn from(t: T) -> Self { | ||
30 | ModItems(SmallVec::from_buf([t.into(); 1])) | ||
31 | } | ||
32 | } | ||
33 | |||
34 | pub(super) struct Ctx<'a> { | 22 | pub(super) struct Ctx<'a> { |
35 | db: &'a dyn DefDatabase, | 23 | db: &'a dyn DefDatabase, |
36 | tree: ItemTree, | 24 | tree: ItemTree, |
37 | hygiene: Hygiene, | 25 | hygiene: Hygiene, |
38 | file: HirFileId, | ||
39 | source_ast_id_map: Arc<AstIdMap>, | 26 | source_ast_id_map: Arc<AstIdMap>, |
40 | body_ctx: crate::body::LowerCtx<'a>, | 27 | body_ctx: crate::body::LowerCtx<'a>, |
41 | forced_visibility: Option<RawVisibilityId>, | 28 | forced_visibility: Option<RawVisibilityId>, |
@@ -47,7 +34,6 @@ impl<'a> Ctx<'a> { | |||
47 | db, | 34 | db, |
48 | tree: ItemTree::default(), | 35 | tree: ItemTree::default(), |
49 | hygiene, | 36 | hygiene, |
50 | file, | ||
51 | source_ast_id_map: db.ast_id_map(file), | 37 | source_ast_id_map: db.ast_id_map(file), |
52 | body_ctx: crate::body::LowerCtx::new(db, file), | 38 | body_ctx: crate::body::LowerCtx::new(db, file), |
53 | forced_visibility: None, | 39 | forced_visibility: None, |
@@ -55,11 +41,8 @@ impl<'a> Ctx<'a> { | |||
55 | } | 41 | } |
56 | 42 | ||
57 | pub(super) fn lower_module_items(mut self, item_owner: &dyn ModuleItemOwner) -> ItemTree { | 43 | pub(super) fn lower_module_items(mut self, item_owner: &dyn ModuleItemOwner) -> ItemTree { |
58 | self.tree.top_level = item_owner | 44 | self.tree.top_level = |
59 | .items() | 45 | item_owner.items().flat_map(|item| self.lower_mod_item(&item, false)).collect(); |
60 | .flat_map(|item| self.lower_mod_item(&item, false)) | ||
61 | .flat_map(|items| items.0) | ||
62 | .collect(); | ||
63 | self.tree | 46 | self.tree |
64 | } | 47 | } |
65 | 48 | ||
@@ -71,7 +54,6 @@ impl<'a> Ctx<'a> { | |||
71 | _ => None, | 54 | _ => None, |
72 | }) | 55 | }) |
73 | .flat_map(|item| self.lower_mod_item(&item, false)) | 56 | .flat_map(|item| self.lower_mod_item(&item, false)) |
74 | .flat_map(|items| items.0) | ||
75 | .collect(); | 57 | .collect(); |
76 | 58 | ||
77 | // Non-items need to have their inner items collected. | 59 | // Non-items need to have their inner items collected. |
@@ -98,7 +80,7 @@ impl<'a> Ctx<'a> { | |||
98 | self.tree.data_mut() | 80 | self.tree.data_mut() |
99 | } | 81 | } |
100 | 82 | ||
101 | fn lower_mod_item(&mut self, item: &ast::Item, inner: bool) -> Option<ModItems> { | 83 | fn lower_mod_item(&mut self, item: &ast::Item, inner: bool) -> Option<ModItem> { |
102 | // Collect inner items for 1-to-1-lowered items. | 84 | // Collect inner items for 1-to-1-lowered items. |
103 | match item { | 85 | match item { |
104 | ast::Item::Struct(_) | 86 | ast::Item::Struct(_) |
@@ -129,34 +111,28 @@ impl<'a> Ctx<'a> { | |||
129 | }; | 111 | }; |
130 | 112 | ||
131 | let attrs = RawAttrs::new(self.db, item, &self.hygiene); | 113 | let attrs = RawAttrs::new(self.db, item, &self.hygiene); |
132 | let items = match item { | 114 | let item: ModItem = match item { |
133 | ast::Item::Struct(ast) => self.lower_struct(ast).map(Into::into), | 115 | ast::Item::Struct(ast) => self.lower_struct(ast)?.into(), |
134 | ast::Item::Union(ast) => self.lower_union(ast).map(Into::into), | 116 | ast::Item::Union(ast) => self.lower_union(ast)?.into(), |
135 | ast::Item::Enum(ast) => self.lower_enum(ast).map(Into::into), | 117 | ast::Item::Enum(ast) => self.lower_enum(ast)?.into(), |
136 | ast::Item::Fn(ast) => self.lower_function(ast).map(Into::into), | 118 | ast::Item::Fn(ast) => self.lower_function(ast)?.into(), |
137 | ast::Item::TypeAlias(ast) => self.lower_type_alias(ast).map(Into::into), | 119 | ast::Item::TypeAlias(ast) => self.lower_type_alias(ast)?.into(), |
138 | ast::Item::Static(ast) => self.lower_static(ast).map(Into::into), | 120 | ast::Item::Static(ast) => self.lower_static(ast)?.into(), |
139 | ast::Item::Const(ast) => Some(self.lower_const(ast).into()), | 121 | ast::Item::Const(ast) => self.lower_const(ast).into(), |
140 | ast::Item::Module(ast) => self.lower_module(ast).map(Into::into), | 122 | ast::Item::Module(ast) => self.lower_module(ast)?.into(), |
141 | ast::Item::Trait(ast) => self.lower_trait(ast).map(Into::into), | 123 | ast::Item::Trait(ast) => self.lower_trait(ast)?.into(), |
142 | ast::Item::Impl(ast) => self.lower_impl(ast).map(Into::into), | 124 | ast::Item::Impl(ast) => self.lower_impl(ast)?.into(), |
143 | ast::Item::Use(ast) => Some(ModItems( | 125 | ast::Item::Use(ast) => self.lower_use(ast)?.into(), |
144 | self.lower_use(ast).into_iter().map(Into::into).collect::<SmallVec<_>>(), | 126 | ast::Item::ExternCrate(ast) => self.lower_extern_crate(ast)?.into(), |
145 | )), | 127 | ast::Item::MacroCall(ast) => self.lower_macro_call(ast)?.into(), |
146 | ast::Item::ExternCrate(ast) => self.lower_extern_crate(ast).map(Into::into), | 128 | ast::Item::MacroRules(ast) => self.lower_macro_rules(ast)?.into(), |
147 | ast::Item::MacroCall(ast) => self.lower_macro_call(ast).map(Into::into), | 129 | ast::Item::MacroDef(ast) => self.lower_macro_def(ast)?.into(), |
148 | ast::Item::MacroRules(ast) => self.lower_macro_rules(ast).map(Into::into), | 130 | ast::Item::ExternBlock(ast) => self.lower_extern_block(ast).into(), |
149 | ast::Item::MacroDef(ast) => self.lower_macro_def(ast).map(Into::into), | ||
150 | ast::Item::ExternBlock(ast) => Some(self.lower_extern_block(ast).into()), | ||
151 | }; | 131 | }; |
152 | 132 | ||
153 | if !attrs.is_empty() { | 133 | self.add_attrs(item.into(), attrs.clone()); |
154 | for item in items.iter().flat_map(|items| &items.0) { | ||
155 | self.add_attrs((*item).into(), attrs.clone()); | ||
156 | } | ||
157 | } | ||
158 | 134 | ||
159 | items | 135 | Some(item) |
160 | } | 136 | } |
161 | 137 | ||
162 | fn add_attrs(&mut self, item: AttrOwner, attrs: RawAttrs) { | 138 | fn add_attrs(&mut self, item: AttrOwner, attrs: RawAttrs) { |
@@ -190,12 +166,10 @@ impl<'a> Ctx<'a> { | |||
190 | }, | 166 | }, |
191 | ast::Item(item) => { | 167 | ast::Item(item) => { |
192 | // FIXME: This triggers for macro calls in expression/pattern/type position | 168 | // FIXME: This triggers for macro calls in expression/pattern/type position |
193 | let mod_items = self.lower_mod_item(&item, true); | 169 | let mod_item = self.lower_mod_item(&item, true); |
194 | let current_block = block_stack.last(); | 170 | let current_block = block_stack.last(); |
195 | if let (Some(mod_items), Some(block)) = (mod_items, current_block) { | 171 | if let (Some(mod_item), Some(block)) = (mod_item, current_block) { |
196 | if !mod_items.0.is_empty() { | 172 | self.data().inner_items.entry(*block).or_default().push(mod_item); |
197 | self.data().inner_items.entry(*block).or_default().extend(mod_items.0.iter().copied()); | ||
198 | } | ||
199 | } | 173 | } |
200 | }, | 174 | }, |
201 | _ => {} | 175 | _ => {} |
@@ -382,12 +356,13 @@ impl<'a> Ctx<'a> { | |||
382 | _ => TypeRef::unit(), | 356 | _ => TypeRef::unit(), |
383 | }; | 357 | }; |
384 | 358 | ||
385 | let ret_type = if func.async_token().is_some() { | 359 | let (ret_type, async_ret_type) = if func.async_token().is_some() { |
360 | let async_ret_type = ret_type.clone(); | ||
386 | let future_impl = desugar_future_path(ret_type); | 361 | let future_impl = desugar_future_path(ret_type); |
387 | let ty_bound = TypeBound::Path(future_impl); | 362 | let ty_bound = Interned::new(TypeBound::Path(future_impl)); |
388 | TypeRef::ImplTrait(vec![ty_bound]) | 363 | (TypeRef::ImplTrait(vec![ty_bound]), Some(async_ret_type)) |
389 | } else { | 364 | } else { |
390 | ret_type | 365 | (ret_type, None) |
391 | }; | 366 | }; |
392 | 367 | ||
393 | let abi = func.abi().map(lower_abi); | 368 | let abi = func.abi().map(lower_abi); |
@@ -421,6 +396,7 @@ impl<'a> Ctx<'a> { | |||
421 | abi, | 396 | abi, |
422 | params, | 397 | params, |
423 | ret_type: Interned::new(ret_type), | 398 | ret_type: Interned::new(ret_type), |
399 | async_ret_type: async_ret_type.map(Interned::new), | ||
424 | ast_id, | 400 | ast_id, |
425 | flags, | 401 | flags, |
426 | }; | 402 | }; |
@@ -480,10 +456,7 @@ impl<'a> Ctx<'a> { | |||
480 | items: module | 456 | items: module |
481 | .item_list() | 457 | .item_list() |
482 | .map(|list| { | 458 | .map(|list| { |
483 | list.items() | 459 | list.items().flat_map(|item| self.lower_mod_item(&item, false)).collect() |
484 | .flat_map(|item| self.lower_mod_item(&item, false)) | ||
485 | .flat_map(|items| items.0) | ||
486 | .collect() | ||
487 | }) | 460 | }) |
488 | .unwrap_or_else(|| { | 461 | .unwrap_or_else(|| { |
489 | cov_mark::hit!(name_res_works_for_broken_modules); | 462 | cov_mark::hit!(name_res_works_for_broken_modules); |
@@ -503,7 +476,6 @@ impl<'a> Ctx<'a> { | |||
503 | self.lower_generic_params_and_inner_items(GenericsOwner::Trait(trait_def), trait_def); | 476 | self.lower_generic_params_and_inner_items(GenericsOwner::Trait(trait_def), trait_def); |
504 | let is_auto = trait_def.auto_token().is_some(); | 477 | let is_auto = trait_def.auto_token().is_some(); |
505 | let is_unsafe = trait_def.unsafe_token().is_some(); | 478 | let is_unsafe = trait_def.unsafe_token().is_some(); |
506 | let bounds = self.lower_type_bounds(trait_def); | ||
507 | let items = trait_def.assoc_item_list().map(|list| { | 479 | let items = trait_def.assoc_item_list().map(|list| { |
508 | let db = self.db; | 480 | let db = self.db; |
509 | self.with_inherited_visibility(visibility, |this| { | 481 | self.with_inherited_visibility(visibility, |this| { |
@@ -526,7 +498,6 @@ impl<'a> Ctx<'a> { | |||
526 | generic_params, | 498 | generic_params, |
527 | is_auto, | 499 | is_auto, |
528 | is_unsafe, | 500 | is_unsafe, |
529 | bounds: bounds.into(), | ||
530 | items: items.unwrap_or_default(), | 501 | items: items.unwrap_or_default(), |
531 | ast_id, | 502 | ast_id, |
532 | }; | 503 | }; |
@@ -561,30 +532,13 @@ impl<'a> Ctx<'a> { | |||
561 | Some(id(self.data().impls.alloc(res))) | 532 | Some(id(self.data().impls.alloc(res))) |
562 | } | 533 | } |
563 | 534 | ||
564 | fn lower_use(&mut self, use_item: &ast::Use) -> Vec<FileItemTreeId<Import>> { | 535 | fn lower_use(&mut self, use_item: &ast::Use) -> Option<FileItemTreeId<Import>> { |
565 | let visibility = self.lower_visibility(use_item); | 536 | let visibility = self.lower_visibility(use_item); |
566 | let ast_id = self.source_ast_id_map.ast_id(use_item); | 537 | let ast_id = self.source_ast_id_map.ast_id(use_item); |
538 | let (use_tree, _) = lower_use_tree(self.db, &self.hygiene, use_item.use_tree()?)?; | ||
567 | 539 | ||
568 | // Every use item can expand to many `Import`s. | 540 | let res = Import { visibility, ast_id, use_tree }; |
569 | let mut imports = Vec::new(); | 541 | Some(id(self.data().imports.alloc(res))) |
570 | let tree = self.tree.data_mut(); | ||
571 | ModPath::expand_use_item( | ||
572 | self.db, | ||
573 | InFile::new(self.file, use_item.clone()), | ||
574 | &self.hygiene, | ||
575 | |path, _use_tree, is_glob, alias| { | ||
576 | imports.push(id(tree.imports.alloc(Import { | ||
577 | path: Interned::new(path), | ||
578 | alias, | ||
579 | visibility, | ||
580 | is_glob, | ||
581 | ast_id, | ||
582 | index: imports.len(), | ||
583 | }))); | ||
584 | }, | ||
585 | ); | ||
586 | |||
587 | imports | ||
588 | } | 542 | } |
589 | 543 | ||
590 | fn lower_extern_crate( | 544 | fn lower_extern_crate( |
@@ -738,11 +692,12 @@ impl<'a> Ctx<'a> { | |||
738 | Interned::new(generics) | 692 | Interned::new(generics) |
739 | } | 693 | } |
740 | 694 | ||
741 | fn lower_type_bounds(&mut self, node: &impl ast::TypeBoundsOwner) -> Vec<TypeBound> { | 695 | fn lower_type_bounds(&mut self, node: &impl ast::TypeBoundsOwner) -> Vec<Interned<TypeBound>> { |
742 | match node.type_bound_list() { | 696 | match node.type_bound_list() { |
743 | Some(bound_list) => { | 697 | Some(bound_list) => bound_list |
744 | bound_list.bounds().map(|it| TypeBound::from_ast(&self.body_ctx, it)).collect() | 698 | .bounds() |
745 | } | 699 | .map(|it| Interned::new(TypeBound::from_ast(&self.body_ctx, it))) |
700 | .collect(), | ||
746 | None => Vec::new(), | 701 | None => Vec::new(), |
747 | } | 702 | } |
748 | } | 703 | } |
@@ -810,7 +765,7 @@ fn desugar_future_path(orig: TypeRef) -> Path { | |||
810 | let binding = | 765 | let binding = |
811 | AssociatedTypeBinding { name: name![Output], type_ref: Some(orig), bounds: Vec::new() }; | 766 | AssociatedTypeBinding { name: name![Output], type_ref: Some(orig), bounds: Vec::new() }; |
812 | last.bindings.push(binding); | 767 | last.bindings.push(binding); |
813 | generic_args.push(Some(Arc::new(last))); | 768 | generic_args.push(Some(Interned::new(last))); |
814 | 769 | ||
815 | Path::from_known_path(path, generic_args) | 770 | Path::from_known_path(path, generic_args) |
816 | } | 771 | } |
@@ -883,3 +838,81 @@ fn lower_abi(abi: ast::Abi) -> Interned<str> { | |||
883 | } | 838 | } |
884 | } | 839 | } |
885 | } | 840 | } |
841 | |||
842 | struct UseTreeLowering<'a> { | ||
843 | db: &'a dyn DefDatabase, | ||
844 | hygiene: &'a Hygiene, | ||
845 | mapping: Arena<ast::UseTree>, | ||
846 | } | ||
847 | |||
848 | impl UseTreeLowering<'_> { | ||
849 | fn lower_use_tree(&mut self, tree: ast::UseTree) -> Option<UseTree> { | ||
850 | if let Some(use_tree_list) = tree.use_tree_list() { | ||
851 | let prefix = match tree.path() { | ||
852 | // E.g. use something::{{{inner}}}; | ||
853 | None => None, | ||
854 | // E.g. `use something::{inner}` (prefix is `None`, path is `something`) | ||
855 | // or `use something::{path::{inner::{innerer}}}` (prefix is `something::path`, path is `inner`) | ||
856 | Some(path) => { | ||
857 | match ModPath::from_src(self.db, path, &self.hygiene) { | ||
858 | Some(it) => Some(it), | ||
859 | None => return None, // FIXME: report errors somewhere | ||
860 | } | ||
861 | } | ||
862 | }; | ||
863 | |||
864 | let list = | ||
865 | use_tree_list.use_trees().filter_map(|tree| self.lower_use_tree(tree)).collect(); | ||
866 | |||
867 | Some( | ||
868 | self.use_tree( | ||
869 | UseTreeKind::Prefixed { prefix: prefix.map(Interned::new), list }, | ||
870 | tree, | ||
871 | ), | ||
872 | ) | ||
873 | } else { | ||
874 | let is_glob = tree.star_token().is_some(); | ||
875 | let path = match tree.path() { | ||
876 | Some(path) => Some(ModPath::from_src(self.db, path, &self.hygiene)?), | ||
877 | None => None, | ||
878 | }; | ||
879 | let alias = tree.rename().map(|a| { | ||
880 | a.name().map(|it| it.as_name()).map_or(ImportAlias::Underscore, ImportAlias::Alias) | ||
881 | }); | ||
882 | if alias.is_some() && is_glob { | ||
883 | return None; | ||
884 | } | ||
885 | |||
886 | match (path, alias, is_glob) { | ||
887 | (path, None, true) => { | ||
888 | if path.is_none() { | ||
889 | cov_mark::hit!(glob_enum_group); | ||
890 | } | ||
891 | Some(self.use_tree(UseTreeKind::Glob { path: path.map(Interned::new) }, tree)) | ||
892 | } | ||
893 | // Globs can't be renamed | ||
894 | (_, Some(_), true) | (None, None, false) => None, | ||
895 | // `bla::{ as Name}` is invalid | ||
896 | (None, Some(_), false) => None, | ||
897 | (Some(path), alias, false) => Some( | ||
898 | self.use_tree(UseTreeKind::Single { path: Interned::new(path), alias }, tree), | ||
899 | ), | ||
900 | } | ||
901 | } | ||
902 | } | ||
903 | |||
904 | fn use_tree(&mut self, kind: UseTreeKind, ast: ast::UseTree) -> UseTree { | ||
905 | let index = self.mapping.alloc(ast); | ||
906 | UseTree { index, kind } | ||
907 | } | ||
908 | } | ||
909 | |||
910 | pub(super) fn lower_use_tree( | ||
911 | db: &dyn DefDatabase, | ||
912 | hygiene: &Hygiene, | ||
913 | tree: ast::UseTree, | ||
914 | ) -> Option<(UseTree, Arena<ast::UseTree>)> { | ||
915 | let mut lowering = UseTreeLowering { db, hygiene, mapping: Arena::new() }; | ||
916 | let tree = lowering.lower_use_tree(tree)?; | ||
917 | Some((tree, lowering.mapping)) | ||
918 | } | ||