Add TreeId to identify ItemTrees

With per-block `ItemTree`s, the file ID is not enough to identify an
`ItemTree`.

Author: jonas-schievink

crates/hir_def/src/data.rs

@@ -10,7 +10,7 @@ use crate::{
     body::Expander,
     db::DefDatabase,
     intern::Interned,
-    item_tree::{AssocItem, FnFlags, ItemTreeId, ModItem, Param},
+    item_tree::{self, AssocItem, FnFlags, ItemTreeId, ModItem, Param},
     type_ref::{TraitRef, TypeBound, TypeRef},
     visibility::RawVisibility,
     AssocContainerId, AssocItemId, ConstId, ConstLoc, FunctionId, FunctionLoc, HasModule, ImplId,
@@ -171,7 +171,7 @@ impl TraitData {
             module_id,
             &mut expander,
             tr_def.items.iter().copied(),
-            tr_loc.id.file_id(),
+            tr_loc.id.tree_id(),
             container,
             100,
         );
@@ -228,7 +228,7 @@ impl ImplData {
             module_id,
             &mut expander,
             impl_def.items.iter().copied(),
-            impl_loc.id.file_id(),
+            impl_loc.id.tree_id(),
             container,
             100,
         );
@@ -290,15 +290,15 @@ fn collect_items(
     module: ModuleId,
     expander: &mut Expander,
     assoc_items: impl Iterator<Item = AssocItem>,
-    file_id: crate::HirFileId,
+    tree_id: item_tree::TreeId,
     container: AssocContainerId,
     limit: usize,
 ) -> Vec<(Name, AssocItemId)> {
     if limit == 0 {
         return Vec::new();
     }
 
-    let item_tree = db.file_item_tree(file_id);
+    let item_tree = tree_id.item_tree(db);
     let crate_graph = db.crate_graph();
     let cfg_options = &crate_graph[module.krate].cfg_options;
 
@@ -312,7 +312,7 @@ fn collect_items(
         match item {
             AssocItem::Function(id) => {
                 let item = &item_tree[id];
-                let def = FunctionLoc { container, id: ItemTreeId::new(file_id, id) }.intern(db);
+                let def = FunctionLoc { container, id: ItemTreeId::new(tree_id, id) }.intern(db);
                 items.push((item.name.clone(), def.into()));
             }
             AssocItem::Const(id) => {
@@ -321,33 +321,34 @@ fn collect_items(
                     Some(name) => name,
                     None => continue,
                 };
-                let def = ConstLoc { container, id: ItemTreeId::new(file_id, id) }.intern(db);
+                let def = ConstLoc { container, id: ItemTreeId::new(tree_id, id) }.intern(db);
                 items.push((name, def.into()));
             }
             AssocItem::TypeAlias(id) => {
                 let item = &item_tree[id];
-                let def = TypeAliasLoc { container, id: ItemTreeId::new(file_id, id) }.intern(db);
+                let def = TypeAliasLoc { container, id: ItemTreeId::new(tree_id, id) }.intern(db);
                 items.push((item.name.clone(), def.into()));
             }
             AssocItem::MacroCall(call) => {
                 let call = &item_tree[call];
-                let ast_id_map = db.ast_id_map(file_id);
-                let root = db.parse_or_expand(file_id).unwrap();
+                let ast_id_map = db.ast_id_map(tree_id.file_id());
+                let root = db.parse_or_expand(tree_id.file_id()).unwrap();
                 let call = ast_id_map.get(call.ast_id).to_node(&root);
                 let res = expander.enter_expand(db, call);
 
                 if let Ok(res) = res {
                     if let Some((mark, mac)) = res.value {
                         let src: InFile<ast::MacroItems> = expander.to_source(mac);
-                        let item_tree = db.file_item_tree(src.file_id);
+                        let tree_id = item_tree::TreeId::new(src.file_id, None);
+                        let item_tree = tree_id.item_tree(db);
                         let iter =
                             item_tree.top_level_items().iter().filter_map(ModItem::as_assoc_item);
                         items.extend(collect_items(
                             db,
                             module,
                             expander,
                             iter,
-                            src.file_id,
+                            tree_id,
                             container,
                             limit - 1,
                         ));

crates/hir_def/src/item_tree.rs

@@ -67,6 +67,7 @@ use crate::{
     path::{path, AssociatedTypeBinding, GenericArgs, ImportAlias, ModPath, Path, PathKind},
     type_ref::{Mutability, TraitRef, TypeBound, TypeRef},
     visibility::RawVisibility,
+    BlockId,
 };
 
 #[derive(Copy, Clone, Eq, PartialEq)]
@@ -374,23 +375,51 @@ impl<N: ItemTreeNode> fmt::Debug for FileItemTreeId<N> {
     }
 }
 
+/// Identifies a particular [`ItemTree`].
+#[derive(Debug, PartialEq, Eq, Clone, Copy, Hash)]
+pub struct TreeId {
+    file: HirFileId,
+    block: Option<BlockId>,
+}
+
+impl TreeId {
+    pub(crate) fn new(file: HirFileId, block: Option<BlockId>) -> Self {
+        Self { file, block }
+    }
+
+    pub(crate) fn item_tree(&self, db: &dyn DefDatabase) -> Arc<ItemTree> {
+        match self.block {
+            Some(_) => unreachable!("per-block ItemTrees are not yet implemented"),
+            None => db.file_item_tree(self.file),
+        }
+    }
+
+    pub(crate) fn file_id(self) -> HirFileId {
+        self.file
+    }
+}
+
 #[derive(Debug)]
 pub struct ItemTreeId<N: ItemTreeNode> {
-    file: HirFileId,
+    tree: TreeId,
     pub value: FileItemTreeId<N>,
 }
 
 impl<N: ItemTreeNode> ItemTreeId<N> {
-    pub fn new(file: HirFileId, idx: FileItemTreeId<N>) -> Self {
-        Self { file, value: idx }
+    pub fn new(tree: TreeId, idx: FileItemTreeId<N>) -> Self {
+        Self { tree, value: idx }
     }
 
     pub fn file_id(self) -> HirFileId {
-        self.file
+        self.tree.file
+    }
+
+    pub fn tree_id(self) -> TreeId {
+        self.tree
     }
 
     pub fn item_tree(self, db: &dyn DefDatabase) -> Arc<ItemTree> {
-        db.file_item_tree(self.file)
+        self.tree.item_tree(db)
     }
 }
 
@@ -403,15 +432,15 @@ impl<N: ItemTreeNode> Clone for ItemTreeId<N> {
 
 impl<N: ItemTreeNode> PartialEq for ItemTreeId<N> {
     fn eq(&self, other: &Self) -> bool {
-        self.file == other.file && self.value == other.value
+        self.tree == other.tree && self.value == other.value
     }
 }
 
 impl<N: ItemTreeNode> Eq for ItemTreeId<N> {}
 
 impl<N: ItemTreeNode> Hash for ItemTreeId<N> {
     fn hash<H: Hasher>(&self, state: &mut H) {
-        self.file.hash(state);
+        self.tree.hash(state);
         self.value.hash(state);
     }
 }