[interpreter/runtime] Create ScriptContext before Script invocation

This way we don't need to generate bytecodes to push the context.

This drops the stack trace for redeclaration SyntaxErrors but keeps the
message location. This is in line with what we do for other
SyntaxErrors.

Change-Id: Id8e3cc348b4d56a8196753baf51cfd810f07512b
Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/1997439
Commit-Queue: Toon Verwaest <verwaest@chromium.org>
Reviewed-by: Leszek Swirski <leszeks@chromium.org>
Reviewed-by: Simon Zünd <szuend@chromium.org>
Reviewed-by: Ulan Degenbaev <ulan@chromium.org>
Cr-Commit-Position: refs/heads/master@{#65810}

src/builtins/builtins-error.cc

@@ -96,11 +96,9 @@ Object MakeGenericError(Isolate* isolate, BuiltinArguments args,
 
   DCHECK(template_index->IsSmi());
 
-  RETURN_RESULT_OR_FAILURE(
-      isolate, ErrorUtils::MakeGenericError(
-                   isolate, constructor,
-                   MessageTemplateFromInt(Smi::ToInt(*template_index)), arg0,
-                   arg1, arg2, SKIP_NONE));
+  return *ErrorUtils::MakeGenericError(
+      isolate, constructor, MessageTemplateFromInt(Smi::ToInt(*template_index)),
+      arg0, arg1, arg2, SKIP_NONE);
 }
 
 }  // namespace
@@ -130,10 +128,9 @@ BUILTIN(MakeURIError) {
   Handle<JSFunction> constructor = isolate->uri_error_function();
   Handle<Object> undefined = isolate->factory()->undefined_value();
   MessageTemplate template_index = MessageTemplate::kURIMalformed;
-  RETURN_RESULT_OR_FAILURE(
-      isolate,
-      ErrorUtils::MakeGenericError(isolate, constructor, template_index,
-                                   undefined, undefined, undefined, SKIP_NONE));
+  return *ErrorUtils::MakeGenericError(isolate, constructor, template_index,
+                                       undefined, undefined, undefined,
+                                       SKIP_NONE);
 }
 
 }  // namespace internal

src/execution/execution.cc

@@ -157,6 +157,77 @@ Handle<Code> JSEntry(Isolate* isolate, Execution::Target execution_target,
   UNREACHABLE();
 }
 
