Re-introduce ImportDeclaration to the parser

src/ast.h

 // 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.
 
 #ifndef V8_AST_H_
 #define V8_AST_H_
 
 #include "src/v8.h"
 
 #include "src/assembler.h"
@@ skipping 591 matching lines @@
 
  private:
   Module* module_;
 };
 
 
 class ImportDeclaration FINAL : public Declaration {
  public:
   DECLARE_NODE_TYPE(ImportDeclaration)
 
-  Module* module() const { return module_; }
+  const AstRawString* import_name() const { return import_name_; }
+  const AstRawString* module_specifier() const { return module_specifier_; }

[rossberg, 2015/02/25 13:55:49]

Hm, is it necessary that the specifier is duplicated on every importdecl node?
That doesn't make sense from an AST perspective, and the fact that you then need
a setter doesn't make it better.

[arv (Not doing code reviews), 2015/02/25 16:07:25]

At the moment the actual import statement is not represented in the AST so then
I see why this is needed. I think this approach is fine (at least for now).

[adamk, 2015/02/25 21:43:12]

I'm open to other suggestions, but I don't think it will be clear until I get
further along what the right organization for this data will be, which is why I
went with this for now, basically a desugaring of

import {x, y} from "m.js"; -> import {x} from "m.js"; import {y} from "m.js";

just like we do

let x, y; -> let x; let y;

[rossberg, 2015/02/26 07:52:07]

But is this an adequate desugaring? Wouldn't those two forms have somewhat
different interactions with the loader, which might be observable if you
customise it?

Maybe it's fine, if this program equivalence actually holds. But keep in mind
that the AST is a rather specific abstraction, not just organising some data.

+  void set_module_specifier(const AstRawString* module_specifier) {
+    DCHECK(module_specifier_ == NULL);
+    module_specifier_ = module_specifier;
+  }
   InitializationFlag initialization() const OVERRIDE {
-    return kCreatedInitialized;
+    return kNeedsInitialization;
   }
 
  protected:
-  ImportDeclaration(Zone* zone,
-                    VariableProxy* proxy,
-                    Module* module,
-                    Scope* scope,
-                    int pos)
-      : Declaration(zone, proxy, LET, scope, pos),
-        module_(module) {
-  }
+  ImportDeclaration(Zone* zone, VariableProxy* proxy,
+                    const AstRawString* import_name,
+                    const AstRawString* module_specifier, Scope* scope, int pos)
+      : Declaration(zone, proxy, IMPORT, scope, pos),
+        import_name_(import_name),
+        module_specifier_(module_specifier) {}
 
  private:
-  Module* module_;
+  const AstRawString* import_name_;
+  const AstRawString* module_specifier_;
 };
 
 
 class ExportDeclaration FINAL : public Declaration {
  public:
   DECLARE_NODE_TYPE(ExportDeclaration)
 
   InitializationFlag initialization() const OVERRIDE {
     return kCreatedInitialized;
   }
@@ skipping 2509 matching lines @@
   }
 
   ModuleDeclaration* NewModuleDeclaration(VariableProxy* proxy,
                                           Module* module,
                                           Scope* scope,
                                           int pos) {
     return new (zone_) ModuleDeclaration(zone_, proxy, module, scope, pos);
   }
 
   ImportDeclaration* NewImportDeclaration(VariableProxy* proxy,
-                                          Module* module,
-                                          Scope* scope,
-                                          int pos) {
-    return new (zone_) ImportDeclaration(zone_, proxy, module, scope, pos);
+                                          const AstRawString* import_name,
+                                          const AstRawString* module_specifier,
+                                          Scope* scope, int pos) {
+    return new (zone_) ImportDeclaration(zone_, proxy, import_name,
+                                         module_specifier, scope, pos);
   }
 
   ExportDeclaration* NewExportDeclaration(VariableProxy* proxy,
                                           Scope* scope,
                                           int pos) {
     return new (zone_) ExportDeclaration(zone_, proxy, scope, pos);
   }
 
   ModuleLiteral* NewModuleLiteral(Block* body, ModuleDescriptor* descriptor,
                                   int pos) {
@@ skipping 318 matching lines @@
 
  private:
   Zone* zone_;
   AstValueFactory* ast_value_factory_;
 };
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_AST_H_