impl TryToNav for BuiltinType instead

Author: rmehri01

src/tools/rust-analyzer/crates/ide-db/src/famous_defs.rs

@@ -210,6 +210,10 @@ impl FamousDefs<'_, '_> {
     fn find_lang_crate(&self, origin: LangCrateOrigin) -> Option<Crate> {
         let krate = self.1;
         let db = self.0.db;
+        if krate.origin(db) == CrateOrigin::Lang(origin) {
+            return Some(krate);
+        }
+
         let res = krate
             .dependencies(db)
             .into_iter()

src/tools/rust-analyzer/crates/ide/src/goto_definition.rs

@@ -6,13 +6,12 @@ use crate::{
     navigation_target::{self, ToNav},
 };
 use hir::{
-    AsAssocItem, AssocItem, CallableKind, FileRange, HasCrate, InFile, ModuleDef, PathResolution,
-    Semantics, sym,
+    AsAssocItem, AssocItem, CallableKind, FileRange, HasCrate, InFile, ModuleDef, Semantics, sym,
 };
 use ide_db::{
     RootDatabase, SymbolKind,
     base_db::{AnchoredPath, SourceDatabase},
-    defs::{Definition, IdentClass, find_std_module},
+    defs::{Definition, IdentClass},
     famous_defs::FamousDefs,
     helpers::pick_best_token,
 };
@@ -91,9 +90,6 @@ pub(crate) fn goto_definition(
             if let Some(navs) = find_definition_for_known_blanket_dual_impls(sema, &token.value) {
                 return Some(navs);
             }
-            if let Some(navs) = find_definition_for_builtin_types(sema, &token.value, edition) {
-                return Some(navs);
-            }
 
             let parent = token.value.parent()?;
 
@@ -208,25 +204,6 @@ fn find_definition_for_known_blanket_dual_impls(
     Some(def_to_nav(sema.db, def))
 }
 
-// If the token is a builtin type search the definition from the rustdoc module shims.
-fn find_definition_for_builtin_types(
-    sema: &Semantics<'_, RootDatabase>,
-    original_token: &SyntaxToken,
-    edition: Edition,
-) -> Option<Vec<NavigationTarget>> {
-    let path = original_token.parent_ancestors().find_map(ast::Path::cast)?;
-    let res = sema.resolve_path(&path)?;
-    let PathResolution::Def(ModuleDef::BuiltinType(builtin)) = res else {
-        return None;
-    };
-
-    let fd = FamousDefs(sema, sema.scope(path.syntax())?.krate());
-    let primitive_mod = format!("prim_{}", builtin.name().display(fd.0.db, edition));
-    let doc_owner = find_std_module(&fd, &primitive_mod, edition)?;
-
-    Some(def_to_nav(sema.db, doc_owner.into()))
-}
-
 fn try_lookup_include_path(
     sema: &Semantics<'_, RootDatabase>,
     token: InFile<ast::String>,

src/tools/rust-analyzer/crates/ide/src/navigation_target.rs

@@ -5,14 +5,15 @@ use std::fmt;
 use arrayvec::ArrayVec;
 use either::Either;
 use hir::{
-    AssocItem, FieldSource, HasContainer, HasCrate, HasSource, HirDisplay, HirFileId, InFile,
-    LocalSource, ModuleSource, db::ExpandDatabase, symbols::FileSymbol,
+    AssocItem, Crate, FieldSource, HasContainer, HasCrate, HasSource, HirDisplay, HirFileId,
+    InFile, LocalSource, ModuleSource, Semantics, db::ExpandDatabase, symbols::FileSymbol,
 };
 use ide_db::{
     FileId, FileRange, RootDatabase, SymbolKind,
-    base_db::salsa,
-    defs::Definition,
+    base_db::{CrateOrigin, LangCrateOrigin, RootQueryDb, salsa},
+    defs::{Definition, find_std_module},
     documentation::{Documentation, HasDocs},
+    famous_defs::FamousDefs,
 };
 use span::Edition;
 use stdx::never;
@@ -262,8 +263,8 @@ impl TryToNav for Definition {
             Definition::TypeAlias(it) => it.try_to_nav(db),
             Definition::ExternCrateDecl(it) => it.try_to_nav(db),
             Definition::InlineAsmOperand(it) => it.try_to_nav(db),
+            Definition::BuiltinType(it) => it.try_to_nav(db),
             Definition::BuiltinLifetime(_)
-            | Definition::BuiltinType(_)
             | Definition::TupleField(_)
             | Definition::ToolModule(_)
             | Definition::InlineAsmRegOrRegClass(_)
@@ -746,6 +747,26 @@ impl TryToNav for hir::InlineAsmOperand {
     }
 }
 
+impl TryToNav for hir::BuiltinType {
+    fn try_to_nav(&self, db: &RootDatabase) -> Option<UpmappingResult<NavigationTarget>> {
+        let sema = Semantics::new(db);
+
+        let krate = db
+            .all_crates()
+            .iter()
+            .copied()
+            .find(|&krate| matches!(krate.data(db).origin, CrateOrigin::Lang(LangCrateOrigin::Std)))
+            .map(Crate::from)?;
+        let edition = krate.edition(db);
+
+        let fd = FamousDefs(&sema, krate);
+        let primitive_mod = format!("prim_{}", self.name().display(fd.0.db, edition));
+        let doc_owner = find_std_module(&fd, &primitive_mod, edition)?;
+
+        Some(doc_owner.to_nav(db))
+    }
+}
+
 #[derive(Debug)]
 pub struct UpmappingResult<T> {
     /// The macro call site.