[Analysis API test] migrate more tests from doTestByModuleStructure to doTestByMainFile

^KT-64805

analysis/analysis-api-impl-base/tests/org/jetbrains/kotlin/analysis/api/impl/base/test/cases/components/callResolver/AbstractMultiModuleResolveCallTest.kt

@@ -1,30 +1,23 @@
 /*
- * Copyright 2010-2022 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Copyright 2010-2024 JetBrains s.r.o. and Kotlin Programming Language contributors.
  * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
  */
 
 package org.jetbrains.kotlin.analysis.api.impl.base.test.cases.components.callResolver
 
-import com.intellij.psi.PsiElement
-import org.jetbrains.kotlin.analysis.api.KtAnalysisSession
-import org.jetbrains.kotlin.analysis.api.calls.KtCallInfo
 import org.jetbrains.kotlin.analysis.api.impl.base.test.cases.components.stringRepresentation
 import org.jetbrains.kotlin.analysis.test.framework.base.AbstractAnalysisApiBasedTest
 import org.jetbrains.kotlin.analysis.test.framework.services.expressionMarkerProvider
 import org.jetbrains.kotlin.analysis.test.framework.utils.executeOnPooledThreadInReadAction
-import org.jetbrains.kotlin.psi.KtCallElement
-import org.jetbrains.kotlin.psi.KtElement
 import org.jetbrains.kotlin.psi.KtExpression
