Split StringLiteral from Literal.

src/parser.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 "v8.h"
 
 #include "api.h"
 #include "ast.h"
 #include "bootstrapper.h"
 #include "char-predicates-inl.h"
@@ skipping 406 matching lines @@
 
 bool ParserTraits::IsIdentifier(Expression* expression) {
   VariableProxy* operand = expression->AsVariableProxy();
   return operand != NULL && !operand->is_this();
 }
 
 
 void ParserTraits::PushPropertyName(FuncNameInferrer* fni,
                                     Expression* expression) {
   if (expression->IsPropertyName()) {
-    fni->PushLiteralName(expression->AsLiteral()->AsPropertyName());
+    fni->PushLiteralName(expression->AsStringLiteral()->AsPropertyName());
   } else {
     fni->PushLiteralName(
         parser_->isolate()->factory()->anonymous_function_string());
   }
 }
 
 
 void ParserTraits::CheckAssigningFunctionLiteralToProperty(Expression* left,
                                                            Expression* right) {
   ASSERT(left != NULL);
@@ skipping 19 matching lines @@
       ? expression->AsVariableProxy()
       : NULL;
   if (proxy != NULL) proxy->MarkAsLValue();
   return expression;
 }
 
 
 bool ParserTraits::ShortcutNumericLiteralBinaryExpression(
     Expression** x, Expression* y, Token::Value op, int pos,
     AstNodeFactory<AstConstructionVisitor>* factory) {
-  if ((*x)->AsLiteral() && (*x)->AsLiteral()->value()->IsNumber() &&
-      y->AsLiteral() && y->AsLiteral()->value()->IsNumber()) {
-    double x_val = (*x)->AsLiteral()->value()->Number();
-    double y_val = y->AsLiteral()->value()->Number();
+  if ((*x)->AsNumberLiteral() && y->AsNumberLiteral()) {
+    double x_val = (*x)->AsNumberLiteral()->number();
+    double y_val = y->AsNumberLiteral()->number();
     switch (op) {
       case Token::ADD:
         *x = factory->NewNumberLiteral(x_val + y_val, pos);
         return true;
       case Token::SUB:
         *x = factory->NewNumberLiteral(x_val - y_val, pos);
         return true;
       case Token::MUL:
         *x = factory->NewNumberLiteral(x_val * y_val, pos);
         return true;
@@ skipping 37 matching lines @@
     }
   }
   return false;
 }
 
 
 Expression* ParserTraits::BuildUnaryExpression(
     Expression* expression, Token::Value op, int pos,
     AstNodeFactory<AstConstructionVisitor>* factory) {
   ASSERT(expression != NULL);
-  if (expression->AsLiteral() != NULL) {
-    Handle<Object> literal = expression->AsLiteral()->value();
+  if (expression->AsAnyLiteral() != NULL) {
+    Handle<Object> literal = expression->AsAnyLiteral()->value();
     if (op == Token::NOT) {
       // Convert the literal to a boolean condition and negate it.
       bool condition = literal->BooleanValue();
       Handle<Object> result =
           parser_->isolate()->factory()->ToBoolean(!condition);
       return factory->NewLiteral(result, pos);
     } else if (literal->IsNumber()) {
       // Compute some expressions involving only number literals.
       double value = literal->Number();
       switch (op) {
         case Token::ADD:
           return expression;
         case Token::SUB:
           return factory->NewNumberLiteral(-value, pos);
         case Token::BIT_NOT:
           return factory->NewNumberLiteral(~DoubleToInt32(value), pos);
         default:
           break;
       }
     }
   }
+
   // Desugar '+foo' => 'foo*1'
   if (op == Token::ADD) {
     return factory->NewBinaryOperation(
         Token::MUL, expression, factory->NewNumberLiteral(1, pos), pos);
   }
   // The same idea for '-foo' => 'foo*(-1)'.
   if (op == Token::SUB) {
     return factory->NewBinaryOperation(
         Token::MUL, expression, factory->NewNumberLiteral(-1, pos), pos);
   }
@@ skipping 44 matching lines @@
     Handle<Object> element = arguments[i];
     if (!element.is_null()) {
       elements->set(i, *element);
     }
   }
   Handle<JSArray> array =
       factory->NewJSArrayWithElements(elements, FAST_ELEMENTS, TENURED);
 
   ZoneList<Expression*>* args = new(zone) ZoneList<Expression*>(2, zone);
   Handle<String> type = factory->InternalizeUtf8String(message);
-  args->Add(parser_->factory()->NewLiteral(type, pos), zone);
+  args->Add(parser_->factory()->NewStringLiteral(type, pos), zone);
   args->Add(parser_->factory()->NewLiteral(array, pos), zone);
   CallRuntime* call_constructor =
       parser_->factory()->NewCallRuntime(constructor, NULL, args, pos);
   return parser_->factory()->NewThrow(call_constructor, pos);
 }
 
 
 void ParserTraits::ReportMessageAt(Scanner::Location source_location,
                                    const char* message,
                                    const char* arg,
@@ skipping 96 matching lines @@
   Interface* interface = Interface::NewUnknown(parser_->zone());
   return scope->NewUnresolved(factory, name, interface, pos);
 }
 
 
 Expression* ParserTraits::ExpressionFromString(
     int pos, Scanner* scanner,
     AstNodeFactory<AstConstructionVisitor>* factory) {
   Handle<String> symbol = GetSymbol(scanner);
   if (parser_->fni_ != NULL) parser_->fni_->PushLiteralName(symbol);
-  return factory->NewLiteral(symbol, pos);
+  return factory->NewStringLiteral(symbol, pos);
 }
 
 
 Literal* ParserTraits::GetLiteralTheHole(
     int position, AstNodeFactory<AstConstructionVisitor>* factory) {
   return factory->NewLiteral(parser_->isolate()->factory()->the_hole_value(),
                              RelocInfo::kNoPosition);
 }
 
 
@@ skipping 325 matching lines @@
       stat = ParseBlockElement(NULL, CHECK_OK);
     }
     if (stat == NULL || stat->IsEmpty()) {
       directive_prologue = false;   // End of directive prologue.
       continue;
     }
 
     if (directive_prologue) {
       // A shot at a directive.
       ExpressionStatement* e_stat;
-      Literal* literal;
+      StringLiteral* literal;
       // Still processing directive prologue?
       if ((e_stat = stat->AsExpressionStatement()) != NULL &&
-          (literal = e_stat->expression()->AsLiteral()) != NULL &&
-          literal->value()->IsString()) {
-        Handle<String> directive = Handle<String>::cast(literal->value());
+          (literal = e_stat->expression()->AsStringLiteral()) != NULL) {
+        Handle<String> directive = literal->string();
 
         // Check "use strict" directive (ES5 14.1).
         if (strict_mode() == SLOPPY &&
             String::Equals(isolate()->factory()->use_strict_string(),
                            directive) &&
             token_loc.end_pos - token_loc.beg_pos ==
               isolate()->heap()->use_strict_string()->length() + 2) {
           // TODO(mstarzinger): Global strict eval calls, need their own scope
           // as specified in ES5 10.4.2(3). The correct fix would be to always
           // add this scope in DoParseProgram(), but that requires adaptations
@@ skipping 1093 matching lines @@
     // properties in the prototype chain, but only after the variable
     // declaration statement has been executed. This is important in
     // browsers where the global object (window) has lots of
     // properties defined in prototype objects.
     if (initialization_scope->is_global_scope() &&
         !IsLexicalVariableMode(mode)) {
       // Compute the arguments for the runtime call.
       ZoneList<Expression*>* arguments =
           new(zone()) ZoneList<Expression*>(3, zone());
       // We have at least 1 parameter.
-      arguments->Add(factory()->NewLiteral(name, pos), zone());
+      arguments->Add(factory()->NewStringLiteral(name, pos), zone());
       CallRuntime* initialize;
 
       if (is_const) {
         arguments->Add(value, zone());
         value = NULL;  // zap the value to avoid the unnecessary assignment
 
         // Construct the call to Runtime_InitializeConstGlobal
         // and add it to the initialization statement block.
         // Note that the function does different things depending on
         // the number of arguments (1 or 2).
@@ skipping 581 matching lines @@
     // var iterator = iterable;
     {
       Expression* iterator_proxy = factory()->NewVariableProxy(iterator);
       assign_iterator = factory()->NewAssignment(
           Token::ASSIGN, iterator_proxy, subject, RelocInfo::kNoPosition);
     }
 
     // var result = iterator.next();
     {
       Expression* iterator_proxy = factory()->NewVariableProxy(iterator);
-      Expression* next_literal = factory()->NewLiteral(
+      Expression* next_literal = factory()->NewStringLiteral(
           heap_factory->next_string(), RelocInfo::kNoPosition);
       Expression* next_property = factory()->NewProperty(
           iterator_proxy, next_literal, RelocInfo::kNoPosition);
       ZoneList<Expression*>* next_arguments =
           new(zone()) ZoneList<Expression*>(0, zone());
       Expression* next_call = factory()->NewCall(
           next_property, next_arguments, RelocInfo::kNoPosition);
       Expression* result_proxy = factory()->NewVariableProxy(result);
       next_result = factory()->NewAssignment(
           Token::ASSIGN, result_proxy, next_call, RelocInfo::kNoPosition);
     }
 
     // result.done
     {
-      Expression* done_literal = factory()->NewLiteral(
+      Expression* done_literal = factory()->NewStringLiteral(
           heap_factory->done_string(), RelocInfo::kNoPosition);
       Expression* result_proxy = factory()->NewVariableProxy(result);
       result_done = factory()->NewProperty(
           result_proxy, done_literal, RelocInfo::kNoPosition);
     }
 
     // each = result.value
     {
-      Expression* value_literal = factory()->NewLiteral(
+      Expression* value_literal = factory()->NewStringLiteral(
           heap_factory->value_string(), RelocInfo::kNoPosition);
       Expression* result_proxy = factory()->NewVariableProxy(result);
       Expression* result_value = factory()->NewProperty(
           result_proxy, value_literal, RelocInfo::kNoPosition);
       assign_each = factory()->NewAssignment(
           Token::ASSIGN, each, result_value, RelocInfo::kNoPosition);
     }
 
     for_of->Initialize(each, subject, body,
                        assign_iterator, next_result, result_done, assign_each);
@@ skipping 64 matching lines @@
     Statement* assignment_statement = factory()->NewExpressionStatement(
         assignment, RelocInfo::kNoPosition);
     outer_block->AddStatement(assignment_statement, zone());
     temps.Add(temp, zone());
   }
 
   Variable* flag = scope_->DeclarationScope()->NewTemporary(temp_name);
   // Make statement: flag = 1.
   {
     VariableProxy* flag_proxy = factory()->NewVariableProxy(flag);
-    Expression* const1 = factory()->NewLiteral(smi1, RelocInfo::kNoPosition);
+    Expression* const1 =
+        factory()->NewNumberLiteral(smi1, RelocInfo::kNoPosition);
     Assignment* assignment = factory()->NewAssignment(
         Token::ASSIGN, flag_proxy, const1, RelocInfo::kNoPosition);
     Statement* assignment_statement = factory()->NewExpressionStatement(
         assignment, RelocInfo::kNoPosition);
     outer_block->AddStatement(assignment_statement, zone());
   }
 
   outer_block->AddStatement(loop, zone());
   outer_block->set_scope(for_scope);
   scope_ = inner_scope;
@@ skipping 19 matching lines @@
         assignment, pos);
     proxy->var()->set_initializer_position(pos);
     inner_block->AddStatement(assignment_statement, zone());
   }
 
   // Make statement: if (flag == 1) { flag = 0; } else { next; }.
   {
     Expression* compare = NULL;
     // Make compare expresion: flag == 1.
     {
-      Expression* const1 = factory()->NewLiteral(smi1, RelocInfo::kNoPosition);
+      Expression* const1 =
+          factory()->NewNumberLiteral(smi1, RelocInfo::kNoPosition);
       VariableProxy* flag_proxy = factory()->NewVariableProxy(flag);
       compare = factory()->NewCompareOperation(
           Token::EQ, flag_proxy, const1, RelocInfo::kNoPosition);
     }
     Statement* clear_flag = NULL;
     // Make statement: flag = 0.
     {
       VariableProxy* flag_proxy = factory()->NewVariableProxy(flag);
-      Expression* const0 = factory()->NewLiteral(smi0, RelocInfo::kNoPosition);
+      Expression* const0 =
+          factory()->NewNumberLiteral(smi0, RelocInfo::kNoPosition);
       Assignment* assignment = factory()->NewAssignment(
           Token::ASSIGN, flag_proxy, const0, RelocInfo::kNoPosition);
       clear_flag = factory()->NewExpressionStatement(assignment, pos);
     }
     Statement* clear_flag_or_next = factory()->NewIfStatement(
         compare, clear_flag, next, RelocInfo::kNoPosition);
     inner_block->AddStatement(clear_flag_or_next, zone());
   }
 
 
@@ skipping 249 matching lines @@
 }
 
 
 void Parser::ReportInvalidCachedData(Handle<String> name, bool* ok) {
   ParserTraits::ReportMessage("invalid_cached_data_function", name);
   *ok = false;
 }
 
 
 bool CompileTimeValue::IsCompileTimeValue(Expression* expression) {
-  if (expression->AsLiteral() != NULL) return true;
+  if (expression->AsAnyLiteral() != NULL) {
+    return true;
+  }
   MaterializedLiteral* lit = expression->AsMaterializedLiteral();
   return lit != NULL && lit->is_simple();
 }
 
 
 Handle<FixedArray> CompileTimeValue::GetValue(Isolate* isolate,
                                               Expression* expression) {
   Factory* factory = isolate->factory();
   ASSERT(IsCompileTimeValue(expression));
   Handle<FixedArray> result = factory->NewFixedArray(2, TENURED);
@@ skipping 1543 matching lines @@
       ASSERT(info()->isolate()->has_pending_exception());
     } else {
       result = ParseProgram();
     }
   }
   info()->SetFunction(result);
   return (result != NULL);
 }
 
 } }  // namespace v8::internal