Reason for revert:
Breaks layout test. Please change test expectation on blink first.
--- /mnt/data/b/build/slave/V8-Blink_Linux_64/build/layout-test-results/inspector/sources/debugger-pause/debugger-pause-in-internal-expected.txt
+++ /mnt/data/b/build/slave/V8-Blink_Linux_64/build/layout-test-results/inspector/sources/debugger-pause/debugger-pause-in-internal-actual.txt
@@ -1,4 +1,4 @@
-CONSOLE ERROR: line 9: Uncaught SyntaxError: Expected () to start arrow function, but got '}' instead of '=>'
+CONSOLE ERROR: line 9: Uncaught SyntaxError: Unexpected token )
Tests that pause on exception in internal script does not crash.
Script source was shown.
Original issue's description:
> Parse arrow functions at proper precedence level
>
> BUG=v8:4211
> LOG=Y
> R=rossberg@chromium.org
>
> Committed: https://crrev.com/
9271b0ccf9ddb217deb1f0b9ef9b59b64dc40214
> Cr-Commit-Position: refs/heads/master@{#30298}
TBR=rossberg@chromium.org,mstarzinger@chromium.org,fennyfanny655@gmail.com,machenbach@chromium.org,wingo@igalia.com
NOPRESUBMIT=true
NOTREECHECKS=true
NOTRY=true
BUG=v8:4211
Review URL: https://codereview.chromium.org/
1315503002
Cr-Commit-Position: refs/heads/master@{#30318}
}
-void AstLiteralReindexer::VisitEmptyParentheses(EmptyParentheses* node) {}
-
-
void AstLiteralReindexer::VisitForInStatement(ForInStatement* node) {
Visit(node->each());
Visit(node->enumerable());
}
-void AstNumberingVisitor::VisitEmptyParentheses(EmptyParentheses* node) {
- UNREACHABLE();
-}
-
-
void AstNumberingVisitor::VisitForInStatement(ForInStatement* node) {
IncrementNodeCount();
DisableSelfOptimization();
V(ThisFunction) \
V(SuperPropertyReference) \
V(SuperCallReference) \
- V(CaseClause) \
- V(EmptyParentheses)
+ V(CaseClause)
#define AST_NODE_LIST(V) \
DECLARATION_NODE_LIST(V) \
};
-// This class is produced when parsing the () in arrow functions without any
-// arguments and is not actually a valid expression.
-class EmptyParentheses final : public Expression {
- public:
- DECLARE_NODE_TYPE(EmptyParentheses)
-
- private:
- EmptyParentheses(Zone* zone, int pos) : Expression(zone, pos) {}
-};
-
-
#undef DECLARE_NODE_TYPE
this_function_var, pos);
}
- EmptyParentheses* NewEmptyParentheses(int pos) {
- return new (zone_) EmptyParentheses(zone_, pos);
- }
-
private:
Zone* zone_;
AstValueFactory* ast_value_factory_;
}
-void AstGraphBuilder::VisitEmptyParentheses(EmptyParentheses* expr) {
- // Handled entirely by the parser itself.
- UNREACHABLE();
-}
-
-
void AstGraphBuilder::VisitThisFunction(ThisFunction* expr) {
Node* value = GetFunctionClosure();
ast_context()->ProduceValue(value);
void ALAA::VisitSpread(Spread* e) { Visit(e->expression()); }
-void ALAA::VisitEmptyParentheses(EmptyParentheses* e) { UNREACHABLE(); }
-
-
void ALAA::VisitCaseClause(CaseClause* cc) {
if (!cc->is_default()) Visit(cc->label());
VisitStatements(cc->statements());
void FullCodeGenerator::VisitSpread(Spread* expr) { UNREACHABLE(); }
-void FullCodeGenerator::VisitEmptyParentheses(EmptyParentheses* expr) {
- UNREACHABLE();
-}
-
-
FullCodeGenerator::NestedStatement* FullCodeGenerator::TryFinally::Exit(
int* stack_depth, int* context_length) {
// The macros used here must preserve the result register.
void HOptimizedGraphBuilder::VisitSpread(Spread* expr) { UNREACHABLE(); }
-void HOptimizedGraphBuilder::VisitEmptyParentheses(EmptyParentheses* expr) {
- UNREACHABLE();
-}
-
-
HInstruction* HOptimizedGraphBuilder::BuildThisFunction() {
// If we share optimized code between different closures, the
// this-function is not a constant, except inside an inlined body.
void BytecodeGenerator::VisitSpread(Spread* node) { UNIMPLEMENTED(); }
-void BytecodeGenerator::VisitEmptyParentheses(EmptyParentheses* node) {
- UNIMPLEMENTED();
-}
-
-
void BytecodeGenerator::VisitThisFunction(ThisFunction* node) {
UNIMPLEMENTED();
}
T(MalformedArrowFunParamList, "Malformed arrow function parameter list") \
T(MalformedRegExp, "Invalid regular expression: /%/: %") \
T(MalformedRegExpFlags, "Invalid regular expression flags") \
+ T(MissingArrow, \
+ "Expected () to start arrow function, but got '%' instead of '=>'") \
T(ModuleExportUndefined, "Export '%' is not defined in module") \
T(MultipleDefaultsInSwitch, \
"More than one default clause in switch statement") \
ParserFormalParameters* parameters, Expression* expr,
const Scanner::Location& params_loc,
Scanner::Location* duplicate_loc, bool* ok) {
- if (expr->IsEmptyParentheses()) return;
-
ParseArrowFunctionFormalParameters(parameters, expr, params_loc,
duplicate_loc, ok);
if (!*ok) return;
}
-void Parser::PatternRewriter::VisitEmptyParentheses(EmptyParentheses* node) {
- UNREACHABLE();
-}
-
-
// =============== UNREACHABLE =============================
void Parser::PatternRewriter::Visit(AstNode* node) { UNREACHABLE(); }
return PreParserExpression::Spread(expression);
}
- PreParserExpression NewEmptyParentheses(int pos) {
- return PreParserExpression::Default();
- }
-
// Return the object itself as AstVisitor and implement the needed
// dummy method right in this class.
PreParserFactory* visitor() { return this; }
}
BindingPatternUnexpectedToken(classifier);
Consume(Token::LPAREN);
- if (Check(Token::RPAREN)) {
- // ()=>x. The continuation that looks for the => is in
- // ParseAssignmentExpression.
- classifier->RecordExpressionError(scanner()->location(),
- MessageTemplate::kUnexpectedToken,
- Token::String(Token::RPAREN));
+ if (allow_harmony_arrow_functions() && Check(Token::RPAREN)) {
+ // As a primary expression, the only thing that can follow "()" is "=>".
classifier->RecordBindingPatternError(scanner()->location(),
MessageTemplate::kUnexpectedToken,
Token::String(Token::RPAREN));
- result = factory()->NewEmptyParentheses(beg_pos);
- } else if (allow_harmony_rest_parameters() && Check(Token::ELLIPSIS)) {
- // (...x)=>x. The continuation that looks for the => is in
- // ParseAssignmentExpression.
- int ellipsis_pos = scanner()->location().beg_pos;
- classifier->RecordExpressionError(scanner()->location(),
- MessageTemplate::kUnexpectedToken,
- Token::String(Token::ELLIPSIS));
- Scanner::Location expr_loc = scanner()->peek_location();
- Token::Value tok = peek();
- result = this->ParseAssignmentExpression(true, classifier, CHECK_OK);
- // Patterns are not allowed as rest parameters. There is no way we can
- // succeed so go ahead and use the convenient ReportUnexpectedToken
- // interface.
- if (!Traits::IsIdentifier(result)) {
- ReportUnexpectedTokenAt(expr_loc, tok);
+ // Give a good error to the user who might have typed e.g. "return();".
+ if (peek() != Token::ARROW) {
+ ReportUnexpectedTokenAt(scanner_->peek_location(), peek(),
+ MessageTemplate::kMissingArrow);
*ok = false;
return this->EmptyExpression();
}
- result = factory()->NewSpread(result, ellipsis_pos);
+ Scope* scope =
+ this->NewScope(scope_, ARROW_SCOPE, FunctionKind::kArrowFunction);
+ FormalParametersT parameters(scope);
+ scope->set_start_position(beg_pos);
+ ExpressionClassifier args_classifier;
+ result = this->ParseArrowFunctionLiteral(parameters, args_classifier,
+ CHECK_OK);
+ } else if (allow_harmony_arrow_functions() &&
+ allow_harmony_rest_parameters() && Check(Token::ELLIPSIS)) {
+ // (...x) => y
+ Scope* scope =
+ this->NewScope(scope_, ARROW_SCOPE, FunctionKind::kArrowFunction);
+ FormalParametersT formals(scope);
+ scope->set_start_position(beg_pos);
+ ExpressionClassifier formals_classifier;
+ formals.has_rest = true;
+ this->ParseFormalParameter(&formals, &formals_classifier, CHECK_OK);
+ Traits::DeclareFormalParameter(
+ formals.scope, formals.at(0), formals.is_simple,
+ &formals_classifier);
if (peek() == Token::COMMA) {
ReportMessageAt(scanner()->peek_location(),
MessageTemplate::kParamAfterRest);
return this->EmptyExpression();
}
Expect(Token::RPAREN, CHECK_OK);
+ result = this->ParseArrowFunctionLiteral(formals, formals_classifier,
+ CHECK_OK);
} else {
// Heuristically try to detect immediately called functions before
// seeing the call parentheses.
}
-void CallPrinter::VisitEmptyParentheses(EmptyParentheses* node) {
- UNREACHABLE();
-}
-
-
void CallPrinter::VisitThisFunction(ThisFunction* node) {}
}
-void PrettyPrinter::VisitEmptyParentheses(EmptyParentheses* node) {
- Print("<empty-parentheses>");
-}
-
-
void PrettyPrinter::VisitThisFunction(ThisFunction* node) {
Print("<this-function>");
}
}
-void AstPrinter::VisitEmptyParentheses(EmptyParentheses* node) {
- IndentedScope indent(this, "()");
-}
-
-
void AstPrinter::VisitThisFunction(ThisFunction* node) {
IndentedScope indent(this, "THIS-FUNCTION");
}
void AstTyper::VisitSpread(Spread* expr) { RECURSE(Visit(expr->expression())); }
-void AstTyper::VisitEmptyParentheses(EmptyParentheses* expr) {
- UNREACHABLE();
-}
-
-
void AstTyper::VisitThisFunction(ThisFunction* expr) {
}
-*%(basename)s:7: SyntaxError: Unexpected token )
+*%(basename)s:7: SyntaxError: Expected () to start arrow function, but got ';' instead of '=>'
function foo() { return(); }
- ^
-SyntaxError: Unexpected token )
+ ^
+SyntaxError: Expected () to start arrow function, but got ';' instead of '=>'
+++ /dev/null
-// Copyright 2015 the V8 project authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-//
-// Flags: --harmony-arrow-functions --harmony-rest-parameters
-
-assertThrows("()=>{}()", SyntaxError);
-assertThrows("x=>{}()", SyntaxError);
-assertThrows("(...x)=>{}()", SyntaxError);
-assertThrows("(x)=>{}()", SyntaxError);
-assertThrows("(x,y)=>{}()", SyntaxError);
-assertThrows("(x,y,...z)=>{}()", SyntaxError);