Rust: Remove uncalled methods.

Author: geoffw0

rust/extractor/src/translate/base.rs

@@ -494,159 +494,6 @@ impl<'a> Translator<'a> {
         }
     }
 
-    fn canonical_path_from_type(&self, ty: Type) -> Option<String> {
-        let sema = self.semantics.as_ref().unwrap();
-        // rust-analyzer doesn't provide a type enum directly
-        if let Some(it) = ty.as_adt() {
-            return match it {
-                Adt::Struct(it) => self.canonical_path_from_hir(it),
-                Adt::Union(it) => self.canonical_path_from_hir(it),
-                Adt::Enum(it) => self.canonical_path_from_hir(it),
-            };
-        };
-        if let Some((it, size)) = ty.as_array(sema.db) {
-            return self
-                .canonical_path_from_type(it)
-                .map(|p| format!("[{p}; {size}]"));
-        }
-        if let Some(it) = ty.as_slice() {
-            return self.canonical_path_from_type(it).map(|p| format!("[{p}]"));
-        }
-        if let Some(it) = ty.as_builtin() {
-            return Some(it.name().as_str().to_owned());
-        }
-        if let Some(it) = ty.as_dyn_trait() {
-            return self.canonical_path_from_hir(it).map(|p| format!("dyn {p}"));
-        }
-        if let Some((it, mutability)) = ty.as_reference() {
-            let mut_str = match mutability {
-                Mutability::Shared => "",
-                Mutability::Mut => "mut ",
-            };
-            return self
-                .canonical_path_from_type(it)
-                .map(|p| format!("&{mut_str}{p}"));
-        }
-        if let Some(it) = ty.as_impl_traits(sema.db) {
-            let paths = it
-                .map(|t| self.canonical_path_from_hir(t))
-                .collect::<Option<Vec<_>>>()?;
-            return Some(format!("impl {}", paths.join(" + ")));
-        }
-        if ty.as_type_param(sema.db).is_some() {
-            // from the canonical path perspective, we just want a special name
-            // e.g. `crate::<_ as SomeTrait>::func`
-            return Some("_".to_owned());
-        }
-        None
-    }
-
-    fn canonical_path_from_hir_module(&self, item: Module) -> Option<String> {
-        if ModuleId::from(item).containing_block().is_some() {
-            // this means this is a block module, i.e. a virtual module for an anonymous block scope
-            return None;
-        }
-        if item.is_crate_root() {
-            return Some("crate".into());
-        }
-        self.canonical_path_from_hir::<ast::Module>(item)
-    }
-
-    fn canonical_path_from_hir<T: AstNode>(&self, item: impl AddressableHir<T>) -> Option<String> {
-        // if we have a Hir entity, it means we have semantics
-        let sema = self.semantics.as_ref().unwrap();
-        let name = item.name(sema)?;
-        let container = item.container(sema.db);
-        let prefix = match container {
-            ItemContainer::Trait(it) => self.canonical_path_from_hir(it),
-            ItemContainer::Impl(it) => {
-                let ty = self.canonical_path_from_type(it.self_ty(sema.db))?;
-                if let Some(trait_) = it.trait_(sema.db) {
-                    let tr = self.canonical_path_from_hir(trait_)?;
-                    Some(format!("<{ty} as {tr}>"))
-                } else {
-                    Some(format!("<{ty}>"))
-                }
-            }
-            ItemContainer::Module(it) => self.canonical_path_from_hir_module(it),
-            ItemContainer::ExternBlock(..) | ItemContainer::Crate(..) => Some("".to_owned()),
-        }?;
-        Some(format!("{prefix}::{name}"))
-    }
-
-    fn canonical_path_from_module_def(&self, item: ModuleDef) -> Option<String> {
-        match item {
-            ModuleDef::Module(it) => self.canonical_path_from_hir(it),
-            ModuleDef::Function(it) => self.canonical_path_from_hir(it),
-            ModuleDef::Adt(Adt::Enum(it)) => self.canonical_path_from_hir(it),
-            ModuleDef::Adt(Adt::Struct(it)) => self.canonical_path_from_hir(it),
-            ModuleDef::Adt(Adt::Union(it)) => self.canonical_path_from_hir(it),
-            ModuleDef::Trait(it) => self.canonical_path_from_hir(it),
-            ModuleDef::Variant(it) => self.canonical_path_from_enum_variant(it),
-            ModuleDef::Static(_) => None,
-            ModuleDef::TraitAlias(_) => None,
-            ModuleDef::TypeAlias(_) => None,
-            ModuleDef::BuiltinType(_) => None,
-            ModuleDef::Macro(_) => None,
-            ModuleDef::Const(_) => None,
-        }
-    }
-
-    fn canonical_path_from_enum_variant(&self, item: Variant) -> Option<String> {
-        // if we have a Hir entity, it means we have semantics
-        let sema = self.semantics.as_ref().unwrap();
-        let prefix = self.canonical_path_from_hir(item.parent_enum(sema.db))?;
-        let name = item.name(sema.db);
-        Some(format!("{prefix}::{}", name.as_str()))
-    }
-
-    fn origin_from_hir<T: AstNode>(&self, item: impl AddressableHir<T>) -> String {
-        // if we have a Hir entity, it means we have semantics
-        let sema = self.semantics.as_ref().unwrap();
-        self.origin_from_crate(item.module(sema).krate())
-    }
-
-    fn origin_from_crate(&self, item: Crate) -> String {
-        // if we have a Hir entity, it means we have semantics
-        let sema = self.semantics.as_ref().unwrap();
-        match item.origin(sema.db) {
-            CrateOrigin::Rustc { name } => format!("rustc:{name}"),
-            CrateOrigin::Local { repo, name } => format!(
-                "repo:{}:{}",
-                repo.unwrap_or_default(),
-                name.map(|s| s.as_str().to_owned()).unwrap_or_default()
-            ),
-            CrateOrigin::Library { repo, name } => {
-                format!("repo:{}:{}", repo.unwrap_or_default(), name)
-            }
-            CrateOrigin::Lang(it) => format!("lang:{it}"),
-        }
-    }
-
-    fn origin_from_module_def(&self, item: ModuleDef) -> Option<String> {
-        match item {
-            ModuleDef::Module(it) => Some(self.origin_from_hir(it)),
-            ModuleDef::Function(it) => Some(self.origin_from_hir(it)),
-            ModuleDef::Adt(Adt::Enum(it)) => Some(self.origin_from_hir(it)),
-            ModuleDef::Adt(Adt::Struct(it)) => Some(self.origin_from_hir(it)),
-            ModuleDef::Adt(Adt::Union(it)) => Some(self.origin_from_hir(it)),
-            ModuleDef::Trait(it) => Some(self.origin_from_hir(it)),
-            ModuleDef::Variant(it) => Some(self.origin_from_enum_variant(it)),
-            ModuleDef::Static(_) => None,
-            ModuleDef::TraitAlias(_) => None,
-            ModuleDef::TypeAlias(_) => None,
-            ModuleDef::BuiltinType(_) => None,
-            ModuleDef::Macro(_) => None,
-            ModuleDef::Const(_) => None,
-        }
-    }
-
-    fn origin_from_enum_variant(&self, item: Variant) -> String {
-        // if we have a Hir entity, it means we have semantics
-        let sema = self.semantics.as_ref().unwrap();
-        self.origin_from_hir(item.parent_enum(sema.db))
-    }
-
     pub(crate) fn should_be_excluded(&self, item: &impl ast::HasAttrs) -> bool {
         self.semantics.is_some_and(|sema| {
             item.attrs().any(|attr| {