}

    @Test
    @TestMetadata("parenthesis.kt")
    public void testParenthesis() {
      runTest("analysis/analysis-api/testData/components/dataFlowInfoProvider/exitPointSnapshot/controlFlow/parenthesis.kt");
    }

    @Nested

    }

    @Test
    @TestMetadata("parenthesis.kt")
    public void testParenthesis() {
      runTest("analysis/analysis-api/testData/components/dataFlowInfoProvider/exitPointSnapshot/controlFlow/parenthesis.kt");
    }

    @Nested

    }

    @Test
    @TestMetadata("parenthesis.kt")
    public void testParenthesis() {
      runTest("analysis/analysis-api/testData/components/dataFlowInfoProvider/exitPointSnapshot/controlFlow/parenthesis.kt");
    }

    @Nested

	go ( /* ERROR "expression in go must not be parenthesized" */ gos())
	go gos()
	var c chan int
	go close(c)
	go len /* ERROR "go discards result" */ (c)
}

func defers() {
	defer 1; /* ERROR "must be function call" */
	defer int /* ERROR "defer requires function call, not conversion" */ (0)
	defer ( /* ERROR "expression in defer must not be parenthesized" */ defers())
	defer defers()
	var c chan int

func urlEscaper(args ...any) string {
	return urlProcessor(false, args...)
}

// urlNormalizer normalizes URL content so it can be embedded in a quote-delimited
// string or parenthesis delimited url(...).
// The normalizer does not encode all HTML specials. Specifically, it does not
// encode '&' so correct embedding in an HTML attribute requires escaping of
// '&' to '&'.

		fun
	  The result is the value of invoking the function, fun(). The return
	  types and values behave as in methods. Functions and function
	  names are described below.
	- A parenthesized instance of one the above, for grouping. The result
	  may be accessed by a field or map key invocation.
		print (.F1 arg1) (.F2 arg2)
		(.StructValuedMethod "arg").Field

 * Can be combined with other parsers in the usual way and its delegate can be set at a later moment in time.
 *
 * It can also be used to create recursive parsers.
 * For example, a parser for a balanced parenthesized symbolic expression can be defined as:
 * ```kotlin
 * var parser by reference<String>()
 * parser = paren(parser) + token(IDENTIFIER) { tokenText }
 * ```
 *

	}
	if m := check.Types; m != nil {
		m[x] = TypeAndValue{mode, typ, val}
	}
}

func (check *Checker) recordBuiltinType(f ast.Expr, sig *Signature) {
	// f must be a (possibly parenthesized, possibly qualified)
	// identifier denoting a built-in (including unsafe's non-constant
	// functions Add and Slice): record the signature for f and possible
	// children.
	for {

		tSpace,
		mkItem(itemChar, ","),
		tSpace,
		mkItem(itemVariable, "$w"),
		tSpace,
		mkItem(itemDeclare, ":="),
		tSpace,
		mkItem(itemNumber, "3"),
		tRight,
		tEOF,
	}},
	{"field of parenthesized expression", "{{(.X).Y}}", []item{
		tLeft,
		tLpar,
		mkItem(itemField, ".X"),
		tRpar,
		mkItem(itemField, ".Y"),
		tRight,
		tEOF,
	}},

		}
		// binary expressions
		return combinesWithName(x.X) && !isTypeElem(x.Y)
	case *ParenExpr:
		// name(x) combines but we are making sure at
		// the call site that x is never parenthesized.
		panic("unexpected parenthesized expression")
	}
	return false
}

func (p *printer) printStmtList(list []Stmt, braces bool) {
	for i, x := range list {
		p.print(x, _Semi)
		if i+1 < len(list) {