}

    private fun collectStubsFromBinaryRoot(
        binaryRoot: VirtualFile,
        binaryClassCache: ClsKotlinBinaryClassCache,
    ): Map<VirtualFile, KotlinFileStubImpl> =
        buildMap {
            VfsUtilCore.visitChildrenRecursively(binaryRoot, object : VirtualFileVisitor<Void>() {
                override fun visitFile(file: VirtualFile): Boolean {
                    if (!file.isDirectory) {

        // In all cases, the size of arguments and parameters is the same,
        // so this check exists just to be sure
        if (typeArguments.size != typeParameters.size) return emptyMap()

        return buildMap(typeArguments.size) {
            for ((index, projection) in typeArguments.withIndex()) {
                if (projection !is ConeKotlinType) return emptyMap()
                put(typeParameters[index], projection.asKtType())

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

// license that can be found in the LICENSE file.

package main

func init() {
	addTestCases(buildtagTests, buildtag)
}

var buildtagTests = []testCase{
	{
		Name:    "buildtag.oldGo",
		Version: "go1.10",
		In: `//go:build yes
// +build yes

package main
`,
	},
	{
		Name:    "buildtag.new",
		Version: "go1.99",
		In: `//go:build yes
// +build yes

package main
`,
		Out: `//go:build yes

        given:
        applyPlugin(buildA, true, withVersion)
        addLifecycleTasks(buildA)

        includePluginBuild pluginBuild

        when:
        execute(buildA, "taskFromPluginBuild")

        then:
        executed ":pluginBuild:jar", ":taskFromPluginBuild"

        when:
        execute(buildA, "assemble")

        then:

            }
        """
        includedBuilds = [empty]
        createDirs("buildA", "buildA/subproject1")
        buildA.settingsFile << """
            include('subproject1')
            $includeRootStatement
        """

        when:
        checkDependencies()

        then:
        def expectSubstitution = rootIsIncluded.contains("yes")
        checkGraph {

@TargetGradleVersion('>=5.6')
class CompositeProjectSubstitutionCrossVersionSpec extends ToolingApiSpecification {

    TestFile buildA
    TestFile buildB
    TestFile buildC

    def setup() {

        buildA = singleProjectBuildInRootFolder("buildA") {
            buildFile << """
                apply plugin: 'java-library'
                dependencies {

@TargetGradleVersion(">=3.1")
class PersistentCompositeDependencySubstitutionCrossVersionSpec extends ToolingApiSpecification implements WithOldConfigurationsSupport {
    TestFile buildA
    TestFile buildB
    TestFile buildC

    def setup() {

        buildA = singleProjectBuildInRootFolder("buildA") {
            buildFile << """
                apply plugin: 'java'
                dependencies {

            println "configuring \$project.path"
            classes.doLast { t ->
                println "classes of \$t.path"
            }
        """

        when:
        execute(buildA, ":assemble")

        then:
        outputContains("> Configure project :${buildName}")
        result.groupedOutput.task(":${buildName}:classes").output.contains("classes of :classes")

        where: