Revision: 25087
Author: [email protected]
Date: Mon Nov 3 19:53:36 2014 UTC
Log: Classes: static should still be treated as a strict reserved word
When --harmony-classes is enabled we did not treat static as a
strict reserved word.
BUG=v8:3642
LOG=Y
[email protected]
Review URL: https://codereview.chromium.org/652743009
https://code.google.com/p/v8/source/detail?r=25087
Modified:
/branches/bleeding_edge/src/parser.h
/branches/bleeding_edge/src/preparser.cc
/branches/bleeding_edge/src/preparser.h
/branches/bleeding_edge/src/scanner.cc
/branches/bleeding_edge/test/cctest/test-parsing.cc
=======================================
--- /branches/bleeding_edge/src/parser.h Thu Oct 9 10:40:18 2014 UTC
+++ /branches/bleeding_edge/src/parser.h Mon Nov 3 19:53:36 2014 UTC
@@ -853,8 +853,7 @@
bool ParserTraits::IsFutureStrictReserved(
const AstRawString* identifier) const {
- return identifier->IsOneByteEqualTo("yield") ||
- parser_->scanner()->IdentifierIsFutureStrictReserved(identifier);
+ return parser_->scanner()->IdentifierIsFutureStrictReserved(identifier);
}
=======================================
--- /branches/bleeding_edge/src/preparser.cc Fri Oct 24 15:02:29 2014 UTC
+++ /branches/bleeding_edge/src/preparser.cc Mon Nov 3 19:53:36 2014 UTC
@@ -50,6 +50,8 @@
return PreParserIdentifier::FutureStrictReserved();
} else if (scanner->current_token() == Token::LET) {
return PreParserIdentifier::Let();
+ } else if (scanner->current_token() == Token::STATIC) {
+ return PreParserIdentifier::Static();
} else if (scanner->current_token() == Token::YIELD) {
return PreParserIdentifier::Yield();
}
@@ -491,8 +493,7 @@
// identifier.
DCHECK(!expr.AsIdentifier().IsFutureReserved());
DCHECK(strict_mode() == SLOPPY ||
- (!expr.AsIdentifier().IsFutureStrictReserved() &&
- !expr.AsIdentifier().IsYield()));
+ !IsFutureStrictReserved(expr.AsIdentifier()));
Consume(Token::COLON);
return ParseStatement(ok);
// Preparsing is disabled for extensions (because the extension details
=======================================
--- /branches/bleeding_edge/src/preparser.h Fri Oct 31 13:03:15 2014 UTC
+++ /branches/bleeding_edge/src/preparser.h Mon Nov 3 19:53:36 2014 UTC
@@ -336,11 +336,9 @@
bool peek_any_identifier() {
Token::Value next = peek();
- return next == Token::IDENTIFIER ||
- next == Token::FUTURE_RESERVED_WORD ||
- next == Token::FUTURE_STRICT_RESERVED_WORD ||
- next == Token::LET ||
- next == Token::YIELD;
+ return next == Token::IDENTIFIER || next ==
Token::FUTURE_RESERVED_WORD ||
+ next == Token::FUTURE_STRICT_RESERVED_WORD || next ==
Token::LET ||
+ next == Token::STATIC || next == Token::YIELD;
}
bool CheckContextualKeyword(Vector<const char> keyword) {
@@ -606,6 +604,9 @@
static PreParserIdentifier Let() {
return PreParserIdentifier(kLetIdentifier);
}
+ static PreParserIdentifier Static() {
+ return PreParserIdentifier(kStaticIdentifier);
+ }
static PreParserIdentifier Yield() {
return PreParserIdentifier(kYieldIdentifier);
}
@@ -619,6 +620,8 @@
bool IsArguments(const AstValueFactory* = NULL) const {
return type_ == kArgumentsIdentifier;
}
+ bool IsLet() const { return type_ == kLetIdentifier; }
+ bool IsStatic() const { return type_ == kStaticIdentifier; }
bool IsYield() const { return type_ == kYieldIdentifier; }
bool IsPrototype() const { return type_ == kPrototypeIdentifier; }
bool IsConstructor() const { return type_ == kConstructorIdentifier; }
@@ -627,14 +630,15 @@
}
bool IsFutureReserved() const { return type_ ==
kFutureReservedIdentifier; }
bool IsFutureStrictReserved() const {
- return type_ == kFutureStrictReservedIdentifier;
+ return type_ == kFutureStrictReservedIdentifier ||
+ type_ == kLetIdentifier || type_ == kStaticIdentifier ||
+ type_ == kYieldIdentifier;
}
bool IsValidStrictVariable() const { return type_ == kUnknownIdentifier;
}
V8_INLINE bool IsValidArrowParam() const {
// A valid identifier can be an arrow function parameter
// except for eval, arguments, yield, and reserved keywords.
- return !(IsEval() || IsArguments() || IsYield() ||
- IsFutureStrictReserved());
+ return !(IsEval() || IsArguments() || IsFutureStrictReserved());
}
// Allow identifier->name()[->length()] to work. The preparser
@@ -651,6 +655,7 @@
kFutureReservedIdentifier,
kFutureStrictReservedIdentifier,
kLetIdentifier,
+ kStaticIdentifier,
kYieldIdentifier,
kEvalIdentifier,
kArgumentsIdentifier,
@@ -1172,7 +1177,7 @@
}
static bool IsFutureStrictReserved(PreParserIdentifier identifier) {
- return identifier.IsYield() || identifier.IsFutureStrictReserved();
+ return identifier.IsFutureStrictReserved();
}
static bool IsBoilerplateProperty(PreParserExpression property) {
@@ -1593,6 +1598,7 @@
case Token::FUTURE_RESERVED_WORD:
return ReportMessageAt(source_location, "unexpected_reserved");
case Token::LET:
+ case Token::STATIC:
case Token::YIELD:
case Token::FUTURE_STRICT_RESERVED_WORD:
return ReportMessageAt(source_location, strict_mode() == SLOPPY
@@ -1622,8 +1628,8 @@
return name;
} else if (strict_mode() == SLOPPY &&
(next == Token::FUTURE_STRICT_RESERVED_WORD ||
- (next == Token::LET) ||
- (next == Token::YIELD && !is_generator()))) {
+ next == Token::LET || next == Token::STATIC ||
+ (next == Token::YIELD && !is_generator()))) {
return this->GetSymbol(scanner());
} else {
this->ReportUnexpectedToken(next);
@@ -1640,8 +1646,8 @@
Token::Value next = Next();
if (next == Token::IDENTIFIER) {
*is_strict_reserved = false;
- } else if (next == Token::FUTURE_STRICT_RESERVED_WORD ||
- next == Token::LET ||
+ } else if (next == Token::FUTURE_STRICT_RESERVED_WORD || next ==
Token::LET ||
+ next == Token::STATIC ||
(next == Token::YIELD && !this->is_generator())) {
*is_strict_reserved = true;
} else {
@@ -1662,7 +1668,7 @@
ParserBase<Traits>::ParseIdentifierName(bool* ok) {
Token::Value next = Next();
if (next != Token::IDENTIFIER && next != Token::FUTURE_RESERVED_WORD &&
- next != Token::LET && next != Token::YIELD &&
+ next != Token::LET && next != Token::STATIC && next != Token::YIELD
&&
next != Token::FUTURE_STRICT_RESERVED_WORD
&& !Token::IsKeyword(next)) {
this->ReportUnexpectedToken(next);
*ok = false;
@@ -1765,6 +1771,7 @@
case Token::IDENTIFIER:
case Token::LET:
+ case Token::STATIC:
case Token::YIELD:
case Token::FUTURE_STRICT_RESERVED_WORD: {
// Using eval or arguments in this context is OK even in strict mode.
=======================================
--- /branches/bleeding_edge/src/scanner.cc Fri Oct 31 13:03:15 2014 UTC
+++ /branches/bleeding_edge/src/scanner.cc Mon Nov 3 19:53:36 2014 UTC
@@ -1006,11 +1006,15 @@
bool Scanner::IdentifierIsFutureStrictReserved(
const AstRawString* string) const {
// Keywords are always 1-byte strings.
- return string->is_one_byte() &&
- Token::FUTURE_STRICT_RESERVED_WORD ==
- KeywordOrIdentifierToken(string->raw_data(), string->length(),
- harmony_scoping_, harmony_modules_,
- harmony_classes_);
+ if (!string->is_one_byte()) return false;
+ if (string->IsOneByteEqualTo("let") ||
string->IsOneByteEqualTo("static") ||
+ string->IsOneByteEqualTo("yield")) {
+ return true;
+ }
+ return Token::FUTURE_STRICT_RESERVED_WORD ==
+ KeywordOrIdentifierToken(string->raw_data(), string->length(),
+ harmony_scoping_, harmony_modules_,
+ harmony_classes_);
}
=======================================
--- /branches/bleeding_edge/test/cctest/test-parsing.cc Fri Oct 31 13:03:15
2014 UTC
+++ /branches/bleeding_edge/test/cctest/test-parsing.cc Mon Nov 3 19:53:36
2014 UTC
@@ -1812,6 +1812,33 @@
RunParserSyncTest(context_data, statement_data, kSuccess, NULL, 0,
always_flags, arraysize(always_flags));
}
+
+
+#define FUTURE_STRICT_RESERVED_WORDS(V) \
+ V(implements) \
+ V(interface) \
+ V(let) \
+ V(package) \
+ V(private) \
+ V(protected) \
+ V(public) \
+ V(static) \
+ V(yield)
+
+
+#define FUTURE_STRICT_RESERVED_STATEMENTS(NAME) \
+ "var " #NAME ";", \
+ "var foo, " #NAME ";", \
+ "try { } catch (" #NAME ") { }", \
+ "function " #NAME "() { }", \
+ "(function " #NAME "() { })", \
+ "function foo(" #NAME ") { }", \
+ "function foo(bar, " #NAME ") { }", \
+ #NAME " = 1;", \
+ #NAME " += 1;", \
+ "var foo = " #NAME " = 1;", \
+ "++" #NAME ";", \
+ #NAME " ++;",
TEST(ErrorsFutureStrictReservedWords) {
@@ -1826,24 +1853,19 @@
{ NULL, NULL }
};
- const char* statement_data[] = {
- "var interface;",
- "var foo, interface;",
- "try { } catch (interface) { }",
- "function interface() { }",
- "function foo(interface) { }",
- "function foo(bar, interface) { }",
- "interface = 1;",
- "var foo = interface = 1;",
- "++interface;",
- "interface++;",
- "var yield = 13;",
+ const char* statement_data[] {
+ FUTURE_STRICT_RESERVED_WORDS(FUTURE_STRICT_RESERVED_STATEMENTS)
NULL
};
static const ParserFlag always_flags[] = {kAllowArrowFunctions};
RunParserSyncTest(context_data, statement_data, kError, NULL, 0,
always_flags,
arraysize(always_flags));
+
+ static const ParserFlag classes_flags[] = {
+ kAllowArrowFunctions, kAllowClasses, kAllowHarmonyScoping};
+ RunParserSyncTest(context_data, statement_data, kError, NULL, 0,
+ classes_flags, arraysize(classes_flags));
}
@@ -1856,23 +1878,18 @@
};
const char* statement_data[] = {
- "var interface;",
- "var foo, interface;",
- "try { } catch (interface) { }",
- "function interface() { }",
- "function foo(interface) { }",
- "function foo(bar, interface) { }",
- "interface = 1;",
- "var foo = interface = 1;",
- "++interface;",
- "interface++;",
- "var yield = 13;",
+ FUTURE_STRICT_RESERVED_WORDS(FUTURE_STRICT_RESERVED_STATEMENTS)
NULL
};
static const ParserFlag always_flags[] = {kAllowArrowFunctions};
RunParserSyncTest(context_data, statement_data, kSuccess, NULL, 0,
always_flags, arraysize(always_flags));
+
+ static const ParserFlag classes_flags[] = {
+ kAllowArrowFunctions, kAllowClasses, kAllowHarmonyScoping};
+ RunParserSyncTest(context_data, statement_data, kSuccess, NULL, 0,
+ classes_flags, arraysize(classes_flags));
}
@@ -2252,12 +2269,13 @@
{ NULL, NULL }
};
+#define LABELLED_WHILE(NAME) #NAME ": while (true) { break " #NAME "; }",
const char* statement_data[] = {
"super: while(true) { break super; }",
- "interface: while(true) { break interface; }",
- "yield: while(true) { break yield; }",
+ FUTURE_STRICT_RESERVED_WORDS(LABELLED_WHILE)
NULL
};
+#undef LABELLED_WHILE
RunParserSyncTest(context_data, statement_data, kError);
}
@@ -2281,6 +2299,27 @@
"arguments: while(true) { break arguments; }",
NULL
};
+
+ static const ParserFlag always_flags[] = {kAllowArrowFunctions};
+ RunParserSyncTest(context_data, statement_data, kSuccess, NULL, 0,
+ always_flags, arraysize(always_flags));
+}
+
+
+TEST(NoErrorsFutureStrictReservedAsLabelsSloppy) {
+ const char* context_data[][2] = {
+ { "", ""},
+ { "function test_func() {", "}" },
+ { "() => {", "}" },
+ { NULL, NULL }
+ };
+
+#define LABELLED_WHILE(NAME) #NAME ": while (true) { break " #NAME "; }",
+ const char* statement_data[] {
+ FUTURE_STRICT_RESERVED_WORDS(LABELLED_WHILE)
+ NULL
+ };
+#undef LABELLED_WHILE
static const ParserFlag always_flags[] = {kAllowArrowFunctions};
RunParserSyncTest(context_data, statement_data, kSuccess, NULL, 0,
--
--
v8-dev mailing list
[email protected]
http://groups.google.com/group/v8-dev
---
You received this message because you are subscribed to the Google Groups "v8-dev" group.
To unsubscribe from this group and stop receiving emails from it, send an email
to [email protected].
For more options, visit https://groups.google.com/d/optout.
