Rust: split ImplItemCanonicalPath for trait and type impls

Author: Paolo Tranquilli

rust/extractor/src/generated/.generated.list

@@ -643,19 +643,36 @@ impl<'a> Translator<'a> {
                 )
             }
             ItemContainer::Impl(it) => {
-                let trait_ref = it.trait_ref(sema.db);
-                let type_path = self.canonical_path_from_type(it.self_ty(sema.db))?;
-                let trait_path = trait_ref.and_then(|t| self.canonical_path_from_trait_ref(t));
-                Some(
-                    self.trap
-                        .emit(generated::ImplItemCanonicalPath {
-                            id: trap_key!("<", type_path, "as", trait_path, ">::", name),
-                            type_path,
-                            trait_path,
-                            name,
-                        })
-                        .into(),
-                )
+                let ty = it.self_ty(sema.db);
+                if let Some(trait_path) = it
+                    .trait_ref(sema.db)
+                    .and_then(|t| self.canonical_path_from_trait_ref(t))
+                {
+                    let type_path = self.canonical_path_from_type(ty)?;
+                    Some(
+                        self.trap
+                            .emit(generated::TraitImplItemCanonicalPath {
+                                id: trap_key!("<", type_path, "as", trait_path, ">::", name),
+                                type_path,
+                                trait_path,
+                                name,
+                            })
+                            .into(),
+                    )
+                } else {
+                    // with no trait this must be an Adt impl
+                    let adt = ty.as_adt()?;
+                    let parent = self.canonical_path_from_module_item(adt)?;
+                    Some(
+                        self.trap
+                            .emit(generated::TypeImplItemCanonicalPath {
+                                id: trap_key!(parent, name),
+                                parent,
+                                name,
+                            })
+                            .into(),
+                    )
+                }
             }
             ItemContainer::Module(it) => {
                 let namespace = self.canonical_path_from_module(it)?;

rust/extractor/src/generated/mod.rs

@@ -1,6 +1,8 @@
 use crate::generated::{self};
 use crate::trap::{Label, TrapClass, UntypedLabel};
-use ra_ap_hir::{Crate, Enum, Function, Module, Struct, Trait, TraitRef, Type, Union, Variant};
+use ra_ap_hir::{
+    Adt, Crate, Enum, Function, Module, Struct, Trait, TraitRef, Type, Union, Variant,
+};
 use std::collections::HashMap;
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
@@ -57,6 +59,16 @@ impl StorableAsModuleItemCanonicalPath for Trait {
     }
 }
 
+impl StorableAsModuleItemCanonicalPath for Adt {
+    fn to_key(&self) -> Key {
+        match *self {
+            Adt::Struct(it) => Key::Struct(it),
+            Adt::Union(it) => Key::Union(it),
+            Adt::Enum(it) => Key::Enum(it),
+        }
+    }
+}
+
 impl StorableAsModuleItemCanonicalPath for Enum {
     fn to_key(&self) -> Key {
         Key::Enum(*self)

rust/extractor/src/translate/base.rs

@@ -1,5 +1,5 @@
 use crate::translate::label_cache::StorableAsModuleItemCanonicalPath;
-use ra_ap_hir::{Enum, Module, Semantics, Struct, Trait, Union};
+use ra_ap_hir::{Adt, Enum, Module, Semantics, Struct, Trait, Union};
 use ra_ap_ide_db::RootDatabase;
 use ra_ap_syntax::{ast, ast::RangeItem, AstNode};
 
@@ -92,6 +92,16 @@ pub trait ModuleItem: StorableAsModuleItemCanonicalPath {
     fn name(&self, sema: &Semantics<'_, RootDatabase>) -> String;
 }
 
+impl ModuleItem for Adt {
+    fn module(&self, sema: &Semantics<'_, RootDatabase>) -> Module {
+        Adt::module(*self, sema.db)
+    }
+
+    fn name(&self, sema: &Semantics<'_, RootDatabase>) -> String {
+        Adt::name(*self, sema.db).as_str().to_owned()
+    }
+}
+
 impl ModuleItem for Enum {
     fn module(&self, sema: &Semantics<'_, RootDatabase>) -> Module {
         Enum::module(*self, sema.db)