Various clean-ups after top-level lexical declarations are done.

src/runtime/runtime-scopes.cc

 // Copyright 2014 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/v8.h"
 
 #include "src/accessors.h"
 #include "src/arguments.h"
 #include "src/frames-inl.h"
 #include "src/runtime/runtime-utils.h"
 #include "src/scopeinfo.h"
 #include "src/scopes.h"
 
 namespace v8 {
 namespace internal {
 
 static Object* ThrowRedeclarationError(Isolate* isolate, Handle<String> name) {
   HandleScope scope(isolate);
   Handle<Object> args[1] = {name};
   THROW_NEW_ERROR_RETURN_FAILURE(
       isolate, NewTypeError("var_redeclaration", HandleVector(args, 1)));
 }
 
 
 // May throw a RedeclarationError.
 static Object* DeclareGlobals(Isolate* isolate, Handle<GlobalObject> global,
                               Handle<String> name, Handle<Object> value,
                               PropertyAttributes attr, bool is_var,
                               bool is_const, bool is_function) {
-  Handle<GlobalContextTable> global_contexts(
-      global->native_context()->global_context_table());
-  GlobalContextTable::LookupResult lookup;
-  if (GlobalContextTable::Lookup(global_contexts, name, &lookup) &&
+  Handle<ScriptContextTable> script_contexts(
+      global->native_context()->script_context_table());
+  ScriptContextTable::LookupResult lookup;
+  if (ScriptContextTable::Lookup(script_contexts, name, &lookup) &&
       IsLexicalVariableMode(lookup.mode)) {
     return ThrowRedeclarationError(isolate, name);
   }
 
   // Do the lookup own properties only, see ES5 erratum.
   LookupIterator it(global, name, LookupIterator::HIDDEN_SKIP_INTERCEPTOR);
   Maybe<PropertyAttributes> maybe = JSReceiver::GetPropertyAttributes(&it);
   if (!maybe.has_value) return isolate->heap()->exception();
 
   if (it.IsFound()) {
@@ skipping 146 matching lines @@
                                            global, name, value, attr));
 
   return *value;
 }
 
 
 RUNTIME_FUNCTION(Runtime_DeclareLookupSlot) {
   HandleScope scope(isolate);
   DCHECK(args.length() == 4);
 
-  // Declarations are always made in a function, native, or global context. In
+  // Declarations are always made in a function, eval or script context. In
   // the case of eval code, the context passed is the context of the caller,
   // which may be some nested context and not the declaration context.
   CONVERT_ARG_HANDLE_CHECKED(Context, context_arg, 0);
   Handle<Context> context(context_arg->declaration_context());
   CONVERT_ARG_HANDLE_CHECKED(String, name, 1);
   CONVERT_SMI_ARG_CHECKED(attr_arg, 2);
   PropertyAttributes attr = static_cast<PropertyAttributes>(attr_arg);
   RUNTIME_ASSERT(attr == READ_ONLY || attr == NONE);
   CONVERT_ARG_HANDLE_CHECKED(Object, initial_value, 3);
 
@@ skipping 299 matching lines @@
 
   // The caller ensures that we pretenure closures that are assigned
   // directly to properties.
   PretenureFlag pretenure_flag = pretenure ? TENURED : NOT_TENURED;
   return *isolate->factory()->NewFunctionFromSharedFunctionInfo(shared, context,
                                                                 pretenure_flag);
 }
 
 static Object* FindNameClash(Handle<ScopeInfo> scope_info,
                              Handle<GlobalObject> global_object,
-                             Handle<GlobalContextTable> global_context) {
+                             Handle<ScriptContextTable> script_context) {
   Isolate* isolate = scope_info->GetIsolate();
   for (int var = 0; var < scope_info->ContextLocalCount(); var++) {
     Handle<String> name(scope_info->ContextLocalName(var));
     VariableMode mode = scope_info->ContextLocalMode(var);
-    GlobalContextTable::LookupResult lookup;
-    if (GlobalContextTable::Lookup(global_context, name, &lookup)) {
+    ScriptContextTable::LookupResult lookup;
+    if (ScriptContextTable::Lookup(script_context, name, &lookup)) {
       if (IsLexicalVariableMode(mode) || IsLexicalVariableMode(lookup.mode)) {
         return ThrowRedeclarationError(isolate, name);
       }
     }
 
     if (IsLexicalVariableMode(mode)) {
       LookupIterator it(global_object, name,
                         LookupIterator::HIDDEN_SKIP_INTERCEPTOR);
       Maybe<PropertyAttributes> maybe = JSReceiver::GetPropertyAttributes(&it);
       if (!maybe.has_value) return isolate->heap()->exception();
       if ((maybe.value & DONT_DELETE) != 0) {
         return ThrowRedeclarationError(isolate, name);
       }
 
       GlobalObject::InvalidatePropertyCell(global_object, name);
     }
   }
   return isolate->heap()->undefined_value();
 }
 
 
-RUNTIME_FUNCTION(Runtime_NewGlobalContext) {
+RUNTIME_FUNCTION(Runtime_NewScriptContext) {
   HandleScope scope(isolate);
   DCHECK(args.length() == 2);
 
   CONVERT_ARG_HANDLE_CHECKED(JSFunction, function, 0);
   CONVERT_ARG_HANDLE_CHECKED(ScopeInfo, scope_info, 1);
   Handle<GlobalObject> global_object(function->context()->global_object());
   Handle<Context> native_context(global_object->native_context());
-  Handle<GlobalContextTable> global_context_table(
-      native_context->global_context_table());
+  Handle<ScriptContextTable> script_context_table(
+      native_context->script_context_table());
 
   Handle<String> clashed_name;
   Object* name_clash_result =
-      FindNameClash(scope_info, global_object, global_context_table);
+      FindNameClash(scope_info, global_object, script_context_table);
   if (isolate->has_pending_exception()) return name_clash_result;
 
   Handle<Context> result =
-      isolate->factory()->NewGlobalContext(function, scope_info);
+      isolate->factory()->NewScriptContext(function, scope_info);
 
   DCHECK(function->context() == isolate->context());
   DCHECK(function->context()->global_object() == result->global_object());
 
-  Handle<GlobalContextTable> new_global_context_table =
-      GlobalContextTable::Extend(global_context_table, result);
-  native_context->set_global_context_table(*new_global_context_table);
+  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(args.length() == 1);
 
   CONVERT_ARG_HANDLE_CHECKED(JSFunction, function, 0);
 
@@ skipping 89 matching lines @@
 }
 
 
 RUNTIME_FUNCTION(Runtime_PushModuleContext) {
   SealHandleScope shs(isolate);
   DCHECK(args.length() == 2);
   CONVERT_SMI_ARG_CHECKED(index, 0);
 
   if (!args[1]->IsScopeInfo()) {
     // Module already initialized. Find hosting context and retrieve context.
-    Context* host = Context::cast(isolate->context())->global_context();
+    Context* host = Context::cast(isolate->context())->script_context();
     Context* context = Context::cast(host->get(index));
     DCHECK(context->previous() == isolate->context());
     isolate->set_context(context);
     return context;
   }
 
   CONVERT_ARG_HANDLE_CHECKED(ScopeInfo, scope_info, 1);
 
   // Allocate module context.
   HandleScope scope(isolate);
   Factory* factory = isolate->factory();
   Handle<Context> context = factory->NewModuleContext(scope_info);
   Handle<JSModule> module = factory->NewJSModule(context, scope_info);
   context->set_module(*module);
   Context* previous = isolate->context();
   context->set_previous(previous);
   context->set_closure(previous->closure());
   context->set_global_object(previous->global_object());
   isolate->set_context(*context);
 
   // Find hosting scope and initialize internal variable holding module there.
-  previous->global_context()->set(index, *context);
+  previous->script_context()->set(index, *context);
 
   return *context;
 }
 
 
 RUNTIME_FUNCTION(Runtime_DeclareModules) {
   HandleScope scope(isolate);
   DCHECK(args.length() == 1);
   CONVERT_ARG_HANDLE_CHECKED(FixedArray, descriptions, 0);
   Context* host_context = isolate->context();
@@ skipping 354 matching lines @@
   return Smi::FromInt(frame->GetArgumentsLength());
 }
 
 
 RUNTIME_FUNCTION(RuntimeReference_Arguments) {
   SealHandleScope shs(isolate);
   return __RT_impl_Runtime_GetArgumentsProperty(args, isolate);
 }
 }
 }  // namespace v8::internal