import org.jetbrains.kotlin.psi.KtAnnotated
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`:

# Test go build -pgo=auto flag with multiple main packages.

go install -a -n -pgo=auto ./a ./b ./nopgo

# a/default.pgo and b/default.pgo are both preprocessed
stderr 'preprofile.*-i.*a(/|\\\\)default\.pgo'
stderr 'preprofile.*-i.*b(/|\\\\)default\.pgo'

# a and b built once each with PGO.
# Ideally we would check that the passed profile is the expected profile (here
# and for dependencies). Unfortunately there is no nice way to map the expected

    /**
     * Whether [firSymbol] is computed lazily. Equality will fall back to PSI-equality if one of the symbols is lazy and both classes have
     * an associated [PsiClass].
     */
    open val hasLazyFirSymbol: Boolean get() = false

    override fun equals(other: Any?): Boolean {
        if (this === other) return true

    /**
     * [onModification] is invoked in a write action before or after a context change for code fragments depending on the [module].
     *
     * All code fragments depending on [module], both directly or transitively, should be considered modified when this event is received.
     *
     * @see KotlinModificationTopics
     */
    public fun onModification(module: KtModule)

import com.intellij.openapi.project.Project
import com.intellij.util.messages.MessageBus

/**
 * Provides the [project]'s [MessageBus] as the Analysis API message bus. This is the default implementation for both the standalone and the
 * IDE Analysis API.
 *
 * [KotlinMessageBusProvider] exists so that this default may change in the future without breaking the API. Hence, it should not be assumed

/**
 * Some constant value (which may be used as initializer of `const val`) used as annotation argument. It may be String literal, number literal or some simple expression.
 * E.g: `@A(1 +2, "a" + "b")` -- both arguments here are [KaConstantAnnotationValue]
 * @see [KaConstantValue]
 */
public class KaConstantAnnotationValue @KaAnalysisApiInternals constructor(
    constantValue: KaConstantValue,
    token: KaLifetimeToken

//   2. Rewrite (CMPconst [0] (Select0 (OpCC ...))) into (Select1 (OpCC...))
// Note: to minimize potentially expensive regeneration of CC opcodes during the flagalloc pass, only rewrite if
//       both ops are in the same block.
(CMPconst [0] z:((ADD|AND|ANDN|OR|SUB|NOR|XOR) x y)) && v.Block == z.Block => (CMPconst [0] convertPPC64OpToOpCC(z))

# This module has the same module dependency graph in Go 1.16 as in Go 1.17,
# but in 1.16 requires (checksums for) additional (irrelevant) go.mod files.
#
# The module graph under both versions looks like:
#
# m ---- example.com/version v1.1.0
# |
# + ---- example.net/lazy v0.1.0 ---- example.com/version v1.0.1
#
# Go 1.17 avoids loading the go.mod file for example.com/version v1.0.1

    public val hasEscapingJumps: Boolean,

    /**
     * `true` if there are jumps of different kinds (e.g., there is both a `break` and a `return`).
     */
    public val hasMultipleJumpKinds: Boolean,

    /**
     * `true` if two or more jumps have different next-executed instructions.
     * Such as, there are both inner and outer loop `break`, or a `break` and `continue` for the same loop.
     */

     * in platform modules is expected. Note, that in the following example:
     * ```
     * expect class A {
     *     class Nested
     * }
     * ```
     * `isExpect` returns `true` for both `A` and `A.Nested`.
     */
    public val isExpect: Boolean
}