PREFIX_EXPRESSION -> tree.unsupported(node, UnsupportedLanguageFeature.PrefixExpression)
            OPERATION_REFERENCE -> tree.unsupported(node, UnsupportedLanguageFeature.UnsupportedOperator)
            PARENTHESIZED -> parenthesized(tree, node)
            LAMBDA_EXPRESSION -> tree.unsupported(node, UnsupportedLanguageFeature.FunctionDeclaration)
            THIS_EXPRESSION -> Element(This(tree.sourceData(node)))

import org.jetbrains.kotlin.KtNodeTypes.FUNCTION_LITERAL
import org.jetbrains.kotlin.KtNodeTypes.LAMBDA_ARGUMENT
import org.jetbrains.kotlin.KtNodeTypes.LAMBDA_EXPRESSION
import org.jetbrains.kotlin.KtNodeTypes.PARENTHESIZED
import org.jetbrains.kotlin.KtNodeTypes.SCRIPT
import org.jetbrains.kotlin.com.intellij.lang.LighterASTNode
import org.jetbrains.kotlin.com.intellij.lang.impl.PsiBuilderImpl

2474          ; disallowed_STD3_mapped ; 0028 0031 0029 #1.1  PARENTHESIZED DIGIT ONE
2475          ; disallowed_STD3_mapped ; 0028 0032 0029 #1.1  PARENTHESIZED DIGIT TWO
2476          ; disallowed_STD3_mapped ; 0028 0033 0029 #1.1  PARENTHESIZED DIGIT THREE
2477          ; disallowed_STD3_mapped ; 0028 0034 0029 #1.1  PARENTHESIZED DIGIT FOUR
2478          ; disallowed_STD3_mapped ; 0028 0035 0029 #1.1  PARENTHESIZED DIGIT FIVE

	// The empty string must be preserved inside parens in order
	// to make submatches work right, so these tests are less
	// interesting than they might otherwise be. String inserts
	// explicit (?:) in place of non-parenthesized empty strings,
	// to make them easier to spot for other parsers.
	{`(a|b|c|)`, `([a-c]|(?:))`},
	{`(a|b|)`, `([ab]|(?:))`},
	{`(|)`, `()`},
	{`a()`, `a()`},
	{`(()|())`, `(()|())`},
	{`(a|)`, `(a|(?:))`},

// component. If the second N is unsigned, a + sign is required between the two components
// as indicated by the ±. If the second N is NaN, only a + sign is accepted.
// The form may be parenthesized and cannot contain any spaces.
// The resulting complex number consists of the two components converted by ParseFloat.
//
// The errors that ParseComplex returns have concrete type [*NumError]
// and include err.Num = s.

	`package p; type _ struct{ ( /* ERROR "cannot parenthesize embedded type" */ int) }`,
	`package p; type _ struct{ ( /* ERROR "cannot parenthesize embedded type" */ []byte) }`,
	`package p; type _ struct{ *( /* ERROR "cannot parenthesize embedded type" */ int) }`,
	`package p; type _ struct{ *( /* ERROR "cannot parenthesize embedded type" */ []byte) }`,

	// go.dev/issue/8656

		*syntax.AssignStmt, *syntax.CallStmt:
		// no chance

	case *syntax.LabeledStmt:
		return check.isTerminating(s.Stmt, s.Label.Value)

	case *syntax.ExprStmt:
		// calling the predeclared (possibly parenthesized) panic() function is terminating
		if call, ok := syntax.Unparen(s.X).(*syntax.CallExpr); ok && check.isPanic[call] {
			return true
		}

	case *syntax.ReturnStmt:
		return true

	case *syntax.BranchStmt:

		*ast.RangeStmt:
		// no chance

	case *ast.LabeledStmt:
		return check.isTerminating(s.Stmt, s.Label.Name)

	case *ast.ExprStmt:
		// calling the predeclared (possibly parenthesized) panic() function is terminating
		if call, ok := ast.Unparen(s.X).(*ast.CallExpr); ok && check.isPanic[call] {
			return true
		}

	case *ast.ReturnStmt:
		return true

	case *ast.BranchStmt:

			fun = call.Fun
			n++
		}
	}
	if n != 1 {
		t.Errorf("%s: got %d CallExprs; want 1", src0, n)
		return
	}

	// check recorded types for fun and descendents (may be parenthesized)
	for {
		// the recorded type for the built-in must match the wanted signature
		typ := types[fun].Type
		if typ == nil {
			t.Errorf("%s: no type recorded for %s", src0, ExprString(fun))
			return
		}

		Incomplete bool      // true if (source) expressions are missing in the Elts list
	}

	// A ParenExpr node represents a parenthesized expression.
	ParenExpr struct {
		Lparen token.Pos // position of "("
		X      Expr      // parenthesized expression
		Rparen token.Pos // position of ")"
	}

	// A SelectorExpr node represents an expression followed by a selector.
	SelectorExpr struct {