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

src/full-codegen.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/v8.h"
 
 #include "src/ast.h"
 #include "src/ast-numbering.h"
 #include "src/code-factory.h"
 #include "src/codegen.h"
@@ skipping 583 matching lines @@
 
 void FullCodeGenerator::DoTest(const TestContext* context) {
   DoTest(context->condition(),
          context->true_label(),
          context->false_label(),
          context->fall_through());
 }
 
 
 void FullCodeGenerator::AllocateModules(ZoneList<Declaration*>* declarations) {
-  DCHECK(scope_->is_global_scope());
+  DCHECK(scope_->is_script_scope());
 
   for (int i = 0; i < declarations->length(); i++) {
     ModuleDeclaration* declaration = declarations->at(i)->AsModuleDeclaration();
     if (declaration != NULL) {
       ModuleLiteral* module = declaration->module()->AsModuleLiteral();
       if (module != NULL) {
         Comment cmnt(masm_, "[ Link nested modules");
         Scope* scope = module->body()->scope();
         Interface* interface = scope->interface();
         DCHECK(interface->IsModule() && interface->IsFrozen());
@@ skipping 20 matching lines @@
   }
 }
 
 
 // Modules have their own local scope, represented by their own context.
 // Module instance objects have an accessor for every export that forwards
 // access to the respective slot from the module's context. (Exports that are
 // modules themselves, however, are simple data properties.)
 //
 // All modules have a _hosting_ scope/context, which (currently) is the
-// (innermost) enclosing global scope. To deal with recursion, nested modules
-// are hosted by the same scope as global ones.
+// enclosing script scope. To deal with recursion, nested modules are hosted
+// by the same scope as global ones.
 //
 // For every (global or nested) module literal, the hosting context has an
 // internal slot that points directly to the respective module context. This
 // enables quick access to (statically resolved) module members by 2-dimensional
 // access through the hosting context. For example,
 //
 //   module A {
 //     let x;
 //     module B { let y; }
 //   }
 //   module C { let z; }
 //
 // allocates contexts as follows:
 //
 // [header| .A | .B | .C | A | C ]  (global)
 //           |    |    |
 //           |    |    +-- [header| z ]  (module)
 //           |    |
 //           |    +------- [header| y ]  (module)
 //           |
 //           +------------ [header| x | B ]  (module)
 //
 // Here, .A, .B, .C are the internal slots pointing to the hosted module
 // contexts, whereas A, B, C hold the actual instance objects (note that every
 // module context also points to the respective instance object through its
 // extension slot in the header).
 //
 // To deal with arbitrary recursion and aliases between modules,
 // they are created and initialized in several stages. Each stage applies to
-// all modules in the hosting global scope, including nested ones.
+// all modules in the hosting script scope, including nested ones.
 //
 // 1. Allocate: for each module _literal_, allocate the module contexts and
 //    respective instance object and wire them up. This happens in the
 //    PushModuleContext runtime function, as generated by AllocateModules
 //    (invoked by VisitDeclarations in the hosting scope).
 //
 // 2. Bind: for each module _declaration_ (i.e. literals as well as aliases),
 //    assign the respective instance object to respective local variables. This
 //    happens in VisitModuleDeclaration, and uses the instance objects created
 //    in the previous stage.
@@ skipping 14 matching lines @@
   Handle<FixedArray> saved_modules = modules_;
   int saved_module_index = module_index_;
   ZoneList<Handle<Object> >* saved_globals = globals_;
   ZoneList<Handle<Object> > inner_globals(10, zone());
   globals_ = &inner_globals;
 
   if (scope_->num_modules() != 0) {
     // This is a scope hosting modules. Allocate a descriptor array to pass
     // to the runtime for initialization.
     Comment cmnt(masm_, "[ Allocate modules");
-    DCHECK(scope_->is_global_scope());
+    DCHECK(scope_->is_script_scope());
     modules_ =
         isolate()->factory()->NewFixedArray(scope_->num_modules(), TENURED);
     module_index_ = 0;
 
     // Generate code for allocating all modules, including nested ones.
     // The allocated contexts are stored in internal variables in this scope.
     AllocateModules(declarations);
   }
 
   AstVisitor::VisitDeclarations(declarations);
@@ skipping 1067 matching lines @@
   }
   return true;
 }
 #endif  // DEBUG
 
 
 #undef __
 
 
 } }  // namespace v8::internal