): Map<String, FqName> = buildMap {
        trees.forEach { import ->
            val fqn = DefaultFqName(
                import.name.nameParts.dropLast(1).joinToString("."), import.name.nameParts.last()
            )

            compute(fqn.simpleName) { _, existing ->
                if (existing != null && existing != fqn) {

        println("===")
        schema.reflectAndPrint(newCode)
    }
}


private
fun String.replaceRange(range: IntRange, replacement: String): String {
    return take(range.start) + replacement + drop(range.last + 1)
}


val pluginDefinition = schema.dataClassesByFqName
    .getValue(DefaultFqName.parse("org.gradle.internal.declarativedsl.demo.demoPlugins.PluginDefinition"))

    ): FunctionSemantics {
        val lastParam = function.parameters[function.parameters.lastIndex]
        val configuredType = configureLambdas.getTypeConfiguredByLambda(function.parameters.last().type)
        val blockRequirement = when {
            configuredType == null -> FunctionSemanticsInternal.DefaultConfigureBlockRequirement.DefaultNotAllowed

    }

    fun nextCallId(): OperationId = OperationId(nextInstant.incrementAndGet(), generationId)

    fun leaveScope(scope: AnalysisScope) {
        check(mutableScopes.last() === scope)
        mutableScopes.removeLast()
    }

- The first line that begins with an `@` character ends the description; you cannot continue the description following block tags.
- Block tags must be added in order.
- The last line contains the end-comment delimiter ( `*/`).

So lines won't wrap, limit any doc-comment lines to 120 characters.

### 1.1.2 HTML

import kotlin.reflect.KClass
import kotlin.reflect.full.memberFunctions


/**
 * Provides type discovery via functions that return an object or configure an object accepting a lambda as the last parameter
 * (via [org.gradle.api.Action] or a Kotlin function type, see [gradleConfigureLambdas]).
 *

        extraParameters = "--checks none --rerun --cross-version-only"
    ),
    historical(
        displayName = "Historical Performance Test",
        timeout = 600,
        defaultBaselines = "last",
        channel = "historical",
        extraParameters = "--checks none --cross-version-only"
    ),
    adHoc(
        displayName = "AdHoc Performance Test",
        timeout = 30,
        channel = "adhoc",

                    underlayNodesByMergeKey[overlayMergeKey]?.also { underlayItems ->
                        val underlayProperty = underlayItems.last() as? PropertyNode ?: error("cannot merge a property $overlayItem with non-properties $underlayItems")
                        overlayPropertyOrigin[overlayItem] = OverlayNodeOrigin.ShadowedProperty(underlayProperty, overlayItem)

    companion object {
        fun parse(fqNameString: String): FqName {
            val parts = fqNameString.split(".")
            return DefaultFqName(parts.dropLast(1).joinToString("."), parts.last())
        }
    }

    override
    val qualifiedName by lazy { "$packageName.$simpleName" }

    override fun toString(): String = qualifiedName
}


val DataTopLevelFunction.fqName: FqName

        )
        assertThat(events.size, equalTo(4))
        assertNoEditorReport()
    }

    fun <T : ResolverEvent> assertLastEventIsInstanceOf(eventType: KClass<T>) {
        assertThat(
            events.last().event,
            instanceOf(eventType.java)
        )
    }

    fun assertNoEditorReport() {
        assertTrue(reports.isEmpty())
    }

    fun assertSingleEditorReport() {