+MaybeHandle<Context> NewScriptContext(Isolate* isolate,
+                                      Handle<JSFunction> function) {
+  SaveAndSwitchContext save(isolate, function->context());
+  SharedFunctionInfo sfi = function->shared();
+  Handle<Script> script(Script::cast(sfi.script()), isolate);
+  Handle<ScopeInfo> scope_info(sfi.scope_info(), isolate);
+  Handle<NativeContext> native_context(NativeContext::cast(function->context()),
+                                       isolate);
+  Handle<JSGlobalObject> global_object(native_context->global_object(),
+                                       isolate);
+  Handle<ScriptContextTable> script_context(
+      native_context->script_context_table(), isolate);
+
+  // Find name clashes.
+  for (int var = 0; var < scope_info->ContextLocalCount(); var++) {
+    Handle<String> name(scope_info->ContextLocalName(var), isolate);
+    VariableMode mode = scope_info->ContextLocalMode(var);
+    ScriptContextTable::LookupResult lookup;
+    if (ScriptContextTable::Lookup(isolate, *script_context, *name, &lookup)) {
+      if (IsLexicalVariableMode(mode) || IsLexicalVariableMode(lookup.mode)) {
+        Handle<Context> context = ScriptContextTable::GetContext(
+            isolate, script_context, lookup.context_index);
+        // If we are trying to re-declare a REPL-mode let as a let, allow it.
+        if (!(mode == VariableMode::kLet && lookup.mode == VariableMode::kLet &&
+              scope_info->IsReplModeScope() &&
+              context->scope_info().IsReplModeScope())) {
+          // ES#sec-globaldeclarationinstantiation 5.b:
+          // If envRec.HasLexicalDeclaration(name) is true, throw a SyntaxError
+          // exception.
+          MessageLocation location(script, 0, 1);
+          isolate->ThrowAt(isolate->factory()->NewSyntaxError(
+                               MessageTemplate::kVarRedeclaration, name),
+                           &location);
+          return MaybeHandle<Context>();
+        }
+      }
+    }
+
+    if (IsLexicalVariableMode(mode)) {
+      LookupIterator it(isolate, global_object, name, global_object,
+                        LookupIterator::OWN_SKIP_INTERCEPTOR);
+      Maybe<PropertyAttributes> maybe = JSReceiver::GetPropertyAttributes(&it);
+      // Can't fail since the we looking up own properties on the global object
+      // skipping interceptors.
+      CHECK(!maybe.IsNothing());
+      if ((maybe.FromJust() & DONT_DELETE) != 0) {
+        // ES#sec-globaldeclarationinstantiation 5.a:
+        // If envRec.HasVarDeclaration(name) is true, throw a SyntaxError
+        // exception.
+        // ES#sec-globaldeclarationinstantiation 5.d:
+        // If hasRestrictedGlobal is true, throw a SyntaxError exception.
+        MessageLocation location(script, 0, 1);
+        isolate->ThrowAt(isolate->factory()->NewSyntaxError(
+                             MessageTemplate::kVarRedeclaration, name),
+                         &location);
+        return MaybeHandle<Context>();
+      }
+
+      JSGlobalObject::InvalidatePropertyCell(global_object, name);
+    }
+  }
+
+  Handle<Context> result =
+      isolate->factory()->NewScriptContext(native_context, scope_info);
+
+  Handle<ScriptContextTable> new_script_context_table =
+      ScriptContextTable::Extend(script_context, result);
+  native_context->set_script_context_table(*new_script_context_table);
+  return result;
+}
+
 V8_WARN_UNUSED_RESULT MaybeHandle<Object> Invoke(Isolate* isolate,
                                                  const InvokeParams& params) {
   RuntimeCallTimerScope timer(isolate, RuntimeCallCounterId::kInvoke);
@@ -206,6 +277,22 @@ V8_WARN_UNUSED_RESULT MaybeHandle<Object> Invoke(Isolate* isolate,
       }
       return value;
     }
+
+    // Set up a ScriptContext when running scripts that need it.
+    if (function->shared().needs_script_context()) {
+      Handle<Context> context;
+      if (!NewScriptContext(isolate, function).ToHandle(&context)) {
+        if (params.message_handling == Execution::MessageHandling::kReport) {
+          isolate->ReportPendingMessages();
+        }
+        return MaybeHandle<Object>();
+      }
+
+      // We mutate the context if we allocate a script context. This is
+      // guaranteed to only happen once in a native context since scripts will
+      // always produce name clashes with themselves.
+      function->set_context(*context);
+    }
   }
 
   // Entering JavaScript.

src/execution/isolate.cc

@@ -1342,6 +1342,30 @@ Object Isolate::StackOverflow() {
   return ReadOnlyRoots(heap()).exception();
 }
 
+void Isolate::ThrowAt(Handle<JSObject> exception, MessageLocation* location) {
+  Handle<Name> key_start_pos = factory()->error_start_pos_symbol();
+  Object::SetProperty(this, exception, key_start_pos,
+                      handle(Smi::FromInt(location->start_pos()), this),
+                      StoreOrigin::kMaybeKeyed,
+                      Just(ShouldThrow::kThrowOnError))
+      .Check();
+
+  Handle<Name> key_end_pos = factory()->error_end_pos_symbol();
+  Object::SetProperty(this, exception, key_end_pos,
+                      handle(Smi::FromInt(location->end_pos()), this),
+                      StoreOrigin::kMaybeKeyed,
+                      Just(ShouldThrow::kThrowOnError))
+      .Check();
+
+  Handle<Name> key_script = factory()->error_script_symbol();
+  Object::SetProperty(this, exception, key_script, location->script(),
+                      StoreOrigin::kMaybeKeyed,
+                      Just(ShouldThrow::kThrowOnError))
+      .Check();
+
+  Throw(*exception, location);
+}
+
 Object Isolate::TerminateExecution() {
   return Throw(ReadOnlyRoots(this).termination_exception(), nullptr);
 }

src/execution/isolate.h

@@ -772,6 +772,8 @@ class Isolate final : private HiddenFactory {
     return MaybeHandle<T>();
   }
 
