1 //! A simplified AST that only contains items.
3 //! This is the primary IR used throughout `hir_def`. It is the input to the name resolution
4 //! algorithm, as well as to the queries defined in `adt.rs`, `data.rs`, and most things in
7 //! `ItemTree`s are built per `HirFileId`, from the syntax tree of the parsed file. This means that
8 //! they are crate-independent: they don't know which `#[cfg]`s are active or which module they
9 //! belong to, since those concepts don't exist at this level (a single `ItemTree` might be part of
10 //! multiple crates, or might be included into the same crate twice via `#[path]`).
12 //! One important purpose of this layer is to provide an "invalidation barrier" for incremental
13 //! computations: when typing inside an item body, the `ItemTree` of the modified file is typically
14 //! unaffected, so we don't have to recompute name resolution results or item data (see `data.rs`).
16 //! The `ItemTree` for the currently open file can be displayed by using the VS Code command
17 //! "Rust Analyzer: Debug ItemTree".
19 //! Compared to rustc's architecture, `ItemTree` has properties from both rustc's AST and HIR: many
20 //! syntax-level Rust features are already desugared to simpler forms in the `ItemTree`, but name
21 //! resolution has not yet been performed. `ItemTree`s are per-file, while rustc's AST and HIR are
22 //! per-crate, because we are interested in incrementally computing it.
24 //! The representation of items in the `ItemTree` should generally mirror the surface syntax: it is
25 //! usually a bad idea to desugar a syntax-level construct to something that is structurally
26 //! different here. Name resolution needs to be able to process attributes and expand macros
27 //! (including attribute macros), and having a 1-to-1 mapping between syntax and the `ItemTree`
28 //! avoids introducing subtle bugs.
30 //! In general, any item in the `ItemTree` stores its `AstId`, which allows mapping it back to its
46 use ast::{AstNode, HasName, StructKind};
50 ast_id_map::FileAstId,
52 name::{name, AsName, Name},
53 ExpandTo, HirFileId, InFile,
55 use la_arena::{Arena, Idx, IdxRange, RawIdx};
57 use rustc_hash::FxHashMap;
58 use smallvec::SmallVec;
59 use syntax::{ast, match_ast, SyntaxKind};
62 attr::{Attrs, RawAttrs},
64 generics::GenericParams,
66 path::{path, AssociatedTypeBinding, GenericArgs, ImportAlias, ModPath, Path, PathKind},
67 type_ref::{Mutability, TraitRef, TypeBound, TypeRef},
68 visibility::RawVisibility,
72 #[derive(Copy, Clone, Eq, PartialEq)]
73 pub struct RawVisibilityId(u32);
75 impl RawVisibilityId {
76 pub const PUB: Self = RawVisibilityId(u32::max_value());
77 pub const PRIV: Self = RawVisibilityId(u32::max_value() - 1);
78 pub const PUB_CRATE: Self = RawVisibilityId(u32::max_value() - 2);
81 impl fmt::Debug for RawVisibilityId {
82 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
83 let mut f = f.debug_tuple("RawVisibilityId");
85 Self::PUB => f.field(&"pub"),
86 Self::PRIV => f.field(&"pub(self)"),
87 Self::PUB_CRATE => f.field(&"pub(crate)"),
88 _ => f.field(&self.0),
94 /// The item tree of a source file.
95 #[derive(Debug, Default, Eq, PartialEq)]
99 top_level: SmallVec<[ModItem; 1]>,
100 attrs: FxHashMap<AttrOwner, RawAttrs>,
102 data: Option<Box<ItemTreeData>>,
106 pub(crate) fn file_item_tree_query(db: &dyn DefDatabase, file_id: HirFileId) -> Arc<ItemTree> {
107 let _p = profile::span("file_item_tree_query").detail(|| format!("{:?}", file_id));
108 let syntax = match db.parse_or_expand(file_id) {
110 None => return Default::default(),
112 if syntax.kind() == SyntaxKind::ERROR {
113 // FIXME: not 100% sure why these crop up, but return an empty tree to avoid a panic
114 return Default::default();
117 let hygiene = Hygiene::new(db.upcast(), file_id);
118 let ctx = lower::Ctx::new(db, hygiene.clone(), file_id);
119 let mut top_attrs = None;
120 let mut item_tree = match_ast! {
122 ast::SourceFile(file) => {
123 top_attrs = Some(RawAttrs::new(db, &file, &hygiene));
124 ctx.lower_module_items(&file)
126 ast::MacroItems(items) => {
127 ctx.lower_module_items(&items)
129 ast::MacroStmts(stmts) => {
130 // The produced statements can include items, which should be added as top-level
132 ctx.lower_macro_stmts(stmts)
135 panic!("cannot create item tree from {:?} {}", syntax, syntax);
140 if let Some(attrs) = top_attrs {
141 item_tree.attrs.insert(AttrOwner::TopLevel, attrs);
143 item_tree.shrink_to_fit();
147 fn block_item_tree(db: &dyn DefDatabase, block: BlockId) -> Arc<ItemTree> {
148 let loc = db.lookup_intern_block(block);
149 let block = loc.ast_id.to_node(db.upcast());
150 let hygiene = Hygiene::new(db.upcast(), loc.ast_id.file_id);
151 let ctx = lower::Ctx::new(db, hygiene.clone(), loc.ast_id.file_id);
152 Arc::new(ctx.lower_block(&block))
155 fn shrink_to_fit(&mut self) {
156 if let Some(data) = &mut self.data {
180 imports.shrink_to_fit();
181 extern_crates.shrink_to_fit();
182 extern_blocks.shrink_to_fit();
183 functions.shrink_to_fit();
184 params.shrink_to_fit();
185 structs.shrink_to_fit();
186 fields.shrink_to_fit();
187 unions.shrink_to_fit();
188 enums.shrink_to_fit();
189 variants.shrink_to_fit();
190 consts.shrink_to_fit();
191 statics.shrink_to_fit();
192 traits.shrink_to_fit();
193 impls.shrink_to_fit();
194 type_aliases.shrink_to_fit();
195 mods.shrink_to_fit();
196 macro_calls.shrink_to_fit();
197 macro_rules.shrink_to_fit();
198 macro_defs.shrink_to_fit();
200 vis.arena.shrink_to_fit();
204 /// Returns an iterator over all items located at the top level of the `HirFileId` this
205 /// `ItemTree` was created from.
206 pub fn top_level_items(&self) -> &[ModItem] {
210 /// Returns the inner attributes of the source file.
211 pub fn top_level_attrs(&self, db: &dyn DefDatabase, krate: CrateId) -> Attrs {
212 self.attrs.get(&AttrOwner::TopLevel).unwrap_or(&RawAttrs::EMPTY).clone().filter(db, krate)
215 pub(crate) fn raw_attrs(&self, of: AttrOwner) -> &RawAttrs {
216 self.attrs.get(&of).unwrap_or(&RawAttrs::EMPTY)
219 pub fn attrs(&self, db: &dyn DefDatabase, krate: CrateId, of: AttrOwner) -> Attrs {
220 self.raw_attrs(of).clone().filter(db, krate)
223 pub fn pretty_print(&self) -> String {
224 pretty::print_item_tree(self)
227 fn data(&self) -> &ItemTreeData {
228 self.data.as_ref().expect("attempted to access data of empty ItemTree")
231 fn data_mut(&mut self) -> &mut ItemTreeData {
232 self.data.get_or_insert_with(Box::default)
236 #[derive(Default, Debug, Eq, PartialEq)]
237 struct ItemVisibilities {
238 arena: Arena<RawVisibility>,
241 impl ItemVisibilities {
242 fn alloc(&mut self, vis: RawVisibility) -> RawVisibilityId {
244 RawVisibility::Public => RawVisibilityId::PUB,
245 RawVisibility::Module(path) if path.segments().is_empty() => match &path.kind {
246 PathKind::Super(0) => RawVisibilityId::PRIV,
247 PathKind::Crate => RawVisibilityId::PUB_CRATE,
248 _ => RawVisibilityId(self.arena.alloc(vis).into_raw().into()),
250 _ => RawVisibilityId(self.arena.alloc(vis).into_raw().into()),
255 static VIS_PUB: RawVisibility = RawVisibility::Public;
256 static VIS_PRIV: RawVisibility = RawVisibility::Module(ModPath::from_kind(PathKind::Super(0)));
257 static VIS_PUB_CRATE: RawVisibility = RawVisibility::Module(ModPath::from_kind(PathKind::Crate));
259 #[derive(Default, Debug, Eq, PartialEq)]
260 struct ItemTreeData {
261 imports: Arena<Import>,
262 extern_crates: Arena<ExternCrate>,
263 extern_blocks: Arena<ExternBlock>,
264 functions: Arena<Function>,
265 params: Arena<Param>,
266 structs: Arena<Struct>,
267 fields: Arena<Field>,
268 unions: Arena<Union>,
270 variants: Arena<Variant>,
271 consts: Arena<Const>,
272 statics: Arena<Static>,
273 traits: Arena<Trait>,
275 type_aliases: Arena<TypeAlias>,
277 macro_calls: Arena<MacroCall>,
278 macro_rules: Arena<MacroRules>,
279 macro_defs: Arena<MacroDef>,
281 vis: ItemVisibilities,
284 #[derive(Debug, Eq, PartialEq, Hash)]
286 /// Attributes on an item.
288 /// Inner attributes of the source file.
291 Variant(Idx<Variant>),
296 macro_rules! from_attrs {
297 ( $( $var:ident($t:ty) ),+ ) => {
299 impl From<$t> for AttrOwner {
300 fn from(t: $t) -> AttrOwner {
308 from_attrs!(ModItem(ModItem), Variant(Idx<Variant>), Field(Idx<Field>), Param(Idx<Param>));
310 /// Trait implemented by all item nodes in the item tree.
311 pub trait ItemTreeNode: Clone {
312 type Source: AstNode + Into<ast::Item>;
314 fn ast_id(&self) -> FileAstId<Self::Source>;
316 /// Looks up an instance of `Self` in an item tree.
317 fn lookup(tree: &ItemTree, index: Idx<Self>) -> &Self;
319 /// Downcasts a `ModItem` to a `FileItemTreeId` specific to this type.
320 fn id_from_mod_item(mod_item: ModItem) -> Option<FileItemTreeId<Self>>;
322 /// Upcasts a `FileItemTreeId` to a generic `ModItem`.
323 fn id_to_mod_item(id: FileItemTreeId<Self>) -> ModItem;
326 pub struct FileItemTreeId<N: ItemTreeNode> {
331 impl<N: ItemTreeNode> Clone for FileItemTreeId<N> {
332 fn clone(&self) -> Self {
333 Self { index: self.index, _p: PhantomData }
336 impl<N: ItemTreeNode> Copy for FileItemTreeId<N> {}
338 impl<N: ItemTreeNode> PartialEq for FileItemTreeId<N> {
339 fn eq(&self, other: &FileItemTreeId<N>) -> bool {
340 self.index == other.index
343 impl<N: ItemTreeNode> Eq for FileItemTreeId<N> {}
345 impl<N: ItemTreeNode> Hash for FileItemTreeId<N> {
346 fn hash<H: Hasher>(&self, state: &mut H) {
347 self.index.hash(state)
351 impl<N: ItemTreeNode> fmt::Debug for FileItemTreeId<N> {
352 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
357 /// Identifies a particular [`ItemTree`].
358 #[derive(Debug, PartialEq, Eq, Clone, Copy, Hash)]
361 block: Option<BlockId>,
365 pub(crate) fn new(file: HirFileId, block: Option<BlockId>) -> Self {
369 pub(crate) fn item_tree(&self, db: &dyn DefDatabase) -> Arc<ItemTree> {
371 Some(block) => ItemTree::block_item_tree(db, block),
372 None => db.file_item_tree(self.file),
376 pub(crate) fn file_id(self) -> HirFileId {
380 pub(crate) fn is_block(self) -> bool {
386 pub struct ItemTreeId<N: ItemTreeNode> {
388 pub value: FileItemTreeId<N>,
391 impl<N: ItemTreeNode> ItemTreeId<N> {
392 pub fn new(tree: TreeId, idx: FileItemTreeId<N>) -> Self {
393 Self { tree, value: idx }
396 pub fn file_id(self) -> HirFileId {
400 pub fn tree_id(self) -> TreeId {
404 pub fn item_tree(self, db: &dyn DefDatabase) -> Arc<ItemTree> {
405 self.tree.item_tree(db)
409 impl<N: ItemTreeNode> Copy for ItemTreeId<N> {}
410 impl<N: ItemTreeNode> Clone for ItemTreeId<N> {
411 fn clone(&self) -> Self {
416 impl<N: ItemTreeNode> PartialEq for ItemTreeId<N> {
417 fn eq(&self, other: &Self) -> bool {
418 self.tree == other.tree && self.value == other.value
422 impl<N: ItemTreeNode> Eq for ItemTreeId<N> {}
424 impl<N: ItemTreeNode> Hash for ItemTreeId<N> {
425 fn hash<H: Hasher>(&self, state: &mut H) {
426 self.tree.hash(state);
427 self.value.hash(state);
431 macro_rules! mod_items {
432 ( $( $typ:ident in $fld:ident -> $ast:ty ),+ $(,)? ) => {
433 #[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)]
436 $typ(FileItemTreeId<$typ>),
441 impl From<FileItemTreeId<$typ>> for ModItem {
442 fn from(id: FileItemTreeId<$typ>) -> ModItem {
449 impl ItemTreeNode for $typ {
452 fn ast_id(&self) -> FileAstId<Self::Source> {
456 fn lookup(tree: &ItemTree, index: Idx<Self>) -> &Self {
457 &tree.data().$fld[index]
460 fn id_from_mod_item(mod_item: ModItem) -> Option<FileItemTreeId<Self>> {
462 ModItem::$typ(id) => Some(id),
467 fn id_to_mod_item(id: FileItemTreeId<Self>) -> ModItem {
472 impl Index<Idx<$typ>> for ItemTree {
475 fn index(&self, index: Idx<$typ>) -> &Self::Output {
476 &self.data().$fld[index]
484 Import in imports -> ast::Use,
485 ExternCrate in extern_crates -> ast::ExternCrate,
486 ExternBlock in extern_blocks -> ast::ExternBlock,
487 Function in functions -> ast::Fn,
488 Struct in structs -> ast::Struct,
489 Union in unions -> ast::Union,
490 Enum in enums -> ast::Enum,
491 Const in consts -> ast::Const,
492 Static in statics -> ast::Static,
493 Trait in traits -> ast::Trait,
494 Impl in impls -> ast::Impl,
495 TypeAlias in type_aliases -> ast::TypeAlias,
496 Mod in mods -> ast::Module,
497 MacroCall in macro_calls -> ast::MacroCall,
498 MacroRules in macro_rules -> ast::MacroRules,
499 MacroDef in macro_defs -> ast::MacroDef,
502 macro_rules! impl_index {
503 ( $($fld:ident: $t:ty),+ $(,)? ) => {
505 impl Index<Idx<$t>> for ItemTree {
508 fn index(&self, index: Idx<$t>) -> &Self::Output {
509 &self.data().$fld[index]
516 impl_index!(fields: Field, variants: Variant, params: Param);
518 impl Index<RawVisibilityId> for ItemTree {
519 type Output = RawVisibility;
520 fn index(&self, index: RawVisibilityId) -> &Self::Output {
522 RawVisibilityId::PRIV => &VIS_PRIV,
523 RawVisibilityId::PUB => &VIS_PUB,
524 RawVisibilityId::PUB_CRATE => &VIS_PUB_CRATE,
525 _ => &self.data().vis.arena[Idx::from_raw(index.0.into())],
530 impl<N: ItemTreeNode> Index<FileItemTreeId<N>> for ItemTree {
532 fn index(&self, id: FileItemTreeId<N>) -> &N {
533 N::lookup(self, id.index)
537 #[derive(Debug, Clone, Eq, PartialEq)]
539 pub visibility: RawVisibilityId,
540 pub ast_id: FileAstId<ast::Use>,
541 pub use_tree: UseTree,
544 #[derive(Debug, Clone, Eq, PartialEq)]
546 pub index: Idx<ast::UseTree>,
550 #[derive(Debug, Clone, Eq, PartialEq)]
551 pub enum UseTreeKind {
553 /// use path::to::Item;
554 /// use path::to::Item as Renamed;
555 /// use path::to::Trait as _;
557 Single { path: Interned<ModPath>, alias: Option<ImportAlias> },
560 /// use *; // (invalid, but can occur in nested tree)
563 Glob { path: Option<Interned<ModPath>> },
566 /// use prefix::{self, Item, ...};
568 Prefixed { prefix: Option<Interned<ModPath>>, list: Box<[UseTree]> },
571 #[derive(Debug, Clone, Eq, PartialEq)]
572 pub struct ExternCrate {
574 pub alias: Option<ImportAlias>,
575 pub visibility: RawVisibilityId,
576 pub ast_id: FileAstId<ast::ExternCrate>,
579 #[derive(Debug, Clone, Eq, PartialEq)]
580 pub struct ExternBlock {
581 pub abi: Option<Interned<str>>,
582 pub ast_id: FileAstId<ast::ExternBlock>,
583 pub children: Box<[ModItem]>,
586 #[derive(Debug, Clone, Eq, PartialEq)]
587 pub struct Function {
589 pub visibility: RawVisibilityId,
590 pub explicit_generic_params: Interned<GenericParams>,
591 pub abi: Option<Interned<str>>,
592 pub params: IdxRange<Param>,
593 pub ret_type: Interned<TypeRef>,
594 pub async_ret_type: Option<Interned<TypeRef>>,
595 pub ast_id: FileAstId<ast::Fn>,
596 pub(crate) flags: FnFlags,
599 #[derive(Debug, Clone, Eq, PartialEq)]
601 Normal(Interned<TypeRef>),
605 #[derive(Debug, Clone, Copy, Eq, PartialEq, Default)]
606 pub(crate) struct FnFlags {
610 pub(crate) const HAS_SELF_PARAM: u8 = 1 << 0;
611 pub(crate) const HAS_BODY: u8 = 1 << 1;
612 pub(crate) const IS_DEFAULT: u8 = 1 << 2;
613 pub(crate) const IS_CONST: u8 = 1 << 3;
614 pub(crate) const IS_ASYNC: u8 = 1 << 4;
615 pub(crate) const IS_UNSAFE: u8 = 1 << 5;
616 /// Whether the function is located in an `extern` block (*not* whether it is an
617 /// `extern "abi" fn`).
618 pub(crate) const IS_IN_EXTERN_BLOCK: u8 = 1 << 6;
619 pub(crate) const IS_VARARGS: u8 = 1 << 7;
622 #[derive(Debug, Clone, Eq, PartialEq)]
625 pub visibility: RawVisibilityId,
626 pub generic_params: Interned<GenericParams>,
628 pub ast_id: FileAstId<ast::Struct>,
631 #[derive(Debug, Clone, Eq, PartialEq)]
634 pub visibility: RawVisibilityId,
635 pub generic_params: Interned<GenericParams>,
637 pub ast_id: FileAstId<ast::Union>,
640 #[derive(Debug, Clone, Eq, PartialEq)]
643 pub visibility: RawVisibilityId,
644 pub generic_params: Interned<GenericParams>,
645 pub variants: IdxRange<Variant>,
646 pub ast_id: FileAstId<ast::Enum>,
649 #[derive(Debug, Clone, Eq, PartialEq)]
651 /// const _: () = ();
652 pub name: Option<Name>,
653 pub visibility: RawVisibilityId,
654 pub type_ref: Interned<TypeRef>,
655 pub ast_id: FileAstId<ast::Const>,
658 #[derive(Debug, Clone, Eq, PartialEq)]
661 pub visibility: RawVisibilityId,
663 /// Whether the static is in an `extern` block.
665 pub type_ref: Interned<TypeRef>,
666 pub ast_id: FileAstId<ast::Static>,
669 #[derive(Debug, Clone, Eq, PartialEq)]
672 pub visibility: RawVisibilityId,
673 pub generic_params: Interned<GenericParams>,
676 pub items: Box<[AssocItem]>,
677 pub ast_id: FileAstId<ast::Trait>,
680 #[derive(Debug, Clone, Eq, PartialEq)]
682 pub generic_params: Interned<GenericParams>,
683 pub target_trait: Option<Interned<TraitRef>>,
684 pub self_ty: Interned<TypeRef>,
685 pub is_negative: bool,
686 pub items: Box<[AssocItem]>,
687 pub ast_id: FileAstId<ast::Impl>,
690 #[derive(Debug, Clone, PartialEq, Eq)]
691 pub struct TypeAlias {
693 pub visibility: RawVisibilityId,
694 /// Bounds on the type alias itself. Only valid in trait declarations, eg. `type Assoc: Copy;`.
695 pub bounds: Box<[Interned<TypeBound>]>,
696 pub generic_params: Interned<GenericParams>,
697 pub type_ref: Option<Interned<TypeRef>>,
699 pub ast_id: FileAstId<ast::TypeAlias>,
702 #[derive(Debug, Clone, Eq, PartialEq)]
705 pub visibility: RawVisibilityId,
707 pub ast_id: FileAstId<ast::Module>,
710 #[derive(Debug, Clone, Eq, PartialEq)]
713 Inline { items: Box<[ModItem]> },
719 #[derive(Debug, Clone, Eq, PartialEq)]
720 pub struct MacroCall {
721 /// Path to the called macro.
722 pub path: Interned<ModPath>,
723 pub ast_id: FileAstId<ast::MacroCall>,
724 pub expand_to: ExpandTo,
727 #[derive(Debug, Clone, Eq, PartialEq)]
728 pub struct MacroRules {
729 /// The name of the declared macro.
731 pub ast_id: FileAstId<ast::MacroRules>,
734 /// "Macros 2.0" macro definition.
735 #[derive(Debug, Clone, Eq, PartialEq)]
736 pub struct MacroDef {
738 pub visibility: RawVisibilityId,
739 pub ast_id: FileAstId<ast::MacroDef>,
743 /// Maps a `UseTree` contained in this import back to its AST node.
744 pub fn use_tree_to_ast(
746 db: &dyn DefDatabase,
748 index: Idx<ast::UseTree>,
750 // Re-lower the AST item and get the source map.
751 // Note: The AST unwraps are fine, since if they fail we should have never obtained `index`.
752 let ast = InFile::new(file_id, self.ast_id).to_node(db.upcast());
753 let ast_use_tree = ast.use_tree().expect("missing `use_tree`");
754 let hygiene = Hygiene::new(db.upcast(), file_id);
755 let (_, source_map) =
756 lower::lower_use_tree(db, &hygiene, ast_use_tree).expect("failed to lower use tree");
757 source_map[index].clone()
761 #[derive(Clone, Copy, Debug, Eq, PartialEq)]
762 pub enum ImportKind {
763 /// The `ModPath` is imported normally.
765 /// This is a glob-import of all names in the `ModPath`.
767 /// This is a `some::path::self` import, which imports `some::path` only in type namespace.
772 /// Expands the `UseTree` into individually imported `ModPath`s.
775 mut cb: impl FnMut(Idx<ast::UseTree>, ModPath, ImportKind, Option<ImportAlias>),
777 self.expand_impl(None, &mut cb)
782 prefix: Option<ModPath>,
783 cb: &mut dyn FnMut(Idx<ast::UseTree>, ModPath, ImportKind, Option<ImportAlias>),
786 prefix: Option<ModPath>,
788 ) -> Option<(ModPath, ImportKind)> {
789 match (prefix, &path.kind) {
790 (None, _) => Some((path.clone(), ImportKind::Plain)),
791 (Some(mut prefix), PathKind::Plain) => {
792 for segment in path.segments() {
793 prefix.push_segment(segment.clone());
795 Some((prefix, ImportKind::Plain))
797 (Some(prefix), PathKind::Super(0)) => {
798 // `some::path::self` == `some::path`
799 if path.segments().is_empty() {
800 Some((prefix, ImportKind::TypeOnly))
805 (Some(_), _) => None,
810 UseTreeKind::Single { path, alias } => {
811 if let Some((path, kind)) = concat_mod_paths(prefix, path) {
812 cb(self.index, path, kind, alias.clone());
815 UseTreeKind::Glob { path: Some(path) } => {
816 if let Some((path, _)) = concat_mod_paths(prefix, path) {
817 cb(self.index, path, ImportKind::Glob, None);
820 UseTreeKind::Glob { path: None } => {
821 if let Some(prefix) = prefix {
822 cb(self.index, prefix, ImportKind::Glob, None);
825 UseTreeKind::Prefixed { prefix: additional_prefix, list } => {
826 let prefix = match additional_prefix {
827 Some(path) => match concat_mod_paths(prefix, path) {
828 Some((path, ImportKind::Plain)) => Some(path),
833 for tree in &**list {
834 tree.expand_impl(prefix.clone(), cb);
841 macro_rules! impl_froms {
842 ($e:ident { $($v:ident ($t:ty)),* $(,)? }) => {
844 impl From<$t> for $e {
845 fn from(it: $t) -> $e {
854 pub fn as_assoc_item(&self) -> Option<AssocItem> {
857 | ModItem::ExternCrate(_)
858 | ModItem::ExternBlock(_)
866 | ModItem::MacroRules(_)
867 | ModItem::MacroDef(_) => None,
868 ModItem::MacroCall(call) => Some(AssocItem::MacroCall(*call)),
869 ModItem::Const(konst) => Some(AssocItem::Const(*konst)),
870 ModItem::TypeAlias(alias) => Some(AssocItem::TypeAlias(*alias)),
871 ModItem::Function(func) => Some(AssocItem::Function(*func)),
875 pub fn downcast<N: ItemTreeNode>(self) -> Option<FileItemTreeId<N>> {
876 N::id_from_mod_item(self)
879 pub fn ast_id(&self, tree: &ItemTree) -> FileAstId<ast::Item> {
881 ModItem::Import(it) => tree[it.index].ast_id().upcast(),
882 ModItem::ExternCrate(it) => tree[it.index].ast_id().upcast(),
883 ModItem::ExternBlock(it) => tree[it.index].ast_id().upcast(),
884 ModItem::Function(it) => tree[it.index].ast_id().upcast(),
885 ModItem::Struct(it) => tree[it.index].ast_id().upcast(),
886 ModItem::Union(it) => tree[it.index].ast_id().upcast(),
887 ModItem::Enum(it) => tree[it.index].ast_id().upcast(),
888 ModItem::Const(it) => tree[it.index].ast_id().upcast(),
889 ModItem::Static(it) => tree[it.index].ast_id().upcast(),
890 ModItem::Trait(it) => tree[it.index].ast_id().upcast(),
891 ModItem::Impl(it) => tree[it.index].ast_id().upcast(),
892 ModItem::TypeAlias(it) => tree[it.index].ast_id().upcast(),
893 ModItem::Mod(it) => tree[it.index].ast_id().upcast(),
894 ModItem::MacroCall(it) => tree[it.index].ast_id().upcast(),
895 ModItem::MacroRules(it) => tree[it.index].ast_id().upcast(),
896 ModItem::MacroDef(it) => tree[it.index].ast_id().upcast(),
901 #[derive(Debug, Copy, Clone, Eq, PartialEq)]
903 Function(FileItemTreeId<Function>),
904 TypeAlias(FileItemTreeId<TypeAlias>),
905 Const(FileItemTreeId<Const>),
906 MacroCall(FileItemTreeId<MacroCall>),
909 impl_froms!(AssocItem {
910 Function(FileItemTreeId<Function>),
911 TypeAlias(FileItemTreeId<TypeAlias>),
912 Const(FileItemTreeId<Const>),
913 MacroCall(FileItemTreeId<MacroCall>),
916 impl From<AssocItem> for ModItem {
917 fn from(item: AssocItem) -> Self {
919 AssocItem::Function(it) => it.into(),
920 AssocItem::TypeAlias(it) => it.into(),
921 AssocItem::Const(it) => it.into(),
922 AssocItem::MacroCall(it) => it.into(),
927 #[derive(Debug, Eq, PartialEq)]
933 #[derive(Debug, Clone, PartialEq, Eq)]
935 Record(IdxRange<Field>),
936 Tuple(IdxRange<Field>),
940 /// A single field of an enum variant or struct
941 #[derive(Debug, Clone, PartialEq, Eq)]
944 pub type_ref: Interned<TypeRef>,
945 pub visibility: RawVisibilityId,