}


sealed interface FunctionArgument : LanguageTreeElement {
    sealed interface ValueArgument : FunctionArgument {
        val expr: Expr
    }

    data class Positional(override val expr: Expr, override val sourceData: SourceData) : ValueArgument
    data class Named(val name: String, override val expr: Expr, override val sourceData: SourceData) : ValueArgument

    override fun doResolveExpressionStatement(context: AnalysisContext, expr: Expr) {
        val resolvedExpr = expressionResolver.doResolveExpression(context, expr)

        when (expr) {
            is FunctionCall ->
                if (resolvedExpr is ObjectOrigin.FunctionOrigin && isDanglingPureCall(resolvedExpr))
                    errorCollector.collect(ResolutionError(expr, ErrorReason.DanglingPureExpression))

    lateinit var codeAnalyzer: CodeAnalyzer
    lateinit var errorCollector: ErrorCollector

    override fun doResolveExpression(context: AnalysisContext, expr: Expr): ObjectOrigin? =
        expressionResolver.doResolveExpression(context, expr)

    override fun analyzeStatementsInProgramOrder(context: AnalysisContext, elements: List<DataStatement>) {
        codeAnalyzer.analyzeStatementsInProgramOrder(context, elements)

fun calculate() {
    val a = 1
    val b = 2
    val c = 3
    val result = a * <expr>(b + c)</expr> - a
    println(result)

// FILE: JavaConst.java
public interface JavaConst {
    public static final int x = KotlinConst.y;
}

// FILE: main.kt
object KotlinConst {
    const val y = <expr>JavaConst.x</expr>;

fun test() {
    val string = <expr>String</expr>::class

// MODULE: main
// TARGET_PLATFORM: JS
// FILE: lib.kt
@file:JsExport
package lib

open class Base {
    val foo: String = "foo"
}

// FILE: main.kt
package main

import lib.*

const val x = <expr>"$y"</expr>

@MetaAnno
annotation class Anno


// MODULE: main(lib)
// TARGET_PLATFORM: Native
// FILE: main.kt
package main

import lib.*

@Anno
abstract class Base

fun test() {
    val string = <expr>String</expr>::class