Split StringLiteral from Literal.

src/prettyprinter.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 <stdarg.h>
 
 #include "v8.h"
 
 #include "prettyprinter.h"
 #include "scopes.h"
@@ skipping 291 matching lines @@
   Print(" : ");
   Visit(node->else_expression());
 }
 
 
 void PrettyPrinter::VisitLiteral(Literal* node) {
   PrintLiteral(node->value(), true);
 }
 
 
+void PrettyPrinter::VisitStringLiteral(StringLiteral* node) {
+  VisitLiteral(node);
+}
+
+
+void PrettyPrinter::VisitNumberLiteral(NumberLiteral* node) {
+  VisitLiteral(node);
+}
+
+
 void PrettyPrinter::VisitRegExpLiteral(RegExpLiteral* node) {
   Print(" RegExp(");
   PrintLiteral(node->pattern(), false);
   Print(",");
   PrintLiteral(node->flags(), false);
   Print(") ");
 }
 
 
 void PrettyPrinter::VisitObjectLiteral(ObjectLiteral* node) {
@@ skipping 39 matching lines @@
 
 
 void PrettyPrinter::VisitThrow(Throw* node) {
   Print("throw ");
   Visit(node->exception());
 }
 
 
 void PrettyPrinter::VisitProperty(Property* node) {
   Expression* key = node->key();
-  Literal* literal = key->AsLiteral();
-  if (literal != NULL && literal->value()->IsInternalizedString()) {
+  StringLiteral* literal = key->AsStringLiteral();
+  if (literal != NULL) {
     Print("(");
     Visit(node->obj());
     Print(").");
     PrintLiteral(literal->value(), false);
   } else {
     Visit(node->obj());
     Print("[");
     Visit(key);
     Print("]");
   }
@@ skipping 588 matching lines @@
   PrintIndentedVisit("ELSE", node->else_expression());
 }
 
 
 // TODO(svenpanne) Start with IndentedScope.
 void AstPrinter::VisitLiteral(Literal* node) {
   PrintLiteralIndented("LITERAL", node->value(), true);
 }
 
 
+void AstPrinter::VisitStringLiteral(StringLiteral* node) {
+  VisitLiteral(node);
+}
+
+
+void AstPrinter::VisitNumberLiteral(NumberLiteral* node) {
+  VisitLiteral(node);
+}
+
+
 void AstPrinter::VisitRegExpLiteral(RegExpLiteral* node) {
   IndentedScope indent(this, "REGEXP LITERAL");
   PrintLiteralIndented("PATTERN", node->pattern(), false);
   PrintLiteralIndented("FLAGS", node->flags(), false);
 }
 
 
 void AstPrinter::VisitObjectLiteral(ObjectLiteral* node) {
   IndentedScope indent(this, "OBJ LITERAL");
   for (int i = 0; i < node->properties()->length(); i++) {
@@ skipping 78 matching lines @@
 
 void AstPrinter::VisitThrow(Throw* node) {
   IndentedScope indent(this, "THROW");
   Visit(node->exception());
 }
 
 
 void AstPrinter::VisitProperty(Property* node) {
   IndentedScope indent(this, "PROPERTY");
   Visit(node->obj());
-  Literal* literal = node->key()->AsLiteral();
-  if (literal != NULL && literal->value()->IsInternalizedString()) {
+  StringLiteral* literal = node->key()->AsStringLiteral();
+  if (literal != NULL) {
     PrintLiteralIndented("NAME", literal->value(), false);
   } else {
     PrintIndentedVisit("KEY", node->key());
   }
 }
 
 
 void AstPrinter::VisitCall(Call* node) {
   IndentedScope indent(this, "CALL");
   Visit(node->expression());
@@ skipping 44 matching lines @@
 }
 
 
 void AstPrinter::VisitThisFunction(ThisFunction* node) {
   IndentedScope indent(this, "THIS-FUNCTION");
 }
 
 #endif  // DEBUG
 
 } }  // namespace v8::internal