object Some {
    fun foo() {

    }
}

fun test() {
    <expr>Some</expr>.foo()

/**
 * A [KaSubstitutor] which substitution logic can be represented as a [Map] from a [KaTypeParameterSymbol] to corresponding [KaType]
 * This is an implementation details and Analysis API clients should not depend on the fact if some [KaSubstitutor] is [KaMapBackedSubstitutor] or not.
 */
@KaAnalysisApiInternals
interface KaMapBackedSubstitutor : KaSubstitutor {
    /**
     * Substitution rules in a form of a `Map<KaTypeParameterSymbol, KaType>`

package some.example

open class Person(
    val name: String
) {
    open fun greet() = "Hello"

package common

import some.example.Person

fun greetEachOther(people: Collection<Person>) {
    for (person in people) {
        person.greet()
    }

 */

package org.jetbrains.kotlin.analysis.api.symbols.markers

import org.jetbrains.kotlin.analysis.api.symbols.KaSymbol

/**
 * A marker interface for symbols which could potentially be members of some class.
 *
 * @see org.jetbrains.kotlin.analysis.api.components.KaTypeProviderMixIn.getDispatchReceiverType
 */
public interface KaPossibleMemberSymbol : KaSymbol

KaDataFlowExitPointSnapshot:
  defaultExpressionInfo = DefaultExpressionInfo:
    expression = Some
    type = Some
  hasEscapingJumps = false
  hasJumps = false
  hasMultipleJumpKinds = false
  hasMultipleJumpTargets = false
  jumpExpressions = []
  returnValueType = null
  valuedReturnExpressions = []

}

public inline fun <R> KaLifetimeOwner.withValidityAssertion(action: () -> R): R {
    assertIsValidAndAccessible()
    return action()
}

/**
 * This is a helper function to properly expose parameters in some [KaLifetimeOwner] implementation.
 *
 * An example:
 * ```kotlin
 * public class KaCall(symbol: KaSymbol) : KaLifetimeTokenOwner {
 *     public val symbol: KaSymbol by validityAsserted(symbol)
 * }
 * ```
 *

import org.jetbrains.kotlin.name.ClassId
import org.jetbrains.kotlin.psi.KtCallElement

/**
 * Application of annotation to some declaration, type, or as argument inside another annotation.
 *
 * Some examples:
 * - For declarations: `@Deprecated("Should not be used") fun foo(){}`
 * - For types: `fun foo(x: List<@A Int>){}`

import com.intellij.psi.PsiElement
import org.jetbrains.kotlin.analysis.api.symbols.KaSymbolOrigin
import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol

/**
 * A [KaFirSymbol] that is backed by some [PsiElement] and builds [firSymbol] lazily (by convention), allowing some properties to be
 * calculated without the need to build a [firSymbol].
 */
internal interface KaFirPsiSymbol<P : PsiElement, out S : FirBasedSymbol<*>> : KaFirSymbol<S> {

 */

package org.jetbrains.kotlin.analysis.api.annotations

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'.")