Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(480)

Issues Search
    My Issues | Starred     Open | Closed | All

Unified Diff: test/cctest/test-parsing.cc

Issue 372983003: Revert "Implement handling of arrow functions in the parser" (Closed) Base URL: https://v8.googlecode.com/svn/branches/bleeding_edge
Patch Set: Created 6 years, 5 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View side-by-side diff with in-line comments
Download patch
« no previous file with comments | « src/token.h ('k') | no next file » | no next file with comments »
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
Index: test/cctest/test-parsing.cc
diff --git a/test/cctest/test-parsing.cc b/test/cctest/test-parsing.cc
index 440c3bf46bab0b63ceb9d18af4257d56fefa3f22..b12098a85a19e5352471686389ca8387a1789031 100644
--- a/test/cctest/test-parsing.cc
+++ b/test/cctest/test-parsing.cc
@@ -283,10 +283,13 @@ TEST(StandAlonePreParser) {
128 * 1024);
const char* programs[] = {
- "{label: 42}", "var x = 42;",
- "function foo(x, y) { return x + y; }", "%ArgleBargle(glop);",
- "var x = new new Function('this.x = 42');", "var f = (x, y) => x + y;",
- NULL};
+ "{label: 42}",
+ "var x = 42;",
+ "function foo(x, y) { return x + y; }",
+ "%ArgleBargle(glop);",
+ "var x = new new Function('this.x = 42');",
+ NULL
+ };
uintptr_t stack_limit = CcTest::i_isolate()->stack_guard()->real_climit();
for (int i = 0; programs[i]; i++) {
@@ -301,7 +304,6 @@ TEST(StandAlonePreParser) {
i::PreParser preparser(&scanner, &log, stack_limit);
preparser.set_allow_lazy(true);
preparser.set_allow_natives_syntax(true);
- preparser.set_allow_arrow_functions(true);
i::PreParser::PreParseResult result = preparser.PreParseProgram();
CHECK_EQ(i::PreParser::kPreParseSuccess, result);
i::ScriptData data(log.ExtractData());
@@ -1166,8 +1168,7 @@ enum ParserFlag {
kAllowModules,
kAllowGenerators,
kAllowForOf,
- kAllowHarmonyNumericLiterals,
- kAllowArrowFunctions
+ kAllowHarmonyNumericLiterals
};
@@ -1188,7 +1189,6 @@ void SetParserFlags(i::ParserBase<Traits>* parser,
parser->set_allow_for_of(flags.Contains(kAllowForOf));
parser->set_allow_harmony_numeric_literals(
flags.Contains(kAllowHarmonyNumericLiterals));
- parser->set_allow_arrow_functions(flags.Contains(kAllowArrowFunctions));
}
@@ -1390,9 +1390,10 @@ TEST(ParserSync) {
CcTest::i_isolate()->stack_guard()->SetStackLimit(GetCurrentStackPosition() -
128 * 1024);
- static const ParserFlag flags1[] = {kAllowLazy, kAllowHarmonyScoping,
- kAllowModules, kAllowGenerators,
- kAllowForOf, kAllowArrowFunctions};
+ static const ParserFlag flags1[] = {
+ kAllowLazy, kAllowHarmonyScoping, kAllowModules, kAllowGenerators,
+ kAllowForOf
+ };
for (int i = 0; context_data[i][0] != NULL; ++i) {
for (int j = 0; statement_data[j] != NULL; ++j) {
for (int k = 0; termination_data[k] != NULL; ++k) {
@@ -1467,8 +1468,9 @@ void RunParserSyncTest(const char* context_data[][2],
128 * 1024);
static const ParserFlag default_flags[] = {
- kAllowLazy, kAllowHarmonyScoping, kAllowModules, kAllowGenerators,
- kAllowForOf, kAllowNativesSyntax, kAllowArrowFunctions};
+ kAllowLazy, kAllowHarmonyScoping, kAllowModules, kAllowGenerators,
+ kAllowForOf, kAllowNativesSyntax
+ };
ParserFlag* generated_flags = NULL;
if (flags == NULL) {
flags = default_flags;
@@ -1532,19 +1534,28 @@ TEST(ErrorsEvalAndArguments) {
};
const char* statement_data[] = {
- "var eval;", "var arguments",
- "var foo, eval;", "var foo, arguments;",
- "try { } catch (eval) { }", "try { } catch (arguments) { }",
- "function eval() { }", "function arguments() { }",
- "function foo(eval) { }", "function foo(arguments) { }",
- "function foo(bar, eval) { }", "function foo(bar, arguments) { }",
- "(eval) => { }", "(arguments) => { }",
- "(foo, eval) => { }", "(foo, arguments) => { }",
- "eval = 1;", "arguments = 1;",
- "var foo = eval = 1;", "var foo = arguments = 1;",
- "++eval;", "++arguments;",
- "eval++;", "arguments++;",
- NULL};
+ "var eval;",
+ "var arguments",
+ "var foo, eval;",
+ "var foo, arguments;",
+ "try { } catch (eval) { }",
+ "try { } catch (arguments) { }",
+ "function eval() { }",
+ "function arguments() { }",
+ "function foo(eval) { }",
+ "function foo(arguments) { }",
+ "function foo(bar, eval) { }",
+ "function foo(bar, arguments) { }",
+ "eval = 1;",
+ "arguments = 1;",
+ "var foo = eval = 1;",
+ "var foo = arguments = 1;",
+ "++eval;",
+ "++arguments;",
+ "eval++;",
+ "arguments++;",
+ NULL
+ };
RunParserSyncTest(context_data, statement_data, kError);
}
@@ -1589,10 +1600,10 @@ TEST(NoErrorsEvalAndArgumentsSloppy) {
TEST(NoErrorsEvalAndArgumentsStrict) {
const char* context_data[][2] = {
- {"\"use strict\";", ""},
- {"function test_func() { \"use strict\";", "}"},
- {"() => { \"use strict\"; ", "}"},
- {NULL, NULL}};
+ { "\"use strict\";", "" },
+ { "function test_func() { \"use strict\";", "}" },
+ { NULL, NULL }
+ };
const char* statement_data[] = {
"eval;",
@@ -1606,9 +1617,7 @@ TEST(NoErrorsEvalAndArgumentsStrict) {
NULL
};
- static const ParserFlag always_flags[] = {kAllowArrowFunctions};
- RunParserSyncTest(context_data, statement_data, kSuccess, NULL, 0,
- always_flags, ARRAY_SIZE(always_flags));
+ RunParserSyncTest(context_data, statement_data, kSuccess);
}
@@ -1618,10 +1627,10 @@ TEST(ErrorsFutureStrictReservedWords) {
// it's ok to use future strict reserved words as identifiers. With the strict
// mode, it isn't.
const char* context_data[][2] = {
- {"\"use strict\";", ""},
- {"function test_func() {\"use strict\"; ", "}"},
- {"() => { \"use strict\"; ", "}"},
- {NULL, NULL}};
+ { "\"use strict\";", "" },
+ { "function test_func() {\"use strict\"; ", "}"},
+ { NULL, NULL }
+ };
const char* statement_data[] = {
"var interface;",
@@ -1638,17 +1647,16 @@ TEST(ErrorsFutureStrictReservedWords) {
NULL
};
- static const ParserFlag always_flags[] = {kAllowArrowFunctions};
- RunParserSyncTest(context_data, statement_data, kError, NULL, 0, always_flags,
- ARRAY_SIZE(always_flags));
+ RunParserSyncTest(context_data, statement_data, kError);
}
TEST(NoErrorsFutureStrictReservedWords) {
- const char* context_data[][2] = {{"", ""},
- {"function test_func() {", "}"},
- {"() => {", "}"},
- {NULL, NULL}};
+ const char* context_data[][2] = {
+ { "", "" },
+ { "function test_func() {", "}"},
+ { NULL, NULL }
+ };
const char* statement_data[] = {
"var interface;",
@@ -1665,9 +1673,7 @@ TEST(NoErrorsFutureStrictReservedWords) {
NULL
};
- static const ParserFlag always_flags[] = {kAllowArrowFunctions};
- RunParserSyncTest(context_data, statement_data, kSuccess, NULL, 0,
- always_flags, ARRAY_SIZE(always_flags));
+ RunParserSyncTest(context_data, statement_data, kSuccess);
}
@@ -1676,22 +1682,27 @@ TEST(ErrorsReservedWords) {
// using future reserved words as identifiers. These tests don't depend on the
// strict mode.
const char* context_data[][2] = {
- {"", ""},
- {"\"use strict\";", ""},
- {"var eval; function test_func() {", "}"},
- {"var eval; function test_func() {\"use strict\"; ", "}"},
- {"var eval; () => {", "}"},
- {"var eval; () => {\"use strict\"; ", "}"},
- {NULL, NULL}};
+ { "", "" },
+ { "\"use strict\";", "" },
+ { "var eval; function test_func() {", "}"},
+ { "var eval; function test_func() {\"use strict\"; ", "}"},
+ { NULL, NULL }
+ };
const char* statement_data[] = {
- "var super;", "var foo, super;",
- "try { } catch (super) { }", "function super() { }",
- "function foo(super) { }", "function foo(bar, super) { }",
- "(super) => { }", "(bar, super) => { }",
- "super = 1;", "var foo = super = 1;",
- "++super;", "super++;",
- "function foo super", NULL};
+ "var super;",
+ "var foo, super;",
+ "try { } catch (super) { }",
+ "function super() { }",
+ "function foo(super) { }",
+ "function foo(bar, super) { }",
+ "super = 1;",
+ "var foo = super = 1;",
+ "++super;",
+ "super++;",
+ "function foo super",
+ NULL
+ };
RunParserSyncTest(context_data, statement_data, kError);
}
@@ -1727,9 +1738,7 @@ TEST(NoErrorsYieldSloppyAllModes) {
NULL
};
- static const ParserFlag always_flags[] = {kAllowArrowFunctions};
- RunParserSyncTest(context_data, statement_data, kSuccess, NULL, 0,
- always_flags, ARRAY_SIZE(always_flags));
+ RunParserSyncTest(context_data, statement_data, kSuccess);
}
@@ -1778,14 +1787,14 @@ TEST(NoErrorsYieldSloppyGeneratorsEnabled) {
TEST(ErrorsYieldStrict) {
const char* context_data[][2] = {
- {"\"use strict\";", ""},
- {"\"use strict\"; function not_gen() {", "}"},
- {"function test_func() {\"use strict\"; ", "}"},
- {"\"use strict\"; function * gen() { function not_gen() {", "} }"},
- {"\"use strict\"; (function not_gen() {", "})"},
- {"\"use strict\"; (function * gen() { (function not_gen() {", "}) })"},
- {"() => {\"use strict\"; ", "}"},
- {NULL, NULL}};
+ { "\"use strict\";", "" },
+ { "\"use strict\"; function not_gen() {", "}" },
+ { "function test_func() {\"use strict\"; ", "}"},
+ { "\"use strict\"; function * gen() { function not_gen() {", "} }" },
+ { "\"use strict\"; (function not_gen() {", "})" },
+ { "\"use strict\"; (function * gen() { (function not_gen() {", "}) })" },
+ { NULL, NULL }
+ };
const char* statement_data[] = {
"var yield;",
@@ -1991,10 +2000,11 @@ TEST(NoErrorsNameOfStrictGenerator) {
TEST(ErrorsIllegalWordsAsLabelsSloppy) {
// Using future reserved words as labels is always an error.
- const char* context_data[][2] = {{"", ""},
- {"function test_func() {", "}"},
- {"() => {", "}"},
- {NULL, NULL}};
+ const char* context_data[][2] = {
+ { "", ""},
+ { "function test_func() {", "}" },
+ { NULL, NULL }
+ };
const char* statement_data[] = {
"super: while(true) { break super; }",
@@ -2008,10 +2018,10 @@ TEST(ErrorsIllegalWordsAsLabelsSloppy) {
TEST(ErrorsIllegalWordsAsLabelsStrict) {
// Tests that illegal tokens as labels produce the correct errors.
const char* context_data[][2] = {
- {"\"use strict\";", ""},
- {"function test_func() {\"use strict\"; ", "}"},
- {"() => {\"use strict\"; ", "}"},
- {NULL, NULL}};
+ { "\"use strict\";", "" },
+ { "function test_func() {\"use strict\"; ", "}"},
+ { NULL, NULL }
+ };
const char* statement_data[] = {
"super: while(true) { break super; }",
@@ -2027,13 +2037,12 @@ TEST(ErrorsIllegalWordsAsLabelsStrict) {
TEST(NoErrorsIllegalWordsAsLabels) {
// Using eval and arguments as labels is legal even in strict mode.
const char* context_data[][2] = {
- {"", ""},
- {"function test_func() {", "}"},
- {"() => {", "}"},
- {"\"use strict\";", ""},
- {"\"use strict\"; function test_func() {", "}"},
- {"\"use strict\"; () => {", "}"},
- {NULL, NULL}};
+ { "", ""},
+ { "function test_func() {", "}" },
+ { "\"use strict\";", "" },
+ { "\"use strict\"; function test_func() {", "}" },
+ { NULL, NULL }
+ };
const char* statement_data[] = {
"mylabel: while(true) { break mylabel; }",
@@ -2042,18 +2051,17 @@ TEST(NoErrorsIllegalWordsAsLabels) {
NULL
};
- static const ParserFlag always_flags[] = {kAllowArrowFunctions};
- RunParserSyncTest(context_data, statement_data, kSuccess, NULL, 0,
- always_flags, ARRAY_SIZE(always_flags));
+ RunParserSyncTest(context_data, statement_data, kSuccess);
}
TEST(ErrorsParenthesizedLabels) {
// Parenthesized identifiers shouldn't be recognized as labels.
- const char* context_data[][2] = {{"", ""},
- {"function test_func() {", "}"},
- {"() => {", "}"},
- {NULL, NULL}};
+ const char* context_data[][2] = {
+ { "", ""},
+ { "function test_func() {", "}" },
+ { NULL, NULL }
+ };
const char* statement_data[] = {
"(mylabel): while(true) { break mylabel; }",
@@ -2894,107 +2902,3 @@ TEST(UseAsmUseCount) {
"function bar() { \"use asm\"; var baz = 1; }");
CHECK_EQ(2, use_counts[v8::Isolate::kUseAsm]);
}
-
-
-TEST(ErrorsArrowFunctions) {
- // Tests that parser and preparser generate the same kind of errors
- // on invalid arrow function syntax.
- const char* context_data[][2] = {{"", ";"},
- {"v = ", ";"},
- {"bar ? (", ") : baz;"},
- {"bar ? baz : (", ");"},
- {"bar[", "];"},
- {"bar, ", ";"},
- {"", ", bar;"},
- {NULL, NULL}};
-
- const char* statement_data[] = {
- "=> 0", "=>",
- "() =>", "=> {}",
- ") => {}", ", => {}",
- "(,) => {}", "return => {}",
- "() => {'value': 42}",
-
- // Check that the early return introduced in ParsePrimaryExpression
- // does not accept stray closing parentheses.
- ")", ") => 0",
- "foo[()]", "()",
-
- // Parameter lists with extra parens should be recognized as errors.
- "(()) => 0", "((x)) => 0",
- "((x, y)) => 0", "(x, (y)) => 0",
- "((x, y, z)) => 0", "(x, (y, z)) => 0",
- "((x, y), z) => 0",
-
- // Parameter lists are always validated as strict, so those are errors.
- "eval => {}", "arguments => {}",
- "yield => {}", "interface => {}",
- "(eval) => {}", "(arguments) => {}",
- "(yield) => {}", "(interface) => {}",
- "(eval, bar) => {}", "(bar, eval) => {}",
- "(bar, arguments) => {}", "(bar, yield) => {}",
- "(bar, interface) => {}",
- // TODO(aperez): Detecting duplicates does not work in PreParser.
- // "(bar, bar) => {}",
-
- // The parameter list is parsed as an expression, but only
- // a comma-separated list of identifier is valid.
- "32 => {}", "(32) => {}",
- "(a, 32) => {}", "if => {}",
- "(if) => {}", "(a, if) => {}",
- "a + b => {}", "(a + b) => {}",
- "(a + b, c) => {}", "(a, b - c) => {}",
- "\"a\" => {}", "(\"a\") => {}",
- "(\"a\", b) => {}", "(a, \"b\") => {}",
- "-a => {}", "(-a) => {}",
- "(-a, b) => {}", "(a, -b) => {}",
- "{} => {}", "({}) => {}",
- "(a, {}) => {}", "({}, a) => {}",
- "a++ => {}", "(a++) => {}",
- "(a++, b) => {}", "(a, b++) => {}",
- "[] => {}", "([]) => {}",
- "(a, []) => {}", "([], a) => {}",
- "(a = b) => {}", "(a = b, c) => {}",
- "(a, b = c) => {}", "(foo ? bar : baz) => {}",
- "(a, foo ? bar : baz) => {}", "(foo ? bar : baz, a) => {}",
- NULL};
-
- RunParserSyncTest(context_data, statement_data, kError);
-}
-
-
-TEST(NoErrorsArrowFunctions) {
- // Tests that parser and preparser accept valid arrow functions syntax.
- const char* context_data[][2] = {{"", ";"},
- {"bar ? (", ") : baz;"},
- {"bar ? baz : (", ");"},
- {"bar, ", ";"},
- {"", ", bar;"},
- {NULL, NULL}};
-
- const char* statement_data[] = {
- "() => {}", "() => { return 42 }",
- "x => { return x; }", "(x) => { return x; }",
- "(x, y) => { return x + y; }", "(x, y, z) => { return x + y + z; }",
- "(x, y) => { x.a = y; }", "() => 42",
- "x => x", "x => x * x",
- "(x) => x", "(x) => x * x",
- "(x, y) => x + y", "(x, y, z) => x, y, z",
- "(x, y) => x.a = y", "() => ({'value': 42})",
- "x => y => x + y", "(x, y) => (u, v) => x*u + y*v",
- "(x, y) => z => z * (x + y)", "x => (y, z) => z * (x + y)",
-
- // Those are comma-separated expressions, with arrow functions as items.
- // They stress the code for validating arrow function parameter lists.
- "a, b => 0", "a, b, (c, d) => 0",
- "(a, b, (c, d) => 0)", "(a, b) => 0, (c, d) => 1",
- "(a, b => {}, a => a + 1)", "((a, b) => {}, (a => a + 1))",
- "(a, (a, (b, c) => 0))",
-
- // Arrow has more precedence, this is the same as: foo ? bar : (baz = {})
- "foo ? bar : baz => {}", NULL};
-
- static const ParserFlag always_flags[] = {kAllowArrowFunctions};
- RunParserSyncTest(context_data, statement_data, kSuccess, NULL, 0,
- always_flags, ARRAY_SIZE(always_flags));
-}
« no previous file with comments | « src/token.h ('k') | no next file » | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698