val lazyFun: Int by <expr>lazy {
    1000

fun test(foo: String.(String) -> Unit) {
    "A" <expr>foo</expr> "B"

			if len(call.Args) != 1 {
				return true
			}
			expr := call.Args[0]
			if pass.TypesInfo.Types[expr].Type == nil {
				return true
			}
			t := pass.TypesInfo.Types[expr].Type.Underlying()
			tSign, argOk := t.(*types.Signature)
			// Argument should be a function
			if !argOk {
				pass.ReportRangef(expr, "argument to Fuzz must be a function")
				return false
			}

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

fun test(flag: Boolean) {
    block {
        consume("before")

        <expr>if (flag) {
            return@block 1
        }

        2</expr>
    }
}

fun block(block: () -> Int) {
    block()
}

fun foo(a: Int): Int {
    val b: Int = 1
    return when (a + b) {
        <expr>0</expr> -> b
        1 -> -b
        else -> a - b
    }

// 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>;

@file:Suppress("ANNOTATION_ARGUMENT_MUST_BE_CONST")
package test

annotation class Anno(val value: String)

@Anno(value = "A" <expr>foo</expr> "B")
class Foo

fun <T> Array<T>.check(f: (T) -> Boolean): Boolean = false

fun test(words: Array<String>) {
    if (<expr>words.check { it.length == 5 }</expr>) {
        consume("OK")
    }
}

fun test() {
    buildFoo {
        <expr>value</expr> = produceString()
    }
}

fun buildFoo(builder: Foo.() -> Unit): Foo {
    val foo = Foo()
    foo.builder()
    return foo
}

class Foo {
    var value: String? = null
}