}
			data = s
			// some keywords followed by a newline imply a semicolon
			switch x {
			case token.BREAK, token.CONTINUE, token.FALLTHROUGH, token.RETURN,
				token.INC, token.DEC, token.RPAREN, token.RBRACK, token.RBRACE:
				impliedSemi = true
			}
			p.lastTok = x

		case string:
			// incorrect AST - print error message
			data = x
			isLit = true
			impliedSemi = true
			p.lastTok = token.STRING

		case '(':
			tok = token.LPAREN
		case ')':
			insertSemi = true
			tok = token.RPAREN
		case '[':
			tok = token.LBRACK
		case ']':
			insertSemi = true
			tok = token.RBRACK
		case '{':
			tok = token.LBRACE
		case '}':
			insertSemi = true
			tok = token.RBRACE
		case '+':
			tok = s.switch3(token.ADD, token.ADD_ASSIGN, '+', token.INC)
			if tok == token.INC {
				insertSemi = true
			}

	{token.DEFINE, ":=", operator},
	{token.ELLIPSIS, "...", operator},

	{token.LPAREN, "(", operator},
	{token.LBRACK, "[", operator},
	{token.LBRACE, "{", operator},
	{token.COMMA, ",", operator},
	{token.PERIOD, ".", operator},

	{token.RPAREN, ")", operator},
	{token.RBRACK, "]", operator},
	{token.RBRACE, "}", operator},
	{token.SEMICOLON, ";", operator},
	{token.COLON, ":", operator},
	{token.TILDE, "~", operator},

	"⪭︀":                           "\u2aad\ufe00",
	"⤌":                           "\u290c",
	"❲":                           "\u2772",
	"{":                          "\u007b",
	"[":                          "\u005b",
	"⦋":                           "\u298b",
	"⦏":                         "\u298f",
	"⦍":                         "\u298d",

		"late;":                            '\U00002AAD',
		"lbarr;":                           '\U0000290C',
		"lbbrk;":                           '\U00002772',
		"lbrace;":                          '\U0000007B',
		"lbrack;":                          '\U0000005B',
		"lbrke;":                           '\U0000298B',
		"lbrksld;":                         '\U0000298F',
		"lbrkslu;":                         '\U0000298D',

	if trace {
		defer p.trace("typeInstance")()
	}

	pos := p.pos()
	p.want(_Lbrack)
	x := new(IndexExpr)
	x.pos = pos
	x.X = typ
	if p.tok == _Rbrack {
		p.syntaxError("expected type argument list")
		x.Index = p.badExpr()
	} else {
		x.Index, _ = p.typeList(true)
	}
	p.want(_Rbrack)
	return x
}

// If context != "", type parameters are not permitted.

import org.jetbrains.kotlin.lexer.KtTokens.COMMENTS
import org.jetbrains.kotlin.lexer.KtTokens.IDENTIFIER
import org.jetbrains.kotlin.lexer.KtTokens.LBRACE
import org.jetbrains.kotlin.lexer.KtTokens.PACKAGE_KEYWORD
import org.jetbrains.kotlin.lexer.KtTokens.RBRACE
import org.jetbrains.kotlin.lexer.KtTokens.WHITE_SPACE


internal
abstract class UnexpectedBlock(message: String) : RuntimeException(message) {

package org.gradle.kotlin.dsl.execution

import org.gradle.kotlin.dsl.support.expectedKotlinDslPluginsVersion
import org.jetbrains.kotlin.lexer.KtTokens.DOT
import org.jetbrains.kotlin.lexer.KtTokens.LBRACE
import org.jetbrains.kotlin.lexer.KtTokens.RBRACE


internal
sealed class PluginsBlockInterpretation {

    /**
     * The `plugins` block applies exactly the given list of [plugins].
     */

		{"IncDecStmt.X", Field, 0},
		{"IndexExpr", Type, 0},
		{"IndexExpr.Index", Field, 0},
		{"IndexExpr.Lbrack", Field, 0},
		{"IndexExpr.Rbrack", Field, 0},
		{"IndexExpr.X", Field, 0},
		{"IndexListExpr", Type, 18},
		{"IndexListExpr.Indices", Field, 18},
		{"IndexListExpr.Lbrack", Field, 18},
		{"IndexListExpr.Rbrack", Field, 18},
		{"IndexListExpr.X", Field, 18},
		{"Inspect", Func, 0},
		{"InterfaceType", Type, 0},

	_ = x[_Literal-3]
	_ = x[_Operator-4]
	_ = x[_AssignOp-5]
	_ = x[_IncOp-6]
	_ = x[_Assign-7]
	_ = x[_Define-8]
	_ = x[_Arrow-9]
	_ = x[_Star-10]
	_ = x[_Lparen-11]
	_ = x[_Lbrack-12]
	_ = x[_Lbrace-13]
	_ = x[_Rparen-14]
	_ = x[_Rbrack-15]
	_ = x[_Rbrace-16]
	_ = x[_Comma-17]
	_ = x[_Semi-18]
	_ = x[_Colon-19]
	_ = x[_Dot-20]
	_ = x[_DotDotDot-21]
	_ = x[_Break-22]
	_ = x[_Case-23]
	_ = x[_Chan-24]