Split StringLiteral from Literal.

src/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_H_
 #define V8_AST_H_
 
 #include "v8.h"
 
 #include "assembler.h"
@@ skipping 60 matching lines @@
   V(TryCatchStatement)                          \
   V(TryFinallyStatement)                        \
   V(DebuggerStatement)
 
 #define EXPRESSION_NODE_LIST(V)                 \
   V(FunctionLiteral)                            \
   V(NativeFunctionLiteral)                      \
   V(Conditional)                                \
   V(VariableProxy)                              \
   V(Literal)                                    \
+  V(StringLiteral)                              \
+  V(NumberLiteral)                              \
   V(RegExpLiteral)                              \
   V(ObjectLiteral)                              \
   V(ArrayLiteral)                               \
   V(Assignment)                                 \
   V(Yield)                                      \
   V(Throw)                                      \
   V(Property)                                   \
   V(Call)                                       \
   V(CallNew)                                    \
   V(CallRuntime)                                \
@@ skipping 232 matching lines @@
   // names because [] for string objects is handled only by keyed ICs.
   virtual bool IsPropertyName() const { return false; }
 
   // True iff the result can be safely overwritten (to avoid allocation).
   // False for operations that can return one of their operands.
   virtual bool ResultOverwriteAllowed() const { return false; }
 
   // 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;
-
   // True iff the expression is the null literal.
   bool IsNullLiteral() const;
 
   // True if we can prove that the expression is the undefined literal.
   bool IsUndefinedLiteral(Isolate* isolate) const;
 
+  Literal* AsAnyLiteral();
+
   // Expression type bounds
   Bounds bounds() const { return bounds_; }
   void set_bounds(Bounds bounds) { bounds_ = bounds; }
 
   // Type feedback information for assignments and properties.
   virtual bool IsMonomorphic() {
     UNREACHABLE();
     return false;
   }
   virtual SmallMapList* GetReceiverTypes() {
@@ skipping 969 matching lines @@
 
 class EmptyStatement V8_FINAL : public Statement {
  public:
   DECLARE_NODE_TYPE(EmptyStatement)
 
  protected:
   explicit EmptyStatement(Zone* zone, int pos): Statement(zone, pos) {}
 };
 
 
-class Literal V8_FINAL : public Expression {
+class Literal : public Expression {
  public:
   DECLARE_NODE_TYPE(Literal)
 
-  virtual bool IsPropertyName() const V8_OVERRIDE {
-    if (value_->IsInternalizedString()) {
-      uint32_t ignored;
-      return !String::cast(*value_)->AsArrayIndex(&ignored);
-    }
-    return false;
-  }
-
-  Handle<String> AsPropertyName() {
-    ASSERT(IsPropertyName());
-    return Handle<String>::cast(value_);
-  }
-
   virtual bool ToBooleanIsTrue() const V8_OVERRIDE {
-    return value_->BooleanValue();
+    return value()->BooleanValue();
   }
   virtual bool ToBooleanIsFalse() const V8_OVERRIDE {
-    return !value_->BooleanValue();
+    return !value()->BooleanValue();
   }
 
   // Identity testers.
   bool IsNull() const {
     ASSERT(!value_.is_null());
     return value_->IsNull();
   }
   bool IsTrue() const {
     ASSERT(!value_.is_null());
     return value_->IsTrue();
   }
   bool IsFalse() const {
     ASSERT(!value_.is_null());
     return value_->IsFalse();
   }
 
-  Handle<Object> value() const { return value_; }
+  virtual Handle<Object> value() const { return value_; }
 
   // Support for using Literal as a HashMap key. NOTE: Currently, this works
   // only for string and number literals!
   uint32_t Hash() { return ToString()->Hash(); }
 
   static bool Match(void* literal1, void* literal2) {
     Handle<String> s1 = static_cast<Literal*>(literal1)->ToString();
     Handle<String> s2 = static_cast<Literal*>(literal2)->ToString();
     return String::Equals(s1, s2);
   }
 
   TypeFeedbackId LiteralFeedbackId() const { return reuse(id()); }
 
  protected:
+  Literal(Zone* zone, int position)
+      : Expression(zone, position),
+        isolate_(zone->isolate()) {}
   Literal(Zone* zone, Handle<Object> value, int position)
       : Expression(zone, position),
-        value_(value),
-        isolate_(zone->isolate()) { }
+        isolate_(zone->isolate()),
+        value_(value) {}
+
+  virtual Handle<String> ToString() const;
+
+  // TODO(dcarney): remove.  this is only needed for Match and Hash.
+  Isolate* isolate_;
 
  private:
-  Handle<String> ToString();
+  Handle<Object> value_;
+};
+
+
+class StringLiteral V8_FINAL : public Literal {
+ public:
+  DECLARE_NODE_TYPE(StringLiteral)
+
+  virtual bool IsPropertyName() const V8_OVERRIDE {
+    uint32_t ignored;
+    return !string_->AsArrayIndex(&ignored);
+  }
+
+  virtual Handle<String> AsPropertyName() const V8_OVERRIDE {
+    ASSERT(IsPropertyName());
+    return string_;
+  }
+
+  virtual Handle<Object> value() const V8_OVERRIDE {
+    return string_;
+  }
+
+  virtual Handle<String> string() const V8_OVERRIDE { return string_; }
+
+ protected:
+  virtual Handle<String> ToString() const V8_OVERRIDE { return string_; }
+
+ private:
+  StringLiteral(Zone* zone, Handle<String> string,
+                int position)
+      : Literal(zone, position), string_(string) {}
+
+  Handle<String> string_;
+};
+
+
+class NumberLiteral V8_FINAL : public Literal {
+ public:
+  DECLARE_NODE_TYPE(NumberLiteral)
+
+  virtual Handle<Object> value() const V8_OVERRIDE {
+    return value_;
+  }
+
+  double number() const {
+    return value_->Number();
+  }
+
+ protected:
+  virtual Handle<String> ToString() const V8_OVERRIDE;
+
+ private:
+  NumberLiteral(Zone* zone, Handle<Object> value,
+                int position)
+      : Literal(zone, position), value_(value) {
+    ASSERT(value->IsNumber());
+  }
 
   Handle<Object> value_;
-  // TODO(dcarney): remove.  this is only needed for Match and Hash.
-  Isolate* isolate_;
 };
 
 
+
 // Base class for literals that needs space in the corresponding JSFunction.
 class MaterializedLiteral : public Expression {
  public:
   virtual MaterializedLiteral* AsMaterializedLiteral() { return this; }
 
   int literal_index() { return literal_index_; }
 
   int depth() const {
     // only callable after initialization.
     ASSERT(depth_ >= 1);
@@ skipping 1713 matching lines @@
   }
 
   CaseClause* NewCaseClause(
       Expression* label, ZoneList<Statement*>* statements, int pos) {
     CaseClause* clause =
         new(zone_) CaseClause(zone_, label, statements, pos);
     VISIT_AND_RETURN(CaseClause, clause)
   }
 
   Literal* NewLiteral(Handle<Object> handle, int pos) {
+    ASSERT(!handle->IsString());
     Literal* lit = new(zone_) Literal(zone_, handle, pos);
     VISIT_AND_RETURN(Literal, lit)
   }
 
-  Literal* NewNumberLiteral(double number, int pos) {
-    return NewLiteral(
+  StringLiteral* NewStringLiteral(Handle<String> handle, int pos) {
+    StringLiteral* lit = new(zone_) StringLiteral(zone_, handle, pos);
+    VISIT_AND_RETURN(StringLiteral, lit)
+  }
+
+  NumberLiteral* NewNumberLiteral(Handle<Object> handle, int pos) {
+    ASSERT(handle->IsNumber());
+    NumberLiteral* lit = new(zone_) NumberLiteral(zone_, handle, pos);
+    VISIT_AND_RETURN(NumberLiteral, lit)
+  }
+
+  NumberLiteral* NewNumberLiteral(double number, int pos) {
+    return NewNumberLiteral(
         zone_->isolate()->factory()->NewNumber(number, TENURED), pos);
   }
 
   ObjectLiteral* NewObjectLiteral(
       ZoneList<ObjectLiteral::Property*>* properties,
       int literal_index,
       int boilerplate_properties,
       bool has_function,
       int pos) {
     ObjectLiteral* lit = new(zone_) ObjectLiteral(
         zone_, properties, literal_index, boilerplate_properties,
         has_function, pos);
     VISIT_AND_RETURN(ObjectLiteral, lit)
   }
 
   ObjectLiteral::Property* NewObjectLiteralProperty(Literal* key,
                                                     Expression* value) {
     return new(zone_) ObjectLiteral::Property(zone_, key, value);
   }
 
   ObjectLiteral::Property* NewObjectLiteralProperty(bool is_getter,
                                                     FunctionLiteral* value,
                                                     int pos) {
     ObjectLiteral::Property* prop =
         new(zone_) ObjectLiteral::Property(zone_, is_getter, value);
-    prop->set_key(NewLiteral(value->name(), pos));
+    prop->set_key(NewStringLiteral(value->name(), pos));
     return prop;  // Not an AST node, will not be visited.
   }
 
   RegExpLiteral* NewRegExpLiteral(Handle<String> pattern,
                                   Handle<String> flags,
                                   int literal_index,
                                   int pos) {
     RegExpLiteral* lit =
         new(zone_) RegExpLiteral(zone_, pattern, flags, literal_index, pos);
     VISIT_AND_RETURN(RegExpLiteral, lit);
@@ skipping 160 matching lines @@
 
  private:
   Zone* zone_;
   Visitor visitor_;
 };
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_AST_H_