[modules] AST and parser rework.

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 "src/api.h"
 #include "src/ast/ast.h"
 #include "src/ast/ast-expression-rewriter.h"
 #include "src/ast/ast-expression-visitor.h"
@@ skipping 931 matching lines @@
     AstNodeFactory function_factory(ast_value_factory());
     FunctionState function_state(&function_state_, &scope_, scope,
                                  kNormalFunction, &function_factory);
 
     ZoneList<Statement*>* body = new(zone()) ZoneList<Statement*>(16, zone());
     bool ok = true;
     int beg_pos = scanner()->location().beg_pos;
     parsing_module_ = info->is_module();
     if (parsing_module_) {
       ParseModuleItemList(body, &ok);
+      ok = ok &&
+           scope_->module()->Validate(scope_, &pending_error_handler_, zone());
     } else {
       // Don't count the mode in the use counters--give the program a chance
       // to enable script-wide strict mode below.
       scope_->SetLanguageMode(info->language_mode());
       ParseStatementList(body, Token::EOS, &ok);
     }
 
     // The parser will peek but not consume EOS.  Our scope logically goes all
     // the way to the EOS, though.
     scope->set_end_position(scanner()->peek_location().beg_pos);
@@ skipping 350 matching lines @@
       }
     /* falls through */
     default:
       break;
   }
   return ParseStatement(NULL, kAllowLabelledFunctionStatement, ok);
 }
 
 
 Statement* Parser::ParseModuleItem(bool* ok) {
-  // (Ecma 262 6th Edition, 15.2):
+  // ecma262/#prod-ModuleItem
   // ModuleItem :
   //    ImportDeclaration
   //    ExportDeclaration
   //    StatementListItem
 
   switch (peek()) {
     case Token::IMPORT:
-      return ParseImportDeclaration(ok);
+      ParseImportDeclaration(CHECK_OK);
+      return factory()->NewEmptyStatement(kNoSourcePosition);
     case Token::EXPORT:
       return ParseExportDeclaration(ok);
     default:
       return ParseStatementListItem(ok);
   }
 }
 
 
 void* Parser::ParseModuleItemList(ZoneList<Statement*>* body, bool* ok) {

[adamk, 2016/07/13 18:38:21]

This doesn't seem to need a return value at all (could be "void" instead of
"void*"). ParseStatementList has other callers which is why it returns a void* I
think.

[neis, 2016/07/14 10:28:24]

void* is needed because of the beautiful CHECK_OK macro.

[adamk, 2016/07/14 18:26:33]

Except no one calls this with CHECK_OK. But I guess someone might in future,
doesn't matter much either way.

-  // (Ecma 262 6th Edition, 15.2):
+  // ecma262/#prod-Module
   // Module :
   //    ModuleBody?
   //
+  // ecma262/#prod-ModuleItemList
   // ModuleBody :
   //    ModuleItem*
 
   DCHECK(scope_->is_module_scope());
-
   while (peek() != Token::EOS) {
     Statement* stat = ParseModuleItem(CHECK_OK);
     if (stat && !stat->IsEmpty()) {
       body->Add(stat, zone());
     }
   }
-
-  // Check that all exports are bound.
-  ModuleDescriptor* descriptor = scope_->module();
-  for (ModuleDescriptor::Iterator it = descriptor->iterator(); !it.done();
-       it.Advance()) {
-    if (scope_->LookupLocal(it.local_name()) == NULL) {
-      // TODO(adamk): Pass both local_name and export_name once ParserTraits
-      // supports multiple arg error messages.
-      // Also try to report this at a better location.
-      ParserTraits::ReportMessage(MessageTemplate::kModuleExportUndefined,
-                                  it.local_name());
-      *ok = false;
-      return NULL;
-    }
-  }
-
   return NULL;
 }
 
 
 const AstRawString* Parser::ParseModuleSpecifier(bool* ok) {
   // ModuleSpecifier :
   //    StringLiteral
 
   Expect(Token::STRING, CHECK_OK);
   return GetSymbol(scanner());
@@ skipping 37 matching lines @@
     }
     export_names->Add(export_name, zone());
     local_names->Add(local_name, zone());
     export_locations->Add(scanner()->location(), zone());
     if (peek() == Token::RBRACE) break;
     Expect(Token::COMMA, CHECK_OK);
   }
 
   Expect(Token::RBRACE, CHECK_OK);
 
