import org.gradle.internal.declarativedsl.dom.DeclarativeDocument


fun <D, C : NodeData<D>> C.collectToNodeMap(document: DeclarativeDocument): Map<DeclarativeDocument.DocumentNode, D> =
    buildMap {
        fun visit(node: DeclarativeDocument.DocumentNode) {
            put(node, data(node))
            when (node) {
                is DeclarativeDocument.DocumentNode.ElementNode -> node.content.forEach(::visit)

    override fun doTestByMainFile(mainFile: KtFile, mainModule: KtTestModule, testServices: TestServices) {
        val shortenings = executeOnPooledThreadInReadAction {
            analyseForTest(mainFile) {
                buildMap {
                    this += "default settings" to collectPossibleReferenceShortenings(mainFile, mainFile.textRange)

                    this += ShortenStrategy.entries.associateWith { option ->

        val element = testServices.expressionMarkerProvider.getSelectedElementOfType<KtElement>(mainFile)

        val shortenings = executeOnPooledThreadInReadAction {
            analyseForTest(element) {
                buildMap {
                    this += "default settings" to collectPossibleReferenceShorteningsInElement(element)

                    this += ShortenStrategy.entries.associate { option ->

    override fun buildSubstitutor(builder: KaSubstitutorBuilder): KaSubstitutor {
        if (builder.mappings.isEmpty()) return KaSubstitutor.Empty(token)

        val firSubstitution = buildMap {
            builder.mappings.forEach { (ktTypeParameterSymbol, ktType) ->
                check(ktTypeParameterSymbol is KaFirTypeParameterSymbol)
                check(ktType is KaFirType)

    }

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

        hasLambda: Boolean,
        configureLambdaHandler: ConfigureLambdaHandler
    ): Binding? {
        var captor: ConfigureLambdaHandler.ValueCaptor? = null
        val map = buildMap(arguments.size + 1) {
            val namedArguments = arguments.mapKeys { (param, _) -> param.name }
            var used = 0

            if (kFunction.instanceParameter != null && kFunction.extensionReceiverParameter != null)

}

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

            dsu[get(left)] = right
        }

        assignmentByNode.forEach { (key, value) ->
            union(key, value.node)
        }

        return buildMap {
            assignmentByNode.forEach { (lhs, _) ->
                put(lhs.propertyReferenceResolution, run {
                    when (val result = get(lhs)) {
                        is ResolutionNode.PrimitiveValue -> {

	"strings"
)

func init() {
	register(buildtagFix)
}

const buildtagGoVersionCutoff = "go1.18"

var buildtagFix = fix{
	name: "buildtag",
	date: "2021-08-25",
	f:    buildtag,
	desc: `Remove +build comments from modules using Go 1.18 or later`,
}

func buildtag(f *ast.File) bool {
	if version.Compare(*goVersion, buildtagGoVersionCutoff) < 0 {
		return false
	}

// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

//go:build go1.16
// +build go1.16

// Package buildtag defines an Analyzer that checks build tags.
package buildtag

import (
	"go/ast"
	"go/build/constraint"
	"go/parser"
	"go/token"
	"strings"
	"unicode"

	"golang.org/x/tools/go/analysis"