[modules] Mark namespace variables as kCreatedInitialized.

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.h"
@@ skipping 1472 matching lines @@
                              parsing_module_)) {
       *ok = false;
       ReportMessage(MessageTemplate::kUnexpectedReserved);
       return nullptr;
     } else if (IsEvalOrArguments(local_name)) {
       *ok = false;
       ReportMessage(MessageTemplate::kStrictEvalArguments);
       return nullptr;
     }
 
-    DeclareImport(local_name, position(), CHECK_OK);
+    DeclareConstVariable(local_name, kNeedsInitialization, position(),
+                         CHECK_OK);
 
     NamedImport* import = new (zone()) NamedImport(
         import_name, local_name, scanner()->location());
     result->Add(import, zone());
 
     if (peek() == Token::RBRACE) break;
     Expect(Token::COMMA, CHECK_OK);
   }
 
   Expect(Token::RBRACE, CHECK_OK);
@@ skipping 29 matching lines @@
     return;
   }
 
   // Parse ImportedDefaultBinding if present.
   const AstRawString* import_default_binding = nullptr;
   Scanner::Location import_default_binding_loc;
   if (tok != Token::MUL && tok != Token::LBRACE) {
     import_default_binding =
         ParseIdentifier(kDontAllowRestrictedIdentifiers, CHECK_OK_VOID);
     import_default_binding_loc = scanner()->location();
-    DeclareImport(import_default_binding, pos, CHECK_OK_VOID);
+    DeclareConstVariable(import_default_binding, kNeedsInitialization, pos,
+                         CHECK_OK_VOID);
   }
 
   // Parse NameSpaceImport or NamedImports if present.
   const AstRawString* module_namespace_binding = nullptr;
   Scanner::Location module_namespace_binding_loc;
   const ZoneList<const NamedImport*>* named_imports = nullptr;
   if (import_default_binding == nullptr || Check(Token::COMMA)) {
     switch (peek()) {
       case Token::MUL: {
         Consume(Token::MUL);
         ExpectContextualKeyword(CStrVector("as"), CHECK_OK_VOID);
         module_namespace_binding =
             ParseIdentifier(kDontAllowRestrictedIdentifiers, CHECK_OK_VOID);
         module_namespace_binding_loc = scanner()->location();
-        DeclareImport(module_namespace_binding, pos, CHECK_OK_VOID);
+        DeclareConstVariable(module_namespace_binding, kCreatedInitialized, pos,
+                             CHECK_OK_VOID);
         break;
       }
 
       case Token::LBRACE:
         named_imports = ParseNamedImports(pos, CHECK_OK_VOID);
         break;
 
       default:
         *ok = false;
         ReportUnexpectedToken(scanner()->current_token());
         return;
     }
   }
 
   ExpectContextualKeyword(CStrVector("from"), CHECK_OK_VOID);
   const AstRawString* module_specifier = ParseModuleSpecifier(CHECK_OK_VOID);
   ExpectSemicolon(CHECK_OK_VOID);
 
   // Now that we have all the information, we can make the appropriate
   // declarations.
 
-  // TODO(neis): Would prefer to call DeclareImport below rather than above and
-  // in ParseNamedImports, but then a possible error message would point to the
-  // wrong location.  Maybe have a DeclareAt version of Declare that takes a
-  // location?
+  // TODO(neis): Would prefer to call DeclareConstVariable for each case below
+  // rather than above and in ParseNamedImports, but then a possible error
+  // message would point to the wrong location.  Maybe have a DeclareAt version
+  // of Declare that takes a location?
 
   if (module_namespace_binding != nullptr) {
     module()->AddStarImport(module_namespace_binding, module_specifier,
                             module_namespace_binding_loc, zone());
-    // DeclareImport(module_namespace_binding, pos, CHECK_OK_VOID);
   }
 
   if (import_default_binding != nullptr) {
     module()->AddImport(ast_value_factory()->default_string(),
                         import_default_binding, module_specifier,
                         import_default_binding_loc, zone());
-    // DeclareImport(import_default_binding, pos, CHECK_OK_VOID);
   }
 
   if (named_imports != nullptr) {
     if (named_imports->length() == 0) {
       module()->AddEmptyImport(module_specifier, scanner()->location(), zone());
     } else {
       for (int i = 0; i < named_imports->length(); ++i) {
         const NamedImport* import = named_imports->at(i);
         module()->AddImport(import->import_name, import->local_name,
                             module_specifier, import->location, zone());
-        // DeclareImport(import->local_name, pos, CHECK_OK_VOID);
       }
     }
   }
 }
 
 
 Statement* Parser::ParseExportDefault(bool* ok) {
   //  Supports the following productions, starting after the 'default' token:
   //    'export' 'default' HoistableDeclaration
   //    'export' 'default' ClassDeclaration
@@ skipping 317 matching lines @@
   // scope.
   // Let/const variables are always added to the immediately enclosing scope.
   Scope* scope = IsLexicalVariableMode(mode)
                      ? this->scope()
                      : this->scope()->DeclarationScope();
   return scope->NewUnresolved(factory(), name, Variable::NORMAL,
                               scanner()->location().beg_pos,
                               scanner()->location().end_pos);
 }
 
-
-void Parser::DeclareImport(const AstRawString* local_name, int pos, bool* ok) {
-  DCHECK_NOT_NULL(local_name);
-  VariableProxy* proxy = NewUnresolved(local_name, CONST);
+void Parser::DeclareConstVariable(const AstRawString* name,
+                                  InitializationFlag init, int pos, bool* ok) {
+  DCHECK_NOT_NULL(name);
+  VariableProxy* proxy = NewUnresolved(name, CONST);
   Declaration* declaration =
-      factory()->NewVariableDeclaration(proxy, CONST, scope(), pos);
+      factory()->NewVariableDeclaration(proxy, CONST, scope(), init, pos);
   Declare(declaration, DeclarationDescriptor::NORMAL, true, CHECK_OK_VOID);
 }

[neis, 2016/08/03 14:48:14]

I will try to reuse this function in other places, perhaps in a slightly
generalized form.  I think these three steps are very common.

 
 
 Variable* Parser::Declare(Declaration* declaration,
                           DeclarationDescriptor::Kind declaration_kind,
                           bool resolve, bool* ok, Scope* scope) {
   VariableProxy* proxy = declaration->proxy();
   DCHECK(proxy->raw_name() != NULL);
   const AstRawString* name = proxy->raw_name();
   VariableMode mode = declaration->mode();
   DCHECK(IsDeclaredVariableMode(mode) && mode != CONST_LEGACY);
@@ skipping 5161 matching lines @@
   node->Print(Isolate::Current());
 }
 #endif  // DEBUG
 
 #undef CHECK_OK
 #undef CHECK_OK_VOID
 #undef CHECK_FAILED
 
 }  // namespace internal
 }  // namespace v8