OLD | NEW |
---|---|
1 // Copyright 2012 the V8 project authors. All rights reserved. | 1 // Copyright 2012 the V8 project authors. All rights reserved. |
2 // Redistribution and use in source and binary forms, with or without | 2 // Redistribution and use in source and binary forms, with or without |
3 // modification, are permitted provided that the following conditions are | 3 // modification, are permitted provided that the following conditions are |
4 // met: | 4 // met: |
5 // | 5 // |
6 // * Redistributions of source code must retain the above copyright | 6 // * Redistributions of source code must retain the above copyright |
7 // notice, this list of conditions and the following disclaimer. | 7 // notice, this list of conditions and the following disclaimer. |
8 // * Redistributions in binary form must reproduce the above | 8 // * Redistributions in binary form must reproduce the above |
9 // copyright notice, this list of conditions and the following | 9 // copyright notice, this list of conditions and the following |
10 // disclaimer in the documentation and/or other materials provided | 10 // disclaimer in the documentation and/or other materials provided |
(...skipping 1490 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
1501 data.Dispose(); | 1501 data.Dispose(); |
1502 return i::MessageTemplate::FormatMessage(isolate, message, arg_object); | 1502 return i::MessageTemplate::FormatMessage(isolate, message, arg_object); |
1503 } | 1503 } |
1504 | 1504 |
1505 enum ParserFlag { | 1505 enum ParserFlag { |
1506 kAllowLazy, | 1506 kAllowLazy, |
1507 kAllowNatives, | 1507 kAllowNatives, |
1508 kAllowHarmonyFunctionSent, | 1508 kAllowHarmonyFunctionSent, |
1509 kAllowHarmonyRestrictiveDeclarations, | 1509 kAllowHarmonyRestrictiveDeclarations, |
1510 kAllowHarmonyExponentiationOperator, | 1510 kAllowHarmonyExponentiationOperator, |
1511 kAllowHarmonyForIn | 1511 kAllowHarmonyForIn, |
1512 kAllowHarmonyAsyncAwait | |
1512 }; | 1513 }; |
1513 | 1514 |
1514 enum ParserSyncTestResult { | 1515 enum ParserSyncTestResult { |
1515 kSuccessOrError, | 1516 kSuccessOrError, |
1516 kSuccess, | 1517 kSuccess, |
1517 kError | 1518 kError |
1518 }; | 1519 }; |
1519 | 1520 |
1520 template <typename Traits> | 1521 template <typename Traits> |
1521 void SetParserFlags(i::ParserBase<Traits>* parser, | 1522 void SetParserFlags(i::ParserBase<Traits>* parser, |
1522 i::EnumSet<ParserFlag> flags) { | 1523 i::EnumSet<ParserFlag> flags) { |
1523 parser->set_allow_lazy(flags.Contains(kAllowLazy)); | 1524 parser->set_allow_lazy(flags.Contains(kAllowLazy)); |
1524 parser->set_allow_natives(flags.Contains(kAllowNatives)); | 1525 parser->set_allow_natives(flags.Contains(kAllowNatives)); |
1525 parser->set_allow_harmony_function_sent( | 1526 parser->set_allow_harmony_function_sent( |
1526 flags.Contains(kAllowHarmonyFunctionSent)); | 1527 flags.Contains(kAllowHarmonyFunctionSent)); |
1527 parser->set_allow_harmony_restrictive_declarations( | 1528 parser->set_allow_harmony_restrictive_declarations( |
1528 flags.Contains(kAllowHarmonyRestrictiveDeclarations)); | 1529 flags.Contains(kAllowHarmonyRestrictiveDeclarations)); |
1529 parser->set_allow_harmony_exponentiation_operator( | 1530 parser->set_allow_harmony_exponentiation_operator( |
1530 flags.Contains(kAllowHarmonyExponentiationOperator)); | 1531 flags.Contains(kAllowHarmonyExponentiationOperator)); |
1531 parser->set_allow_harmony_for_in(flags.Contains(kAllowHarmonyForIn)); | 1532 parser->set_allow_harmony_for_in(flags.Contains(kAllowHarmonyForIn)); |
1533 parser->set_allow_harmony_async_await( | |
1534 flags.Contains(kAllowHarmonyAsyncAwait)); | |
1532 } | 1535 } |
1533 | 1536 |
1534 | 1537 |
1535 void TestParserSyncWithFlags(i::Handle<i::String> source, | 1538 void TestParserSyncWithFlags(i::Handle<i::String> source, |
1536 i::EnumSet<ParserFlag> flags, | 1539 i::EnumSet<ParserFlag> flags, |
1537 ParserSyncTestResult result, | 1540 ParserSyncTestResult result, |
1538 bool is_module = false, | 1541 bool is_module = false, |
1539 bool test_preparser = true) { | 1542 bool test_preparser = true) { |
1540 i::Isolate* isolate = CcTest::i_isolate(); | 1543 i::Isolate* isolate = CcTest::i_isolate(); |
1541 i::Factory* factory = isolate->factory(); | 1544 i::Factory* factory = isolate->factory(); |
(...skipping 5896 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
7438 NULL | 7441 NULL |
7439 }; | 7442 }; |
7440 // clang-format on | 7443 // clang-format on |
7441 | 7444 |
7442 static const ParserFlag always_flags[] = { | 7445 static const ParserFlag always_flags[] = { |
7443 kAllowHarmonyExponentiationOperator}; | 7446 kAllowHarmonyExponentiationOperator}; |
7444 RunParserSyncTest(context_data, error_data, kError, NULL, 0, always_flags, | 7447 RunParserSyncTest(context_data, error_data, kError, NULL, 0, always_flags, |
7445 arraysize(always_flags)); | 7448 arraysize(always_flags)); |
7446 } | 7449 } |
7447 | 7450 |
7451 TEST(AsyncAwait) { | |
7452 // clang-format off | |
7453 const char* context_data[][2] = { | |
7454 { "'use strict';", "" }, | |
7455 { "", "" }, | |
7456 { NULL, NULL } | |
7457 }; | |
7458 | |
7459 const char* data[] = { | |
7460 "var asyncFn = async function() { await 1; };", | |
7461 "var asyncFn = async function withName() { await 1; };", | |
7462 "var asyncFn = async () => await 'test';", | |
7463 "var asyncFn = async x => await x + 'test';", | |
7464 "async function asyncFn() { await 1; }", | |
7465 "var O = { async method() { await 1; } }", | |
7466 "var O = { async ['meth' + 'od']() { await 1; } }", | |
7467 "var O = { async 'method'() { await 1; } }", | |
7468 "var O = { async 0() { await 1; } }", | |
7469 "async function await() {}", | |
7470 NULL | |
7471 }; | |
7472 // clang-format on | |
7473 | |
7474 static const ParserFlag always_flags[] = {kAllowHarmonyAsyncAwait}; | |
7475 RunParserSyncTest(context_data, data, kSuccess, NULL, 0, always_flags, | |
7476 arraysize(always_flags)); | |
7477 | |
7478 // clang-format off | |
7479 const char* async_body_context_data[][2] = { | |
7480 { "async function f() {", "}" }, | |
7481 { "var f = async function() {", "}" }, | |
7482 { "var f = async() => {", "}" }, | |
7483 { "var O = { async method() {", "} }" }, | |
7484 { "'use strict'; async function f() {", "}" }, | |
7485 { "'use strict'; var f = async function() {", "}" }, | |
7486 { "'use strict'; var f = async() => {", "}" }, | |
7487 { "'use strict'; var O = { async method() {", "} }" }, | |
7488 { NULL, NULL } | |
7489 }; | |
7490 | |
7491 const char* body_context_data[][2] = { | |
7492 { "function f() {", "}" }, | |
7493 { "function* g() {", "}" }, | |
7494 { "var f = function() {", "}" }, | |
7495 { "var g = function*() {", "}" }, | |
7496 { "var O = { method() {", "} }" }, | |
7497 { "var O = { *method() {", "} }" }, | |
7498 { "var f = () => {", "}" }, | |
7499 { "'use strict'; function f() {", "}" }, | |
7500 { "'use strict'; function* g() {", "}" }, | |
7501 { "'use strict'; var f = function() {", "}" }, | |
7502 { "'use strict'; var g = function*() {", "}" }, | |
7503 { "'use strict'; var O = { method() {", "} }" }, | |
7504 { "'use strict'; var O = { *method() {", "} }" }, | |
7505 { "'use strict'; var f = () => {", "}" }, | |
7506 { NULL, NULL } | |
7507 }; | |
7508 | |
7509 const char* body_data[] = { | |
7510 "var async = 1; return async;", | |
7511 "let async = 1; return async;", | |
7512 "const async = 1; return async;", | |
7513 "function async() {} return async();", | |
7514 "var async = async => async; return async();", | |
7515 "function foo() { var await = 1; return await; }", | |
7516 "function foo(await) { return await; }", | |
7517 "function* foo() { var await = 1; return await; }", | |
7518 "function* foo(await) { return await; }", | |
7519 "var f = (await) => await;", | |
7520 "var f = () => { var await = 1; return await; }", | |
7521 "var O = { method() { var await = 1; return await; } };", | |
7522 "var O = { method(await) { return await; } };", | |
7523 "var O = { *method() { var await = 1; return await; } };", | |
7524 "var O = { *method(await) { return await; } };", | |
7525 NULL | |
7526 }; | |
7527 // clang-format on | |
7528 | |
7529 RunParserSyncTest(async_body_context_data, body_data, kSuccess, NULL, 0, | |
7530 always_flags, arraysize(always_flags)); | |
7531 RunParserSyncTest(body_context_data, body_data, kSuccess, NULL, 0, | |
7532 always_flags, arraysize(always_flags)); | |
7533 } | |
7534 | |
7535 TEST(AsyncAwaitErrors) { | |
7536 // clang-format off | |
7537 const char* context_data[][2] = { | |
7538 { "'use strict';", "" }, | |
7539 { "", "" }, | |
7540 { NULL, NULL } | |
7541 }; | |
7542 | |
7543 const char* strict_context_data[][2] = { | |
7544 { "'use strict';", "" }, | |
7545 { NULL, NULL } | |
7546 }; | |
7547 | |
7548 const char* error_data[] = { | |
7549 "var asyncFn = async function() { var await = 1; };", | |
7550 "var asyncFn = async function() { var { await } = 1; };", | |
7551 "var asyncFn = async function() { var [ await ] = 1; };", | |
7552 "var asyncFn = async function await() {};", | |
7553 "var asyncFn = async () => var await = 'test';", | |
7554 "var asyncFn = async await => await + 'test';", | |
7555 "var asyncFn = async function(await) {};", | |
7556 "var asyncFn = async function() { return async (await) => {}; }", | |
7557 "var asyncFn = async (await) => 'test';", | |
7558 "var asyncFn = async x => { var await = 1; }", | |
7559 "var asyncFn = async x => { var { await } = 1; }", | |
7560 "var asyncFn = async x => { var [ await ] = 1; }", | |
7561 "async function f(await) {}", | |
7562 "async function f() { var await = 1; }", | |
7563 "async function f() { var { await } = 1; }", | |
7564 "async function f() { var [ await ] = 1; }", | |
7565 | |
7566 "var O = { async method(a, a) {} }", | |
7567 "var O = { async ['meth' + 'od'](a, a) {} }", | |
7568 "var O = { async 'method'(a, a) {} }", | |
7569 "var O = { async 0(a, a) {} }", | |
7570 | |
7571 "async function f() { var O = { async [await](a, a) {} } }", | |
7572 | |
7573 "var asyncFn = async function() { await; }", | |
7574 "async function f() { await; }", | |
7575 "var O = { async method() { await; } };", | |
7576 "var f = async() => await;", | |
7577 "var f = async() => { await; };", | |
7578 | |
7579 "var asyncFn = async function*() {}", | |
7580 "async function* f() {}", | |
7581 "var O = { *async method() {} };", | |
7582 "var O = { async *method() {} };", | |
7583 "var O = { async method*() {} };", | |
7584 | |
7585 "var asyncFn = async function(x = await 1) { return x; }", | |
7586 "async function f(x = await 1) { return x; }", | |
7587 "var f = async(x = await 1) => x;", | |
7588 "var O = { async method(x = await 1) { return x; } };", | |
7589 NULL | |
7590 }; | |
7591 | |
7592 const char* strict_error_data[] = { | |
7593 "var O = { async method(eval) {} }", | |
7594 "var O = { async ['meth' + 'od'](eval) {} }", | |
7595 "var O = { async 'method'(eval) {} }", | |
7596 "var O = { async 0(eval) {} }", | |
7597 | |
7598 "var O = { async method(arguments) {} }", | |
7599 "var O = { async ['meth' + 'od'](arguments) {} }", | |
7600 "var O = { async 'method'(arguments) {} }", | |
7601 "var O = { async 0(arguments) {} }", | |
7602 | |
7603 // TODO(caitp): preparser needs to report duplicadte parameter errors. | |
7604 // "var O = { async method(dupe, dupe) {} }", | |
Dan Ehrenberg
2016/05/06 00:08:56
If these work, then probably good to uncomment the
| |
7605 // "var f = async(dupe, dupe) => {}", | |
Dan Ehrenberg
2016/05/06 00:08:56
I'm fine with the arrow functions not enforcing th
| |
7606 NULL | |
7607 }; | |
7608 // clang-format on | |
7609 | |
7610 static const ParserFlag always_flags[] = {kAllowHarmonyAsyncAwait}; | |
7611 RunParserSyncTest(context_data, error_data, kError, NULL, 0, always_flags, | |
7612 arraysize(always_flags)); | |
7613 RunParserSyncTest(strict_context_data, strict_error_data, kError, NULL, 0, | |
7614 always_flags, arraysize(always_flags)); | |
7615 } | |
7616 | |
7448 TEST(RestrictiveForInErrors) { | 7617 TEST(RestrictiveForInErrors) { |
7449 // clang-format off | 7618 // clang-format off |
7450 const char* context_data[][2] = { | 7619 const char* context_data[][2] = { |
7451 { "'use strict'", "" }, | 7620 { "'use strict'", "" }, |
7452 { "", "" }, | 7621 { "", "" }, |
7453 { NULL, NULL } | 7622 { NULL, NULL } |
7454 }; | 7623 }; |
7455 const char* error_data[] = { | 7624 const char* error_data[] = { |
7456 "for (var x = 0 in {});", | 7625 "for (var x = 0 in {});", |
7457 "for (const x = 0 in {});", | 7626 "for (const x = 0 in {});", |
7458 "for (let x = 0 in {});", | 7627 "for (let x = 0 in {});", |
7459 NULL | 7628 NULL |
7460 }; | 7629 }; |
7461 // clang-format on | 7630 // clang-format on |
7462 | 7631 |
7463 static const ParserFlag always_flags[] = {kAllowHarmonyForIn}; | 7632 static const ParserFlag always_flags[] = {kAllowHarmonyForIn}; |
7464 RunParserSyncTest(context_data, error_data, kError, nullptr, 0, always_flags, | 7633 RunParserSyncTest(context_data, error_data, kError, nullptr, 0, always_flags, |
7465 arraysize(always_flags)); | 7634 arraysize(always_flags)); |
7466 } | 7635 } |
OLD | NEW |