.col-md-8, .col-md-9, .col-md-10, .col-md-11, .col-md-12, .col-md,\n.col-md-auto, .col-lg-1, .col-lg-2, .col-lg-3, .col-lg-4, .col-lg-5, .col-lg-6, .col-lg-7, .col-lg-8, .col-lg-9, .col-lg-10, .col-lg-11, .col-lg-12, .col-lg,\n.col-lg-auto, .col-xl-1, .col-xl-2, .col-xl-3, .col-xl-4, .col-xl-5, .col-xl-6, .col-xl-7, .col-xl-8, .col-xl-9, .col-xl-10, .col-xl-11, .col-xl-12, .col-xl,\n.col-xl-auto {\n  position: relative;\n  width: 100%;\n  padding-right: 15px;\n  padding-left: 15px;\n}\n\n.col {\n  -ms-flex-preferred-size:...

fun test(foo: Foo) {
    <caret_context>foo.call()
}

expect class Foo {
    fun call()
}


// MODULE: main
// MODULE_KIND: CodeFragment
// CONTEXT_MODULE: common

// FILE: fragment.kt
// CODE_FRAGMENT_KIND: EXPRESSION
foo.call()


// MODULE: jvm()()(common)
// TARGET_PLATFORM: JVM

// FILE: Jvm.kt
package test

actual class Foo {
    fun call() {}

     * Returns true if the [candidate] is in the final set of candidates that the call is actually resolved to. There can be multiple
     * candidates if the call is ambiguous.
     */
    public val isInBestCandidates: Boolean by validityAsserted(isInBestCandidates)
}

public typealias KtCallCandidateInfo = KaCallCandidateInfo

/**

        }
    }

    private
    fun checkOutputContains(call: MethodCallExpression) {
        val receiver = call.receiver!!
        if (receiver is PropertyExpression) {
            if (receiver.propertyAsString == "output") {
                val objectExpr = receiver.objectExpression!!
                checkIndirectOutputContains(objectExpr, call)
            }
        }
    }

    private

    @Test
    fun `can use closure with single argument call`() {
        val list = arrayListOf<Int>()
        closureOf<MutableList<Int>> { add(42) }.call(list)
        assertEquals(42, list.first())
    }

    @Test
    fun `can use closure with single nullable argument call`() {
        var passedIntoClosure: Any? = "Something non null"
        closureOf<Any?> { passedIntoClosure = this }.call(null)
        assertNull(passedIntoClosure)
    }

        EXPRESSION_BODY
          BLOCK type=kotlin.Int origin=null
            CALL 'public final fun plus (other: kotlin.Int): kotlin.Int [operator] declared in kotlin.Int' type=kotlin.Int origin=PLUS
              $this: CALL 'public final fun plus (other: kotlin.Int): kotlin.Int [operator] declared in kotlin.Int' type=kotlin.Int origin=PLUS

    override val resolveKind: String get() = "call"

    override fun generateResolveOutput(mainElement: KtElement, testServices: TestServices): String = analyseForTest(mainElement) {
        val call = mainElement.resolveCallOld()
        val secondCall = mainElement.resolveCallOld()

        ignoreStabilityIfNeeded(testServices.moduleStructure.allDirectives) {
            assertStableResult(testServices, call, secondCall)
        }

fun test() {
    block("foo") { foo ->
        fun call() {
            consume(foo)
        }

        <caret_context>call()
    }
}

fun <T> block(obj: T, block: (T) -> Unit) {
    block(obj)
}

fun consume(text: String) {}


// MODULE: main
// MODULE_KIND: CodeFragment
// CONTEXT_MODULE: context

// FILE: fragment.kt
// CODE_FRAGMENT_KIND: EXPRESSION

// MODULE: context

// FILE: context.kt
class Foo {
    fun String.test() {
        var x: Int

        fun call(a: Int) {
            consume(a)
            consume(this@Foo)
            consume(this@test)
            x = 42
        }

        <caret_context>call(1)
    }
}

fun consume(obj: Any) {}


// MODULE: main
// MODULE_KIND: CodeFragment
// CONTEXT_MODULE: context

// FILE: fragment.kt

 * A problem is identified using a key object.
 * The implementation should be thread-safe and should support tracking problems in multiple threads, each with its own call stack.
 */
interface DynamicCallProblemReporting {
    /**
     * Begin tracking a new dynamic call on the call stack, with no problems reported in it initially.