Method parseObjectLiteralElement

internal/parser/parser.go:5640–5690

()

}

func (p *Parser) parseObjectLiteralElement() *ast.Node {
	pos := p.nodePos()
	jsdoc := p.jsdocScannerInfo()
	if p.parseOptional(ast.KindDotDotDotToken) {
		expression := p.parseAssignmentExpressionOrHigher()
		result := p.finishNode(p.factory.NewSpreadAssignment(expression), pos)
		p.withJSDoc(result, jsdoc)
		return result
	}
	modifiers := p.parseModifiersEx(true /*allowDecorators*/, false /*permitConstAsModifier*/, false /*stopOnStartOfClassStaticBlock*/)
	if p.parseContextualModifier(ast.KindGetKeyword) {
		return p.parseAccessorDeclaration(pos, jsdoc, modifiers, ast.KindGetAccessor, ParseFlagsNone)
	}
	if p.parseContextualModifier(ast.KindSetKeyword) {
		return p.parseAccessorDeclaration(pos, jsdoc, modifiers, ast.KindSetAccessor, ParseFlagsNone)
	}
	asteriskToken := p.parseOptionalToken(ast.KindAsteriskToken)
	tokenIsIdentifier := p.isIdentifier()
	name := p.parsePropertyName()
	// Disallowing of optional property assignments and definite assignment assertion happens in the grammar checker.
	postfixToken := p.parseOptionalToken(ast.KindQuestionToken)
	// Decorators, Modifiers, questionToken, and exclamationToken are not supported by property assignments and are reported in the grammar checker
	if postfixToken == nil {
		postfixToken = p.parseOptionalToken(ast.KindExclamationToken)
	}
	if asteriskToken != nil || p.token == ast.KindOpenParenToken || p.token == ast.KindLessThanToken {
		return p.parseMethodDeclaration(pos, jsdoc, modifiers, asteriskToken, name, postfixToken, nil /*diagnosticMessage*/)
	}
	// check if it is short-hand property assignment or normal property assignment
	// NOTE: if token is EqualsToken it is interpreted as CoverInitializedName production
	// CoverInitializedName[Yield] :
	//     IdentifierReference[?Yield] Initializer[In, ?Yield]
	// this is necessary because ObjectLiteral productions are also used to cover grammar for ObjectAssignmentPattern
	var node *ast.Node
	isShorthandPropertyAssignment := tokenIsIdentifier && p.token != ast.KindColonToken
	if isShorthandPropertyAssignment {
		equalsToken := p.parseOptionalToken(ast.KindEqualsToken)
		var initializer *ast.Expression
		if equalsToken != nil {
			initializer = doInContext(p, ast.NodeFlagsDisallowInContext, false, (*Parser).parseAssignmentExpressionOrHigher)
		}
		node = p.factory.NewShorthandPropertyAssignment(modifiers, name, postfixToken, nil /*typeNode*/, equalsToken, initializer)
	} else {
		p.parseExpected(ast.KindColonToken)
		initializer := doInContext(p, ast.NodeFlagsDisallowInContext, false, (*Parser).parseAssignmentExpressionOrHigher)
		node = p.factory.NewPropertyAssignment(modifiers, name, postfixToken, nil /*typeNode*/, initializer)
	}
	p.finishNode(node, pos)
	p.withJSDoc(node, jsdoc)
	return node
}

func (p *Parser) parseFunctionExpression() *ast.Expression {
	// GeneratorExpression: