feat: Virtual macro files

Author: Veykril

Cargo.lock

@@ -38,11 +38,45 @@ pub type HirFilePosition = FilePositionWrapper<HirFileId>;
 pub type MacroFilePosition = FilePositionWrapper<MacroFileId>;
 pub type FilePosition = FilePositionWrapper<EditionedFileId>;
 
-impl From<FilePositionWrapper<EditionedFileId>> for FilePositionWrapper<span::FileId> {
-    fn from(value: FilePositionWrapper<EditionedFileId>) -> Self {
+impl From<FilePosition> for FilePositionWrapper<span::FileId> {
+    fn from(value: FilePosition) -> Self {
         FilePositionWrapper { file_id: value.file_id.into(), offset: value.offset }
     }
 }
+
+impl From<FileRange> for HirFileRange {
+    fn from(value: FileRange) -> Self {
+        HirFileRange { file_id: value.file_id.into(), range: value.range }
+    }
+}
+
+impl From<FilePosition> for HirFilePosition {
+    fn from(value: FilePosition) -> Self {
+        HirFilePosition { file_id: value.file_id.into(), offset: value.offset }
+    }
+}
+
+impl FilePositionWrapper<span::FileId> {
+    pub fn with_edition(self, edition: span::Edition) -> FilePosition {
+        FilePositionWrapper {
+            file_id: EditionedFileId::new(self.file_id, edition),
+            offset: self.offset,
+        }
+    }
+}
+
+impl FileRangeWrapper<span::FileId> {
+    pub fn with_edition(self, edition: span::Edition) -> FileRange {
+        FileRangeWrapper { file_id: EditionedFileId::new(self.file_id, edition), range: self.range }
+    }
+}
+
+impl<T> InFileWrapper<span::FileId, T> {
+    pub fn with_edition(self, edition: span::Edition) -> InRealFile<T> {
+        InRealFile { file_id: EditionedFileId::new(self.file_id, edition), value: self.value }
+    }
+}
+
 #[derive(Debug, PartialEq, Eq, Clone, Copy, Hash)]
 pub struct FileRangeWrapper<FileKind> {
     pub file_id: FileKind,
@@ -191,6 +225,9 @@ impl<FileId: Copy, N: AstNode> InFileWrapper<FileId, N> {
     pub fn syntax(&self) -> InFileWrapper<FileId, &SyntaxNode> {
         self.with_value(self.value.syntax())
     }
+    pub fn node_file_range(&self) -> FileRangeWrapper<FileId> {
+        FileRangeWrapper { file_id: self.file_id, range: self.value.syntax().text_range() }
+    }
 }
 
 impl<FileId: Copy, N: AstNode> InFileWrapper<FileId, &N> {
@@ -201,9 +238,9 @@ impl<FileId: Copy, N: AstNode> InFileWrapper<FileId, &N> {
 }
 
 // region:specific impls
-impl<SN: Borrow<SyntaxNode>> InRealFile<SN> {
-    pub fn file_range(&self) -> FileRange {
-        FileRange { file_id: self.file_id, range: self.value.borrow().text_range() }
+impl<FileId: Copy, SN: Borrow<SyntaxNode>> InFileWrapper<FileId, SN> {
+    pub fn file_range(&self) -> FileRangeWrapper<FileId> {
+        FileRangeWrapper { file_id: self.file_id, range: self.value.borrow().text_range() }
     }
 }
 

crates/hir-expand/src/files.rs

@@ -347,6 +347,7 @@ pub trait HirFileIdExt {
 
     /// If this is a macro call, returns the syntax node of the very first macro call this file resides in.
     fn original_call_node(self, db: &dyn ExpandDatabase) -> Option<InRealFile<SyntaxNode>>;
+    fn call_node(self, db: &dyn ExpandDatabase) -> Option<InFile<SyntaxNode>>;
 
     fn as_builtin_derive_attr_node(&self, db: &dyn ExpandDatabase) -> Option<InFile<ast::Attr>>;
 }
@@ -405,6 +406,10 @@ impl HirFileIdExt for HirFileId {
         }
     }
 
+    fn call_node(self, db: &dyn ExpandDatabase) -> Option<InFile<SyntaxNode>> {
+        Some(db.lookup_intern_macro_call(self.macro_file()?.macro_call_id).to_node(db))
+    }
+
     fn as_builtin_derive_attr_node(&self, db: &dyn ExpandDatabase) -> Option<InFile<ast::Attr>> {
         let macro_file = self.macro_file()?;
         let loc: MacroCallLoc = db.lookup_intern_macro_call(macro_file.macro_call_id);

crates/hir-expand/src/lib.rs

@@ -24,11 +24,11 @@ use hir_expand::{
     attrs::collect_attrs,
     builtin::{BuiltinFnLikeExpander, EagerExpander},
     db::ExpandDatabase,
-    files::InRealFile,
+    files::{HirFileRange, InRealFile},
     hygiene::SyntaxContextExt as _,
     inert_attr_macro::find_builtin_attr_idx,
     name::AsName,
-    ExpandResult, FileRange, InMacroFile, MacroCallId, MacroFileId, MacroFileIdExt,
+    ExpandResult, FileRange, HirFileIdExt, InMacroFile, MacroCallId, MacroFileId, MacroFileIdExt,
 };
 use intern::{sym, Symbol};
 use itertools::Itertools;
@@ -239,10 +239,21 @@ impl<DB: HirDatabase> Semantics<'_, DB> {
         self.imp.file_to_module_defs(file.into()).next()
     }
 
+    pub fn hir_file_to_module_def(&self, file: impl Into<HirFileId>) -> Option<Module> {
+        self.imp.hir_file_to_module_defs(file.into()).next()
+    }
+
     pub fn file_to_module_defs(&self, file: impl Into<FileId>) -> impl Iterator<Item = Module> {
         self.imp.file_to_module_defs(file.into())
     }
 
+    pub fn hir_file_to_module_defs(
+        &self,
+        file: impl Into<HirFileId>,
+    ) -> impl Iterator<Item = Module> {
+        self.imp.hir_file_to_module_defs(file.into())
+    }
+
     pub fn to_adt_def(&self, a: &ast::Adt) -> Option<Adt> {
         self.imp.to_def(a)
     }
@@ -327,6 +338,14 @@ impl<'db> SemanticsImpl<'db> {
         tree
     }
 
+    pub fn adjust_edition(&self, file_id: HirFileId) -> HirFileId {
+        if let Some(editioned_file_id) = file_id.file_id() {
+            self.attach_first_edition(editioned_file_id.file_id()).map_or(file_id, Into::into)
+        } else {
+            file_id
+        }
+    }
+
     pub fn find_parent_file(&self, file_id: HirFileId) -> Option<InFile<SyntaxNode>> {
         match file_id.repr() {
             HirFileIdRepr::FileId(file_id) => {
@@ -697,6 +716,28 @@ impl<'db> SemanticsImpl<'db> {
         })
     }
 
+    /// Retrieves the formatting part of the format_args! template string at the given offset.
+    pub fn check_for_format_args_template_with_file(
+        &self,
+        original_token: SyntaxToken,
+        offset: TextSize,
+    ) -> Option<(HirFileRange, Option<Either<PathResolution, InlineAsmOperand>>)> {
+        let string_start = original_token.text_range().start();
+        let original_token = self.wrap_token_infile(original_token);
+        self.descend_into_macros_breakable2(original_token, |token, _| {
+            (|| {
+                self.resolve_offset_in_format_args(
+                    ast::String::cast(token.value)?,
+                    offset.checked_sub(string_start)?,
+                )
+                .map(|(range, res)| {
+                    (HirFileRange { file_id: token.file_id, range: range + string_start }, res)
+                })
+            })()
+            .map_or(ControlFlow::Continue(()), ControlFlow::Break)
+        })
+    }
+
     fn resolve_offset_in_format_args(
         &self,
         string: ast::String,
@@ -891,6 +932,14 @@ impl<'db> SemanticsImpl<'db> {
         self.descend_into_macros_impl(token.clone(), &mut cb)
     }
 
+    pub fn descend_into_macros_breakable2<T>(
+        &self,
+        token: InFile<SyntaxToken>,
+        mut cb: impl FnMut(InFile<SyntaxToken>, SyntaxContextId) -> ControlFlow<T>,
+    ) -> Option<T> {
+        self.descend_into_macros_impl_(token.clone(), &mut cb)
+    }
+
     /// Descends the token into expansions, returning the tokens that matches the input
     /// token's [`SyntaxKind`] and text.
     pub fn descend_into_macros_exact(&self, token: SyntaxToken) -> SmallVec<[SyntaxToken; 1]> {
@@ -914,6 +963,32 @@ impl<'db> SemanticsImpl<'db> {
         r
     }
 
+    /// Descends the token into expansions, returning the tokens that matches the input
+    /// token's [`SyntaxKind`] and text.
+    pub fn descend_into_macros_exact_with_file(
+        &self,
+        token: SyntaxToken,
+    ) -> SmallVec<[InFile<SyntaxToken>; 1]> {
+        let mut r = smallvec![];
+        let text = token.text();
+        let kind = token.kind();
+
+        self.descend_into_macros_cb(token.clone(), |InFile { value, file_id }, ctx| {
+            let mapped_kind = value.kind();
+            let any_ident_match = || kind.is_any_identifier() && value.kind().is_any_identifier();
+            let matches = (kind == mapped_kind || any_ident_match())
+                && text == value.text()
+                && !ctx.is_opaque(self.db.upcast());
+            if matches {
+                r.push(InFile { value, file_id });
+            }
+        });
+        if r.is_empty() {
+            r.push(self.wrap_token_infile(token));
+        }
+        r
+    }
+
     /// Descends the token into expansions, returning the first token that matches the input
     /// token's [`SyntaxKind`] and text.
     pub fn descend_into_macros_single_exact(&self, token: SyntaxToken) -> SyntaxToken {
@@ -945,10 +1020,18 @@ impl<'db> SemanticsImpl<'db> {
         &self,
         InRealFile { value: token, file_id }: InRealFile<SyntaxToken>,
         f: &mut dyn FnMut(InFile<SyntaxToken>, SyntaxContextId) -> ControlFlow<T>,
+    ) -> Option<T> {
+        self.descend_into_macros_impl_(InFile::new(file_id.into(), token), f)
+    }
+
+    fn descend_into_macros_impl_<T>(
+        &self,
+        InFile { value: token, file_id }: InFile<SyntaxToken>,
+        f: &mut dyn FnMut(InFile<SyntaxToken>, SyntaxContextId) -> ControlFlow<T>,
     ) -> Option<T> {
         let _p = tracing::info_span!("descend_into_macros_impl").entered();
 
-        let span = self.db.real_span_map(file_id).span_for_range(token.text_range());
+        let span = self.db.span_map(file_id).span_for_range(token.text_range());
 
         // Process the expansion of a call, pushing all tokens with our span in the expansion back onto our stack
         let process_expansion_for_token = |stack: &mut Vec<_>, macro_file| {
@@ -972,17 +1055,16 @@ impl<'db> SemanticsImpl<'db> {
         // the tokens themselves aren't that interesting as the span that is being used to map
         // things down never changes.
         let mut stack: Vec<(_, SmallVec<[_; 2]>)> = vec![];
-        let include = self.s2d_cache.borrow_mut().get_or_insert_include_for(self.db, file_id);
+        let include = file_id.file_id().and_then(|file_id| {
+            self.s2d_cache.borrow_mut().get_or_insert_include_for(self.db, file_id)
+        });
         match include {
             Some(include) => {
                 // include! inputs are always from real files, so they only need to be handled once upfront
                 process_expansion_for_token(&mut stack, include)?;
             }
             None => {
-                stack.push((
-                    file_id.into(),
-                    smallvec![(token, SyntaxContextId::root(file_id.edition()))],
-                ));
+                stack.push((file_id, smallvec![(token, span.ctx)]));
             }
         }
 
@@ -1648,6 +1730,16 @@ impl<'db> SemanticsImpl<'db> {
         self.with_ctx(|ctx| ctx.file_to_def(file).to_owned()).into_iter().map(Module::from)
     }
 
+    fn hir_file_to_module_defs(&self, file: HirFileId) -> impl Iterator<Item = Module> {
+        self.with_ctx(|ctx| {
+            // FIXME: Do this properly
+            ctx.file_to_def(file.original_file_respecting_includes(ctx.db.upcast()).file_id())
+                .to_owned()
+        })
+        .into_iter()
+        .map(Module::from)
+    }
+
     pub fn scope(&self, node: &SyntaxNode) -> Option<SemanticsScope<'db>> {
         self.analyze_no_infer(node).map(|SourceAnalyzer { file_id, resolver, .. }| SemanticsScope {
             db: self.db,

crates/hir/src/semantics.rs

@@ -208,7 +208,7 @@ fn replace_usages(
     target_module: &hir::Module,
     delayed_mutations: &mut Vec<(ImportScope, ast::Path)>,
 ) {
-    for (file_id, references) in usages {
+    for (file_id, references) in usages.map_out_of_macros(&ctx.sema) {
         edit.edit_file(file_id.file_id());
 
         let refs_with_imports = augment_references_with_imports(ctx, references, target_module);

crates/ide-assists/src/handlers/bool_to_enum.rs

@@ -147,7 +147,7 @@ fn edit_struct_references(
     };
     let usages = strukt_def.usages(&ctx.sema).include_self_refs().all();
 
-    for (file_id, refs) in usages {
+    for (file_id, refs) in usages.map_out_of_macros(&ctx.sema) {
         edit.edit_file(file_id.file_id());
         for r in refs {
             process_struct_name_reference(ctx, r, edit);
@@ -225,7 +225,7 @@ fn edit_field_references(
         };
         let def = Definition::Field(field);
         let usages = def.usages(&ctx.sema).all();
-        for (file_id, refs) in usages {
+        for (file_id, refs) in usages.map_out_of_macros(&ctx.sema) {
             edit.edit_file(file_id.file_id());
             for r in refs {
                 if let Some(name_ref) = r.name.as_name_ref() {

crates/ide-assists/src/handlers/convert_named_struct_to_tuple_struct.rs

@@ -5,7 +5,7 @@ use ide_db::{
     defs::Definition,
     helpers::mod_path_to_ast,
     imports::insert_use::{insert_use, ImportScope},
-    search::{FileReference, UsageSearchResult},
+    search::{FileReference, RealFileUsageSearchResult},
     source_change::SourceChangeBuilder,
     syntax_helpers::node_ext::{for_each_tail_expr, walk_expr},
     FxHashSet,
@@ -69,7 +69,8 @@ pub(crate) fn convert_tuple_return_type_to_struct(
             let ret_type = edit.make_mut(ret_type);
             let fn_ = edit.make_mut(fn_);
 
-            let usages = Definition::Function(fn_def).usages(&ctx.sema).all();
+            let usages =
+                Definition::Function(fn_def).usages(&ctx.sema).all().map_out_of_macros(&ctx.sema);
             let struct_name = format!("{}Result", stdx::to_camel_case(&fn_name.to_string()));
             let parent = fn_.syntax().ancestors().find_map(<Either<ast::Impl, ast::Trait>>::cast);
             add_tuple_struct_def(
@@ -100,7 +101,7 @@ pub(crate) fn convert_tuple_return_type_to_struct(
 fn replace_usages(
     edit: &mut SourceChangeBuilder,
     ctx: &AssistContext<'_>,
-    usages: &UsageSearchResult,
+    usages: &RealFileUsageSearchResult,
     struct_name: &str,
     target_module: &hir::Module,
 ) {
@@ -230,7 +231,7 @@ fn augment_references_with_imports(
 fn add_tuple_struct_def(
     edit: &mut SourceChangeBuilder,
     ctx: &AssistContext<'_>,
-    usages: &UsageSearchResult,
+    usages: &RealFileUsageSearchResult,
     parent: &SyntaxNode,
     tuple_ty: &ast::TupleType,
     struct_name: &str,

crates/ide-assists/src/handlers/convert_tuple_return_type_to_struct.rs

@@ -134,7 +134,8 @@ fn edit_struct_references(
         Either::Left(s) => Definition::Adt(hir::Adt::Struct(s)),
         Either::Right(v) => Definition::Variant(v),
     };
-    let usages = strukt_def.usages(&ctx.sema).include_self_refs().all();
+    let usages =
+        strukt_def.usages(&ctx.sema).include_self_refs().all().map_out_of_macros(&ctx.sema);
 
     let edit_node = |edit: &mut SourceChangeBuilder, node: SyntaxNode| -> Option<()> {
         match_ast! {
@@ -219,7 +220,7 @@ fn edit_field_references(
             None => continue,
         };
         let def = Definition::Field(field);
-        let usages = def.usages(&ctx.sema).all();
+        let usages = def.usages(&ctx.sema).all().map_out_of_macros(&ctx.sema);
         for (file_id, refs) in usages {
             edit.edit_file(file_id.file_id());
             for r in refs {

crates/ide-assists/src/handlers/convert_tuple_struct_to_named_struct.rs

@@ -330,7 +330,7 @@ impl Module {
         let out_of_sel = |node: &SyntaxNode| !self.text_range.contains_range(node.text_range());
         let mut use_stmts_set = FxHashSet::default();
 
-        for (file_id, refs) in node_def.usages(&ctx.sema).all() {
+        for (file_id, refs) in node_def.usages(&ctx.sema).all().map_out_of_macros(&ctx.sema) {
             let source_file = ctx.sema.parse(file_id);
             let usages = refs.into_iter().filter_map(|FileReference { range, .. }| {
                 // handle normal usages

crates/ide-assists/src/handlers/extract_module.rs

@@ -68,7 +68,7 @@ pub(crate) fn extract_struct_from_enum_variant(
             visited_modules_set.insert(current_module);
             // record file references of the file the def resides in, we only want to swap to the edited file in the builder once
             let mut def_file_references = None;
-            for (file_id, references) in usages {
+            for (file_id, references) in usages.map_out_of_macros(&ctx.sema) {
                 if file_id == ctx.file_id() {
                     def_file_references = Some(references);
                     continue;