code is a great way to give something back to the open source community. Before
you dig right into the code, there are a few guidelines that we need
contributors to follow so that we can have a chance of keeping on top of
things.

Some of the ideas are documented in the [Maven Wiki][maven-wiki]
which might be interesting to read and for further discussion.

Getting Started
---------------

    /**
     * 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]
     *
     * Returned [PsiElement] will be used as a navigation target inside the IDE.
     */

    implementation(project(":analysis:analysis-api"))
    implementation(project(":analysis:analysis-api-impl-base"))
    implementation(project(":analysis:analysis-api-fir"))
    implementation(project(":analysis:symbol-light-classes"))
    implementation(project(":analysis:analysis-api-standalone:analysis-api-standalone-base"))
    implementation(project(":analysis:analysis-internal-utils"))
}


sourceSets {
    "main" { projectDefault() }

     * alias application, not simply `MyList`.
     *
     * If this [KaType] is an unexpanded type alias application, [abbreviatedType] is `null`. Not all type alias applications are currently
     * expanded right away and the Analysis API makes no guarantees about the specific circumstances.
     *
     * While [abbreviatedType] is available for all [KaType]s, it can currently only be present in [KaClassType]s. However, abbreviated

import org.jetbrains.kotlin.psi.KtElement

/**
 * A service to match declarations with their annotations and vice versa.
 *
 * N.B. This service can produce both false positives and false negatives from time to time, since it might not be allowed to use
 * full-blown resolve to understand the true FqName of used annotation.
 *
 * The next statement should be `true` for any `annotation`:
 * ```
 * declarationsByAnnotation(annotation).all { declaration ->

        logicalOr.left.accept(),
        logicalOr.right.accept(),
        KaContractBinaryLogicExpression.KaLogicOperation.OR
    )

    override fun visitLogicalAnd(logicalAnd: LogicalAnd, data: Unit): Any = KaContractBinaryLogicExpression(
        logicalAnd.left.accept(),
        logicalAnd.right.accept(),
        KaContractBinaryLogicExpression.KaLogicOperation.AND
    )

@KaAnalysisNonPublicApi
public interface KaKlibSourceFileProviderMixIn : KaSessionMixIn {
    /**
     * If [KtDeclaration] is a deserialized, klib based symbol, then information about the original
     * [SourceFile] might be retained.
     */
    public fun KaDeclarationSymbol.getKlibSourceFileName(): String? =
        withValidityAssertion { analysisSession.klibSourceFileProvider.getKlibSourceFileName(this) }
}

@KaAnalysisNonPublicApi

    testImplementation(projectTests(":compiler:tests-common-new"))
    testImplementation(projectTests(":analysis:analysis-api-impl-barebone"))
    testImplementation(project(":analysis:symbol-light-classes"))
    testImplementation(projectTests(":analysis:decompiled:decompiler-to-file-stubs"))
    testImplementation(project(":analysis:decompiled:decompiler-to-file-stubs"))

    override fun processClassifiersByNameWithSubstitution(name: Name, processor: (FirClassifierSymbol<*>, ConeSubstitutor) -> Unit) {
        // We have to filter out classes from supertypes because the base scope might be a use-site scope that provides inner classes from
        // supertypes.
        delegate.processClassifiersByNameWithSubstitution(name) { classifier, substitutor ->

            is KaContractBinaryLogicExpression -> {
                appendProperty(value::left, ::renderKaContractBooleanExpression)
                appendProperty(value::right, ::renderKaContractBooleanExpression)
                appendSimpleProperty(value::operation, endWithNewLine)
            }
            is KaContractIsInstancePredicateExpression -> {