[!cgo] skip
[cross] skip

# Assume we're on a system that can enable cgo normally.
env CGO_ENABLED=
go env CGO_ENABLED
stdout 1

# Clearing CC and removing everything but Go from the PATH should usually
# disable cgo: no C compiler anymore (unless the baked-in defaultCC is an
# absolute path and exists.
env CC=
env PATH=$GOROOT/bin
go env CGO_ENABLED
[!abscc] stdout 0
[abscc] stdout 1

    features {
        publishBuildStatusToGithub(model)
    }

    tcParallelTests(splitNumber)

    requirements {
        // Smoke tests is usually heavy and the build time is twice on EC2 agents
        requiresNotEc2Agent()
    }

    applyTestDefaults(
        model,
        this,
        ":smoke-test:$task",
        timeout = 120,

import org.jetbrains.kotlin.psi.KtElement

public abstract class KaResolveExtensionNavigationTargetsProvider {
    /**
     * Provides a [PsiElement] which will be opened on a navigation request for [element].
     *
     * Usually returns a single result. Might return an empty collection if there is no navigation target.
     * Also, might multiple targets in a case of ambiguity or multiple targets for a [symbol]
     *

import org.jetbrains.kotlin.analysis.api.lifetime.KaLifetimeOwner
import org.jetbrains.kotlin.name.ClassId

/**
 * A list of annotations applied for some entity.
 *
 * Annotation owners are usually implement [KaAnnotated]
 */
public interface KaAnnotationList : List<KaAnnotation>, KaLifetimeOwner {
    @Deprecated("Use the annotation list as a 'List'.")
    public val annotations: List<KaAnnotation>
        get() = this

    private val inlineFunctionsWithBody: MutableSet<KtDeclarationWithBody> = mutableSetOf()

    /**
     * Collects all inline function calls in an [element] (usually a file) and follows each transitively.
     */
    fun analyze(element: KtElement) {
        val project = element.project
        val nextInlineFunctions = HashSet<KtDeclarationWithBody>()

#
# Before Go 1.16, we extracted each module zip to a temporary directory with
# a random name, then renamed that into place with os.Rename. On Windows,
# this failed with ERROR_ACCESS_DENIED when another process (usually an
# anti-virus scanner) opened files in the temporary directory. This test
# simulates that behavior, verifying golang.org/issue/36568.
#
# Since 1.16, we extract to the final directory, but we create a .partial file

    name = "Smoke Ide Tests"
    description = "Tests against IDE sync process"

    features {
        publishBuildStatusToGithub(model)
    }

    requirements {
        // These tests are usually heavy and the build time is twice on EC2 agents
        requiresNotEc2Agent()
    }

    applyTestDefaults(
        model = model,
        buildType = this,
        gradleTasks = ":smoke-ide-test:smokeIdeTest",

import org.jetbrains.kotlin.analysis.api.lifetime.withValidityAssertion

/**
 * Type substitutor. Performs substitution of a type parameters inside a type to some fixed type.
 * Usually can be represented as a map from type parameter to it corresponding substitution.
 *
 * Example of a substitution:
 * ```
 * substitutor = { T -> Int, S -> Long }
 * substitute(Map<T, S>, substitutor) = Map<Int, Long>

 * provider.
 *
 * Composable providers share certain traits: There is a notion of a sequentially composed [KotlinCompositeProvider] of that kind, and there
 * is usually a merge function which allows to create a single provider from a list of providers. Mergers of composable providers may
 * produce a merged provider which is more efficient than the naive sequential composite provider.
 *

    private val transitiveDependentsByKtModule = createConcurrentSoftMap<KtModule, Set<KtModule>>()

    private val refinementDependentsByKtModule: Map<KtModule, Set<KtModule>> by lazy {
        // Refinement dependents will usually only be requested for expect classes, so it's better to compute them lazily as they're not
        // needed for all projects.
        buildDependentsMap(modules) { it.transitiveDependsOnDependencies.asSequence() }
    }