Split the AST representation of class properties from object properties

src/parsing/parser.cc

 // Copyright 2012 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.
 
 #include "src/parsing/parser.h"
 
 #include <memory>
 
 #include "src/api.h"
 #include "src/ast/ast-expression-rewriter.h"
@@ skipping 4518 matching lines @@
     extends = ParseLeftHandSideExpression(CHECK_OK);
     CheckNoTailCallExpressions(CHECK_OK);
     RewriteNonPattern(CHECK_OK);
     impl()->AccumulateFormalParameterContainmentErrors();
   } else {
     block_state.set_start_position(scanner()->location().end_pos);
   }
 
 
   ClassLiteralChecker checker(this);
-  ZoneList<ObjectLiteral::Property*>* properties = NewPropertyList(4);
+  ZoneList<ClassLiteral::Property*>* properties = NewClassPropertyList(4);
   FunctionLiteral* constructor = nullptr;
   bool has_seen_constructor = false;
 
   Expect(Token::LBRACE, CHECK_OK);
 
   const bool has_extends = extends != nullptr;
   while (peek() != Token::RBRACE) {
     if (Check(Token::SEMICOLON)) continue;
     FuncNameInferrer::State fni_state(fni_);
-    const bool in_class = true;
     bool is_computed_name = false;  // Classes do not care about computed
                                     // property names here.
     ExpressionClassifier property_classifier(this);
     const AstRawString* property_name = nullptr;
-    ObjectLiteral::Property* property = ParsePropertyDefinition(
-        &checker, in_class, has_extends, &is_computed_name,
-        &has_seen_constructor, &property_name, CHECK_OK);
+    ClassLiteral::Property* property = ParseClassPropertyDefinition(
+        &checker, has_extends, &is_computed_name, &has_seen_constructor,
+        &property_name, CHECK_OK);
     RewriteNonPattern(CHECK_OK);
     impl()->AccumulateFormalParameterContainmentErrors();
 
     if (has_seen_constructor && constructor == nullptr) {
       constructor = GetPropertyValue(property)->AsFunctionLiteral();
       DCHECK_NOT_NULL(constructor);
       constructor->set_raw_name(
           name != nullptr ? name : ast_value_factory()->empty_string());
     } else {
       properties->Add(property, zone());
@@ skipping 754 matching lines @@
       return true;
     }
     if (expr->IsBinaryOperation() &&
         expr->AsBinaryOperation()->op() == Token::COMMA) {
       return true;
     }
     // Everything else does not need rewriting.
     return false;
   }
 
-  void VisitObjectLiteralProperty(ObjectLiteralProperty* property) override {
+  void VisitLiteralProperty(LiteralProperty* property) override {
     if (property == nullptr) return;
     // Do not rewrite (computed) key expressions
     AST_REWRITE_PROPERTY(Expression, property, value);
   }
 
   Parser* parser_;
 };
 
 void Parser::RewriteNonPattern(bool* ok) {
   ValidateExpression(CHECK_OK_VOID);
@@ skipping 190 matching lines @@
 
   // Ignore "__proto__" as a name when it's being used to set the [[Prototype]]
   // of an object literal.
   if (property->kind() == ObjectLiteralProperty::PROTOTYPE) return;
 
   DCHECK(!value->IsAnonymousFunctionDefinition() ||
          property->kind() == ObjectLiteralProperty::COMPUTED);
   SetFunctionName(value, name);
 }
 
+void Parser::SetFunctionNameFromPropertyName(ClassLiteralProperty* property,

[adamk, 2016/09/01 21:18:23]

Duplicating this is kind of sad...I wonder why we don't just create the right
function name for getter properties to begin with. We don't need to change that
logic in this CL, I guess. But it might help make this duplication less bad.

[bakkot, 2016/09/01 23:24:31]

I'm going to leave this as-is for the moment. I'm going to put together another
CL cleaning up the logic for inferring function names from property names
everywhere, but it doesn't make sense as part of this patch. I misread this code
initially; this also sets names for things like ({x: function(){}}), although
I'm pretty sure it doesn't do anything for shorthand methods.

+                                             const AstRawString* name) {
+  Expression* value = property->value();
+
+  // Computed name setting must happen at runtime.
+  if (property->is_computed_name()) return;
+
+  // Getter and setter names are handled here because their names
+  // change in ES2015, even though they are not anonymous.
+  auto function = value->AsFunctionLiteral();
+  DCHECK_NOT_NULL(function);
+
+  bool is_getter = property->kind() == ClassLiteralProperty::GETTER;
+  bool is_setter = property->kind() == ClassLiteralProperty::SETTER;
+  if (is_getter || is_setter) {
+    DCHECK_NOT_NULL(name);
+    const AstRawString* prefix = is_getter
+                                     ? ast_value_factory()->get_space_string()
+                                     : ast_value_factory()->set_space_string();
+    function->set_raw_name(ast_value_factory()->NewConsString(prefix, name));
+    return;
+  }
+
+  SetFunctionName(value, name);
+}
+
 void Parser::SetFunctionNameFromIdentifierRef(Expression* value,
                                               Expression* identifier) {
   if (!identifier->IsVariableProxy()) return;
   SetFunctionName(value, identifier->AsVariableProxy()->raw_name());
 }
 
 void Parser::SetFunctionName(Expression* value, const AstRawString* name) {
   DCHECK_NOT_NULL(name);
   if (!value->IsAnonymousFunctionDefinition()) return;
   auto function = value->AsFunctionLiteral();
@@ skipping 936 matching lines @@
   node->Print(Isolate::Current());
 }
 #endif  // DEBUG
 
 #undef CHECK_OK
 #undef CHECK_OK_VOID
 #undef CHECK_FAILED
 
 }  // namespace internal
 }  // namespace v8