+  void ThrowAt(Handle<JSObject> exception, MessageLocation* location);
+
   void set_console_delegate(debug::ConsoleDelegate* delegate) {
     console_delegate_ = delegate;
   }

src/execution/messages.cc

@@ -993,7 +993,7 @@ MaybeHandle<String> MessageFormatter::Format(Isolate* isolate,
   return builder.Finish();
 }
 
-MaybeHandle<Object> ErrorUtils::Construct(
+MaybeHandle<JSObject> ErrorUtils::Construct(
     Isolate* isolate, Handle<JSFunction> target, Handle<Object> new_target,
     Handle<Object> message, FrameSkipMode mode, Handle<Object> caller,
     StackTraceCollection stack_trace_collection) {
@@ -1010,7 +1010,7 @@ MaybeHandle<Object> ErrorUtils::Construct(
   ASSIGN_RETURN_ON_EXCEPTION(
       isolate, err,
       JSObject::New(target, new_target_recv, Handle<AllocationSite>::null()),
-      Object);
+      JSObject);
 
   // 3. If message is not undefined, then
   //  a. Let msg be ? ToString(message).
@@ -1022,23 +1022,23 @@ MaybeHandle<Object> ErrorUtils::Construct(
   if (!message->IsUndefined(isolate)) {
     Handle<String> msg_string;
     ASSIGN_RETURN_ON_EXCEPTION(isolate, msg_string,
-                               Object::ToString(isolate, message), Object);
+                               Object::ToString(isolate, message), JSObject);
     RETURN_ON_EXCEPTION(
         isolate,
         JSObject::SetOwnPropertyIgnoreAttributes(
             err, isolate->factory()->message_string(), msg_string, DONT_ENUM),
-        Object);
+        JSObject);
   }
 
   switch (stack_trace_collection) {
     case StackTraceCollection::kDetailed:
       RETURN_ON_EXCEPTION(
-          isolate, isolate->CaptureAndSetDetailedStackTrace(err), Object);
+          isolate, isolate->CaptureAndSetDetailedStackTrace(err), JSObject);
       V8_FALLTHROUGH;
     case StackTraceCollection::kSimple:
       RETURN_ON_EXCEPTION(
           isolate, isolate->CaptureAndSetSimpleStackTrace(err, mode, caller),
-          Object);
+          JSObject);
       break;
     case StackTraceCollection::kNone:
       break;
@@ -1147,7 +1147,7 @@ Handle<String> DoFormatMessage(Isolate* isolate, MessageTemplate index,
 }  // namespace
 
 // static
