// This function is to try to parse a MethodDefinition as defined in 14.3. But in the case of object literals,
// it might be called at a position where there is in fact a short hand identifier pattern or a data property.
// This can only be determined after we consumed up to the left parentheses.
//
// In order to avoid back tracking, it returns `null` if the position is not a MethodDefinition and the caller
// is responsible to visit other options.
public Node tryParseMethodDefinition(Token token, Node key, bool computed, Node node)
{
Node value;
Options options;
Node methodNode;
Options @params;
bool previousAllowYield = state.allowYield;
if (token.type == TokenType.Identifier)
{
// check for `get` and `set`;
if (token.value == "get" && lookaheadPropertyName())
{
computed = match("[");
key = parseObjectPropertyKey();
methodNode = new Node();
expect("(");
expect(")");
state.allowYield = false;
value = parsePropertyFunction(methodNode, new Options()
{
@params = new List<Node>(),
defaults = new List<Node>(),
stricted = null,
firstRestricted = null,
message = null
}, false);
state.allowYield = previousAllowYield;
return node.finishProperty("get", key, computed, value, false, false);
}
else if (token.value == "set" && lookaheadPropertyName())
{
computed = match("[");
key = parseObjectPropertyKey();
methodNode = new Node();
expect("(");
options = new Options()
{
@params = new List<Node>(),
defaultCount = 0,
defaults = new List<Node>(),
firstRestricted = null,
// paramSet = {}
};
if (match(")"))
{
tolerateUnexpectedToken(lookahead);
}
else
{
state.allowYield = false;
parseParam(options);
state.allowYield = previousAllowYield;
if (options.defaultCount == 0)
{
options.defaults = new List<Node>();
}
}
expect(")");
state.allowYield = false;
value = parsePropertyFunction(methodNode, options, false);
state.allowYield = previousAllowYield;
return node.finishProperty("set", key, computed, value, false, false);
}
}
else if (token.type == TokenType.Punctuator && token.value == "*" && lookaheadPropertyName())
{
computed = match("[");
key = parseObjectPropertyKey();
methodNode = new Node();
state.allowYield = true;
@params = parseParams();
state.allowYield = previousAllowYield;
state.allowYield = false;
value = parsePropertyFunction(methodNode, @params, true);
state.allowYield = previousAllowYield;
return node.finishProperty("init", key, computed, value, true, false);
}
if (key != null && match("("))
{
value = parsePropertyMethodFunction();
return node.finishProperty("init", key, computed, value, true, false);
}
// Not a MethodDefinition.
return null;
}
public Node parseObjectProperty( bool hasProto)
{
var token = lookahead;
Node node = new Node();
bool computed;
Node key = null;
Node maybeMethod;
bool proto;
Node value;
computed = match("[");
if (match("*")) {
lex();
} else {
key = parseObjectPropertyKey();
}
maybeMethod = tryParseMethodDefinition(token, key, computed, node);
if (maybeMethod!= null) {
return maybeMethod;
}
if (key== null) {
throwUnexpectedToken(lookahead);
}
// Check for duplicated __proto__
if (!computed) {
proto = (key.type == Syntax.Identifier && key.name == "__proto__") ||
(key.type == Syntax.Literal && key.name== "__proto__");
if (hasProto && proto) {
tolerateError(Messages.DuplicateProtoProperty);
}
hasProto |= proto;
}
if (match(":")) {
lex();
value = inheritCoverGrammar(parseAssignmentExpression);
return node.finishProperty("init", key, computed, value, false, false);
}
if (token.type == TokenType.Identifier) {
if (match("=")) {
firstCoverInitializedNameError = lookahead;
lex();
value = isolateCoverGrammar(parseAssignmentExpression);
return node.finishProperty("init", key, computed,
new Node(token).finishAssignmentPattern(key, value), false, true);
}
return node.finishProperty("init", key, computed, key, false, true);
}
throwUnexpectedToken(lookahead);
return null;
}
public Node parsePropertyPattern(List<Token> @params, string kind)
{
var node = new Node();
Node key;
Token keyToken;
bool computed = match("[");
Node init;
if (lookahead.type == TokenType.Identifier)
{
keyToken = lookahead;
key = parseVariableIdentifier();
if (match("="))
{
@params.Add(keyToken);
lex();
init = parseAssignmentExpression();
return node.finishProperty("init", key, false,
new Node(keyToken).finishAssignmentPattern(key, init), false, false);
}
else if (!match(":"))
{
@params.Add(keyToken);
return node.finishProperty("init", key, false, key, false, true);
}
}
else
{
key = new Node();// parseObjectPropertyKey(@params, kind);
}
expect(":");
init = parsePatternWithDefault(@params, kind);
return node.finishProperty("init", key, computed, init, false, false);
}
