From cebeedc66fc40097eae20bf1767a285d00269966 Mon Sep 17 00:00:00 2001
From: Aleksey Kladov <aleksey.kladov@gmail.com>
Date: Wed, 20 Nov 2019 16:03:59 +0300
Subject: Next gen IDs for functions

The current system with AstIds has two primaraly drawbacks:

* It is possible to manufacture IDs out of thin air.
  For example, it's possible to create IDs for items which are not
  considered in CrateDefMap due to cfg. Or it is possible to mixup
  structs and unions, because they share ID space.

* Getting the ID of a parent requires a secondary index.

Instead, the plan is to pursue the more traditional approach, where
each items stores the id of the parent declaration. This makes
`FromSource` more awkward, but also more correct: now, to get from an
AST to HIR, we first do this recursively for the parent item, and the
just search the children of the parent for the matching def
---
 crates/ra_hir_def/src/traits.rs | 25 ++++++++++++++++++++-----
 1 file changed, 20 insertions(+), 5 deletions(-)

(limited to 'crates/ra_hir_def/src/traits.rs')

diff --git a/crates/ra_hir_def/src/traits.rs b/crates/ra_hir_def/src/traits.rs
index a8ba31594..6e36bc0d0 100644
--- a/crates/ra_hir_def/src/traits.rs
+++ b/crates/ra_hir_def/src/traits.rs
@@ -2,14 +2,17 @@
 
 use std::sync::Arc;
 
-use hir_expand::name::{AsName, Name};
+use hir_expand::{
+    name::{AsName, Name},
+    AstId,
+};
 
 use ra_syntax::ast::{self, NameOwner};
 use rustc_hash::FxHashMap;
 
 use crate::{
-    db::DefDatabase2, AssocItemId, AstItemDef, ConstId, FunctionId, LocationCtx, ModuleDefId,
-    ModuleId, TraitId, TypeAliasId,
+    db::DefDatabase2, AssocItemId, AstItemDef, ConstId, FunctionContainerId, FunctionLoc, Intern,
+    LocationCtx, ModuleDefId, ModuleId, TraitId, TypeAliasId,
 };
 
 #[derive(Debug, Clone, PartialEq, Eq)]
@@ -26,11 +29,17 @@ impl TraitData {
         let module = tr.module(db);
         let ctx = LocationCtx::new(db, module, src.file_id);
         let auto = src.value.is_auto();
+        let ast_id_map = db.ast_id_map(src.file_id);
         let items = if let Some(item_list) = src.value.item_list() {
             item_list
                 .impl_items()
                 .map(|item_node| match item_node {
-                    ast::ImplItem::FnDef(it) => FunctionId::from_ast(ctx, &it).into(),
+                    ast::ImplItem::FnDef(it) => FunctionLoc {
+                        container: FunctionContainerId::TraitId(tr),
+                        ast_id: AstId::new(src.file_id, ast_id_map.ast_id(&it)),
+                    }
+                    .intern(db)
+                    .into(),
                     ast::ImplItem::ConstDef(it) => ConstId::from_ast(ctx, &it).into(),
                     ast::ImplItem::TypeAliasDef(it) => TypeAliasId::from_ast(ctx, &it).into(),
                 })
@@ -54,7 +63,13 @@ impl TraitItemsIndex {
         for decl in crate_def_map[module.module_id].scope.declarations() {
             if let ModuleDefId::TraitId(tr) = decl {
                 for item in db.trait_data(tr).items.iter() {
-                    index.traits_by_def.insert(*item, tr);
+                    match item {
+                        AssocItemId::FunctionId(_) => (),
+                        _ => {
+                            let prev = index.traits_by_def.insert(*item, tr);
+                            assert!(prev.is_none());
+                        }
+                    }
                 }
             }
         }
-- 
cgit v1.2.3