get() = withValidityAssertion { emptyList() }

    abstract override fun createPointer(): KaSymbolPointer<KaLocalVariableSymbol>
}

public typealias KtLocalVariableSymbol = KaLocalVariableSymbol

// TODO design common ancestor of parameter and receiver KTIJ-23745
public sealed interface KaParameterSymbol : KaAnnotatedSymbol

public typealias KtParameterSymbol = KaParameterSymbol

            get() = firReturnTargets.isNotEmpty() || firLoopJumpTargets.isNotEmpty()

        val hasMultipleJumpKinds: Boolean
            get() = (firReturnExpressions.size.sign + firBreakExpressions.size.sign + firContinueExpressions.size.sign) > 1

        val variableReassignments = mutableListOf<VariableReassignment>()

        val firReturnExpressions = mutableListOf<FirReturnExpression>()

/**
 * A special dynamic type, which is used to support interoperability with dynamically typed libraries, platforms or languages.
 *
 * Although this can be viewed as a flexible type (kotlin.Nothing..kotlin.Any?), a platform may assign special meaning to the
 * values of dynamic type, and handle differently from the regular flexible type.
 */
public abstract class KaDynamicType : KaType

/native/objcexport-header-generator/impl/analysis-api/ "Kotlin in Fleet"

/plugins/allopen/ "Kotlin Compiler Core"
/plugins/android-extensions/ "Kotlin Compiler Core"
/plugins/assign-plugin/ "Kotlin Compiler Core"
/plugins/atomicfu/ "Kotlin Libraries"
/plugins/compose/ Compose
/plugins/fir-plugin-prototype/ "Kotlin Compiler Core"
/plugins/imports-dumper/ "Kotlin Compiler Core"

        }

        override fun afterGlobalInvalidation() {
            // Session invalidation events currently don't report whether library modules were included in the global invalidation. This is
            // by design to avoid iterating through the whole analysis session cache and to simplify the global session invalidation event.

 *
 * Most modification events may be published before or after a modification, so subscribers should not assume that the modification has or
 * hasn't happened yet. The reason for this design decision is that some of the underlying events (such as PSI tree changes) may be
 * published before or after a change, or even both. Modification events published before the modification should however be published close

- [`KT-59441`](https://youtrack.jetbrains.com/issue/KT-59441) Design reading and writing future versions of Kotlin metadata

#### Performance Improvements

- [`KT-64361`](https://youtrack.jetbrains.com/issue/KT-64361) Optimization opportunity in Int.sign
- [`KT-65590`](https://youtrack.jetbrains.com/issue/KT-65590) Make CharSequence.isBlank idiomatic and improve its performance

    /**
     * A compound access that read, compute, and write the computed value back. Note that calls to `<op>Assign` is not represented by this.
     */
    public class CompoundAssign(
        operationPartiallyAppliedSymbol: KaPartiallyAppliedFunctionSymbol<KaFunctionSymbol>,
        kind: Kind,
        operand: KtExpression,

 *   // }
 *   // accessType: IncDec {
 *   //   kind: INC
 *   //   precedence: POSTFIX
 *   //   operationSymbol: Int.inc()
 *   // }
 * }
 * ```
 * Note that if the variable has a `<op>Assign` member, then it's represented as a simple `KaFunctionCall`. For example,
 * ```
 * fun test(m: MutableList<String>) {

     * mean one can assign `null` to a variable of this type because it may be unknown if this type can accept `null`. For example, a public value
     * of type `T:Any?` can potentially be null. But one can not assign `null` to such a variable because the instantiated type may not be
     * nullable.
     */