}
		t.Run(tc.name, func(t *testing.T) {
			for _, expr := range tc.expressions {
				t.Run(expr, func(t *testing.T) {
					t.Run("expression", func(t *testing.T) {
						options := OptionalVariableDeclarations{HasParams: tc.hasParams, HasAuthorizer: tc.hasAuthorizer}

						result := compiler.CompileCELExpression(&fakeValidationCondition{
							Expression: expr,
						}, options, envType)
						if result.Error != nil {

val lazyFun: Int by <expr>lazy {
    1000

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

// If the type switch expression is invalid, x is nil.
func (check *Checker) caseTypes(x *operand, types []syntax.Expr, seen map[Type]syntax.Expr) (T Type) {
	var dummy operand
L:
	for _, e := range types {
		// The spec allows the value nil instead of a type.
		if check.isNil(e) {
			T = nil
			check.expr(nil, &dummy, e) // run e through expr so we get the usual Info recordings
		} else {
			T = check.varType(e)
			if !isValid(T) {

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

        {
          "datasource": {
            "type": "prometheus",
            "uid": "${DS_PROMETHEUS}"
          },
          "editorMode": "code",
          "exemplar": true,
          "expr": "sum by (bucket,range) (minio_bucket_objects_size_distribution{job=\"$scrape_jobs\"})",
          "format": "time_series",
          "instant": false,
          "interval": "",
          "intervalFactor": 1,