-MaybeHandle<Object> ErrorUtils::MakeGenericError(
+Handle<JSObject> ErrorUtils::MakeGenericError(
     Isolate* isolate, Handle<JSFunction> constructor, MessageTemplate index,
     Handle<Object> arg0, Handle<Object> arg1, Handle<Object> arg2,
     FrameSkipMode mode) {
@@ -1170,8 +1170,11 @@ MaybeHandle<Object> ErrorUtils::MakeGenericError(
   DCHECK(mode != SKIP_UNTIL_SEEN);
 
   Handle<Object> no_caller;
+  // The call below can't fail because constructor is a builtin.
+  DCHECK(constructor->shared().HasBuiltinId());
   return ErrorUtils::Construct(isolate, constructor, constructor, msg, mode,
-                               no_caller, StackTraceCollection::kDetailed);
+                               no_caller, StackTraceCollection::kDetailed)
+      .ToHandleChecked();
 }
 
 namespace {

src/execution/messages.h

@@ -269,14 +269,14 @@ class ErrorUtils : public AllStatic {
   // |kNone| is useful when you don't need the stack information at all, for
   // example when creating a deserialized error.
   enum class StackTraceCollection { kDetailed, kSimple, kNone };
-  static MaybeHandle<Object> Construct(
+  static MaybeHandle<JSObject> Construct(
       Isolate* isolate, Handle<JSFunction> target, Handle<Object> new_target,
       Handle<Object> message, FrameSkipMode mode, Handle<Object> caller,
       StackTraceCollection stack_trace_collection);
 
   static MaybeHandle<String> ToString(Isolate* isolate, Handle<Object> recv);
 
-  static MaybeHandle<Object> MakeGenericError(
+  static Handle<JSObject> MakeGenericError(
       Isolate* isolate, Handle<JSFunction> constructor, MessageTemplate index,
       Handle<Object> arg0, Handle<Object> arg1, Handle<Object> arg2,
       FrameSkipMode mode);

src/heap/factory.cc

@@ -1364,9 +1364,10 @@ Handle<Context> Factory::NewScriptContext(Handle<NativeContext> outer,
                                           Handle<ScopeInfo> scope_info) {
   DCHECK_EQ(scope_info->scope_type(), SCRIPT_SCOPE);
   int variadic_part_length = scope_info->ContextLength();
-  Handle<Context> context = NewContext(
-      isolate()->script_context_map(), Context::SizeFor(variadic_part_length),
-      variadic_part_length, AllocationType::kOld);
+  Handle<Context> context =
+      NewContext(handle(outer->script_context_map(), isolate()),
+                 Context::SizeFor(variadic_part_length), variadic_part_length,
+                 AllocationType::kOld);
   context->set_scope_info(*scope_info);
   context->set_previous(*outer);
   DCHECK(context->IsScriptContext());
@@ -2181,51 +2182,30 @@ Handle<FreshlyAllocatedBigInt> Factory::NewBigInt(int length,
   return handle(bigint, isolate());
 }
 
-Handle<Object> Factory::NewError(Handle<JSFunction> constructor,
-                                 MessageTemplate template_index,
-                                 Handle<Object> arg0, Handle<Object> arg1,
-                                 Handle<Object> arg2) {
+Handle<JSObject> Factory::NewError(Handle<JSFunction> constructor,
+                                   MessageTemplate template_index,
+                                   Handle<Object> arg0, Handle<Object> arg1,
+                                   Handle<Object> arg2) {
   HandleScope scope(isolate());
-  if (isolate()->bootstrapper()->IsActive()) {
-    // During bootstrapping we cannot construct error objects.
-    return scope.CloseAndEscape(NewStringFromAsciiChecked(
-        MessageFormatter::TemplateString(template_index)));
-  }
 
   if (arg0.is_null()) arg0 = undefined_value();
   if (arg1.is_null()) arg1 = undefined_value();
   if (arg2.is_null()) arg2 = undefined_value();
 
-  Handle<Object> result;
-  if (!ErrorUtils::MakeGenericError(isolate(), constructor, template_index,
-                                    arg0, arg1, arg2, SKIP_NONE)
-           .ToHandle(&result)) {
-    // If an exception is thrown while
-    // running the factory method, use the exception as the result.
-    DCHECK(isolate()->has_pending_exception());
-    result = handle(isolate()->pending_exception(), isolate());
-    isolate()->clear_pending_exception();
-  }
-
-  return scope.CloseAndEscape(result);
+  return scope.CloseAndEscape(ErrorUtils::MakeGenericError(
+      isolate(), constructor, template_index, arg0, arg1, arg2, SKIP_NONE));
 }
 
-Handle<Object> Factory::NewError(Handle<JSFunction> constructor,
-                                 Handle<String> message) {
+Handle<JSObject> Factory::NewError(Handle<JSFunction> constructor,
+                                   Handle<String> message) {
   // Construct a new error object. If an exception is thrown, use the exception
   // as the result.
 
   Handle<Object> no_caller;
-  MaybeHandle<Object> maybe_error = ErrorUtils::Construct(
-      isolate(), constructor, constructor, message, SKIP_NONE, no_caller,
-      ErrorUtils::StackTraceCollection::kDetailed);
-  if (maybe_error.is_null()) {
-    DCHECK(isolate()->has_pending_exception());
-    maybe_error = handle(isolate()->pending_exception(), isolate());
-    isolate()->clear_pending_exception();
-  }
-
-  return maybe_error.ToHandleChecked();
+  return ErrorUtils::Construct(isolate(), constructor, constructor, message,
+                               SKIP_NONE, no_caller,
+                               ErrorUtils::StackTraceCollection::kDetailed)
+      .ToHandleChecked();
 }
 
 Handle<Object> Factory::NewInvalidStringLengthError() {
@@ -2240,9 +2220,9 @@ Handle<Object> Factory::NewInvalidStringLengthError() {
 }
 
 #define DEFINE_ERROR(NAME, name)                                              \
-  Handle<Object> Factory::New##NAME(MessageTemplate template_index,           \
-                                    Handle<Object> arg0, Handle<Object> arg1, \
-                                    Handle<Object> arg2) {                    \
+  Handle<JSObject> Factory::New##NAME(                                        \
+      MessageTemplate template_index, Handle<Object> arg0,                    \
+      Handle<Object> arg1, Handle<Object> arg2) {                             \
     return NewError(isolate()->name##_function(), template_index, arg0, arg1, \
                     arg2);                                                    \
   }

src/heap/factory.h

@@ -779,24 +779,24 @@ class V8_EXPORT_PRIVATE Factory : public FactoryBase<Factory> {
   Handle<BytecodeArray> CopyBytecodeArray(Handle<BytecodeArray>);
 
   // Interface for creating error objects.
-  Handle<Object> NewError(Handle<JSFunction> constructor,
-                          Handle<String> message);
+  Handle<JSObject> NewError(Handle<JSFunction> constructor,
+                            Handle<String> message);
 
   Handle<Object> NewInvalidStringLengthError();
 
   inline Handle<Object> NewURIError();
 
-  Handle<Object> NewError(Handle<JSFunction> constructor,
-                          MessageTemplate template_index,
-                          Handle<Object> arg0 = Handle<Object>(),
-                          Handle<Object> arg1 = Handle<Object>(),
-                          Handle<Object> arg2 = Handle<Object>());
-
-#define DECLARE_ERROR(NAME)                                        \
-  Handle<Object> New##NAME(MessageTemplate template_index,         \
-                           Handle<Object> arg0 = Handle<Object>(), \
-                           Handle<Object> arg1 = Handle<Object>(), \
-                           Handle<Object> arg2 = Handle<Object>());
+  Handle<JSObject> NewError(Handle<JSFunction> constructor,
+                            MessageTemplate template_index,
+                            Handle<Object> arg0 = Handle<Object>(),
+                            Handle<Object> arg1 = Handle<Object>(),
+                            Handle<Object> arg2 = Handle<Object>());
+
+#define DECLARE_ERROR(NAME)                                          \
+  Handle<JSObject> New##NAME(MessageTemplate template_index,         \
+                             Handle<Object> arg0 = Handle<Object>(), \
+                             Handle<Object> arg1 = Handle<Object>(), \
+                             Handle<Object> arg2 = Handle<Object>());
   DECLARE_ERROR(Error)
   DECLARE_ERROR(EvalError)
   DECLARE_ERROR(RangeError)

src/interpreter/bytecode-generator.cc

@@ -1166,7 +1166,7 @@ void BytecodeGenerator::GenerateBytecode(uintptr_t stack_limit) {
     BuildGeneratorPrologue();
   }
 
-  if (closure_scope()->NeedsContext()) {
+  if (closure_scope()->NeedsContext() && !closure_scope()->is_script_scope()) {
     // Push a new inner context scope for the function.
     BuildNewLocalActivationContext();
     ContextScope local_function_context(this, closure_scope());
@@ -5982,13 +5982,7 @@ void BytecodeGenerator::BuildNewLocalActivationContext() {
   DCHECK_EQ(current_scope(), closure_scope());
 
   // Create the appropriate context.
-  if (scope->is_script_scope()) {
-    Register scope_reg = register_allocator()->NewRegister();
-    builder()
-        ->LoadLiteral(scope)
-        .StoreAccumulatorInRegister(scope_reg)
-        .CallRuntime(Runtime::kNewScriptContext, scope_reg);
-  } else if (scope->is_module_scope()) {
+  if (scope->is_module_scope()) {
     // We don't need to do anything for the outer script scope.
     DCHECK(scope->outer_scope()->is_script_scope());
 

src/objects/scope-info.cc

@@ -581,6 +581,10 @@ ScopeType ScopeInfo::scope_type() const {
   return ScopeTypeBits::decode(Flags());
 }
 
+bool ScopeInfo::is_script_scope() const {
+  return length() > 0 && scope_type() == SCRIPT_SCOPE;
+}
+
 bool ScopeInfo::SloppyEvalCanExtendVars() const {
   bool sloppy_eval_can_extend_vars =
       length() > 0 && SloppyEvalCanExtendVarsBit::decode(Flags());

src/objects/scope-info.h

@@ -196,6 +196,8 @@ class ScopeInfo : public FixedArray, public TorqueGeneratedScopeFlagsFields {
   // Return the outer ScopeInfo if present.
   ScopeInfo OuterScopeInfo() const;
 
+  bool is_script_scope() const;
+
   // Returns true if this ScopeInfo has a black list attached containing
   // stack allocated local variables.
   V8_EXPORT_PRIVATE bool HasLocalsBlackList() const;

src/objects/shared-function-info-inl.h

@@ -148,6 +148,16 @@ void SharedFunctionInfo::SetName(String name) {
   UpdateFunctionMapIndex();
 }
 
+bool SharedFunctionInfo::is_script() const {
+  return scope_info().is_script_scope() &&
+         Script::cast(script()).compilation_type() ==
+             Script::COMPILATION_TYPE_HOST;
+}
+
+bool SharedFunctionInfo::needs_script_context() const {
+  return is_script() && scope_info().ContextLocalCount() > 0;
+}
+
 AbstractCode SharedFunctionInfo::abstract_code() {
   if (HasBytecodeArray()) {
     return AbstractCode::cast(GetBytecodeArray());

src/objects/shared-function-info.h

@@ -223,6 +223,9 @@ class SharedFunctionInfo : public HeapObject,
   inline void set_raw_scope_info(ScopeInfo scope_info,
                                  WriteBarrierMode mode = UPDATE_WRITE_BARRIER);
 
+  inline bool is_script() const;
+  inline bool needs_script_context() const;
+
   // End position of this function in the script source.
   V8_EXPORT_PRIVATE int EndPosition() const;
 

src/parsing/pending-compilation-error-handler.cc

@@ -97,37 +97,9 @@ void PendingCompilationErrorHandler::ThrowPendingError(Isolate* isolate,
   isolate->debug()->OnCompileError(script);
 
   Factory* factory = isolate->factory();
-  Handle<Object> error =
+  Handle<JSObject> error =
       factory->NewSyntaxError(error_details_.message(), argument);
-
-  if (!error->IsJSObject()) {
-    isolate->Throw(*error, &location);
-    return;
-  }
-
-  Handle<JSObject> jserror = Handle<JSObject>::cast(error);
-
-  Handle<Name> key_start_pos = factory->error_start_pos_symbol();
-  Object::SetProperty(isolate, jserror, key_start_pos,
-                      handle(Smi::FromInt(location.start_pos()), isolate),
-                      StoreOrigin::kMaybeKeyed,
-                      Just(ShouldThrow::kThrowOnError))
-      .Check();
-
-  Handle<Name> key_end_pos = factory->error_end_pos_symbol();
-  Object::SetProperty(isolate, jserror, key_end_pos,
-                      handle(Smi::FromInt(location.end_pos()), isolate),
-                      StoreOrigin::kMaybeKeyed,
-                      Just(ShouldThrow::kThrowOnError))
-      .Check();
-
-  Handle<Name> key_script = factory->error_script_symbol();
-  Object::SetProperty(isolate, jserror, key_script, script,
-                      StoreOrigin::kMaybeKeyed,
-                      Just(ShouldThrow::kThrowOnError))
-      .Check();
-
-  isolate->Throw(*error, &location);
+  isolate->ThrowAt(error, &location);
 }
 
 Handle<String> PendingCompilationErrorHandler::FormatErrorMessageForTest(

src/runtime/runtime-scopes.cc

@@ -597,76 +597,6 @@ RUNTIME_FUNCTION(Runtime_NewClosure_Tenured) {
   return *function;
 }
 
-static Object FindNameClash(Isolate* isolate, Handle<ScopeInfo> scope_info,
-                            Handle<JSGlobalObject> global_object,
-                            Handle<ScriptContextTable> script_context) {
-  for (int var = 0; var < scope_info->ContextLocalCount(); var++) {
-    Handle<String> name(scope_info->ContextLocalName(var), isolate);
-    VariableMode mode = scope_info->ContextLocalMode(var);
-    ScriptContextTable::LookupResult lookup;
-    if (ScriptContextTable::Lookup(isolate, *script_context, *name, &lookup)) {
-      if (IsLexicalVariableMode(mode) || IsLexicalVariableMode(lookup.mode)) {
-        Handle<Context> context = ScriptContextTable::GetContext(
-            isolate, script_context, lookup.context_index);
-        // If we are trying to re-declare a REPL-mode let as a let, allow it.
-        if (!(mode == VariableMode::kLet && lookup.mode == VariableMode::kLet &&
-              scope_info->IsReplModeScope() &&
-              context->scope_info().IsReplModeScope())) {
-          // ES#sec-globaldeclarationinstantiation 5.b:
-          // If envRec.HasLexicalDeclaration(name) is true, throw a SyntaxError
-          // exception.
-          return ThrowRedeclarationError(isolate, name,
-                                         RedeclarationType::kSyntaxError);
-        }
-      }
-    }
-
-    if (IsLexicalVariableMode(mode)) {
-      LookupIterator it(isolate, global_object, name, global_object,
-                        LookupIterator::OWN_SKIP_INTERCEPTOR);
-      Maybe<PropertyAttributes> maybe = JSReceiver::GetPropertyAttributes(&it);
-      if (maybe.IsNothing()) return ReadOnlyRoots(isolate).exception();
-      if ((maybe.FromJust() & DONT_DELETE) != 0) {
-        // ES#sec-globaldeclarationinstantiation 5.a:
-        // If envRec.HasVarDeclaration(name) is true, throw a SyntaxError
-        // exception.
-        // ES#sec-globaldeclarationinstantiation 5.d:
-        // If hasRestrictedGlobal is true, throw a SyntaxError exception.
-        return ThrowRedeclarationError(isolate, name,
-                                       RedeclarationType::kSyntaxError);
-      }
-
-      JSGlobalObject::InvalidatePropertyCell(global_object, name);
-    }
-  }
-  return ReadOnlyRoots(isolate).undefined_value();
-}
-
-RUNTIME_FUNCTION(Runtime_NewScriptContext) {
-  HandleScope scope(isolate);
-  DCHECK_EQ(1, args.length());
-
-  CONVERT_ARG_HANDLE_CHECKED(ScopeInfo, scope_info, 0);
-  Handle<NativeContext> native_context(NativeContext::cast(isolate->context()),
-                                       isolate);
-  Handle<JSGlobalObject> global_object(native_context->global_object(),
-                                       isolate);
-  Handle<ScriptContextTable> script_context_table(
-      native_context->script_context_table(), isolate);
-
-  Object name_clash_result =
-      FindNameClash(isolate, scope_info, global_object, script_context_table);
-  if (isolate->has_pending_exception()) return name_clash_result;
-
-  Handle<Context> result =
-      isolate->factory()->NewScriptContext(native_context, scope_info);
-
-  Handle<ScriptContextTable> new_script_context_table =
-      ScriptContextTable::Extend(script_context_table, result);
-  native_context->set_script_context_table(*new_script_context_table);
-  return *result;
-}
-
 RUNTIME_FUNCTION(Runtime_NewFunctionContext) {
   HandleScope scope(isolate);
   DCHECK_EQ(1, args.length());

src/runtime/runtime.h

@@ -397,7 +397,6 @@ namespace internal {
   F(NewClosure_Tenured, 2, 1)               \
   F(NewFunctionContext, 1, 1)               \
   F(NewRestParameter, 1, 1)                 \
-  F(NewScriptContext, 1, 1)                 \
   F(NewSloppyArguments, 3, 1)               \
   F(NewSloppyArguments_Generic, 1, 1)       \
   F(NewStrictArguments, 1, 1)               \

test/inspector/console/scoped-variables-expected.txt

@@ -15,7 +15,7 @@ Evaluating 'let a = 239;'
         columnNumber : 0
         exception : {
             className : SyntaxError
-            description : SyntaxError: Identifier 'a' has already been declared     at <anonymous>:1:1
+            description : SyntaxError: Identifier 'a' has already been declared
             objectId : <objectId>
             subtype : error
             type : object
@@ -27,7 +27,7 @@ Evaluating 'let a = 239;'
     }
     result : {
         className : SyntaxError
-        description : SyntaxError: Identifier 'a' has already been declared     at <anonymous>:1:1
+        description : SyntaxError: Identifier 'a' has already been declared
         objectId : <objectId>
         subtype : error
         type : object