Merge #9132 #9151

9132: RES: Fix nested `include!`-ed files in different directory r=vlad20012 a=dima74

Fixes #8614

Related: #7156 (but that is for mod declaration in `include!`-ed file )

changelog: Fix resolve of items from nested `include!`-ed files in some cases


9151: RES: Fix cache invalidation after toggle "Expand macros" settings r=vlad20012 a=dima74

Currently when toggle ["Expand macros" option](#9127), we have two problems:
* `CrateDefMap`s don't rebuild
* `structureModificationTracker` doesn't increment if option was disabled but becomes enabled

---

This may lead to problems like (thanks `@neonaot):`
```rust
macro_rules! gen {
    () => { fn func() {} }
}
gen!();
fn main() {
    func();
}
```

* Disable "Expand macros" - `func` is unresolved (good)
* Enable "Expand macros" - `func` is still unresolved (bad)

changelog: Fix cache invalidation after toggle "Expand macros" settings


Co-authored-by: Dmitry Murzin <diralik@yandex.ru>

src/main/kotlin/org/rust/lang/core/macros/MacroExpansionManager.kt

@@ -566,6 +566,10 @@ private class MacroExpansionServiceImplInner(
         if (!isExpansionModeNew) {
             cleanMacrosDirectoryAndStorage()
         }
+        project.runWriteCommandAction {
+            project.defMapService.scheduleRebuildAllDefMaps()
+            project.rustPsiManager.incRustStructureModificationCount()
+        }
         processUnprocessedMacros()
     }
 

src/main/kotlin/org/rust/lang/core/resolve2/DefCollector.kt

@@ -399,21 +399,27 @@ class DefCollector(
     }
 
     private fun expandIncludeMacroCall(call: MacroCallInfo) {
-        val modData = call.containingMod
-        val containingFile = PersistentFS.getInstance().findFileById(modData.fileId ?: return) ?: return
+        val containingFile = PersistentFS.getInstance().findFileById(call.containingFileId ?: return) ?: return
         val includePath = (call.body as? MacroCallBody.FunctionLike)?.text ?: return
         val parentDirectory = containingFile.parent
         val includingFile = parentDirectory.findFileByMaybeRelativePath(includePath)
         val includingRsFile = includingFile?.toPsiFile(project)?.rustFile
         if (includingRsFile != null) {
             val context = getModCollectorContextForExpandedElements(call) ?: return
-            collectScope(includingRsFile, call.containingMod, context, call.macroIndex, propagateLegacyMacros = true)
+            collectScope(
+                includingRsFile,
+                call.containingMod,
+                context,
+                call.macroIndex,
+                includeMacroFile = includingFile,
+                propagateLegacyMacros = true
+            )
         } else if (!context.isHangingMode) {
             val filePath = parentDirectory.pathAsPath.resolve(includePath)
             defMap.missedFiles.add(filePath)
         }
         if (includingFile != null) {
-            recordChildFileInUnusualLocation(modData, includingFile.fileId)
+            recordChildFileInUnusualLocation(call.containingMod, includingFile.fileId)
         }
     }
 
@@ -528,6 +534,7 @@ class MacroCallInfo(
     val path: Array<String>,
     val body: MacroCallBody,
     val bodyHash: HashCode?,  // null for `include!` macro
+    val containingFileId: FileId?,  // needed only if this is `include!` macro
     val depth: Int,
     /**
      * `srcOffset` - [CratePersistentId]

src/main/kotlin/org/rust/lang/core/resolve2/ModCollector.kt

@@ -58,12 +58,13 @@ fun collectScope(
     context: ModCollectorContext,
     modMacroIndex: MacroIndex = modData.macroIndex,
     dollarCrateHelper: DollarCrateHelper? = null,
+    includeMacroFile: VirtualFile? = null,
     propagateLegacyMacros: Boolean = false,
 ): LegacyMacros {
     val hashCalculator = HashCalculator(modData.isEnabledByCfgInner)
         .takeIf { modData.isNormalCrate }
 
-    val collector = ModCollector(modData, context, modMacroIndex, hashCalculator, dollarCrateHelper)
+    val collector = ModCollector(modData, context, modMacroIndex, hashCalculator, dollarCrateHelper, includeMacroFile)
     collector.collectMod(scope.getOrBuildStub() ?: return emptyMap(), propagateLegacyMacros)
 
     if (hashCalculator != null && scope is RsFile) {
@@ -80,7 +81,14 @@ fun collectExpandedElements(
     context: ModCollectorContext,
     dollarCrateHelper: DollarCrateHelper?
 ) {
-    val collector = ModCollector(call.containingMod, context, call.macroIndex, hashCalculator = null, dollarCrateHelper)
+    val collector = ModCollector(
+        call.containingMod,
+        context,
+        call.macroIndex,
+        hashCalculator = null,
+        dollarCrateHelper,
+        includeMacroFile = null
+    )
     collector.collectMod(expandedFile, propagateLegacyMacros = true)
 }
 
@@ -98,6 +106,8 @@ private class ModCollector(
     private val parentMacroIndex: MacroIndex,
     private val hashCalculator: HashCalculator?,
     private val dollarCrateHelper: DollarCrateHelper?,
+    /** containing file, if it is `include!`-ed */
+    private val includeMacroFile: VirtualFile?,
 ) : ModVisitor {
 
     private val defMap: CrateDefMap = context.defMap
@@ -255,7 +265,8 @@ private class ModCollector(
                     context,
                     childModData.macroIndex,
                     hashCalculator,
-                    dollarCrateHelper
+                    dollarCrateHelper,
+                    includeMacroFile
                 )
                 collector.collectMod(childMod.mod)
                 collector.legacyMacros
@@ -311,6 +322,7 @@ private class ModCollector(
             path,
             MacroCallBody.FunctionLike(call.body),
             bodyHash,
+            containingFileId = includeMacroFile?.fileId ?: modData.fileId,
             macroDepth,
             dollarCrateMap
         )
@@ -335,6 +347,7 @@ private class ModCollector(
             path,
             body,
             bodyHash,
+            containingFileId = null,  // will not be used
             macroDepth,
             dollarCrateMap,
             originalItem

src/test/kotlin/org/rust/lang/core/resolve/RsIncludeMacroResolveTest.kt

@@ -136,6 +136,17 @@ class RsIncludeMacroResolveTest : RsResolveTestBase() {
                 //^ lib.rs
     """)
 
+    fun `test include file in included file 3`() = checkResolve("""
+    //- lib.rs
+        include!("inner/foo.rs");
+        fn foo(x: Foo) {}
+                //^ inner/bar.rs
+    //- inner/foo.rs
+        include!("bar.rs");
+    //- inner/bar.rs
+        struct Foo;
+    """)
+
     @ExpandMacros
     fun `test include macro in macro 1`() = checkResolve("""
     //- lib.rs