kotlin {
    target.compilations.named("testFixtures") {
        associateWith(target.compilations["main"])
    }
    target.compilations.named("test") {
        associateWith(target.compilations["main"])
        associateWith(target.compilations["testFixtures"])
    }
    target.compilations.named("integTest") {
        associateWith(target.compilations["main"])
        associateWith(target.compilations["testFixtures"])
    }
}

tasks {

                buildMap {
                    this += "default settings" to collectPossibleReferenceShortenings(mainFile, mainFile.textRange)

                    this += ShortenStrategy.entries.associateWith { option ->
                        val shorteningsForOption = collectPossibleReferenceShortenings(
                            mainFile,
                            mainFile.textRange,

    internal val arrayOf = Name.identifier("arrayOf")
    internal val arrayTypeToArrayOfCall = run {
        StandardClassIds.primitiveArrayTypeByElementType.values + StandardClassIds.unsignedArrayTypeByElementType.values
    }.associateWith { it.correspondingArrayOfCallFqName() }

    private fun ClassId.correspondingArrayOfCallFqName(): Name =
        Name.identifier("${shortClassName.identifier.replaceFirstChar(Char::lowercaseChar)}Of")

    public GrammarMetadata(GrammarFileMetadata grammarFileMetadata, GrammarDelegate grammarDelegate) {
        this.grammarFileMetadata = grammarFileMetadata;
        this.grammarDelegate = grammarDelegate;
        grammarDelegate.associateWith(this);
    }

    public GrammarFileMetadata getGrammarFile() {
        return grammarFileMetadata;
    }

    public String getClassName() {
        return grammarDelegate.getClassName();
    }

            is InterpretationSchemaBuildingResult.InterpretationSequenceAvailable -> AnalysisSequenceResult(
                built.sequence.steps.associateWith {
                    stepRunner.runInterpretationSequenceStep(scriptFileName, scriptSource, it, analysisContext)
                }
            )
        }
    }

    private

                parameters.taskPathToReports = globalExtension.taskPathToReports.map { taskPathToReportsInExtension ->
                    (taskPathToReportsInExtension.keys + taskPathToReports.keys).associateWith {
                        taskPathToReportsInExtension.getOrDefault(it, emptyList()) + taskPathToReports.getOrDefault(it, emptyList())
                    }
                }
            }

        val softwareTypeNames = assignments.keys + additions.keys + nestedObjectAccess.keys

        return softwareTypeNames.associateWith {
            SoftwareTypeConventionResolutionResults(it, assignments[it].orEmpty(), additions[it].orEmpty(), nestedObjectAccess[it].orEmpty())
        }
    }
}


/**

            options.errorprone {
                isEnabled = extension.enabled
                checks.set(errorproneExtension.disabledChecks.map {
                    it.associateWith { CheckSeverity.OFF }
                })
            }
        }
    }
}

tasks.withType<JavaCompile>().configureEach {
    options.errorprone {
        disableWarningsInGeneratedCode = true

     */
    public GrammarDelegate getSuperGrammarDelegate() {
        return superGrammarDelegate;
    }

    private GrammarMetadata associatedGrammarMetadata;

    public void associateWith(GrammarMetadata associatedGrammarMetadata) {
        this.associatedGrammarMetadata = associatedGrammarMetadata;
    }

    public GrammarMetadata getAssociatedGrammarMetadata() {

    override fun buildFor(parameter: KotlinDslScriptsParameter, rootProject: Project): KotlinDslScriptsModel {
        val scriptModels = parameter.scriptFiles.associateWith { scriptFile ->
            buildScriptModel(rootProject, scriptFile, parameter)
        }
        return StandardKotlinDslScriptsModel.from(scriptModels)
    }

    private
    fun buildScriptModel(