-import org.jetbrains.kotlin.test.services.TestModuleStructure
+import org.jetbrains.kotlin.psi.KtFile
+import org.jetbrains.kotlin.test.model.TestModule
 import org.jetbrains.kotlin.test.services.TestServices
 import org.jetbrains.kotlin.test.services.assertions
 
 abstract class AbstractMultiModuleResolveCallTest : AbstractAnalysisApiBasedTest() {
-    final override fun doTestByModuleStructure(moduleStructure: TestModuleStructure, testServices: TestServices) {
+    override fun doTestByMainFile(mainFile: KtFile, mainModule: TestModule, testServices: TestServices) {
-        val (expression, _) =
+        val expression = testServices.expressionMarkerProvider.getElementOfTypeAtCaret<KtExpression>(mainFile)
-            testServices.expressionMarkerProvider.getElementsOfTypeAtCarets<KtExpression>(moduleStructure, testServices)
-                .single()
-
         val actual = executeOnPooledThreadInReadAction {
             analyseForTest(expression) {
                 expression.resolveCall()?.let { stringRepresentation(it) }

analysis/analysis-api-impl-base/tests/org/jetbrains/kotlin/analysis/api/impl/base/test/cases/components/diagnosticProvider/AbstractCodeFragmentCollectDiagnosticsTest.kt

@@ -1,5 +1,5 @@
 /*
- * Copyright 2010-2023 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Copyright 2010-2024 JetBrains s.r.o. and Kotlin Programming Language contributors.
  * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
  */
 
@@ -14,16 +14,16 @@ import org.jetbrains.kotlin.test.services.TestServices
 import java.io.File
 
 abstract class AbstractCodeFragmentCollectDiagnosticsTest : AbstractCollectDiagnosticsTest() {
-    override fun doTestByFileStructure(ktFile: KtFile, module: TestModule, testServices: TestServices) {
+    override fun doTestByMainFile(mainFile: KtFile, mainModule: TestModule, testServices: TestServices) {
-        val contextElement = testServices.expressionMarkerProvider.getElementOfTypeAtCaret<KtElement>(ktFile)
+        val contextElement = testServices.expressionMarkerProvider.getElementOfTypeAtCaret<KtElement>(mainFile)
 
-        val fragmentText = module.files.single().originalFile
+        val fragmentText = mainModule.files.single().originalFile
             .run { File(parent, "$nameWithoutExtension.fragment.$extension") }
             .readText()
 
         val isBlockFragment = fragmentText.any { it == '\n' }
 
-        val project = ktFile.project
+        val project = mainFile.project
         val factory = KtPsiFactory(project, markGenerated = false)
 
         val codeFragment = when {
@@ -31,6 +31,6 @@ abstract class AbstractCodeFragmentCollectDiagnosticsTest : AbstractCollectDiagn
             else -> factory.createExpressionCodeFragment(fragmentText, contextElement)
         }
 
-        super.doTestByFileStructure(codeFragment, module, testServices)
+        super.doTestByMainFile(codeFragment, mainModule, testServices)
     }
 }

analysis/analysis-api-impl-base/tests/org/jetbrains/kotlin/analysis/api/impl/base/test/cases/components/diagnosticProvider/AbstractCollectDiagnosticsTest.kt

@@ -1,5 +1,5 @@
 /*
- * Copyright 2010-2022 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Copyright 2010-2024 JetBrains s.r.o. and Kotlin Programming Language contributors.
  * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
  */
 
@@ -10,7 +10,6 @@ import com.intellij.psi.PsiElement
 import org.jetbrains.kotlin.analysis.api.components.KtDiagnosticCheckerFilter
 import org.jetbrains.kotlin.analysis.api.diagnostics.KtDiagnosticWithPsi
 import org.jetbrains.kotlin.analysis.test.framework.base.AbstractAnalysisApiBasedTest
-import org.jetbrains.kotlin.analysis.test.framework.project.structure.ktModuleProvider
 import org.jetbrains.kotlin.diagnostics.DiagnosticUtils.getLineAndColumnRangeInPsiFile
 import org.jetbrains.kotlin.diagnostics.PsiDiagnosticUtils.offsetToLineAndColumn
 import org.jetbrains.kotlin.psi.KtElement
@@ -18,28 +17,21 @@ import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.psi.KtTreeVisitorVoid
 import org.jetbrains.kotlin.psi.psiUtil.startOffset
 import org.jetbrains.kotlin.test.model.TestModule
-import org.jetbrains.kotlin.test.services.TestModuleStructure
 import org.jetbrains.kotlin.test.services.TestServices
 import org.jetbrains.kotlin.test.services.assertions
 import kotlin.test.assertEquals
 
 abstract class AbstractCollectDiagnosticsTest : AbstractAnalysisApiBasedTest() {
-    override fun doTestByModuleStructure(moduleStructure: TestModuleStructure, testServices: TestServices) {
+    override fun doTestByMainFile(mainFile: KtFile, mainModule: TestModule, testServices: TestServices) {
-        val lastModule = moduleStructure.modules.last()
-        val firstKtFileFile = testServices.ktModuleProvider.getModuleFiles(lastModule).firstNotNullOf { it as? KtFile }
-        doTestByFileStructure(firstKtFileFile, lastModule, testServices)
-    }
-
-    open fun doTestByFileStructure(ktFile: KtFile, module: TestModule, testServices: TestServices) {
         fun TextRange.asLineColumnRange(): String {
-            return getLineAndColumnRangeInPsiFile(ktFile, this).toString()
+            return getLineAndColumnRangeInPsiFile(mainFile, this).toString()
         }
 
-        analyseForTest(ktFile) {
+        analyseForTest(mainFile) {
             val diagnosticsInFile =
-                ktFile.collectDiagnosticsForFile(KtDiagnosticCheckerFilter.EXTENDED_AND_COMMON_CHECKERS).map { it.getKey() }.sorted()
+                mainFile.collectDiagnosticsForFile(KtDiagnosticCheckerFilter.EXTENDED_AND_COMMON_CHECKERS).map { it.getKey() }.sorted()
             val diagnosticsFromElements = buildList {
-                ktFile.accept(object : KtTreeVisitorVoid() {
+                mainFile.accept(object : KtTreeVisitorVoid() {
                     override fun visitKtElement(element: KtElement) {
                         for (diagnostic in element.getDiagnostics(KtDiagnosticCheckerFilter.EXTENDED_AND_COMMON_CHECKERS)) {
                             add(element to diagnostic.getKey())

analysis/analysis-api-impl-base/tests/org/jetbrains/kotlin/analysis/api/impl/base/test/cases/components/diagnosticProvider/AbstractDanglingFileCollectDiagnosticsTest.kt

@@ -1,5 +1,5 @@
 /*
- * Copyright 2010-2023 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Copyright 2010-2024 JetBrains s.r.o. and Kotlin Programming Language contributors.
  * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
  */
 
@@ -11,10 +11,10 @@ import org.jetbrains.kotlin.test.model.TestModule
 import org.jetbrains.kotlin.test.services.TestServices
 
 abstract class AbstractDanglingFileCollectDiagnosticsTest : AbstractCollectDiagnosticsTest() {
-    override fun doTestByFileStructure(ktFile: KtFile, module: TestModule, testServices: TestServices) {
+    override fun doTestByMainFile(mainFile: KtFile, mainModule: TestModule, testServices: TestServices) {
-        val ktPsiFactory = KtPsiFactory.contextual(ktFile, markGenerated = true, eventSystemEnabled = false)
+        val ktPsiFactory = KtPsiFactory.contextual(mainFile, markGenerated = true, eventSystemEnabled = false)
-        val fakeKtFile = ktPsiFactory.createFile("fake.kt", ktFile.text)
+        val fakeKtFile = ktPsiFactory.createFile("fake.kt", mainFile.text)
 
-        super.doTestByFileStructure(fakeKtFile, module, testServices)
+        super.doTestByMainFile(fakeKtFile, mainModule, testServices)
     }
 }

analysis/analysis-api-impl-base/tests/org/jetbrains/kotlin/analysis/api/impl/base/test/cases/components/multiplatformInfoProvider/AbstractExpectForActualTest.kt

@@ -1,27 +1,22 @@
 /*
- * Copyright 2010-2023 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Copyright 2010-2024 JetBrains s.r.o. and Kotlin Programming Language contributors.
  * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
  */
 
 package org.jetbrains.kotlin.analysis.api.impl.base.test.cases.components.multiplatformInfoProvider
 
 import org.jetbrains.kotlin.analysis.test.framework.base.AbstractAnalysisApiBasedTest
-import org.jetbrains.kotlin.analysis.test.framework.project.structure.ktModuleProvider
 import org.jetbrains.kotlin.analysis.test.framework.services.expressionMarkerProvider
 import org.jetbrains.kotlin.analysis.test.framework.utils.executeOnPooledThreadInReadAction
 import org.jetbrains.kotlin.psi.KtDeclaration
 import org.jetbrains.kotlin.psi.KtFile
-import org.jetbrains.kotlin.test.services.TestModuleStructure
+import org.jetbrains.kotlin.test.model.TestModule
 import org.jetbrains.kotlin.test.services.TestServices
 import org.jetbrains.kotlin.test.services.assertions
 
 abstract class AbstractExpectForActualTest : AbstractAnalysisApiBasedTest() {
-    override fun doTestByModuleStructure(moduleStructure: TestModuleStructure, testServices: TestServices) {
+    override fun doTestByMainFile(mainFile: KtFile, mainModule: TestModule, testServices: TestServices) {
-        val (declaration, _) = moduleStructure.modules.flatMap { module ->
+        val declaration = testServices.expressionMarkerProvider.getElementOfTypeAtCaret<KtDeclaration>(mainFile)
-            val ktFiles = testServices.ktModuleProvider.getModuleFiles(module).filterIsInstance<KtFile>()
-            testServices.expressionMarkerProvider.getElementsOfTypeAtCarets<KtDeclaration>(ktFiles)
-        }.single()
-
         val expectedSymbolText: String? = executeOnPooledThreadInReadAction {
             analyseForTest(declaration) {
                 val expectedSymbols = declaration.getSymbol().getExpectsForActual()

analysis/analysis-api-impl-base/tests/org/jetbrains/kotlin/analysis/api/impl/base/test/cases/components/psiTypeProvider/AbstractAnalysisApiKtTypeByPsiTypeProviderTest.kt

@@ -13,17 +13,15 @@ import org.jetbrains.kotlin.analysis.test.framework.project.structure.ktModulePr
 import org.jetbrains.kotlin.analysis.test.framework.services.expressionMarkerProvider
 import org.jetbrains.kotlin.analysis.test.framework.utils.executeOnPooledThreadInReadAction
 import org.jetbrains.kotlin.psi.KtFile
-import org.jetbrains.kotlin.test.services.TestModuleStructure
+import org.jetbrains.kotlin.test.model.TestModule
 import org.jetbrains.kotlin.test.services.TestServices
 import org.jetbrains.kotlin.test.services.assertions
+import org.jetbrains.kotlin.test.services.moduleStructure
 import org.jetbrains.kotlin.types.Variance
-import org.jetbrains.kotlin.util.PrivateForInline
 
 abstract class AbstractAnalysisApiKtTypeByPsiTypeProviderTest : AbstractAnalysisApiBasedTest() {
-    @OptIn(PrivateForInline::class)
+    override fun doTestByMainFile(mainFile: KtFile, mainModule: TestModule, testServices: TestServices) {
-    override fun doTestByModuleStructure(moduleStructure: TestModuleStructure, testServices: TestServices) {
+        val psiMethod = testServices.moduleStructure.modules.map { module ->
-        val ktFile = moduleStructure.modules.map { testServices.ktModuleProvider.getModuleFiles(it).filterIsInstance<KtFile>().first() }.first()
-        val psiMethod = moduleStructure.modules.map { module ->
             val psiFiles = testServices.ktModuleProvider.getModuleFiles(module).filterIsInstance<PsiJavaFile>()
             val javaFile = psiFiles.first()
             val offset = testServices.expressionMarkerProvider.getCaretPosition(javaFile)
@@ -32,7 +30,7 @@ abstract class AbstractAnalysisApiKtTypeByPsiTypeProviderTest : AbstractAnalysis
 
         val actual = buildString {
             executeOnPooledThreadInReadAction {
-                analyseForTest(ktFile) {
+                analyseForTest(mainFile) {
                     val returnType = psiMethod.returnType
                     testServices.assertions.assertNotNull(returnType)
                     val asKtTypeSuper = returnType!!.asKtType(psiMethod)!!

analysis/analysis-api-impl-base/tests/org/jetbrains/kotlin/analysis/api/impl/base/test/cases/components/psiTypeProvider/AbstractAnalysisApiPsiTypeProviderTest.kt

@@ -1,5 +1,5 @@
 /*
- * Copyright 2010-2022 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Copyright 2010-2024 JetBrains s.r.o. and Kotlin Programming Language contributors.
  * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
  */
 
@@ -9,28 +9,23 @@ import org.jetbrains.kotlin.analysis.api.analyze
 import org.jetbrains.kotlin.analysis.api.impl.base.test.cases.components.psiTypeProvider.AnalysisApiPsiTypeProviderTestUtils.findLightDeclarationContext
 import org.jetbrains.kotlin.analysis.api.impl.base.test.cases.components.psiTypeProvider.AnalysisApiPsiTypeProviderTestUtils.getContainingKtLightClass
 import org.jetbrains.kotlin.analysis.test.framework.base.AbstractAnalysisApiBasedTest
-import org.jetbrains.kotlin.analysis.test.framework.project.structure.ktModuleProvider
 import org.jetbrains.kotlin.analysis.test.framework.services.expressionMarkerProvider
 import org.jetbrains.kotlin.analysis.test.framework.utils.executeOnPooledThreadInReadAction
 import org.jetbrains.kotlin.psi.KtDeclaration
 import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.psi.KtPsiUtil
-import org.jetbrains.kotlin.test.services.TestModuleStructure
+import org.jetbrains.kotlin.test.model.TestModule
 import org.jetbrains.kotlin.test.services.TestServices
 import org.jetbrains.kotlin.test.services.assertions
 import org.jetbrains.kotlin.types.Variance
 
 abstract class AbstractAnalysisApiPsiTypeProviderTest : AbstractAnalysisApiBasedTest() {
-    override fun doTestByModuleStructure(moduleStructure: TestModuleStructure, testServices: TestServices) {
+    override fun doTestByMainFile(mainFile: KtFile, mainModule: TestModule, testServices: TestServices) {
-        val (declaration, ktFile) = moduleStructure.modules.flatMap { module ->
+        val declaration = testServices.expressionMarkerProvider.getElementOfTypeAtCaret<KtDeclaration>(mainFile)
-            val ktFiles = testServices.ktModuleProvider.getModuleFiles(module).filterIsInstance<KtFile>()
-            testServices.expressionMarkerProvider.getElementsOfTypeAtCarets<KtDeclaration>(ktFiles)
-        }.single()
-
         val psiContext = if (KtPsiUtil.isLocal(declaration)) {
             declaration
         } else {
-            val containingClass = getContainingKtLightClass(declaration, ktFile)
+            val containingClass = getContainingKtLightClass(declaration, mainFile)
             containingClass.findLightDeclarationContext(declaration) ?: error("Can't find psi context for $declaration")
         }
 

analysis/analysis-api-impl-base/tests/org/jetbrains/kotlin/analysis/api/impl/base/test/cases/components/resolveExtensionInfoProvider/AbstractResolveExtensionInfoProviderTest.kt

@@ -1,5 +1,5 @@
 /*
- * Copyright 2010-2023 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Copyright 2010-2024 JetBrains s.r.o. and Kotlin Programming Language contributors.
  * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
  */
 
@@ -12,14 +12,11 @@ import org.jetbrains.kotlin.analysis.api.impl.base.test.cases.resolve.extensions
 import org.jetbrains.kotlin.analysis.api.scopes.KtScope
 import org.jetbrains.kotlin.analysis.api.symbols.KtDeclarationSymbol
 import org.jetbrains.kotlin.analysis.test.framework.base.AbstractAnalysisApiBasedTest
-import org.jetbrains.kotlin.analysis.test.framework.base.AbstractAnalysisApiSingleFileTest
-import org.jetbrains.kotlin.analysis.test.framework.project.structure.ktModuleProvider
 import org.jetbrains.kotlin.analysis.utils.printer.prettyPrint
 import org.jetbrains.kotlin.psi.KtElement
 import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.test.builders.TestConfigurationBuilder
 import org.jetbrains.kotlin.test.model.TestModule
-import org.jetbrains.kotlin.test.services.TestModuleStructure
 import org.jetbrains.kotlin.test.services.TestServices
 import org.jetbrains.kotlin.test.services.assertions
 
@@ -29,22 +26,8 @@ abstract class AbstractResolveExtensionInfoProviderTest : AbstractAnalysisApiBas
         KtResolveExtensionTestSupport.configure(builder)
     }
 
-    private fun List<TestModule>.findMainModule(): TestModule =
+    override fun doTestByMainFile(mainFile: KtFile, mainModule: TestModule, testServices: TestServices) {
-        singleOrNull()
+        analyseForTest(mainFile) {
-            ?: find { it.name == "main" }
-            ?: error("There should either be a single module, or a module named 'main'.")
-
-    private fun List<KtFile>.findMainKt(): KtFile =
-        singleOrNull()
-            ?: find { it.name == "main.kt" }
-            ?: error("There should either be a single Kotlin file in the main module, or a file named 'main.kt'.")
-
-    override fun doTestByModuleStructure(moduleStructure: TestModuleStructure, testServices: TestServices) {
-        val mainModule = moduleStructure.modules.findMainModule()
-        val ktFiles = testServices.ktModuleProvider.getModuleFiles(mainModule).filterIsInstance<KtFile>()
-        val mainKt = ktFiles.findMainKt()
-
-        analyseForTest(mainKt) {
             val resolveExtensionScope = getResolveExtensionScopeWithTopLevelDeclarations()
 
             val actual = resolveExtensionScope.renderSymbolsWithExtendedPsiInfo(pretty = false)

analysis/analysis-api-impl-base/tests/org/jetbrains/kotlin/analysis/api/impl/base/test/cases/references/AbstractDanglingFileReferenceResolveTest.kt

@@ -1,5 +1,5 @@
 /*
- * Copyright 2010-2023 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Copyright 2010-2024 JetBrains s.r.o. and Kotlin Programming Language contributors.
  * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
  */
 
@@ -11,7 +11,6 @@ import org.jetbrains.kotlin.analysis.api.analyzeCopy
 import org.jetbrains.kotlin.analysis.api.impl.base.test.cases.references.AbstractDanglingFileReferenceResolveTest.Directives.COPY_RESOLUTION_MODE
 import org.jetbrains.kotlin.analysis.api.symbols.KtSymbol
 import org.jetbrains.kotlin.analysis.project.structure.DanglingFileResolutionMode
-import org.jetbrains.kotlin.analysis.test.framework.project.structure.ktModuleProvider
 import org.jetbrains.kotlin.analysis.test.framework.services.expressionMarkerProvider
 import org.jetbrains.kotlin.psi.KtElement
 import org.jetbrains.kotlin.psi.KtFile
@@ -20,7 +19,6 @@ import org.jetbrains.kotlin.test.builders.TestConfigurationBuilder
 import org.jetbrains.kotlin.test.directives.model.SimpleDirectivesContainer
 import org.jetbrains.kotlin.test.directives.model.singleOrZeroValue
 import org.jetbrains.kotlin.test.model.TestModule
-import org.jetbrains.kotlin.test.services.TestModuleStructure
 import org.jetbrains.kotlin.test.services.TestServices
 
 abstract class AbstractDanglingFileReferenceResolveTest : AbstractReferenceResolveTest() {
@@ -49,17 +47,14 @@ abstract class AbstractDanglingFileReferenceResolveTest : AbstractReferenceResol
         return containingFile.name
     }
 
-    override fun doTestByModuleStructure(moduleStructure: TestModuleStructure, testServices: TestServices) {
+    override fun doTestByMainFile(mainFile: KtFile, mainModule: TestModule, testServices: TestServices) {
-        val mainModule = findMainModule(moduleStructure)
+        val caretPosition = testServices.expressionMarkerProvider.getCaretPosition(mainFile)
-        val ktFiles = testServices.ktModuleProvider.getModuleFiles(mainModule).filterIsInstance<KtFile>()
-        val mainKtFile = findMainFile(ktFiles)
-        val caretPosition = testServices.expressionMarkerProvider.getCaretPosition(mainKtFile)
 
-        val ktPsiFactory = KtPsiFactory.contextual(mainKtFile, markGenerated = true, eventSystemEnabled = true)
+        val ktPsiFactory = KtPsiFactory.contextual(mainFile, markGenerated = true, eventSystemEnabled = true)
-        val fakeKtFile = ktPsiFactory.createFile("fake.kt", mainKtFile.text)
+        val fakeKtFile = ktPsiFactory.createFile("fake.kt", mainFile.text)
 
         if (mainModule.directives.contains(COPY_RESOLUTION_MODE)) {
-            fakeKtFile.originalFile = mainKtFile
+            fakeKtFile.originalFile = mainFile
         }
 
         doTestByFileStructure(fakeKtFile, caretPosition, mainModule, testServices)

analysis/analysis-api-impl-base/tests/org/jetbrains/kotlin/analysis/api/impl/base/test/cases/references/AbstractReferenceResolveTest.kt

@@ -1,5 +1,5 @@
 /*
- * Copyright 2010-2022 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Copyright 2010-2024 JetBrains s.r.o. and Kotlin Programming Language contributors.
  * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
  */
 
@@ -13,7 +13,6 @@ import org.jetbrains.kotlin.analysis.api.renderer.declarations.renderers.callabl
 import org.jetbrains.kotlin.analysis.api.symbols.KtSymbol
 import org.jetbrains.kotlin.analysis.test.framework.AnalysisApiTestDirectives
 import org.jetbrains.kotlin.analysis.test.framework.base.AbstractAnalysisApiBasedTest
-import org.jetbrains.kotlin.analysis.test.framework.project.structure.ktModuleProvider
 import org.jetbrains.kotlin.analysis.test.framework.services.expressionMarkerProvider
 import org.jetbrains.kotlin.analysis.test.framework.utils.unwrapMultiReferences
 import org.jetbrains.kotlin.idea.references.KtReference
@@ -23,7 +22,6 @@ import org.jetbrains.kotlin.test.builders.TestConfigurationBuilder
 import org.jetbrains.kotlin.test.directives.ConfigurationDirectives
 import org.jetbrains.kotlin.test.directives.model.SimpleDirectivesContainer
 import org.jetbrains.kotlin.test.model.TestModule
-import org.jetbrains.kotlin.test.services.TestModuleStructure
 import org.jetbrains.kotlin.test.services.TestServices
 import org.jetbrains.kotlin.test.services.assertions
 
@@ -47,26 +45,9 @@ abstract class AbstractReferenceResolveTest : AbstractAnalysisApiBasedTest() {
         }
     }
 
-    override fun doTestByModuleStructure(moduleStructure: TestModuleStructure, testServices: TestServices) {
+    override fun doTestByMainFile(mainFile: KtFile, mainModule: TestModule, testServices: TestServices) {
-        val mainModule = findMainModule(moduleStructure)
+        val caretPosition = testServices.expressionMarkerProvider.getCaretPosition(mainFile)
-        val ktFiles = testServices.ktModuleProvider.getModuleFiles(mainModule).filterIsInstance<KtFile>()
+        doTestByFileStructure(mainFile, caretPosition, mainModule, testServices)
-        val mainKtFile = findMainFile(ktFiles)
-        val caretPosition = testServices.expressionMarkerProvider.getCaretPosition(mainKtFile)
-        doTestByFileStructure(mainKtFile, caretPosition, mainModule, testServices)
-    }
-
-    protected fun findMainModule(moduleStructure: TestModuleStructure): TestModule {
-        val modules = moduleStructure.modules
-
-        return modules.singleOrNull()
-            ?: modules.find { it.name == "main" }
-            ?: error("There should be a module named 'main' in the multi-module test.")
-    }
-
-    protected fun findMainFile(ktFiles: List<KtFile>): KtFile {
-        return ktFiles.singleOrNull()
-            ?: ktFiles.firstOrNull { it.name == "main.kt" }
-            ?: ktFiles.first()
     }
 
     protected fun doTestByFileStructure(ktFile: KtFile, caretPosition: Int, mainModule: TestModule, testServices: TestServices) {
@@ -79,8 +60,8 @@ abstract class AbstractReferenceResolveTest : AbstractAnalysisApiBasedTest() {
             val symbols = ktReferences.flatMap { it.resolveToSymbols() }
             checkReferenceResultForValidity(ktReferences, mainModule, testServices, symbols)
             val renderPsiClassName = Directives.RENDER_PSI_CLASS_NAME in mainModule.directives
-                renderResolvedTo(symbols, renderPsiClassName, renderingOptions) { getAdditionalSymbolInfo(it) }
+            renderResolvedTo(symbols, renderPsiClassName, renderingOptions) { getAdditionalSymbolInfo(it) }
-            }
+        }
 
         if (Directives.UNRESOLVED_REFERENCE in mainModule.directives) {
             return
@@ -103,7 +84,7 @@ abstract class AbstractReferenceResolveTest : AbstractAnalysisApiBasedTest() {
         references: List<KtReference>,
         module: TestModule,
         testServices: TestServices,
-        resolvedTo: List<KtSymbol>
+        resolvedTo: List<KtSymbol>,
     ) {
         if (Directives.UNRESOLVED_REFERENCE in module.directives) {
             testServices.assertions.assertTrue(resolvedTo.isEmpty()) {

analysis/analysis-api-impl-base/tests/org/jetbrains/kotlin/analysis/api/impl/base/test/cases/symbols/AbstractSymbolTest.kt

@@ -1,5 +1,5 @@
 /*
- * Copyright 2010-2023 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Copyright 2010-2024 JetBrains s.r.o. and Kotlin Programming Language contributors.
  * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
  */
 
@@ -23,7 +23,6 @@ import org.jetbrains.kotlin.analysis.api.symbols.markers.KtSymbolWithTypeParamet
 import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtPsiBasedSymbolPointer
 import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtSymbolPointer
 import org.jetbrains.kotlin.analysis.test.framework.base.AbstractAnalysisApiBasedTest
-import org.jetbrains.kotlin.analysis.test.framework.project.structure.ktModuleProvider
 import org.jetbrains.kotlin.analysis.test.framework.test.configurators.FrontendKind
 import org.jetbrains.kotlin.analysis.test.framework.utils.executeOnPooledThreadInReadAction
 import org.jetbrains.kotlin.analysis.utils.printer.prettyPrint
@@ -33,7 +32,6 @@ import org.jetbrains.kotlin.test.directives.model.Directive
 import org.jetbrains.kotlin.test.directives.model.RegisteredDirectives
 import org.jetbrains.kotlin.test.directives.model.SimpleDirectivesContainer
 import org.jetbrains.kotlin.test.model.TestModule
-import org.jetbrains.kotlin.test.services.TestModuleStructure
 import org.jetbrains.kotlin.test.services.TestServices
 import org.jetbrains.kotlin.test.services.assertions
 import org.jetbrains.kotlin.utils.addIfNotNull
@@ -53,14 +51,8 @@ abstract class AbstractSymbolTest : AbstractAnalysisApiBasedTest() {
 
     abstract fun KtAnalysisSession.collectSymbols(ktFile: KtFile, testServices: TestServices): SymbolsData
 
-    override fun doTestByModuleStructure(moduleStructure: TestModuleStructure, testServices: TestServices) {
+    override fun doTestByMainFile(mainFile: KtFile, mainModule: TestModule, testServices: TestServices) {
-        val lastModule = moduleStructure.modules.last()
+        val directives = mainModule.directives
-        val firstKtFileFile = testServices.ktModuleProvider.getModuleFiles(lastModule).firstNotNullOf { it as? KtFile }
-        doTestByFileStructure(firstKtFileFile, lastModule, testServices)
-    }
-
-    open fun doTestByFileStructure(ktFile: KtFile, module: TestModule, testServices: TestServices) {
-        val directives = module.directives
         val directiveToIgnoreSymbolRestore = directives.doNotCheckSymbolRestoreDirective()
         val directiveToIgnoreNonPsiSymbolRestore = directives.doNotCheckNonPsiSymbolRestoreDirective()
 
@@ -97,10 +89,10 @@ abstract class AbstractSymbolTest : AbstractAnalysisApiBasedTest() {
         }
 
         val pointersWithRendered = executeOnPooledThreadInReadAction {
-            analyseForTest(ktFile) {
+            analyseForTest(mainFile) {
-                val (symbols, symbolForPrettyRendering) = collectSymbols(ktFile, testServices)
+                val (symbols, symbolForPrettyRendering) = collectSymbols(mainFile, testServices)
                 for (symbol in symbols) {
-                    checkContainingFileSymbol(ktFile.getFileSymbol(), symbol, testServices)
+                    checkContainingFileSymbol(mainFile.getFileSymbol(), symbol, testServices)
                 }
 
                 val pointerWithRenderedSymbol = symbols
@@ -143,12 +135,12 @@ abstract class AbstractSymbolTest : AbstractAnalysisApiBasedTest() {
 
         compareResults(pointersWithRendered, testServices)
 
-        configurator.doGlobalModuleStateModification(ktFile.project)
+        configurator.doGlobalModuleStateModification(mainFile.project)
 
         restoreSymbolsInOtherReadActionAndCompareResults(
             directiveToIgnore = directiveToIgnoreSymbolRestore,
             isRegularPointers = true,
-            ktFile = ktFile,
+            ktFile = mainFile,
             pointersWithRendered = pointersWithRendered.pointers,
             testServices = testServices,
             directives = directives,
@@ -158,7 +150,7 @@ abstract class AbstractSymbolTest : AbstractAnalysisApiBasedTest() {
             restoreSymbolsInOtherReadActionAndCompareResults(
                 directiveToIgnore = directiveToIgnoreNonPsiSymbolRestore,
                 isRegularPointers = false,
-                ktFile = ktFile,
+                ktFile = mainFile,
                 pointersWithRendered = pointersWithRendered.pointers,
                 testServices = testServices,
                 directives = directives,
@@ -334,6 +326,8 @@ object SymbolTestDirectives : SimpleDirectivesContainer() {
     )
 
     val PRETTY_RENDERER_OPTION by enumDirective(description = "Explicit rendering mode") { PrettyRendererOption.valueOf(it) }
+
+    val TARGET_FILE_NAME by stringDirective(description = "The name of the main file")
 }
 
 enum class PrettyRendererOption(val transformation: (KtDeclarationRenderer) -> KtDeclarationRenderer) {

analysis/analysis-api-standalone/tests/org/jetbrains/kotlin/analysis/api/standalone/fir/test/cases/components/psiDeclarationProvider/AbstractPsiDeclarationProviderMultiModuleBinaryTest.kt

@@ -1,26 +1,21 @@
 /*
- * Copyright 2010-2023 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Copyright 2010-2024 JetBrains s.r.o. and Kotlin Programming Language contributors.
  * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
  */
 
 package org.jetbrains.kotlin.analysis.api.standalone.fir.test.cases.components.psiDeclarationProvider
 
 import org.jetbrains.kotlin.analysis.test.framework.base.AbstractAnalysisApiBasedTest
-import org.jetbrains.kotlin.analysis.test.framework.project.structure.ktModuleProvider
 import org.jetbrains.kotlin.analysis.test.framework.services.expressionMarkerProvider
 import org.jetbrains.kotlin.psi.KtFile
-import org.jetbrains.kotlin.test.services.TestModuleStructure
+import org.jetbrains.kotlin.test.model.TestModule
 import org.jetbrains.kotlin.test.services.TestServices
 import org.jetbrains.kotlin.test.services.assertions
 
-public abstract class AbstractPsiDeclarationProviderMultiModuleBinaryTest : AbstractAnalysisApiBasedTest() {
+abstract class AbstractPsiDeclarationProviderMultiModuleBinaryTest : AbstractAnalysisApiBasedTest() {
-    override fun doTestByModuleStructure(moduleStructure: TestModuleStructure, testServices: TestServices) {
+    override fun doTestByMainFile(mainFile: KtFile, mainModule: TestModule, testServices: TestServices) {
-        val allKtFiles = moduleStructure.modules.flatMap {
+        val caretPosition = testServices.expressionMarkerProvider.getCaretPosition(mainFile)
-            testServices.ktModuleProvider.getModuleFiles(it).filterIsInstance<KtFile>()
+        val ktReferences = findReferencesAtCaret(mainFile, caretPosition)
-        }
-        val mainKtFile = allKtFiles.firstOrNull { it.name == "main.kt" } ?: allKtFiles.first()
-        val caretPosition = testServices.expressionMarkerProvider.getCaretPosition(mainKtFile)
-        val ktReferences = findReferencesAtCaret(mainKtFile, caretPosition)
         if (ktReferences.isEmpty()) {
             testServices.assertions.fail { "No references at caret found" }
         }

analysis/analysis-api/testData/components/scopeProvider/declaredMemberScope/delegateInterfaceLibrary.kt

@@ -1,4 +1,4 @@
-// MODULE: main
+// MAIN_FILE_NAME: I
 // MODULE_KIND: LibraryBinary
 // FILE: A.kt
 interface A {
@@ -13,4 +13,3 @@ interface A {
 class I(private val p: A) : A by p
 
 // class: I
-

analysis/analysis-api/testData/components/scopeProvider/delegatedMemberScope/simpleLibrary.kt

@@ -1,5 +1,5 @@
 // IGNORE_FE10
-// MODULE: main
+// MAIN_FILE_NAME: I
 // MODULE_KIND: LibraryBinary
 // FILE: A.kt
 interface A {