wuggy/Dactyloidae
wuggy/Dactyloidae
1
0
Fork 0
mirror of https://repo.dactyloidae.xyz/Dactyloidae/UXP.git synced 2026-09-03 14:28:39 +09:00
Code Issues Projects Releases Packages Wiki Activity

Simplify checking of targets within destructuring patterns.

Browse source
This commit is contained in:
wolfbeast 2019-04-06 11:05:22 +02:00 • committed by Roy Tam
commit 33d09dce8b
3 changed files with 14 additions and 82 deletions
Download patch file Download diff file Expand all files Collapse all files

86
js/src/frontend/Parser.cpp
View file

@ -4113,22 +4113,23 @@ Parser<FullParseHandler>::checkDestructuringName(ParseNode* expr, Maybe<Declarat
}
// Otherwise this is an expression in destructuring outside a declaration.
if (!reportIfNotValidSimpleAssignmentTarget(expr, KeyedDestructuringAssignment))
return false;
MOZ_ASSERT(!handler.isFunctionCall(expr),
"function calls shouldn't be considered valid targets in "
"destructuring patterns");
if (handler.isNameAnyParentheses(expr)) {
// The arguments/eval identifiers are simple in non-strict mode code.
// Warn to discourage their use nonetheless.
return reportIfArgumentsEvalTarget(expr);
if (const char* chars = handler.nameIsArgumentsEvalAnyParentheses(expr, context)) {
if (!reportWithNode(ParseStrictError, pc->sc()->strict(), expr,
JSMSG_BAD_STRICT_ASSIGN, chars))
{
return false;
}
}
return true;
}
// Nothing further to do for property accesses.
MOZ_ASSERT(handler.isPropertyAccess(expr));
return true;
if (handler.isPropertyAccess(expr))
return true;
reportWithNode(ParseError, pc->sc()->strict(), expr, JSMSG_BAD_DESTRUCT_TARGET);
return false;
}
template <>
@ -7773,65 +7774,6 @@ Parser<ParseHandler>::isValidSimpleAssignmentTarget(Node node,
return false;
}
template <typename ParseHandler>
bool
Parser<ParseHandler>::reportIfArgumentsEvalTarget(Node nameNode)
{
const char* chars = handler.nameIsArgumentsEvalAnyParentheses(nameNode, context);
if (!chars)
return true;
bool strict = pc->sc()->strict();
if (!reportWithNode(ParseStrictError, strict, nameNode, JSMSG_BAD_STRICT_ASSIGN, chars))
return false;
MOZ_ASSERT(!strict,
"an error should have been reported if this was strict mode "
"code");
return true;
}
template <typename ParseHandler>
bool
Parser<ParseHandler>::reportIfNotValidSimpleAssignmentTarget(Node target, AssignmentFlavor flavor)
{
FunctionCallBehavior behavior = flavor == KeyedDestructuringAssignment
? ForbidAssignmentToFunctionCalls
: PermitAssignmentToFunctionCalls;
if (isValidSimpleAssignmentTarget(target, behavior))
return true;
if (handler.isNameAnyParentheses(target)) {
// Use a special error if the target is arguments/eval. This ensures
// targeting these names is consistently a SyntaxError (which error numbers
// below don't guarantee) while giving us a nicer error message.
if (!reportIfArgumentsEvalTarget(target))
return false;
}
unsigned errnum = 0;
const char* extra = nullptr;
switch (flavor) {
case IncrementAssignment:
errnum = JSMSG_BAD_OPERAND;
extra = "increment";
break;
case DecrementAssignment:
errnum = JSMSG_BAD_OPERAND;
extra = "decrement";
break;
case KeyedDestructuringAssignment:
errnum = JSMSG_BAD_DESTRUCT_TARGET;
break;
}
reportWithNode(ParseError, pc->sc()->strict(), target, errnum, extra);
return false;
}
template <typename ParseHandler>
bool
Parser<ParseHandler>::checkAndMarkAsIncOperand(Node target)