[modules] AST and parser rework.

src/ast/modules.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_MODULES_H_
 #define V8_AST_MODULES_H_
 
+#include "src/parsing/scanner.h"  // Only for Scanner::Location.
+#include "src/pending-compilation-error-handler.h"
 #include "src/zone.h"
 
 namespace v8 {
 namespace internal {
 
 
 class AstRawString;
 
 
 class ModuleDescriptor : public ZoneObject {
  public:
-  // ---------------------------------------------------------------------------
-  // Factory methods.
+  explicit ModuleDescriptor(Zone* zone)
+      : exports_(1, zone), imports_(1, zone) {}
 
-  static ModuleDescriptor* New(Zone* zone) {
-    return new (zone) ModuleDescriptor(zone);
-  }
+  // import x from "foo.js";
+  // import {x} from "foo.js";
+  // import {x as y} from "foo.js";
+  void AddImport(
+    const AstRawString* import_name, const AstRawString* local_name,
+    const AstRawString* module_request, const Scanner::Location loc,
+    Zone* zone);
 
-  // ---------------------------------------------------------------------------
-  // Mutators.
+  // import * as x from "foo.js";
+  void AddStarImport(
+    const AstRawString* local_name, const AstRawString* module_request,
+    const Scanner::Location loc, Zone* zone);
 
-  // Add a name to the list of exports. If it already exists, that's an error.
-  void AddLocalExport(const AstRawString* export_name,
-                      const AstRawString* local_name, Zone* zone, bool* ok);
+  // import "foo.js";
+  // import {} from "foo.js";
+  // export {} from "foo.js";  (sic!)
+  void AddEmptyImport(
+      const AstRawString* module_request, const Scanner::Location loc,
+      Zone* zone);
 
-  // Add module_specifier to the list of requested modules,
-  // if not already present.
-  void AddModuleRequest(const AstRawString* module_specifier, Zone* zone);
+  // export {x};
+  // export {x as y};
+  // export VariableStatement
+  // export Declaration
+  // export default ...
+  void AddExport(
+    const AstRawString* local_name, const AstRawString* export_name,
+    const Scanner::Location loc, Zone* zone);
 
-  // Assign an index.
-  void Allocate(int index) {
-    DCHECK_EQ(-1, index_);
-    index_ = index;
-  }
+  // export {x} from "foo.js";
+  // export {x as y} from "foo.js";
+  void AddExport(
+    const AstRawString* export_name, const AstRawString* import_name,
+    const AstRawString* module_request, const Scanner::Location loc,
+    Zone* zone);
 
-  // ---------------------------------------------------------------------------
-  // Accessors.
+  // export * from "foo.js";
+  void AddStarExport(
+    const AstRawString* module_request, const Scanner::Location loc,
+    Zone* zone);
 
-  int Length() {
-    ZoneHashMap* exports = exports_;
-    return exports ? exports->occupancy() : 0;
-  }
+  // Check if module is well-formed and report error if not.
+  bool Validate(
+      Scope* module_scope, PendingCompilationErrorHandler* error_handler,
+      Zone* zone) const;
 
-  // The context slot in the hosting script context pointing to this module.
-  int Index() {
-    return index_;
-  }
 
-  const AstRawString* LookupLocalExport(const AstRawString* export_name,
-                                        Zone* zone);
+ private:
+  struct ModuleEntry : public ZoneObject {
+    const Scanner::Location location;
+    const AstRawString* export_name;
+    const AstRawString* local_name;
+    const AstRawString* import_name;
+    const AstRawString* module_request;
 
-  const ZoneList<const AstRawString*>& requested_modules() const {
-    return requested_modules_;
-  }
-
-  // ---------------------------------------------------------------------------
-  // Iterators.
-
-  // Use like:
-  //   for (auto it = descriptor->iterator(); !it.done(); it.Advance()) {
-  //     ... it.name() ...
-  //   }
-  class Iterator {
-   public:
-    bool done() const { return entry_ == NULL; }
-    const AstRawString* export_name() const {
-      DCHECK(!done());
-      return static_cast<const AstRawString*>(entry_->key);
-    }
-    const AstRawString* local_name() const {
-      DCHECK(!done());
-      return static_cast<const AstRawString*>(entry_->value);
-    }
-    void Advance() { entry_ = exports_->Next(entry_); }
-
-   private:
-    friend class ModuleDescriptor;
-    explicit Iterator(const ZoneHashMap* exports)
-        : exports_(exports), entry_(exports ? exports->Start() : NULL) {}
-
-    const ZoneHashMap* exports_;
-    ZoneHashMap::Entry* entry_;
+    explicit ModuleEntry(Scanner::Location loc)
+        : location(loc),
+          export_name(nullptr),
+          local_name(nullptr),
+          import_name(nullptr),
+          module_request(nullptr) {}
   };
 
-  Iterator iterator() const { return Iterator(this->exports_); }
-
-  // ---------------------------------------------------------------------------
-  // Implementation.
- private:
-  explicit ModuleDescriptor(Zone* zone)
-      : exports_(NULL), requested_modules_(1, zone), index_(-1) {}
-
-  ZoneHashMap* exports_;   // Module exports and their types (allocated lazily)
-  ZoneList<const AstRawString*> requested_modules_;
-  int index_;
+  ZoneList<const ModuleEntry*> exports_;
+  ZoneList<const ModuleEntry*> imports_;
 };
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_AST_MODULES_H_