// directory containing them.
			// If the directory is outside the main modules, this will resolve to ".",
			// which is not a prefix of any valid module.
			importerPath, _ = modload.MainModules.DirImportPath(ctx, importer.Dir)
		}
		parentOfInternal := p.ImportPath[:i]
		if str.HasPathPrefix(importerPath, parentOfInternal) {
			return nil
		}
	}

 * APIs and conducts CodeGen.
 */
abstract class AbstractFirPluginPrototypeCompilerFacilityTestWithAnalysis : AbstractFirPluginPrototypeMultiModuleCompilerFacilityTest() {
    override fun doTestByMainFile(mainFile: KtFile, mainModule: KtTestModule, testServices: TestServices) {
        // First, run AA for type resolution.
        testServices.ktTestModuleStructure.allMainKtFiles.forEach { file ->
            file.accept(object : KtTreeVisitorVoid() {

    protected open fun KaSession.getSymbolsFromScope(scope: KaScope): Sequence<KaDeclarationSymbol> = scope.getAllSymbols()

    override fun doTestByMainFile(mainFile: KtFile, mainModule: KtTestModule, testServices: TestServices) {
        super.doTestByMainFile(mainFile, mainModule, testServices)

        analyseForTest(mainFile) {
            val scope = getScope(mainFile, testServices)

        super.configureTest(builder)
        with(builder) {
            useDirectives(Directives)
        }
    }

    override fun doTestByMainFile(mainFile: KtFile, mainModule: KtTestModule, testServices: TestServices) {
        val typeString = mainModule.testModule.directives.singleValue(Directives.CLASS_TYPE)
        val actual = analyseForTest(mainFile) {
            val ktType = TypeParser.parseTypeFromString(typeString, mainFile, mainFile)

import java.io.File

abstract class AbstractHasCommonSubtypeTest : AbstractAnalysisApiBasedTest() {
    override fun doTestByMainModuleAndOptionalMainFile(mainFile: KtFile?, mainModule: KtTestModule, testServices: TestServices) {
        val ktFile = mainFile ?: mainModule.ktFiles.first()
        val errors = mutableListOf<String>()
        val originalText = ktFile.text
        val actualTextBuilder = StringBuilder()
        analyseForTest(ktFile) {

abstract class AbstractFileImportingScopeContextTest : AbstractAnalysisApiBasedTest() {
    override fun doTestByMainFile(mainFile: KtFile, mainModule: KtTestModule, testServices: TestServices) {
        val renderDefaultImportingScope = Directives.RENDER_DEFAULT_IMPORTING_SCOPE in mainModule.testModule.directives

        analyseForTest(mainFile) {
            val ktScopeContext = mainFile.getImportingScopeContext()

    private final ProcessArgumentsSpec argumentsSpec = new ProcessArgumentsSpec(this);

    private final Property<String> mainClass;
    private final Property<String> mainModule;
    private final ModularitySpec modularity;
    private final ListProperty<String> jvmArguments;

    private final FileCollectionFactory fileCollectionFactory;
    private ConfigurableFileCollection classpath;

import org.jetbrains.kotlin.test.services.TestServices

abstract class AbstractDanglingFileCollectDiagnosticsTest : AbstractCollectDiagnosticsTest() {
    override fun doTestByMainFile(mainFile: KtFile, mainModule: KtTestModule, testServices: TestServices) {
        val ktPsiFactory = KtPsiFactory.contextual(mainFile, markGenerated = true, eventSystemEnabled = false)
        val fakeKtFile = ktPsiFactory.createFile("fake.kt", mainFile.text)

                </tr>
            </thead>
            <tr>
                <td>applicationName</td>
                <td><literal>project.name</literal></td>
            </tr>
            <tr>
                <td>mainModule</td>
                <td><literal>null</literal></td>
            </tr>
            <tr>
                <td>mainClass</td>
                <td><literal>null</literal></td>
            </tr>
            <tr>

plugins {
    id("myproject.java-conventions")
    application
}

dependencies {
    implementation(project(":utilities"))
}

application {
    mainModule = "org.gradle.sample.app"
    mainClass = "org.gradle.sample.app.Main"