[Parser] Avoid on-the-fly internalization for natives_syntax.

src/parsing/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 "src/parsing/parser.h"
 
 #include <memory>
 
 #include "src/api.h"
 #include "src/ast/ast-expression-rewriter.h"
@@ skipping 497 matching lines @@
 
 Expression* Parser::NewV8Intrinsic(const AstRawString* name,
                                    ZoneList<Expression*>* args, int pos,
                                    bool* ok) {
   if (extension_ != nullptr) {
     // The extension structures are only accessible while parsing the
     // very first time, not when reparsing because of lazy compilation.
     GetClosureScope()->ForceEagerCompilation();
   }
 
-  const Runtime::Function* function = Runtime::FunctionForName(name->string());
+  DCHECK(name->is_one_byte());
+  const Runtime::Function* function =
+      Runtime::FunctionForName(name->raw_data(), name->length());
 
   if (function != nullptr) {
     // Check for possible name clash.
     DCHECK_EQ(Context::kNotFound,
-              Context::IntrinsicIndexForName(name->string()));
+              Context::IntrinsicIndexForName(name->raw_data(), name->length()));
     // Check for built-in IS_VAR macro.
     if (function->function_id == Runtime::kIS_VAR) {
       DCHECK_EQ(Runtime::RUNTIME, function->intrinsic_type);
       // %IS_VAR(x) evaluates to x if x is a variable,
       // leads to a parse error otherwise.  Could be implemented as an
       // inline function %_IS_VAR(x) to eliminate this special case.
       if (args->length() == 1 && args->at(0)->AsVariableProxy() != nullptr) {
         return args->at(0);
       } else {
         ReportMessage(MessageTemplate::kNotIsvar);
         *ok = false;
         return nullptr;
       }
     }
 
     // Check that the expected number of arguments are being passed.
     if (function->nargs != -1 && function->nargs != args->length()) {
       ReportMessage(MessageTemplate::kRuntimeWrongNumArgs);
       *ok = false;
       return nullptr;
     }
 
     return factory()->NewCallRuntime(function, args, pos);
   }
 
-  int context_index = Context::IntrinsicIndexForName(name->string());
+  int context_index =
+      Context::IntrinsicIndexForName(name->raw_data(), name->length());
 
   // Check that the function is defined.
   if (context_index == Context::kNotFound) {
     ReportMessage(MessageTemplate::kNotDefined, name);
     *ok = false;
     return nullptr;
   }
 
   return factory()->NewCallRuntime(context_index, args, pos);
 }
@@ skipping 3869 matching lines @@
 }
 
 
 bool Parser::Parse(ParseInfo* info) {
   DCHECK(info->literal() == NULL);
   FunctionLiteral* result = NULL;
   // Ok to use Isolate here; this function is only called in the main thread.
   DCHECK(parsing_on_main_thread_);
   Isolate* isolate = info->isolate();
   pre_parse_timer_ = isolate->counters()->pre_parse();
-  if (FLAG_trace_parse || allow_natives() || extension_ != NULL) {
-    // If intrinsics are allowed, the Parser cannot operate independent of the
-    // V8 heap because of Runtime. Tell the string table to internalize strings
-    // and values right after they're created.
-    ast_value_factory()->Internalize(isolate);
-  }
 
   if (info->is_lazy()) {
     DCHECK(!info->is_eval());
     if (info->shared_info()->is_function()) {
       result = ParseLazy(isolate, info);
     } else {
       result = ParseProgram(isolate, info);
     }
   } else {
     SetCachedData(info);
@@ skipping 1552 matching lines @@
   node->Print(Isolate::Current());
 }
 #endif  // DEBUG
 
 #undef CHECK_OK
 #undef CHECK_OK_VOID
 #undef CHECK_FAILED
 
 }  // namespace internal
 }  // namespace v8