Split StringLiteral from Literal.

src/ast.cc

Index: src/ast.cc
diff --git a/src/ast.cc b/src/ast.cc
index 303c442f8434301165ec8afd2106637cc410e8ac..c1f633c94aa09831199006be11dc3d912d15c6c5 100644
--- a/src/ast.cc
+++ b/src/ast.cc
@@ -34,17 +34,23 @@ AST_NODE_LIST(DECL_ACCEPT)
 
 
 bool Expression::IsSmiLiteral() const {
-  return AsLiteral() != NULL && AsLiteral()->value()->IsSmi();
+  return AsNumberLiteral() != NULL && AsNumberLiteral()->value()->IsSmi();
 }
 
 
-bool Expression::IsStringLiteral() const {
-  return AsLiteral() != NULL && AsLiteral()->value()->IsString();
+bool Expression::IsNullLiteral() const {
+  return AsLiteral() != NULL && AsLiteral()->value()->IsNull();
 }
 
 
-bool Expression::IsNullLiteral() const {
-  return AsLiteral() != NULL && AsLiteral()->value()->IsNull();
+Literal* Expression::AsAnyLiteral() {
+  if (IsStringLiteral()) {
+    return AsStringLiteral();
+  }
+  if (IsNumberLiteral()) {
+    return AsNumberLiteral();
+  }
+  return AsLiteral();
 }
 
 
@@ -192,7 +198,7 @@ ObjectLiteralProperty::ObjectLiteralProperty(
     kind_ = PROTOTYPE;
   } else if (value_->AsMaterializedLiteral() != NULL) {
     kind_ = MATERIALIZED_LITERAL;
-  } else if (value_->AsLiteral() != NULL) {
+  } else if (value_->AsAnyLiteral() != NULL) {
     kind_ = CONSTANT;
   } else {
     kind_ = COMPUTED;
@@ -390,8 +396,8 @@ void ArrayLiteral::BuildConstantElements(Isolate* isolate) {
 
 Handle<Object> MaterializedLiteral::GetBoilerplateValue(Expression* expression,
                                                         Isolate* isolate) {
-  if (expression->AsLiteral() != NULL) {
-    return expression->AsLiteral()->value();
+  if (expression->AsAnyLiteral() != NULL) {
+    return expression->AsAnyLiteral()->value();
   }
   if (CompileTimeValue::IsCompileTimeValue(expression)) {
     return CompileTimeValue::GetValue(isolate, expression);
@@ -481,7 +487,7 @@ static bool MatchLiteralCompareTypeof(Expression* left,
                                       Handle<String>* check) {
   if (IsTypeof(left) && right->IsStringLiteral() && Token::IsEqualityOp(op)) {
     *expr = left->AsUnaryOperation()->expression();
-    *check = Handle<String>::cast(right->AsLiteral()->value());
+    *check = Handle<String>::cast(right->AsStringLiteral()->value());
     return true;
   }
   return false;
@@ -497,9 +503,8 @@ bool CompareOperation::IsLiteralCompareTypeof(Expression** expr,
 
 static bool IsVoidOfLiteral(Expression* expr) {
   UnaryOperation* maybe_unary = expr->AsUnaryOperation();
-  return maybe_unary != NULL &&
-      maybe_unary->op() == Token::VOID &&
-      maybe_unary->expression()->AsLiteral() != NULL;
+  return maybe_unary != NULL && maybe_unary->op() == Token::VOID &&
+      maybe_unary->expression()->AsAnyLiteral() != NULL;
 }
 
 
@@ -1071,6 +1076,8 @@ REGULAR_NODE(SwitchStatement)
 REGULAR_NODE(CaseClause)
 REGULAR_NODE(Conditional)
 REGULAR_NODE(Literal)
+REGULAR_NODE(StringLiteral)
+REGULAR_NODE(NumberLiteral)
 REGULAR_NODE(ArrayLiteral)
 REGULAR_NODE(ObjectLiteral)
 REGULAR_NODE(RegExpLiteral)
@@ -1138,8 +1145,13 @@ void AstConstructionVisitor::VisitCallRuntime(CallRuntime* node) {
 #undef DONT_CACHE_NODE
 
 
-Handle<String> Literal::ToString() {
-  if (value_->IsString()) return Handle<String>::cast(value_);
+Handle<String> Literal::ToString() const {
+  UNREACHABLE();
+  return Handle<String>();
+}
+
+
+Handle<String> NumberLiteral::ToString() const {
   ASSERT(value_->IsNumber());
   char arr[100];
   Vector<char> buffer(arr, ARRAY_SIZE(arr));