}

    override val allSourceFiles: List<PsiFileSystemItem> by lazy {
        buildList {
            val files = allKtModules.mapNotNull { (it as? KtSourceModuleImpl)?.sourceRoots }.flatten()
            addAll(files)
            addAll(findJvmRootsForJavaFiles(files.filterIsInstance<PsiJavaFile>()))
        }
    }

    var psiDeclaration: PsiElement? = null
    var useSitePosition: PsiElement? = null

    testServices.ktTestModuleStructure.mainModules.forEach { ktTestModule ->
        val psiFiles = ktTestModule.files
        for (psiFile in psiFiles) {
            val targetOffset = testServices.expressionMarkerProvider.getCaretPositionOrNull(psiFile)
            if (targetOffset != null) {

                    analyze(inlineFunction)
                }
            }
            analyzedElements.addAll(nextInlineFunctions)
        }
    }

    /**
     * Returns the list of files that contain all reached inline functions.
     */
    fun allFiles(): List<KtFile> = analyzedElements.mapTo(mutableSetOf()) { it.containingKtFile }.toList()

    /**

            }

            override fun visitFile(file: Path, attrs: BasicFileAttributes): FileVisitResult {
                if (!Files.isRegularFile(file) || !Files.isReadable(file))
                    return FileVisitResult.CONTINUE
                if (file.hasSuitableExtensionToAnalyse()) {
                    result.add(file)
                }
                return FileVisitResult.CONTINUE
            }

class KotlinStandalonePackageProvider(
    project: Project,
    internal val scope: GlobalSearchScope,
    files: Collection<KtFile>
) : KotlinPackageProviderBase(project, scope) {
    private val kotlinPackageToSubPackages: Map<FqName, Set<Name>> = run {
        val filesInScope = files.filter { scope.contains(it.virtualFile) }

            return emptyList()
        }

        // The index provides candidates from an original module, not dangling files. If we resolve the supertypes of a candidate in the
        // context of its session, we will resolve to FIR classes from non-dangling, original modules. If `ktClass` is inside a dangling
        // file, the FIR class for `ktClass` will come from the dangling module. So we'd compare the original FIR class for the supertype

     *
     * The source code of all source [KtModule]s in the project should be considered modified when this event is received. This includes
     * source files being moved or removed. Thus, all caches related to source code and source files should be invalidated.
     *
     * Library modules (including library sources) do not need to be considered modified, so any caches related to library modules and their

public interface KaCompiledFile {
    /**
     * Path of the compiled file relative to the root of the output directory.
     */
    public val path: String

    /**
     * Source files that were compiled to produce this file.
     */
    public val sourceFiles: List<File>

    /**
     * Content of the compiled file.
     */
    public val content: ByteArray
}

    override fun getAllowedContainingFiles(mainFile: KtFile, testServices: TestServices): Set<KtFile> {
        // Package scope tests may collect symbols from multiple files, so we need to allow all main test files.
        return testServices.ktTestModuleStructure.allMainKtFiles.toSet()
    }

/wasm/ "Kotlin Wasm"

# Generated files (no review required)
*Generated.java "Kotlin" "Kotlin IDE Analysis Core"

# Singular files
/.gitattributes "Kotlin Build Infrastructure"
/ChangeLog.md "Kotlin Release"
/CODE_OF_CONDUCT.md "Kotlin Build Infrastructure"
/ReadMe.md "Kotlin Build Infrastructure"
/SECURITY.md "Kotlin Build Infrastructure"

# Build files
**.gradle.kts "Kotlin Build Infrastructure"