var _, _ int = 1, 2
var _ int = 1, 2 /* ERROR "extra init expr 2" */
var _, _ int = 1 /* ERRORx `assignment mismatch: [1-9]+ variables but.*[1-9]+ value(s)?` */
var _, _, _ /* ERROR "missing init expr for _" */ int = 1, 2

var (
	_, _ = 1, 2
	_ = 1, 2 /* ERROR "extra init expr 2" */
	_, _ = 1 /* ERRORx `assignment mismatch: [1-9]+ variables but.*[1-9]+ value(s)?` */
	_, _, _ /* ERROR "missing init expr for _" */ = 1, 2

		}
		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 {

	// ordered comparison with the load used for the later equality check.
	//   if expr[3] <= 'd' { ... if expr[0] == 'f' && expr[1] == 'o' && expr[2] == 'o' && expr[3] == 'd' { ... } }
	// If we did both expr[3] loads in the unsigned domain, they would be CSEd, and that
	// would in turn defeat the combining of expr[0]...expr[3] into a single 4-byte load.
	// See issue 48222.

val p = <expr>42 / 0</expr>...

fun test() {
    <expr>[1, 2, 3]</expr>

class Test {
    <expr>init {
        "value"
    }</expr>

fun test() {
    s::<expr>length</expr>

fun test(): Int = <expr>{
    65

fun test(): Unit = {
    <expr>Unit</expr>

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