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

Issues Search
    My Issues | Starred     Open | Closed | All

Unified Diff: src/parsing/parser-base.h

Issue 2295743003: Revert of Refactor object/class literal property name parsing (Closed)
Patch Set: Created 4 years, 4 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/parsing/parser.cc ('k') | src/parsing/preparser.cc » ('j') | no next file with comments »
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
Index: src/parsing/parser-base.h
diff --git a/src/parsing/parser-base.h b/src/parsing/parser-base.h
index 228f886d63733f2da34d93cfddc5d8e1b6c121a1..5b06e52a95948da3a64266050e466234081cbc18 100644
--- a/src/parsing/parser-base.h
+++ b/src/parsing/parser-base.h
@@ -1074,24 +1074,13 @@
ExpressionT ParseExpression(bool accept_IN, ExpressionClassifier* classifier,
bool* ok);
ExpressionT ParseArrayLiteral(ExpressionClassifier* classifier, bool* ok);
-
- enum class PropertyKind {
- kAccessorProperty,
- kValueProperty,
- kShorthandProperty,
- kMethodProperty
- };
-
- bool SetPropertyKindFromToken(Token::Value token, PropertyKind* kind);
- ExpressionT ParsePropertyName(IdentifierT* name, PropertyKind* kind,
- bool in_class, bool* is_generator, bool* is_get,
- bool* is_set, bool* is_async, bool* is_static,
+ ExpressionT ParsePropertyName(IdentifierT* name, bool* is_get, bool* is_set,
bool* is_computed_name,
ExpressionClassifier* classifier, bool* ok);
ExpressionT ParseObjectLiteral(ExpressionClassifier* classifier, bool* ok);
ObjectLiteralPropertyT ParsePropertyDefinition(
ObjectLiteralCheckerBase* checker, bool in_class, bool has_extends,
- bool* is_computed_name, bool* has_seen_constructor,
+ MethodKind kind, bool* is_computed_name, bool* has_seen_constructor,
ExpressionClassifier* classifier, IdentifierT* name, bool* ok);
typename Types::ExpressionList ParseArguments(
Scanner::Location* first_spread_pos, bool maybe_arrow,
@@ -1189,6 +1178,13 @@
}
return Call::NOT_EVAL;
}
+
+ // Used to validate property names in object literals and class literals
+ enum PropertyKind {
+ kAccessorProperty,
+ kValueProperty,
+ kMethodProperty
+ };
class ObjectLiteralCheckerBase {
public:
@@ -1866,85 +1862,11 @@
}
template <class Impl>
-bool ParserBase<Impl>::SetPropertyKindFromToken(Token::Value token,
- PropertyKind* kind) {
- switch (token) {
- case Token::COLON:
- *kind = PropertyKind::kValueProperty;
- return true;
- case Token::COMMA:
- case Token::RBRACE:
- case Token::ASSIGN:
- *kind = PropertyKind::kShorthandProperty;
- return true;
- case Token::LPAREN:
- *kind = PropertyKind::kMethodProperty;
- return true;
- default:
- break;
- }
- return false;
-}
-
-template <class Impl>
typename ParserBase<Impl>::ExpressionT ParserBase<Impl>::ParsePropertyName(
- IdentifierT* name, PropertyKind* kind, bool in_class, bool* is_generator,
- bool* is_get, bool* is_set, bool* is_async, bool* is_static,
- bool* is_computed_name, ExpressionClassifier* classifier, bool* ok) {
- *is_generator = Check(Token::MUL);
-
+ IdentifierT* name, bool* is_get, bool* is_set, bool* is_computed_name,
+ ExpressionClassifier* classifier, bool* ok) {
Token::Value token = peek();
int pos = peek_position();
-
- if (in_class && !*is_generator && token == Token::STATIC) {
- Consume(Token::STATIC);
- *kind = PropertyKind::kMethodProperty;
- if (peek() == Token::LPAREN) {
- *name = impl()->GetSymbol(); // TODO(bakkot) specialize on 'static'
- return factory()->NewStringLiteral(*name, pos);
- }
- *is_generator = Check(Token::MUL);
- *is_static = true;
- token = peek();
- pos = peek_position();
- }
-
- if (allow_harmony_async_await() && !*is_generator && token == Token::ASYNC &&
- !scanner()->HasAnyLineTerminatorAfterNext()) {
- Consume(Token::ASYNC);
- token = peek();
- if (SetPropertyKindFromToken(token, kind)) {
- *name = impl()->GetSymbol(); // TODO(bakkot) specialize on 'async'
- if (fni_ != nullptr) {
- impl()->PushLiteralName(fni_, *name);
- }
- return factory()->NewStringLiteral(*name, pos);
- }
- *kind = PropertyKind::kMethodProperty;
- *is_async = true;
- pos = peek_position();
- }
-
- if (token == Token::IDENTIFIER && !*is_generator && !*is_async) {
- Consume(Token::IDENTIFIER);
- token = peek();
- if (SetPropertyKindFromToken(token, kind)) {
- *name = impl()->GetSymbol();
- if (fni_ != nullptr) {
- impl()->PushLiteralName(fni_, *name);
- }
- return factory()->NewStringLiteral(*name, pos);
- }
- scanner()->IsGetOrSet(is_get, is_set);
- if (!*is_get && !*is_set) { // TODO(bakkot) have IsGetOrSet return a bool
- Token::Value next = Next();
- ReportUnexpectedToken(next);
- *ok = false;
- return impl()->EmptyExpression();
- }
- *kind = PropertyKind::kAccessorProperty;
- pos = peek_position();
- }
// For non computed property names we normalize the name a bit:
//
@@ -1955,7 +1877,6 @@
//
// This is important because we use the property name as a key in a hash
// table when we compute constant properties.
- ExpressionT expression;
switch (token) {
case Token::STRING:
Consume(Token::STRING);
@@ -1973,42 +1894,22 @@
break;
case Token::LBRACK: {
- *name = impl()->EmptyIdentifier();
*is_computed_name = true;
Consume(Token::LBRACK);
ExpressionClassifier computed_name_classifier(this);
- expression =
+ ExpressionT expression =
ParseAssignmentExpression(true, &computed_name_classifier, CHECK_OK);
impl()->RewriteNonPattern(&computed_name_classifier, CHECK_OK);
classifier->AccumulateFormalParameterContainmentErrors(
&computed_name_classifier);
Expect(Token::RBRACK, CHECK_OK);
- break;
+ return expression;
}
default:
*name = ParseIdentifierName(CHECK_OK);
+ scanner()->IsGetOrSet(is_get, is_set);
break;
- }
-
- if (*kind == PropertyKind::kValueProperty) {
- if (!SetPropertyKindFromToken(peek(), kind) ||
- (*kind == PropertyKind::kShorthandProperty &&
- !Token::IsIdentifier(token, language_mode(), this->is_generator(),
- parsing_module_ || is_async_function()))) {
- Token::Value next = Next();
- ReportUnexpectedToken(next);
- *ok = false;
- return impl()->EmptyExpression();
- }
- }
-
- if (*is_computed_name) {
- return expression;
- }
-
- if (fni_ != nullptr) {
- impl()->PushLiteralName(fni_, *name);
}
uint32_t index;
@@ -2019,43 +1920,46 @@
template <typename Impl>
typename ParserBase<Impl>::ObjectLiteralPropertyT
-ParserBase<Impl>::ParsePropertyDefinition(ObjectLiteralCheckerBase* checker,
- bool in_class, bool has_extends,
- bool* is_computed_name,
- bool* has_seen_constructor,
- ExpressionClassifier* classifier,
- IdentifierT* name, bool* ok) {
- DCHECK(!in_class || has_seen_constructor != nullptr);
+ParserBase<Impl>::ParsePropertyDefinition(
+ ObjectLiteralCheckerBase* checker, bool in_class, bool has_extends,
+ MethodKind method_kind, bool* is_computed_name, bool* has_seen_constructor,
+ ExpressionClassifier* classifier, IdentifierT* name, bool* ok) {
+ DCHECK(!in_class || IsStaticMethod(method_kind) ||
+ has_seen_constructor != nullptr);
bool is_get = false;
bool is_set = false;
- bool is_generator = false;
+ bool is_generator = Check(Token::MUL);
bool is_async = false;
- bool is_static = false;
- PropertyKind kind = PropertyKind::kValueProperty;
+ const bool is_static = IsStaticMethod(method_kind);
Token::Value name_token = peek();
+
+ if (is_generator) {
+ method_kind |= MethodKind::kGenerator;
+ } else if (allow_harmony_async_await() && name_token == Token::ASYNC &&
+ !scanner()->HasAnyLineTerminatorAfterNext() &&
+ PeekAhead() != Token::LPAREN && PeekAhead()) {
+ is_async = true;
+ }
+
int next_beg_pos = scanner()->peek_location().beg_pos;
int next_end_pos = scanner()->peek_location().end_pos;
-
ExpressionT name_expression =
- ParsePropertyName(name, &kind, in_class, &is_generator, &is_get, &is_set,
- &is_async, &is_static, is_computed_name, classifier,
+ ParsePropertyName(name, &is_get, &is_set, is_computed_name, classifier,
CHECK_OK_CUSTOM(EmptyObjectLiteralProperty));
- switch (kind) {
- case PropertyKind::kValueProperty: {
- if (in_class) {
- Token::Value next = Next();
- ReportUnexpectedToken(next);
- *ok = false;
- return impl()->EmptyObjectLiteralProperty();
- }
-
- DCHECK(!is_get && !is_set && !is_generator && !is_async && !is_static);
-
+ if (fni_ != nullptr && !*is_computed_name) {
+ impl()->PushLiteralName(fni_, *name);
+ }
+
+ if (!in_class && !is_generator) {
+ DCHECK(!IsStaticMethod(method_kind));
+ if (peek() == Token::COLON) {
+ // PropertyDefinition
+ // PropertyName ':' AssignmentExpression
if (!*is_computed_name) {
- checker->CheckProperty(name_token, PropertyKind::kValueProperty,
- MethodKind::kNormal, classifier,
+ checker->CheckProperty(name_token, kValueProperty, MethodKind::kNormal,
+ classifier,
CHECK_OK_CUSTOM(EmptyObjectLiteralProperty));
}
Consume(Token::COLON);
@@ -2069,23 +1973,16 @@
is_static, *is_computed_name);
}
- case PropertyKind::kShorthandProperty: {
+ if (Token::IsIdentifier(name_token, language_mode(), this->is_generator(),
+ parsing_module_ || is_async_function()) &&
+ (peek() == Token::COMMA || peek() == Token::RBRACE ||
+ peek() == Token::ASSIGN)) {
// PropertyDefinition
// IdentifierReference
// CoverInitializedName
//
// CoverInitializedName
// IdentifierReference Initializer?
- if (in_class) {
- Token::Value next = Next();
- ReportUnexpectedToken(next);
- *ok = false;
- return impl()->EmptyObjectLiteralProperty();
- }
-
- DCHECK(!is_get && !is_set && !is_generator && !is_async && !is_static &&
- !*is_computed_name);
-
if (classifier->duplicate_finder() != nullptr &&
scanner()->FindSymbol(classifier->duplicate_finder(), 1) != 0) {
classifier->RecordDuplicateFormalParameterError(scanner()->location());
@@ -2134,96 +2031,107 @@
name_expression, value, ObjectLiteralProperty::COMPUTED, is_static,
false);
}
-
- case PropertyKind::kMethodProperty: {
- DCHECK(!is_get && !is_set);
-
- MethodKind method_kind = MethodKind::kNormal;
- if (is_generator) {
- method_kind |= MethodKind::kGenerator;
- }
- if (is_async) {
- method_kind |= MethodKind::kAsync;
- }
- if (is_static) {
- method_kind |= MethodKind::kStatic;
- }
-
- // MethodDefinition
- // PropertyName '(' StrictFormalParameters ')' '{' FunctionBody '}'
- // '*' PropertyName '(' StrictFormalParameters ')' '{' FunctionBody '}'
-
- classifier->RecordPatternError(
- Scanner::Location(next_beg_pos, scanner()->location().end_pos),
- MessageTemplate::kInvalidDestructuringTarget);
-
- if (!*is_computed_name) {
- checker->CheckProperty(name_token, PropertyKind::kMethodProperty,
- method_kind, classifier,
- CHECK_OK_CUSTOM(EmptyObjectLiteralProperty));
- }
-
- FunctionKind kind = is_generator
- ? FunctionKind::kConciseGeneratorMethod
- : is_async ? FunctionKind::kAsyncConciseMethod
- : FunctionKind::kConciseMethod;
-
- if (in_class && !is_static && impl()->IsConstructor(*name)) {
- *has_seen_constructor = true;
- kind = has_extends ? FunctionKind::kSubclassConstructor
- : FunctionKind::kBaseConstructor;
- }
-
- ExpressionT value = impl()->ParseFunctionLiteral(
- *name, scanner()->location(), kSkipFunctionNameCheck, kind,
- kNoSourcePosition, FunctionLiteral::kAccessorOrMethod,
- language_mode(), CHECK_OK_CUSTOM(EmptyObjectLiteralProperty));
-
- return factory()->NewObjectLiteralProperty(
- name_expression, value, ObjectLiteralProperty::COMPUTED, is_static,
- *is_computed_name);
- }
-
- case PropertyKind::kAccessorProperty: {
- DCHECK((is_get || is_set) && !is_generator && !is_async);
-
- MethodKind method_kind = MethodKind::kNormal;
- if (is_static) {
- DCHECK(in_class);
- method_kind |= MethodKind::kStatic;
- }
-
- classifier->RecordPatternError(
- Scanner::Location(next_beg_pos, scanner()->location().end_pos),
- MessageTemplate::kInvalidDestructuringTarget);
- if (!*is_computed_name) {
- checker->CheckProperty(name_token, PropertyKind::kAccessorProperty,
- method_kind, classifier,
- CHECK_OK_CUSTOM(EmptyObjectLiteralProperty));
- }
-
- typename Types::FunctionLiteral value = impl()->ParseFunctionLiteral(
- *name, scanner()->location(), kSkipFunctionNameCheck,
- is_get ? FunctionKind::kGetterFunction
- : FunctionKind::kSetterFunction,
- kNoSourcePosition, FunctionLiteral::kAccessorOrMethod,
- language_mode(), CHECK_OK_CUSTOM(EmptyObjectLiteralProperty));
-
- // Make sure the name expression is a string since we need a Name for
- // Runtime_DefineAccessorPropertyUnchecked and since we can determine this
- // statically we can skip the extra runtime check.
- if (!*is_computed_name) {
- name_expression =
- factory()->NewStringLiteral(*name, name_expression->position());
- }
-
- return factory()->NewObjectLiteralProperty(
- name_expression, value, is_get ? ObjectLiteralProperty::GETTER
- : ObjectLiteralProperty::SETTER,
- is_static, *is_computed_name);
- }
- }
- UNREACHABLE();
+ }
+
+ // Method definitions are never valid in patterns.
+ classifier->RecordPatternError(
+ Scanner::Location(next_beg_pos, scanner()->location().end_pos),
+ MessageTemplate::kInvalidDestructuringTarget);
+
+ if (is_async && !IsSpecialMethod(method_kind)) {
+ DCHECK(!is_get);
+ DCHECK(!is_set);
+ bool dont_care;
+ name_expression = ParsePropertyName(
+ name, &dont_care, &dont_care, is_computed_name, classifier,
+ CHECK_OK_CUSTOM(EmptyObjectLiteralProperty));
+ method_kind |= MethodKind::kAsync;
+ }
+
+ if (is_generator || peek() == Token::LPAREN) {
+ // MethodDefinition
+ // PropertyName '(' StrictFormalParameters ')' '{' FunctionBody '}'
+ // '*' PropertyName '(' StrictFormalParameters ')' '{' FunctionBody '}'
+ if (!*is_computed_name) {
+ checker->CheckProperty(name_token, kMethodProperty, method_kind,
+ classifier,
+ CHECK_OK_CUSTOM(EmptyObjectLiteralProperty));
+ }
+
+ FunctionKind kind = is_generator
+ ? FunctionKind::kConciseGeneratorMethod
+ : is_async ? FunctionKind::kAsyncConciseMethod
+ : FunctionKind::kConciseMethod;
+
+ if (in_class && !IsStaticMethod(method_kind) &&
+ impl()->IsConstructor(*name)) {
+ *has_seen_constructor = true;
+ kind = has_extends ? FunctionKind::kSubclassConstructor
+ : FunctionKind::kBaseConstructor;
+ }
+
+ ExpressionT value = impl()->ParseFunctionLiteral(
+ *name, scanner()->location(), kSkipFunctionNameCheck, kind,
+ kNoSourcePosition, FunctionLiteral::kAccessorOrMethod, language_mode(),
+ CHECK_OK_CUSTOM(EmptyObjectLiteralProperty));
+
+ return factory()->NewObjectLiteralProperty(name_expression, value,
+ ObjectLiteralProperty::COMPUTED,
+ is_static, *is_computed_name);
+ }
+
+ if (in_class && name_token == Token::STATIC && IsNormalMethod(method_kind)) {
+ // ClassElement (static)
+ // 'static' MethodDefinition
+ *name = impl()->EmptyIdentifier();
+ ObjectLiteralPropertyT property = ParsePropertyDefinition(
+ checker, true, has_extends, MethodKind::kStatic, is_computed_name,
+ nullptr, classifier, name, ok);
+ impl()->RewriteNonPattern(classifier, ok);
+ return property;
+ }
+
+ if (is_get || is_set) {
+ // MethodDefinition (Accessors)
+ // get PropertyName '(' ')' '{' FunctionBody '}'
+ // set PropertyName '(' PropertySetParameterList ')' '{' FunctionBody '}'
+ *name = impl()->EmptyIdentifier();
+ bool dont_care = false;
+ name_token = peek();
+
+ name_expression = ParsePropertyName(
+ name, &dont_care, &dont_care, is_computed_name, classifier,
+ CHECK_OK_CUSTOM(EmptyObjectLiteralProperty));
+
+ if (!*is_computed_name) {
+ checker->CheckProperty(name_token, kAccessorProperty, method_kind,
+ classifier,
+ CHECK_OK_CUSTOM(EmptyObjectLiteralProperty));
+ }
+
+ FunctionLiteralT value = impl()->ParseFunctionLiteral(
+ *name, scanner()->location(), kSkipFunctionNameCheck,
+ is_get ? FunctionKind::kGetterFunction : FunctionKind::kSetterFunction,
+ kNoSourcePosition, FunctionLiteral::kAccessorOrMethod, language_mode(),
+ CHECK_OK_CUSTOM(EmptyObjectLiteralProperty));
+
+ // Make sure the name expression is a string since we need a Name for
+ // Runtime_DefineAccessorPropertyUnchecked and since we can determine this
+ // statically we can skip the extra runtime check.
+ if (!*is_computed_name) {
+ name_expression =
+ factory()->NewStringLiteral(*name, name_expression->position());
+ }
+
+ return factory()->NewObjectLiteralProperty(
+ name_expression, value,
+ is_get ? ObjectLiteralProperty::GETTER : ObjectLiteralProperty::SETTER,
+ is_static, *is_computed_name);
+ }
+
+ Token::Value next = Next();
+ ReportUnexpectedToken(next);
+ *ok = false;
return impl()->EmptyObjectLiteralProperty();
}
@@ -2249,8 +2157,8 @@
bool is_computed_name = false;
IdentifierT name = impl()->EmptyIdentifier();
ObjectLiteralPropertyT property = ParsePropertyDefinition(
- &checker, in_class, has_extends, &is_computed_name, nullptr, classifier,
- &name, CHECK_OK);
+ &checker, in_class, has_extends, MethodKind::kNormal, &is_computed_name,
+ NULL, classifier, &name, CHECK_OK);
if (is_computed_name) {
has_computed_names = true;
@@ -3740,12 +3648,11 @@
Token::Value property, PropertyKind type, MethodKind method_type,
ExpressionClassifier* classifier, bool* ok) {
DCHECK(!IsStaticMethod(method_type));
- DCHECK(!IsSpecialMethod(method_type) ||
- type == PropertyKind::kMethodProperty);
+ DCHECK(!IsSpecialMethod(method_type) || type == kMethodProperty);
if (property == Token::SMI || property == Token::NUMBER) return;
- if (type == PropertyKind::kValueProperty && IsProto()) {
+ if (type == kValueProperty && IsProto()) {
if (has_seen_proto_) {
classifier->RecordExpressionError(this->scanner()->location(),
MessageTemplate::kDuplicateProto);
@@ -3759,8 +3666,7 @@
void ParserBase<Impl>::ClassLiteralChecker::CheckProperty(
Token::Value property, PropertyKind type, MethodKind method_type,
ExpressionClassifier* classifier, bool* ok) {
- DCHECK(type == PropertyKind::kMethodProperty ||
- type == PropertyKind::kAccessorProperty);
+ DCHECK(type == kMethodProperty || type == kAccessorProperty);
if (property == Token::SMI || property == Token::NUMBER) return;
@@ -3773,7 +3679,7 @@
} else if (IsConstructor()) {
const bool is_generator = IsGeneratorMethod(method_type);
const bool is_async = IsAsyncMethod(method_type);
- if (is_generator || is_async || type == PropertyKind::kAccessorProperty) {
+ if (is_generator || is_async || type == kAccessorProperty) {
MessageTemplate::Template msg =
is_generator ? MessageTemplate::kConstructorIsGenerator
: is_async ? MessageTemplate::kConstructorIsAsync
« no previous file with comments | « src/parsing/parser.cc ('k') | src/parsing/preparser.cc » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698