-  return 0;
+  return nullptr;
 }
 
 
-ZoneList<ImportDeclaration*>* Parser::ParseNamedImports(int pos, bool* ok) {
+ZoneList<const Parser::NamedImport*>* Parser::ParseNamedImports(
+    int pos, bool* ok) {
   // NamedImports :
   //   '{' '}'
   //   '{' ImportsList '}'
   //   '{' ImportsList ',' '}'
   //
   // ImportsList :
   //   ImportSpecifier
   //   ImportsList ',' ImportSpecifier
   //
   // ImportSpecifier :
   //   BindingIdentifier
   //   IdentifierName 'as' BindingIdentifier
 
   Expect(Token::LBRACE, CHECK_OK);
 
-  ZoneList<ImportDeclaration*>* result =
-      new (zone()) ZoneList<ImportDeclaration*>(1, zone());
+  auto result = new (zone()) ZoneList<const NamedImport*>(1, zone());
   while (peek() != Token::RBRACE) {
     const AstRawString* import_name = ParseIdentifierName(CHECK_OK);
     const AstRawString* local_name = import_name;
     // In the presence of 'as', the left-side of the 'as' can
     // be any IdentifierName. But without 'as', it must be a valid
     // BindingIdentifier.
     if (CheckContextualKeyword(CStrVector("as"))) {
       local_name = ParseIdentifierName(CHECK_OK);
     }
     if (!Token::IsIdentifier(scanner()->current_token(), STRICT, false,
                              parsing_module_)) {
       *ok = false;
       ReportMessage(MessageTemplate::kUnexpectedReserved);
-      return NULL;
+      return nullptr;
     } else if (IsEvalOrArguments(local_name)) {
       *ok = false;
       ReportMessage(MessageTemplate::kStrictEvalArguments);
-      return NULL;
+      return nullptr;
     }
-    VariableProxy* proxy = NewUnresolved(local_name, CONST);
-    ImportDeclaration* declaration =
-        factory()->NewImportDeclaration(proxy, import_name, NULL, scope_, pos);
-    Declare(declaration, DeclarationDescriptor::NORMAL, true, CHECK_OK);
-    result->Add(declaration, zone());
+
+    DeclareImport(local_name, position(), CHECK_OK);  // XXX

[adamk, 2016/07/13 18:38:22]

What's this XXX about? Should it be replaced with a TODO or removed?

[neis, 2016/07/14 10:28:24]

Just an indicator for you (see below). Removed now.

+
+    NamedImport* import = new (zone()->New(sizeof(NamedImport)))

[adamk, 2016/07/13 18:38:22]

Same as elsewhere, if you make NamedImport a ZoneObject then this gets cleaner.

[neis, 2016/07/14 10:28:24]

Done.

+        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);
-
   return result;
 }
 
 
-Statement* Parser::ParseImportDeclaration(bool* ok) {
+void* Parser::ParseImportDeclaration(bool* ok) {
   // ImportDeclaration :
   //   'import' ImportClause 'from' ModuleSpecifier ';'
   //   'import' ModuleSpecifier ';'
   //
   // ImportClause :
+  //   ImportedDefaultBinding
   //   NameSpaceImport
   //   NamedImports
-  //   ImportedDefaultBinding
   //   ImportedDefaultBinding ',' NameSpaceImport
   //   ImportedDefaultBinding ',' NamedImports
   //
   // NameSpaceImport :
   //   '*' 'as' ImportedBinding
 
   int pos = peek_position();
   Expect(Token::IMPORT, CHECK_OK);
 
   Token::Value tok = peek();
 
   // 'import' ModuleSpecifier ';'
   if (tok == Token::STRING) {
     const AstRawString* module_specifier = ParseModuleSpecifier(CHECK_OK);
-    scope_->module()->AddModuleRequest(module_specifier, zone());
     ExpectSemicolon(CHECK_OK);
-    return factory()->NewEmptyStatement(pos);
+    scope_->module()->AddEmptyImport(
+        module_specifier, scanner()->location(), zone());
+    return nullptr;
   }
 
   // Parse ImportedDefaultBinding if present.
-  ImportDeclaration* import_default_declaration = NULL;
+  const AstRawString* import_default_binding = nullptr;
+  Scanner::Location import_default_binding_loc;
   if (tok != Token::MUL && tok != Token::LBRACE) {
-    const AstRawString* local_name =
+    import_default_binding =
         ParseIdentifier(kDontAllowRestrictedIdentifiers, CHECK_OK);
-    VariableProxy* proxy = NewUnresolved(local_name, CONST);
-    import_default_declaration = factory()->NewImportDeclaration(
-        proxy, ast_value_factory()->default_string(), NULL, scope_, pos);
-    Declare(import_default_declaration, DeclarationDescriptor::NORMAL, true,
-            CHECK_OK);
+    import_default_binding_loc = scanner()->location();
+    DeclareImport(import_default_binding, pos, CHECK_OK);  // XXX

[adamk, 2016/07/13 18:38:22]

???

[neis, 2016/07/14 10:28:24]

Done.

   }
 
-  const AstRawString* module_instance_binding = NULL;
-  ZoneList<ImportDeclaration*>* named_declarations = NULL;
-  if (import_default_declaration == NULL || Check(Token::COMMA)) {
+  // 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);
-        module_instance_binding =
+        module_namespace_binding =
             ParseIdentifier(kDontAllowRestrictedIdentifiers, CHECK_OK);
-        // TODO(ES6): Add an appropriate declaration.
+        module_namespace_binding_loc = scanner()->location();
         break;
       }
 
       case Token::LBRACE:
-        named_declarations = ParseNamedImports(pos, CHECK_OK);
+        named_imports = ParseNamedImports(pos, CHECK_OK);
         break;
 
       default:
         *ok = false;
         ReportUnexpectedToken(scanner()->current_token());
-        return NULL;
+        return nullptr;
     }
   }
 
   ExpectContextualKeyword(CStrVector("from"), CHECK_OK);
   const AstRawString* module_specifier = ParseModuleSpecifier(CHECK_OK);
-  scope_->module()->AddModuleRequest(module_specifier, zone());
+  ExpectSemicolon(CHECK_OK);
 
-  if (module_instance_binding != NULL) {
-    // TODO(ES6): Set the module specifier for the module namespace binding.
+  // Now that we have all the information, we can make the appropriate
+  // declarations.
+
+  if (module_namespace_binding != nullptr) {
+    scope_->module()->AddStarImport(
+        module_namespace_binding, module_specifier,
+        module_namespace_binding_loc, zone());
+    // TODO(neis): Create special immutable binding for the namespace object.
   }
 
-  if (import_default_declaration != NULL) {
-    import_default_declaration->set_module_specifier(module_specifier);
+  // 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?
+
+  if (import_default_binding != nullptr) {
+    scope_->module()->AddNonStarImport(
+        ast_value_factory()->default_string(), import_default_binding,
+        module_specifier, import_default_binding_loc, zone());
+    // DeclareImport(import_default_binding, pos, CHECK_OK);

[adamk, 2016/07/13 18:38:22]

Are these what the XXXs are about?

[neis, 2016/07/14 10:28:24]

Exactly.

   }
 
-  if (named_declarations != NULL) {
-    for (int i = 0; i < named_declarations->length(); ++i) {
-      named_declarations->at(i)->set_module_specifier(module_specifier);
+  if (named_imports != nullptr) {
+    if (named_imports->length() == 0) {
+      scope_->module()->AddEmptyImport(
+          module_specifier, scanner()->location(), zone());
+    } else {
+      for (int i = 0; i < named_imports->length(); ++i) {
+        const NamedImport* import = named_imports->at(i);
+        scope_->module()->AddNonStarImport(
+            import->import_name, import->local_name,
+            module_specifier, import->location, zone());
+        // DeclareImport(import->local_name, pos, CHECK_OK);
+      }
     }
   }
 
-  ExpectSemicolon(CHECK_OK);
-  return factory()->NewEmptyStatement(pos);
+  return nullptr;
 }
 
 
 Statement* Parser::ParseExportDefault(bool* ok) {
   //  Supports the following productions, starting after the 'default' token:
-  //    'export' 'default' FunctionDeclaration
+  //    'export' 'default' HoistableDeclaration
   //    'export' 'default' ClassDeclaration
   //    'export' 'default' AssignmentExpression[In] ';'
 
   Expect(Token::DEFAULT, CHECK_OK);
   Scanner::Location default_loc = scanner()->location();
 
-  const AstRawString* default_string = ast_value_factory()->default_string();
-  ZoneList<const AstRawString*> names(1, zone());
+  ZoneList<const AstRawString*> local_names(1, zone());
   Statement* result = nullptr;
-  Expression* default_export = nullptr;
   switch (peek()) {
     case Token::FUNCTION:
-      result = ParseHoistableDeclaration(&names, true, CHECK_OK);
+      result = ParseHoistableDeclaration(&local_names, true, CHECK_OK);
       break;
 
     case Token::CLASS:
       Consume(Token::CLASS);
-      result = ParseClassDeclaration(&names, true, CHECK_OK);
+      result = ParseClassDeclaration(&local_names, true, CHECK_OK);
       break;
 
     case Token::ASYNC:
       if (allow_harmony_async_await() && PeekAhead() == Token::FUNCTION &&
           !scanner()->HasAnyLineTerminatorAfterNext()) {
         Consume(Token::ASYNC);
-        result = ParseAsyncFunctionDeclaration(&names, true, CHECK_OK);
+        result = ParseAsyncFunctionDeclaration(&local_names, true, CHECK_OK);
         break;
       }
     /* falls through */
 
     default: {
-      int pos = peek_position();
+      int pos = position();
       ExpressionClassifier classifier(this);
-      Expression* expr = ParseAssignmentExpression(true, &classifier, CHECK_OK);
+      Expression* value =
+          ParseAssignmentExpression(true, &classifier, CHECK_OK);
       RewriteNonPattern(&classifier, CHECK_OK);
 
+      if (value->IsAnonymousFunctionDefinition()) {
+        // Ensure that the function's "name" property gets set to "default", by
+        // rewriting e.g.
+        //   function () {}
+        // to
+        //   %SetFunctionName(function () {}, "default")
+        // Note that %SetFunctionName returns the function.
+        //
+        // TODO(neis): Make sure this only happens when the function value does
+        // not already have an own "name" property, as can happen with class
+        // literals:
+        //   class { static name() {} }
+        //
+        ZoneList<Expression*>* args =
+            new (zone()) ZoneList<Expression*>(1, zone());
+        args->Add(value, zone());
+        args->Add(factory()->NewStringLiteral(
+            ast_value_factory()->default_string(), kNoSourcePosition), zone());
+        value = factory()->NewCallRuntime(
+            Runtime::kFunctionSetName, args, kNoSourcePosition);

[adamk, 2016/07/13 18:38:22]

Oh, I didn't understand your question this morning. You want the logic that's
currently in ParserTraits::SetFunctionNameFromIdentifierRef(), rather than this
runtime call. That'll set the name in the FunctionLiteral or ClassLiteral AST
node, which will then be properly overridden.

[neis, 2016/07/14 10:28:23]

Ah, I see.  Done (with some refactoring of the existing SetFunctionNameFromFoo
functions).

+      }
+
+      const AstRawString* local_name =
+          ast_value_factory()->star_default_star_string();
+      local_names.Add(local_name, zone());
+
+      // It's fine to declare this as CONST because the user has no way of
+      // writing to it.
+      VariableProxy* proxy = NewUnresolved(local_name, CONST);
+      Declaration* declaration =
+          factory()->NewVariableDeclaration(proxy, CONST, scope_, pos);
+      Declare(declaration, DeclarationDescriptor::NORMAL, true, CHECK_OK);
+      proxy->var()->set_initializer_position(position());
+
+      Assignment* assignment = factory()->NewAssignment(
+          Token::INIT, proxy, value, kNoSourcePosition);
+      result = factory()->NewExpressionStatement(assignment, kNoSourcePosition);
+
       ExpectSemicolon(CHECK_OK);
-      result = factory()->NewExpressionStatement(expr, pos);
       break;
     }
   }
 
-  DCHECK_LE(names.length(), 1);
-  if (names.length() == 1) {
-    scope_->module()->AddLocalExport(default_string, names.first(), zone(), ok);
-    if (!*ok) {
-      ParserTraits::ReportMessageAt(
-          default_loc, MessageTemplate::kDuplicateExport, default_string);
-      return nullptr;
-    }
-  } else {
-    // TODO(ES6): Assign result to a const binding with the name "*default*"
-    // and add an export entry with "*default*" as the local name.
-    USE(default_export);
-  }
+  DCHECK_EQ(local_names.length(), 1);
+  scope_->module()->AddNonStarExport(
+      local_names.first(), ast_value_factory()->default_string(), default_loc,
+      zone());
 
+  DCHECK_NOT_NULL(result);
   return result;
 }
 
-
 Statement* Parser::ParseExportDeclaration(bool* ok) {
   // ExportDeclaration:
   //    'export' '*' 'from' ModuleSpecifier ';'
   //    'export' ExportClause ('from' ModuleSpecifier)? ';'
   //    'export' VariableStatement
   //    'export' Declaration
   //    'export' 'default' ... (handled in ParseExportDefault)
 
   int pos = peek_position();
   Expect(Token::EXPORT, CHECK_OK);
 
-  Statement* result = NULL;
+  Statement* result = nullptr;
   ZoneList<const AstRawString*> names(1, zone());
   switch (peek()) {
     case Token::DEFAULT:
       return ParseExportDefault(ok);
 
     case Token::MUL: {
       Consume(Token::MUL);
       ExpectContextualKeyword(CStrVector("from"), CHECK_OK);
       const AstRawString* module_specifier = ParseModuleSpecifier(CHECK_OK);
-      scope_->module()->AddModuleRequest(module_specifier, zone());
-      // TODO(ES6): scope_->module()->AddStarExport(...)
       ExpectSemicolon(CHECK_OK);
+      scope_->module()->AddStarExport(
+          module_specifier, scanner()->location(), zone());
       return factory()->NewEmptyStatement(pos);
     }
 
     case Token::LBRACE: {
       // There are two cases here:
       //
       // 'export' ExportClause ';'
       // and
       // 'export' ExportClause FromClause ';'
       //
       // In the first case, the exported identifiers in ExportClause must
       // not be reserved words, while in the latter they may be. We
       // pass in a location that gets filled with the first reserved word
       // encountered, and then throw a SyntaxError if we are in the
       // non-FromClause case.
       Scanner::Location reserved_loc = Scanner::Location::invalid();
       ZoneList<const AstRawString*> export_names(1, zone());
       ZoneList<Scanner::Location> export_locations(1, zone());
       ZoneList<const AstRawString*> local_names(1, zone());
       ParseExportClause(&export_names, &export_locations, &local_names,
                         &reserved_loc, CHECK_OK);
-      const AstRawString* indirect_export_module_specifier = NULL;
+      const AstRawString* module_specifier = nullptr;
       if (CheckContextualKeyword(CStrVector("from"))) {
-        indirect_export_module_specifier = ParseModuleSpecifier(CHECK_OK);
+        module_specifier = ParseModuleSpecifier(CHECK_OK);
       } else if (reserved_loc.IsValid()) {
         // No FromClause, so reserved words are invalid in ExportClause.
         *ok = false;
         ReportMessageAt(reserved_loc, MessageTemplate::kUnexpectedReserved);
-        return NULL;
+        return nullptr;
       }
       ExpectSemicolon(CHECK_OK);
       const int length = export_names.length();
       DCHECK_EQ(length, local_names.length());
       DCHECK_EQ(length, export_locations.length());
-      if (indirect_export_module_specifier == NULL) {
+      if (module_specifier == nullptr) {
         for (int i = 0; i < length; ++i) {
-          scope_->module()->AddLocalExport(export_names[i], local_names[i],
-                                           zone(), ok);
-          if (!*ok) {
-            ParserTraits::ReportMessageAt(export_locations[i],
-                                          MessageTemplate::kDuplicateExport,
-                                          export_names[i]);
-            return NULL;
-          }
+          scope_->module()->AddNonStarExport(local_names[i], export_names[i],
+                                             export_locations[i], zone());
         }
       } else {
-        scope_->module()->AddModuleRequest(indirect_export_module_specifier,
-                                           zone());
-        for (int i = 0; i < length; ++i) {
-          // TODO(ES6): scope_->module()->AddIndirectExport(...);(
+        if (length == 0) {

[adamk, 2016/07/13 18:38:22]

You can collapse this up into the outer if statement (I'd find it easier to
grok):

if (module_specifier == nullptr) {
} else if (length == 0) {
} else {
}

[neis, 2016/07/14 10:28:23]

Done. Also removed the TODO since the exact location doesn't really matter for
an empty import.

+          // TODO(neis): Provide better location.
+          scope_->module()->AddEmptyImport(
+              module_specifier, scanner()->location(), zone());
+        } else {
+          auto& import_names = local_names;

[adamk, 2016/07/13 18:38:22]

Is this just for clarity? I'd leave it out.

[neis, 2016/07/14 10:28:23]

Yes. Done. Instead, I renamed local_names to original_names.

+          for (int i = 0; i < length; ++i) {
+            scope_->module()->AddNonStarExport(
+                import_names[i], export_names[i], module_specifier,
+                export_locations[i], zone());
+          }
         }
       }
       return factory()->NewEmptyStatement(pos);
     }
 
     case Token::FUNCTION:
       result = ParseHoistableDeclaration(&names, false, CHECK_OK);
       break;
 
     case Token::CLASS:
       Consume(Token::CLASS);
       result = ParseClassDeclaration(&names, false, CHECK_OK);
       break;
 
     case Token::VAR:
     case Token::LET:
     case Token::CONST:
       result = ParseVariableStatement(kStatementListItem, &names, CHECK_OK);
       break;
 
     case Token::ASYNC:
       if (allow_harmony_async_await()) {
+        // TODO(neis): Why don't we have the same check here as in
+        // ParseStatementListItem?
         Consume(Token::ASYNC);
         result = ParseAsyncFunctionDeclaration(&names, false, CHECK_OK);
         break;
       }
     /* falls through */
 
     default:
       *ok = false;
       ReportUnexpectedToken(scanner()->current_token());
-      return NULL;
+      return nullptr;
   }
 
-  // Extract declared names into export declarations.
   ModuleDescriptor* descriptor = scope_->module();
   for (int i = 0; i < names.length(); ++i) {
-    descriptor->AddLocalExport(names[i], names[i], zone(), ok);
-    if (!*ok) {
-      // TODO(adamk): Possibly report this error at the right place.
-      ParserTraits::ReportMessage(MessageTemplate::kDuplicateExport, names[i]);
-      return NULL;
-    }
+    // TODO(neis): Provide better location.
+    descriptor->AddNonStarExport(
+        names[i], names[i], scanner()->location(), zone());
   }
 
   DCHECK_NOT_NULL(result);
   return result;
 }
 
 Statement* Parser::ParseStatement(ZoneList<const AstRawString*>* labels,
                                   AllowLabelledFunctionStatement allow_function,
                                   bool* ok) {
   // Statement ::
@@ skipping 135 matching lines @@
   // Let/const variables in harmony mode are always added to the immediately
   // enclosing scope.
   Scope* scope =
       IsLexicalVariableMode(mode) ? scope_ : 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, IMPORT);
+  Declaration* declaration =
+      factory()->NewVariableDeclaration(proxy, IMPORT, scope_, pos);
+  Declare(declaration, DeclarationDescriptor::NORMAL, true, CHECK_OK);
+  return nullptr;
+}
+
+
 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);
   bool is_function_declaration = declaration->IsFunctionDeclaration();
   if (scope == nullptr) scope = scope_;
@@ skipping 251 matching lines @@
 
   FuncNameInferrer::State fni_state(fni_);
   if (fni_ != NULL) fni_->PushEnclosingName(name);
   FunctionLiteral* fun = ParseFunctionLiteral(
       name, scanner()->location(), name_validity,
       is_generator ? FunctionKind::kGeneratorFunction
                    : is_async ? FunctionKind::kAsyncFunction
                               : FunctionKind::kNormalFunction,
       pos, FunctionLiteral::kDeclaration, language_mode(), CHECK_OK);
 
-  // Even if we're not at the top-level of the global or a function
-  // scope, we treat it as such and introduce the function with its
-  // initial value upon entering the corresponding scope.
   // In ES6, a function behaves as a lexical binding, except in
   // a script scope, or the initial scope of eval or another function.
   VariableMode mode =
       (!scope_->is_declaration_scope() || scope_->is_module_scope()) ? LET
                                                                      : VAR;
   VariableProxy* proxy = NewUnresolved(variable_name, mode);
   Declaration* declaration =
       factory()->NewFunctionDeclaration(proxy, mode, fun, scope_, pos);
   Declare(declaration, DeclarationDescriptor::NORMAL, true, CHECK_OK);
   if (names) names->Add(variable_name, zone());
@@ skipping 299 matching lines @@
   if (labels != NULL) {
     for (int i = labels->length(); i-- > 0; ) {
       if (labels->at(i) == label) {
         return true;
       }
     }
   }
   return false;
 }
 
+// TODO(neis): Better name.

[adamk, 2016/07/13 18:38:22]

Please expand on this TODO (why does it need a better name?) or remove it.

[neis, 2016/07/14 10:28:23]

This doesn't belong into this CL, removed.

 Statement* Parser::ParseFunctionDeclaration(bool* ok) {
   Consume(Token::FUNCTION);
   int pos = position();
   ParseFunctionFlags flags = ParseFunctionFlags::kIsNormal;
   if (Check(Token::MUL)) {
     flags |= ParseFunctionFlags::kIsGenerator;
     if (allow_harmony_restrictive_declarations()) {
       ParserTraits::ReportMessageAt(scanner()->location(),
                                     MessageTemplate::kGeneratorInLegacyContext);
       *ok = false;
@@ skipping 4493 matching lines @@
 
 #ifdef DEBUG
 void Parser::Print(AstNode* node) {
   ast_value_factory()->Internalize(Isolate::Current());
   node->Print(Isolate::Current());
 }
 #endif  // DEBUG
 
 }  // namespace internal
 }  // namespace v8