}

    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()

    /**

            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

/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"

            }

            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) }

 *
 * All member implementations should consider caching the results for subsequent invocations.
 */
public abstract class KaResolveExtensionProvider {
    /**
     * Provides a list of [KaResolveExtension]s for a given [KtModule].
     *

            DirectiveApplicability.File,
        )
        val RESOLVE_EXTENSION_CLASSIFIER by stringDirective(
            "Name(s) of top-level classifier(s) in this resolve extension file",
            DirectiveApplicability.File,
        )
        val RESOLVE_EXTENSION_CALLABLE by stringDirective(
            "Names of top-level callables in this resolve extension file",
            DirectiveApplicability.File,
        )
    }

    override fun doTest(testServices: TestServices) {
        val files = testServices.ktTestModuleStructure.allMainKtFiles
        val debugRenderer = DebugSymbolRenderer()

        val debugPrinter = PrettyPrinter()
        val prettyPrinter = PrettyPrinter(indentSize = 4)

        for (file in files) {
            val fileDirective = "// FILE: ${file.name}\n"
            debugPrinter.appendLine(fileDirective)