Wrap ClassLiterals in DoExpressions instead of giving them BlockScopes.

src/ast/ast.h

 // 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.
 
 #ifndef V8_AST_AST_H_
 #define V8_AST_AST_H_
 
 #include "src/ast/ast-value-factory.h"
 #include "src/ast/modules.h"
 #include "src/ast/variables.h"
@@ skipping 457 matching lines @@
 
 
 class DoExpression final : public Expression {
  public:
   DECLARE_NODE_TYPE(DoExpression)
 
   Block* block() { return block_; }
   void set_block(Block* b) { block_ = b; }
   VariableProxy* result() { return result_; }
   void set_result(VariableProxy* v) { result_ = v; }
+  FunctionLiteral* represented_function() { return represented_function_; }
+  void set_represented_function(FunctionLiteral* f) {
+    represented_function_ = f;
+  }
+  bool IsAnonymousFunctionDefinition() const;
 
  protected:
   DoExpression(Zone* zone, Block* block, VariableProxy* result, int pos)
-      : Expression(zone, pos, kDoExpression), block_(block), result_(result) {
+      : Expression(zone, pos, kDoExpression),
+        block_(block),
+        result_(result),
+        represented_function_(nullptr) {
     DCHECK_NOT_NULL(block_);
     DCHECK_NOT_NULL(result_);
   }
   static int parent_num_ids() { return Expression::num_ids(); }
 
  private:
   int local_id(int n) const { return base_id() + parent_num_ids() + n; }
 
   Block* block_;
   VariableProxy* result_;
+  FunctionLiteral* represented_function_;
 };
 
 
 class Declaration : public AstNode {
  public:
   VariableProxy* proxy() const { return proxy_; }
   VariableMode mode() const { return mode_; }
   Scope* scope() const { return scope_; }
   InitializationFlag initialization() const;
 
@@ skipping 2207 matching lines @@
   AstProperties ast_properties_;
 };
 
 
 class ClassLiteral final : public Expression {
  public:
   typedef ObjectLiteralProperty Property;
 
   DECLARE_NODE_TYPE(ClassLiteral)
 
-  Scope* scope() const { return scope_; }
   VariableProxy* class_variable_proxy() const { return class_variable_proxy_; }
   Expression* extends() const { return extends_; }
   void set_extends(Expression* e) { extends_ = e; }
   FunctionLiteral* constructor() const { return constructor_; }
   void set_constructor(FunctionLiteral* f) { constructor_ = f; }
   ZoneList<Property*>* properties() const { return properties_; }
   int start_position() const { return position(); }
   int end_position() const { return end_position_; }
 
   BailoutId EntryId() const { return BailoutId(local_id(0)); }
   BailoutId DeclsId() const { return BailoutId(local_id(1)); }
   BailoutId ExitId() { return BailoutId(local_id(2)); }

[Michael Starzinger, 2016/07/25 14:56:47]

The first three bailout ids should no longer be required. Can we drop them and
also decreate the number of ids in {num_ids} accordingly?

[bakkot, 2016/07/25 18:52:04]

Done. Also edited GetIdForProperty, which I am *pretty* sure also refers to the
number of ids required.

   BailoutId CreateLiteralId() const { return BailoutId(local_id(3)); }
   BailoutId PrototypeId() { return BailoutId(local_id(4)); }
 
   // Return an AST id for a property that is used in simulate instructions.
   BailoutId GetIdForProperty(int i) { return BailoutId(local_id(i + 5)); }
 
   // Unlike other AST nodes, this number of bailout IDs allocated for an
   // ClassLiteral can vary, so num_ids() is not a static method.
   int num_ids() const { return parent_num_ids() + 5 + properties()->length(); }
 
   // Object literals need one feedback slot for each non-trivial value, as well
   // as some slots for home objects.
   void AssignFeedbackVectorSlots(Isolate* isolate, FeedbackVectorSpec* spec,
                                  FeedbackVectorSlotCache* cache);
 
   bool NeedsProxySlot() const {
     return class_variable_proxy() != nullptr &&
            class_variable_proxy()->var()->IsUnallocated();
   }
 
   FeedbackVectorSlot PrototypeSlot() const { return prototype_slot_; }
   FeedbackVectorSlot ProxySlot() const { return proxy_slot_; }
 
-  bool IsAnonymousFunctionDefinition() const {
-    return constructor()->raw_name()->length() == 0;
-  }
-
  protected:
-  ClassLiteral(Zone* zone, Scope* scope, VariableProxy* class_variable_proxy,
+  ClassLiteral(Zone* zone, VariableProxy* class_variable_proxy,
                Expression* extends, FunctionLiteral* constructor,
                ZoneList<Property*>* properties, int start_position,
                int end_position)
       : Expression(zone, start_position, kClassLiteral),
         end_position_(end_position),
-        scope_(scope),
         class_variable_proxy_(class_variable_proxy),
         extends_(extends),
         constructor_(constructor),
         properties_(properties) {}
 
   static int parent_num_ids() { return Expression::num_ids(); }
 
  private:
   int local_id(int n) const { return base_id() + parent_num_ids() + n; }
 
   int end_position_;
   FeedbackVectorSlot prototype_slot_;
   FeedbackVectorSlot proxy_slot_;
-  Scope* scope_;
   VariableProxy* class_variable_proxy_;
   Expression* extends_;
   FunctionLiteral* constructor_;
   ZoneList<Property*>* properties_;
 };
 
 
 class NativeFunctionLiteral final : public Expression {
  public:
   DECLARE_NODE_TYPE(NativeFunctionLiteral)
@@ skipping 660 matching lines @@
       int expected_property_count) {
     return new (local_zone_) FunctionLiteral(
         local_zone_, ast_value_factory_->empty_string(), ast_value_factory_,
         scope, body, materialized_literal_count, expected_property_count, 0,
         FunctionLiteral::kAnonymousExpression,
         FunctionLiteral::kNoDuplicateParameters,
         FunctionLiteral::kShouldLazyCompile, FunctionKind::kNormalFunction, 0,
         false);
   }
 
-  ClassLiteral* NewClassLiteral(Scope* scope, VariableProxy* proxy,
-                                Expression* extends,
+  ClassLiteral* NewClassLiteral(VariableProxy* proxy, Expression* extends,
                                 FunctionLiteral* constructor,
                                 ZoneList<ObjectLiteral::Property*>* properties,
                                 int start_position, int end_position) {
     return new (local_zone_)
-        ClassLiteral(local_zone_, scope, proxy, extends, constructor,
-                     properties, start_position, end_position);
+        ClassLiteral(local_zone_, proxy, extends, constructor, properties,
+                     start_position, end_position);
   }
 
   NativeFunctionLiteral* NewNativeFunctionLiteral(const AstRawString* name,
                                                   v8::Extension* extension,
                                                   int pos) {
     return new (local_zone_)
         NativeFunctionLiteral(local_zone_, name, extension, pos);
   }
 
   DoExpression* NewDoExpression(Block* block, Variable* result_var, int pos) {
@@ skipping 93 matching lines @@
                                     : NULL;                                   \
   }
 AST_NODE_LIST(DECLARE_NODE_FUNCTIONS)
 #undef DECLARE_NODE_FUNCTIONS
 
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_AST_AST_H_