WIP: Parser: delay string internalization.

test/cctest/test-parsing.cc

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 19 matching lines @@
 #include <string.h>
 
 #include "v8.h"
 
 #include "cctest.h"
 #include "compiler.h"
 #include "execution.h"
 #include "isolate.h"
 #include "objects.h"
 #include "parser.h"
+#include "parser-symbol-table.h"
 #include "preparser.h"
 #include "scanner-character-streams.h"
 #include "token.h"
 #include "utils.h"
 
 TEST(ScanKeywords) {
   struct KeywordToken {
     const char* keyword;
     i::Token::Value token;
   };
@@ skipping 739 matching lines @@
        reinterpret_cast<const i::byte*>(re_source),
        static_cast<unsigned>(strlen(re_source)));
   i::HandleScope scope(CcTest::i_isolate());
   i::Scanner scanner(CcTest::i_isolate()->unicode_cache());
   scanner.Initialize(&stream);
 
   i::Token::Value start = scanner.peek();
   CHECK(start == i::Token::DIV || start == i::Token::ASSIGN_DIV);
   CHECK(scanner.ScanRegExpPattern(start == i::Token::ASSIGN_DIV));
   scanner.Next();  // Current token is now the regexp literal.
-  i::Handle<i::String> val =
-      scanner.AllocateInternalizedString(CcTest::i_isolate());
+  i::ParserSymbolTable symbol_table;
+  symbol_table.AlwaysInternalize(CcTest::i_isolate());
+  i::Handle<i::String> val = scanner.CurrentString(&symbol_table)->string();
   i::DisallowHeapAllocation no_alloc;
   i::String::FlatContent content = val->GetFlatContent();
   CHECK(content.IsAscii());
   i::Vector<const uint8_t> actual = content.ToOneByteVector();
   for (int i = 0; i < actual.length(); i++) {
     CHECK_NE('\0', expected[i]);
     CHECK_EQ(expected[i], actual[i]);
   }
 }
 
@@ skipping 329 matching lines @@
   }
 }
 
 
 i::Handle<i::String> FormatMessage(i::ScriptData* data) {
   i::Isolate* isolate = CcTest::i_isolate();
   i::Factory* factory = isolate->factory();
   const char* message = data->BuildMessage();
   i::Handle<i::String> format = v8::Utils::OpenHandle(
       *v8::String::NewFromUtf8(CcTest::isolate(), message));
-  i::Vector<const char*> args = data->BuildArgs();
-  i::Handle<i::JSArray> args_array = factory->NewJSArray(args.length());
-  for (int i = 0; i < args.length(); i++) {
+  const char* arg = data->BuildArg();
+  i::Handle<i::JSArray> args_array = factory->NewJSArray(arg != NULL ? 1 : 0);
+  if (arg != NULL) {
     i::JSArray::SetElement(
-        args_array, i, v8::Utils::OpenHandle(*v8::String::NewFromUtf8(
-                                                  CcTest::isolate(), args[i])),
+        args_array, 0,
+        v8::Utils::OpenHandle(*v8::String::NewFromUtf8(CcTest::isolate(), arg)),
         NONE, i::SLOPPY).Check();
   }
   i::Handle<i::JSObject> builtins(isolate->js_builtins_object());
   i::Handle<i::Object> format_fun = i::Object::GetProperty(
       isolate, builtins, "FormatMessage").ToHandleChecked();
   i::Handle<i::Object> arg_handles[] = { format, args_array };
   i::Handle<i::Object> result = i::Execution::Call(
       isolate, format_fun, builtins, 2, arg_handles).ToHandleChecked();
   CHECK(result->IsString());
-  for (int i = 0; i < args.length(); i++) {
-    i::DeleteArray(args[i]);
-  }
-  i::DeleteArray(args.start());
+  i::DeleteArray(arg);
   i::DeleteArray(message);
   return i::Handle<i::String>::cast(result);
 }
 
 
 enum ParserFlag {
   kAllowLazy,
   kAllowNativesSyntax,
   kAllowHarmonyScoping,
   kAllowModules,
@@ skipping 1273 matching lines @@
   RunParserSyncTest(assignment_context_data, bad_statement_data_common, kError);
   RunParserSyncTest(assignment_context_data, bad_statement_data_for_assignment,
                     kError);
 
   RunParserSyncTest(prefix_context_data, good_statement_data, kSuccess);
   RunParserSyncTest(prefix_context_data, bad_statement_data_common, kError);
 
   RunParserSyncTest(postfix_context_data, good_statement_data, kSuccess);
   RunParserSyncTest(postfix_context_data, bad_statement_data_common, kError);
 }