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

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() }
    }

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

    /**
     * A list of [KaVariableSymbol]s which were created from this destructuring declaration.
     *
     * The entries are usually [KaLocalVariableSymbol]s. However, for top-level destructuring declarations in scripts, the entries are
     * [KaPropertySymbol]s instead.
     *
     * E.g., for the following code:
     * ```

- [`KT-56624`](https://youtrack.jetbrains.com/issue/KT-56624) "Unresolved reference" with import alias and enum constructor call
- [`KT-54726`](https://youtrack.jetbrains.com/issue/KT-54726) K1: StackOverflowError on mutually recursive typealiases
- [`KT-35134`](https://youtrack.jetbrains.com/issue/KT-35134) False negative INCOMPATIBLE_TYPES, EQUALITY_NOT_APPLICABLE when comparing smartcast value to Boolean

        val result = mutableMapOf<KaTypeParameterSymbol, KaType>()

        for ((index, typeParameter) in typeParameters.withIndex()) {
            // After resolution all type arguments should be usual types (not FirPlaceholderProjection)
            val typeArgument = typeArguments[index]
            if (typeArgument !is FirTypeProjectionWithVariance || typeArgument.variance != Variance.INVARIANT) return emptyMap()