Rust: restrict canonical path calculations

rust/extractor/src/translate/base.rs

@@ -1,4 +1,4 @@
-use super::mappings::{AddressableAst, AddressableHir};
+use super::mappings::{AddressableAst, AddressableHir, PathAst};
 use crate::generated::MacroCall;
 use crate::generated::{self};
 use crate::rust_analyzer::FileSemanticInformation;
@@ -53,8 +53,20 @@ macro_rules! emit_detached {
         $self.extract_canonical_origin_of_enum_variant(&$node, $label);
     };
     // TODO canonical origin of other items
-    (Path, $self:ident, $node:ident, $label:ident) => {
-        $self.extract_canonical_destination(&$node, $label);
+    (PathExpr, $self:ident, $node:ident, $label:ident) => {
+        $self.extract_path_canonical_destination(&$node, $label.into());
+    };
+    (RecordExpr, $self:ident, $node:ident, $label:ident) => {
+        $self.extract_path_canonical_destination(&$node, $label.into());
+    };
+    (PathPat, $self:ident, $node:ident, $label:ident) => {
+        $self.extract_path_canonical_destination(&$node, $label.into());
+    };
+    (RecordPat, $self:ident, $node:ident, $label:ident) => {
+        $self.extract_path_canonical_destination(&$node, $label.into());
+    };
+    (TupleStructPat, $self:ident, $node:ident, $label:ident) => {
+        $self.extract_path_canonical_destination(&$node, $label.into());
     };
     (MethodCallExpr, $self:ident, $node:ident, $label:ident) => {
         $self.extract_method_canonical_destination(&$node, $label);
@@ -506,25 +518,22 @@ impl<'a> Translator<'a> {
         })();
     }
 
-    pub(crate) fn extract_canonical_destination(
+    pub(crate) fn extract_path_canonical_destination(
         &mut self,
-        item: &ast::Path,
-        label: Label<generated::Path>,
+        item: &impl PathAst,
+        label: Label<generated::Resolvable>,
     ) {
         (|| {
+            let path = item.path()?;
             let sema = self.semantics.as_ref()?;
-            let resolution = sema.resolve_path(item)?;
+            let resolution = sema.resolve_path(&path)?;
             let PathResolution::Def(def) = resolution else {
                 return None;
             };
             let origin = self.origin_from_module_def(def)?;
             let path = self.canonical_path_from_module_def(def)?;
-            generated::Resolvable::emit_resolved_crate_origin(
-                label.into(),
-                origin,
-                &mut self.trap.writer,
-            );
-            generated::Resolvable::emit_resolved_path(label.into(), path, &mut self.trap.writer);
+            generated::Resolvable::emit_resolved_crate_origin(label, origin, &mut self.trap.writer);
+            generated::Resolvable::emit_resolved_path(label, path, &mut self.trap.writer);
             Some(())
         })();
     }

rust/extractor/src/translate/mappings.rs

@@ -170,3 +170,37 @@ impl AddressableAst for ast::Union {
 impl AddressableAst for ast::Module {
     type Hir = Module;
 }
+
+pub trait PathAst: AstNode {
+    fn path(&self) -> Option<ast::Path>;
+}
+
+impl PathAst for ast::PathExpr {
+    fn path(&self) -> Option<ast::Path> {
+        self.path()
+    }
+}
+
+impl PathAst for ast::RecordExpr {
+    fn path(&self) -> Option<ast::Path> {
+        self.path()
+    }
+}
+
+impl PathAst for ast::PathPat {
+    fn path(&self) -> Option<ast::Path> {
+        self.path()
+    }
+}
+
+impl PathAst for ast::RecordPat {
+    fn path(&self) -> Option<ast::Path> {
+        self.path()
+    }
+}
+
+impl PathAst for ast::TupleStructPat {
+    fn path(&self) -> Option<ast::Path> {
+        self.path()
+    }
+}