internal val facadeFileMap: MutableMap<FqName, MutableSet<KtFile>> = mutableMapOf()
    internal val multiFileClassPartMap: MutableMap<FqName, MutableSet<KtFile>> = mutableMapOf()
    internal val scriptMap: MutableMap<FqName, MutableSet<KtScript>> = mutableMapOf()
    internal val classMap: MutableMap<FqName, MutableSet<KtClassOrObject>> = mutableMapOf()
    internal val typeAliasMap: MutableMap<FqName, MutableSet<KtTypeAlias>> = mutableMapOf()

    var visited: Boolean = false
    val dependencies: MutableSet<ClassDetails> = linkedSetOf()
    val outputClassFilename
        get() = "$outputClassName.class"
}


class PackagePatterns(givenPrefixes: Set<String>) {

    private
    val prefixes: MutableSet<String> = hashSetOf()

    private
    val names: MutableSet<String> = hashSetOf()

    init {

import okio.Path
import okio.Sink

class FaultyFileSystem constructor(delegate: FileSystem?) : ForwardingFileSystem(delegate!!) {
  private val writeFaults: MutableSet<Path> = LinkedHashSet()
  private val deleteFaults: MutableSet<Path> = LinkedHashSet()
  private val renameFaults: MutableSet<Path> = LinkedHashSet()

  fun setFaultyWrite(
    file: Path,
    faulty: Boolean,
  ) {
    if (faulty) {
      writeFaults.add(file)

}

private inline fun buildDependentsMap(
    modules: List<KtModule>,
    getDependencies: (KtModule) -> Sequence<KtModule>,
): Map<KtModule, MutableSet<KtModule>> = buildMap<KtModule, MutableSet<KtModule>> {
    for (module in modules) {
        for (dependency in getDependencies(module)) {

    override fun addDependency(dependency: ModuleDependency) =
        delegate.addDependency(dependency)

    override fun getName(): String =
        delegate.name

    override fun getExcludeRules(): MutableSet<ExcludeRule> =
        delegate.excludeRules

    override fun addArtifact(artifact: DependencyArtifact): ModuleDependency =
        delegate.addArtifact(artifact)

    )


private
typealias ClassLoaderId = String


private
class ClassLoaderNode(
    val id: ClassLoaderId,
    val label: String,
    val classPath: MutableSet<URL> = LinkedHashSet(),
    val parents: MutableSet<ClassLoaderId> = LinkedHashSet()
)


private
fun classLoaderHierarchyJsonFor(
    classLoaders: List<ClassLoaderNode>,
    scopes: List<ClassLoaderScope>,

import java.io.File


abstract class IncubatingApiReportWorkAction : WorkAction<IncubatingApiReportParameter> {

    override fun execute() {
        try {
            val versionToIncubating = mutableMapOf<Version, MutableSet<IncubatingDescription>>()
            parameters.srcDirs.forEach { srcDir ->
                if (srcDir.exists()) {
                    val collector = CompositeVersionsToIncubatingCollector(
                        listOf(

            "Unexpected file tree '$fileTree' of type '${fileTree.javaClass}' found while serializing a file collection."
        )
}


private
class CollectingVisitor : AbstractVisitor() {
    val elements: MutableSet<Any> = mutableSetOf()

    override fun startVisit(source: FileCollectionInternal.Source, fileCollection: FileCollectionInternal): Boolean =
        when (fileCollection) {
            is SubtractingFileCollection -> {

class InlineFunctionAnalyzer(
    private val analysisContext: Fe10AnalysisContext,
    private val analyzeOnlyReifiedInlineFunctions: Boolean,
) {
    private val analyzedElements: MutableSet<KtElement> = mutableSetOf()
    private val inlineFunctionsWithBody: MutableSet<KtDeclarationWithBody> = mutableSetOf()

    /**
     * Collects all inline function calls in an [element] (usually a file) and follows each transitively.
     */

    private val platformCategories: Set<String> = setOf("platform", "enforced-platform")

    private val visitedDependencies: MutableSet<ModuleComponentIdentifier> = mutableSetOf()
    private val visitedProjects: MutableSet<ModuleVersionIdentifier> = mutableSetOf()

    private val logger = Logging.getLogger(OrtModelBuilder::class.java)
    private val errors: MutableList<String> = mutableListOf()