Implement modular compilation

lib/src/js_ast/nodes.dart

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 part of js_ast;
 
 abstract class NodeVisitor<T> implements TypeRefVisitor<T> {
   T visitProgram(Program node);
 
   T visitBlock(Block node);
@@ skipping 293 matching lines @@
   }
 }
 
 class Program extends Node {
   /// Script tag hash-bang, e.g. `#!/usr/bin/env node`
   final String scriptTag;
 
   /// Top-level statements in the program.
   final List<ModuleItem> body;
 
-  Program(this.body, {this.scriptTag});
+  /// The module's own name.
+  ///
+  /// This is not used in ES6, but is provided to allow module lowering.
+  final String name;
+
+  Program(this.body, {this.scriptTag, this.name});
 
   accept(NodeVisitor visitor) => visitor.visitProgram(this);
   void visitChildren(NodeVisitor visitor) {
     for (ModuleItem statement in body) statement.accept(visitor);
   }
   Program _clone() => new Program(body);
 }
 
 abstract class Statement extends ModuleItem {
   Statement toStatement() => this;
@@ skipping 409 matching lines @@
   // Code that uses JS must take care of operator precedences, and
   // put parenthesis if needed.
   int get precedenceLevel => PRIMARY;
 }
 
 /**
  * [VariableDeclarationList] is a subclass of [Expression] to simplify the
  * AST.
  */
 class VariableDeclarationList extends Expression {
-  /** The `var` or `let` keyword used for this variable declaration list. */
+  /**
+   * The `var` or `let` or `const` keyword used for this variable declaration
+   * list.
+   */
   final String keyword;
   final List<VariableInitialization> declarations;
 
   VariableDeclarationList(this.keyword, this.declarations);
 
   accept(NodeVisitor visitor) => visitor.visitVariableDeclarationList(this);
 
   void visitChildren(NodeVisitor visitor) {
     for (VariableInitialization declaration in declarations) {
       declaration.accept(visitor);
@@ skipping 971 matching lines @@
 abstract class ModuleItem extends Node {}
 
 class ImportDeclaration extends ModuleItem {
   final Identifier defaultBinding; // Can be null.
 
   // Can be null, a single specifier of `* as name`, or a list.
   final List<NameSpecifier> namedImports;
 
   final LiteralString from;
 
-  ImportDeclaration({this.defaultBinding, this.namedImports, this.from});
+  ImportDeclaration({this.defaultBinding, this.namedImports, this.from}) {
+    assert(from != null);
+  }
 
   /** The `import "name.js"` form of import */
   ImportDeclaration.all(LiteralString module) : this(from: module);
 
   /** If this import has `* as name` returns the name, otherwise null. */
-  String get importStarAs {
+  Identifier get importStarAs {
     if (namedImports != null && namedImports.length == 1 &&
-        namedImports[0].name == '*') {
+        namedImports[0].isStar) {
       return namedImports[0].asName;
     }
     return null;
   }
 
   accept(NodeVisitor visitor) => visitor.visitImportDeclaration(this);
   void visitChildren(NodeVisitor visitor) {
     if (namedImports != null) {
       for (NameSpecifier name in namedImports) name.accept(visitor);
     }
@@ skipping 18 matching lines @@
 
   ExportDeclaration(this.exported, {this.isDefault: false}) {
     assert(exported is ClassDeclaration ||
         exported is FunctionDeclaration ||
         isDefault
             ? exported is Expression
             : exported is VariableDeclarationList ||
               exported is ExportClause);
   }
 
+  /// Gets the list of names exported by this export declaration, or `null`
+  /// if this is an `export *`.
+  ///
+  /// This can be useful for lowering to other module formats.
+  List<Identifier> get exportedNames {
+    if (isDefault) return [new Identifier('default')];
+
+    var exported = this.exported;
+    if (exported is ClassDeclaration) return [exported.classExpr.name];
+    if (exported is FunctionDeclaration) return [exported.name];
+    if (exported is VariableDeclarationList) {
+      return exported.declarations.map((i) => i.declaration).toList();
+    }
+    if (exported is ExportClause) {
+      if (exported.exportStar) return null;
+      return exported.exports.map((e) => e.name).toList();
+    }
+    throw new StateError('invalid export declaration');
+  }
+
   accept(NodeVisitor visitor) => visitor.visitExportDeclaration(this);
   visitChildren(NodeVisitor visitor) => exported.accept(visitor);
   ExportDeclaration _clone() =>
       new ExportDeclaration(exported, isDefault: isDefault);
 }
 
 class ExportClause extends Node {
   final List<NameSpecifier> exports;
   final LiteralString from; // Can be null.
 
   ExportClause(this.exports, {this.from});
 
   /** The `export * from 'name.js'` form. */
   ExportClause.star(LiteralString from)
-      : this([new NameSpecifier('*')], from: from);
+      : this([new NameSpecifier.star()], from: from);
 
   /** True if this is an `export *`. */
-  bool get exportStar => exports.length == 1 && exports[0].name == '*';
+  bool get exportStar => exports.length == 1 && exports[0].isStar;
 
   accept(NodeVisitor visitor) => visitor.visitExportClause(this);
   void visitChildren(NodeVisitor visitor) {
     for (NameSpecifier name in exports) name.accept(visitor);
     if (from != null) from.accept(visitor);
   }
   ExportClause _clone() => new ExportClause(exports, from: from);
 }
 
 /** An import or export specifier. */
 class NameSpecifier extends Node {
-  // TODO(jmesserly): should we wrap this in a node of some sort?
-  final String name;
-  final String asName; // Can be null.
+  final Identifier name;
+  final Identifier asName; // Can be null.
 
   NameSpecifier(this.name, {this.asName});
+  NameSpecifier.star() : this(null);
+
+  /** True if this is a `* as someName` specifier. */
+  bool get isStar => name == null;
 
   accept(NodeVisitor visitor) => visitor.visitNameSpecifier(this);
   void visitChildren(NodeVisitor visitor) {}
   NameSpecifier _clone() => new NameSpecifier(name, asName: asName);
 }
 
 // TODO(jmesserly): should this be related to [Program]?
 class Module extends Node {
   /// The module's name
   // TODO(jmesserly): this is not declared in ES6, but is known by the loader.
   // We use this because some ES5 desugarings require it.
   final String name;
 
   final List<ModuleItem> body;
   Module(this.body, {this.name});
 
   accept(NodeVisitor visitor) => visitor.visitModule(this);
   void visitChildren(NodeVisitor visitor) {
     for (ModuleItem item in body) item.accept(visitor);
   }
   Module _clone() => new Module(body);
 }