Make the AstValueFactory more efficient and less memory hungry

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 296 matching lines @@
   // True iff the expression is a valid reference expression.
   bool IsValidReferenceExpression() const;
 
   // Helpers for ToBoolean conversion.
   bool ToBooleanIsTrue() const;
   bool ToBooleanIsFalse() const;
 
   // Symbols that cannot be parsed as array indices are considered property
   // names.  We do not treat symbols that can be array indexes as property
   // names because [] for string objects is handled only by keyed ICs.
-  // Produces the same result whether |deref_mode| is kAllowed or kDisallowed,
-  // although may be faster with kAllowed.
-  bool IsPropertyName(
-      HandleDereferenceMode deref_mode = HandleDereferenceMode::kAllowed) const;
+  bool IsPropertyName() const;
 
   // True iff the expression is a class or function expression without
   // a syntactic name.
   bool IsAnonymousFunctionDefinition() const;
 
   // True iff the expression is a literal represented as a smi.
   bool IsSmiLiteral() const;
 
   // True iff the expression is a string literal.
   bool IsStringLiteral() const;
@@ skipping 859 matching lines @@
   Statement* statement_;
   Scope* const scope_;
   SloppyBlockFunctionStatement* next_;
 };
 
 
 class Literal final : public Expression {
  public:
   // Returns true if literal represents a property name (i.e. cannot be parsed
   // as array indices). Produces the same result whether |deref_mode| is
   // kAllowed or kDisallowed, although may be faster with kAllowed.

[rmcilroy, 2016/08/10 11:12:57]

Could you update the comment here please.

-  bool IsPropertyName(HandleDereferenceMode deref_mode =
-                          HandleDereferenceMode::kAllowed) const {
-    return value_->IsPropertyName(deref_mode);
-  }
+  bool IsPropertyName() const { return value_->IsPropertyName(); }
 
   Handle<String> AsPropertyName() {
-    DCHECK(IsPropertyName(HandleDereferenceMode::kDisallowed));
+    DCHECK(IsPropertyName());
     return Handle<String>::cast(value());
   }
 
   const AstRawString* AsRawPropertyName() {
     DCHECK(IsPropertyName());
     return value_->AsString();
   }
 
   bool ToBooleanIsTrue() const { return raw_value()->BooleanValue(); }
   bool ToBooleanIsFalse() const { return !raw_value()->BooleanValue(); }
@@ skipping 521 matching lines @@
                                       : FeedbackVectorSlotKind::KEYED_LOAD_IC;
     property_feedback_slot_ = spec->AddSlot(kind);
   }
 
   FeedbackVectorSlot PropertyFeedbackSlot() const {
     return property_feedback_slot_;
   }
 
   // Returns the properties assign type. Produces the same result whether
   // |deref_mode| is kAllowed or kDisallowed, although may be faster with
   // kAllowed.

[rmcilroy, 2016/08/10 11:12:57]

Could you update the comment here please.

   static LhsKind GetAssignType(
       Property* property,
       HandleDereferenceMode deref_mode = HandleDereferenceMode::kAllowed) {
     if (property == NULL) return VARIABLE;
     bool super_access = property->IsSuperAccess();
-    return (property->key()->IsPropertyName(deref_mode))
+    return (property->key()->IsPropertyName())
                ? (super_access ? NAMED_SUPER_PROPERTY : NAMED_PROPERTY)
                : (super_access ? KEYED_SUPER_PROPERTY : KEYED_PROPERTY);
   }
 
  private:
   friend class AstNodeFactory;
 
   Property(Zone* zone, Expression* obj, Expression* key, int pos)
       : Expression(zone, pos, kProperty),
         bit_field_(IsForCallField::encode(false) |
@@ skipping 1720 matching lines @@
                                     : NULL;                                   \
   }
 AST_NODE_LIST(DECLARE_NODE_FUNCTIONS)
 #undef DECLARE_NODE_FUNCTIONS
 
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_AST_AST_H_