Split StringLiteral from Literal.

src/typing.cc

 // Copyright 2013 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 "typing.h"
 
 #include "frames.h"
 #include "frames-inl.h"
 #include "parser.h"  // for CompileTimeValue; TODO(rossberg): should move
 #include "scopes.h"
@@ skipping 371 matching lines @@
   }
 }
 
 
 void AstTyper::VisitLiteral(Literal* expr) {
   Type* type = Type::Constant(expr->value(), zone());
   NarrowType(expr, Bounds(type));
 }
 
 
+void AstTyper::VisitStringLiteral(StringLiteral* expr) {
+  VisitLiteral(expr);
+}
+
+
+void AstTyper::VisitNumberLiteral(NumberLiteral* expr) {
+  VisitLiteral(expr);
+}
+
+
 void AstTyper::VisitRegExpLiteral(RegExpLiteral* expr) {
   NarrowType(expr, Bounds(Type::RegExp(zone())));
 }
 
 
 void AstTyper::VisitObjectLiteral(ObjectLiteral* expr) {
   ZoneList<ObjectLiteral::Property*>* properties = expr->properties();
   for (int i = 0; i < properties->length(); ++i) {
     ObjectLiteral::Property* prop = properties->at(i);
 
@@ skipping 25 matching lines @@
 
 
 void AstTyper::VisitAssignment(Assignment* expr) {
   // Collect type feedback.
   Property* prop = expr->target()->AsProperty();
   if (prop != NULL) {
     TypeFeedbackId id = expr->AssignmentFeedbackId();
     expr->set_is_uninitialized(oracle()->StoreIsUninitialized(id));
     if (!expr->IsUninitialized()) {
       if (prop->key()->IsPropertyName()) {
-        Literal* lit_key = prop->key()->AsLiteral();
-        ASSERT(lit_key != NULL && lit_key->value()->IsString());
+        StringLiteral* lit_key = prop->key()->AsStringLiteral();
+        ASSERT(lit_key != NULL);
         Handle<String> name = Handle<String>::cast(lit_key->value());
         oracle()->AssignmentReceiverTypes(id, name, expr->GetReceiverTypes());
       } else {
         KeyedAccessStoreMode store_mode;
         oracle()->KeyedAssignmentReceiverTypes(
             id, expr->GetReceiverTypes(), &store_mode);
         expr->set_store_mode(store_mode);
       }
     }
   }
@@ skipping 26 matching lines @@
   NarrowType(expr, Bounds(Type::None(zone())));
 }
 
 
 void AstTyper::VisitProperty(Property* expr) {
   // Collect type feedback.
   TypeFeedbackId id = expr->PropertyFeedbackId();
   expr->set_is_uninitialized(oracle()->LoadIsUninitialized(id));
   if (!expr->IsUninitialized()) {
     if (expr->key()->IsPropertyName()) {
-      Literal* lit_key = expr->key()->AsLiteral();
-      ASSERT(lit_key != NULL && lit_key->value()->IsString());
-      Handle<String> name = Handle<String>::cast(lit_key->value());
+      StringLiteral* lit_key = expr->key()->AsStringLiteral();
+      ASSERT(lit_key != NULL);
+      Handle<String> name = lit_key->string();
       bool is_prototype;
       oracle()->PropertyReceiverTypes(
           id, name, expr->GetReceiverTypes(), &is_prototype);
       expr->set_is_function_prototype(is_prototype);
     } else {
       bool is_string;
       oracle()->KeyedPropertyReceiverTypes(
           id, expr->GetReceiverTypes(), &is_string);
       expr->set_is_string_access(is_string);
     }
@@ skipping 272 matching lines @@
 void AstTyper::VisitModuleUrl(ModuleUrl* module) {
 }
 
 
 void AstTyper::VisitModuleStatement(ModuleStatement* stmt) {
   RECURSE(Visit(stmt->body()));
 }
 
 
 } }  // namespace v8::internal