implement ES6 modules in JS AST.

lib/src/js/template.dart

 // Copyright (c) 2014, 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;
 
 class TemplateManager {
   Map<String, Template> expressionTemplates = new Map<String, Template>();
   Map<String, Template> statementTemplates = new Map<String, Template>();
 
   TemplateManager();
 
-
   Template lookupExpressionTemplate(String source) {
     return expressionTemplates[source];
   }
 
   Template defineExpressionTemplate(String source, Node ast) {
     Template template =
         new Template(source, ast, isExpression: true, forceCopy: false);
     expressionTemplates[source] = template;
     return template;
   }
@@ skipping 24 matching lines @@
 
   Instantiator instantiator;
 
   int positionalArgumentCount = -1;
 
   // Null, unless there are named holes.
   List<String> holeNames;
   bool get isPositional => holeNames == null;
 
   Template(this.source, this.ast,
-           {this.isExpression: true, this.forceCopy: false}) {
+      {this.isExpression: true, this.forceCopy: false}) {
     _compile();
   }
 
   Template.withExpressionResult(this.ast)
-      : source = null, isExpression = true, forceCopy = false {
+      : source = null,
+        isExpression = true,
+        forceCopy = false {
     assert(ast is Expression);
     assert(_checkNoPlaceholders());
     positionalArgumentCount = 0;
     instantiator = (arguments) => ast;
   }
 
   Template.withStatementResult(this.ast)
-      : source = null, isExpression = false, forceCopy = false {
+      : source = null,
+        isExpression = false,
+        forceCopy = false {
     assert(ast is Statement);
     assert(_checkNoPlaceholders());
     positionalArgumentCount = 0;
     instantiator = (arguments) => ast;
   }
 
   bool _checkNoPlaceholders() {
     InstantiatorGeneratorVisitor generator =
         new InstantiatorGeneratorVisitor(false);
     generator.compile(ast);
     return generator.analysis.count == 0;
   }
 
   void _compile() {
     InstantiatorGeneratorVisitor generator =
         new InstantiatorGeneratorVisitor(forceCopy);
     instantiator = generator.compile(ast);
     positionalArgumentCount = generator.analysis.count;
     Set<String> names = generator.analysis.holeNames;
-    holeNames = names.toList(growable:false);
+    holeNames = names.toList(growable: false);
   }
 
   /// Instantiates the template with the given [arguments].
   ///
   /// This method fills in the holes with the given arguments. The [arguments]
   /// must be either a [List] or a [Map].
   Node instantiate(var arguments) {
     if (arguments is List) {
       if (arguments.length != positionalArgumentCount) {
         throw 'Wrong number of template arguments, given ${arguments.length}, '
@@ skipping 27 matching lines @@
   }
 }
 
 /**
  * An Instantiator is a Function that generates a JS AST tree or List of
  * trees. [arguments] is a List for positional templates, or Map for
  * named templates.
  */
 typedef Instantiator(var arguments);
 
-
 /**
  * InstantiatorGeneratorVisitor compiles a template.  This class compiles a tree
  * containing [InterpolatedNode]s into a function that will create a copy of the
  * tree with the interpolated nodes substituted with provided values.
  */
 class InstantiatorGeneratorVisitor implements NodeVisitor<Instantiator> {
-
   final bool forceCopy;
 
   InterpolatedNodeAnalysis analysis = new InterpolatedNodeAnalysis();
 
   /**
    * The entire tree is cloned if [forceCopy] is true.
    */
   InstantiatorGeneratorVisitor(this.forceCopy);
 
   Instantiator compile(Node node) {
@@ skipping 69 matching lines @@
 
   Instantiator visitInterpolatedParameter(InterpolatedParameter node) {
     var nameOrPosition = node.nameOrPosition;
     return (arguments) {
       var value = arguments[nameOrPosition];
 
       Identifier toIdentifier(item) {
         if (item is Identifier) return item;
         if (item is String) return new Identifier(item);
         return error('Interpolated value #$nameOrPosition is not an Identifier'
-                     ' or List of Identifiers: $value');
+            ' or List of Identifiers: $value');
       }
       if (value is Iterable) return value.map(toIdentifier);
       return toIdentifier(value);
     };
   }
 
   Instantiator visitInterpolatedSelector(InterpolatedSelector node) {
     // A selector is an expression, as in `a[selector]`.
     // A String argument converted into a LiteralString, so `a.#` with argument
     // 'foo' generates `a["foo"]` which prints as `a.foo`.
@@ skipping 40 matching lines @@
     };
   }
 
   Instantiator visitSplayableStatement(Node node) {
     if (node is InterpolatedStatement) {
       var nameOrPosition = node.nameOrPosition;
       return (arguments) {
         var value = arguments[nameOrPosition];
         Statement toStatement(item) {
           if (item is Statement) return item;
-          if (item is Expression) return item.toStatement();;
+          if (item is Expression) return item.toStatement();
+          ;
           return error('Interpolated value #$nameOrPosition is not '
-                       'a Statement or List of Statements: $value');
+              'a Statement or List of Statements: $value');
         }
         if (value is Iterable) return value.map(toStatement);
         return toStatement(value);
       };
     }
     return visit(node);
   }
 
   Instantiator visitProgram(Program node) {
     List instantiators = node.body.map(visitSplayableStatement).toList();
@@ skipping 56 matching lines @@
   Instantiator visitIfConditionalCompilation(If node) {
     // Special version of visitInterpolatedExpression that permits bools.
     compileCondition(InterpolatedExpression node) {
       var nameOrPosition = node.nameOrPosition;
       return (arguments) {
         var value = arguments[nameOrPosition];
         if (value is bool) return value;
         if (value is Expression) return value;
         if (value is String) return new Identifier(value);
         error('Interpolated value #$nameOrPosition '
-              'is not an Expression: $value');
+            'is not an Expression: $value');
       };
     }
     var makeCondition = compileCondition(node.condition);
     Instantiator makeThen = visit(node.then);
     Instantiator makeOtherwise = visit(node.otherwise);
     return (arguments) {
       var condition = makeCondition(arguments);
       if (condition is bool) {
         if (condition == true) {
           return makeThen(arguments);
         } else {
           return makeOtherwise(arguments);
         }
       }
-      return new If(
-          condition,
-          makeThen(arguments),
-          makeOtherwise(arguments));
+      return new If(condition, makeThen(arguments), makeOtherwise(arguments));
     };
   }
 
   Instantiator visitIfNormal(If node) {
     Instantiator makeCondition = visit(node.condition);
     Instantiator makeThen = visit(node.then);
     Instantiator makeOtherwise = visit(node.otherwise);
     return (arguments) {
-      return new If(
-          makeCondition(arguments),
-          makeThen(arguments),
+      return new If(makeCondition(arguments), makeThen(arguments),
           makeOtherwise(arguments));
     };
   }
 
   Instantiator visitFor(For node) {
     Instantiator makeInit = visitNullable(node.init);
     Instantiator makeCondition = visitNullable(node.condition);
     Instantiator makeUpdate = visitNullable(node.update);
     Instantiator makeBody = visit(node.body);
     return (arguments) {
-      return new For(
-          makeInit(arguments), makeCondition(arguments), makeUpdate(arguments),
-          makeBody(arguments));
+      return new For(makeInit(arguments), makeCondition(arguments),
+          makeUpdate(arguments), makeBody(arguments));
     };
   }
 
   Instantiator visitForIn(ForIn node) {
     Instantiator makeLeftHandSide = visit(node.leftHandSide);
     Instantiator makeObject = visit(node.object);
     Instantiator makeBody = visit(node.body);
     return (arguments) {
-      return new ForIn(
-          makeLeftHandSide(arguments),
-          makeObject(arguments),
+      return new ForIn(makeLeftHandSide(arguments), makeObject(arguments),
           makeBody(arguments));
     };
   }
 
   Instantiator visitForOf(ForOf node) {
     Instantiator makeLeftHandSide = visit(node.leftHandSide);
     Instantiator makeObject = visit(node.iterable);
     Instantiator makeBody = visit(node.body);
     return (arguments) {
-      return new ForOf(
-          makeLeftHandSide(arguments),
-          makeObject(arguments),
+      return new ForOf(makeLeftHandSide(arguments), makeObject(arguments),
           makeBody(arguments));
     };
   }
 
   TODO(String name) {
     throw new UnimplementedError('$this.$name');
   }
 
   Instantiator visitWhile(While node) {
     Instantiator makeCondition = visit(node.condition);
@@ skipping 17 matching lines @@
   Instantiator visitBreak(Break node) =>
       (arguments) => new Break(node.targetLabel);
 
   Instantiator visitReturn(Return node) {
     Instantiator makeExpression = visitNullable(node.value);
     return (arguments) => new Return(makeExpression(arguments));
   }
 
   Instantiator visitDartYield(DartYield node) {
     Instantiator makeExpression = visit(node.expression);
-    return (arguments) => new DartYield(makeExpression(arguments), node.hasStar);
+    return (arguments) =>
+        new DartYield(makeExpression(arguments), node.hasStar);
   }
 
   Instantiator visitThrow(Throw node) {
     Instantiator makeExpression = visit(node.expression);
     return (arguments) => new Throw(makeExpression(arguments));
   }
 
   Instantiator visitTry(Try node) {
     Instantiator makeBody = visit(node.body);
     Instantiator makeCatch = visitNullable(node.catchPart);
     Instantiator makeFinally = visitNullable(node.finallyPart);
     return (arguments) => new Try(
         makeBody(arguments), makeCatch(arguments), makeFinally(arguments));
   }
 
   Instantiator visitCatch(Catch node) {
     Instantiator makeDeclaration = visit(node.declaration);
     Instantiator makeBody = visit(node.body);
-    return (arguments) => new Catch(
-        makeDeclaration(arguments), makeBody(arguments));
+    return (arguments) =>
+        new Catch(makeDeclaration(arguments), makeBody(arguments));
   }
 
   Instantiator visitSwitch(Switch node) {
     Instantiator makeKey = visit(node.key);
     Iterable<Instantiator> makeCases = node.cases.map(visit);
     return (arguments) {
-      return new Switch(makeKey(arguments),
-          makeCases.map((Instantiator makeCase) => makeCase(arguments))
-                   .toList());
+      return new Switch(
+          makeKey(arguments),
+          makeCases
+              .map((Instantiator makeCase) => makeCase(arguments))
+              .toList());
     };
   }
 
   Instantiator visitCase(Case node) {
     Instantiator makeExpression = visit(node.expression);
     Instantiator makeBody = visit(node.body);
     return (arguments) {
       return new Case(makeExpression(arguments), makeBody(arguments));
     };
   }
@@ skipping 34 matching lines @@
       return new VariableDeclarationList(node.keyword, declarations);
     };
   }
 
   Instantiator visitAssignment(Assignment node) {
     Instantiator makeLeftHandSide = visit(node.leftHandSide);
     String op = node.op;
     Instantiator makeValue = visitNullable(node.value);
     return (arguments) {
       return new Assignment.compound(
-          makeLeftHandSide(arguments),
-          op,
-          makeValue(arguments));
+          makeLeftHandSide(arguments), op, makeValue(arguments));
     };
   }
 
   Instantiator visitVariableInitialization(VariableInitialization node) {
     Instantiator makeDeclaration = visit(node.declaration);
     Instantiator makeValue = visitNullable(node.value);
     return (arguments) {
       return new VariableInitialization(
           makeDeclaration(arguments), makeValue(arguments));
     };
   }
 
   Instantiator visitConditional(Conditional cond) {
     Instantiator makeCondition = visit(cond.condition);
     Instantiator makeThen = visit(cond.then);
     Instantiator makeOtherwise = visit(cond.otherwise);
-    return (arguments) => new Conditional(
-        makeCondition(arguments),
-        makeThen(arguments),
-        makeOtherwise(arguments));
+    return (arguments) => new Conditional(makeCondition(arguments),
+        makeThen(arguments), makeOtherwise(arguments));
   }
 
   Instantiator visitNew(New node) =>
       handleCallOrNew(node, (target, arguments) => new New(target, arguments));
 
   Instantiator visitCall(Call node) =>
       handleCallOrNew(node, (target, arguments) => new Call(target, arguments));
 
   Instantiator handleCallOrNew(Call node, finish(target, arguments)) {
     Instantiator makeTarget = visit(node.target);
@@ skipping 40 matching lines @@
   Instantiator visitThis(This node) => (arguments) => new This();
   Instantiator visitSuper(Super node) => (arguments) => new Super();
 
   Instantiator visitIdentifier(Identifier node) =>
       (arguments) => new Identifier(node.name);
 
   Instantiator visitSpread(Spread node) =>
       (args) => new Spread(visit(node.argument)(args));
 
   Instantiator visitYield(Yield node) =>
-      (args) => new Yield(
-          node.value != null ? visit(node.value)(args) : null, star: node.star);
+      (args) => new Yield(node.value != null ? visit(node.value)(args) : null,
+          star: node.star);
 
   Instantiator visitRestParameter(RestParameter node) =>
       (args) => new RestParameter(visit(node.parameter)(args));
 
   Instantiator visitAccess(PropertyAccess node) {
     Instantiator makeReceiver = visit(node.receiver);
     Instantiator makeSelector = visit(node.selector);
     return (arguments) =>
         new PropertyAccess(makeReceiver(arguments), makeSelector(arguments));
   }
@@ skipping 41 matching lines @@
       (arguments) => new LiteralString(node.value);
 
   Instantiator visitLiteralNumber(LiteralNumber node) =>
       (arguments) => new LiteralNumber(node.value);
 
   Instantiator visitLiteralNull(LiteralNull node) =>
       (arguments) => new LiteralNull();
 
   Instantiator visitArrayInitializer(ArrayInitializer node) {
     // TODO(sra): Implement splicing?
-    List<Instantiator> elementMakers = node.elements
-        .map(visit)
-        .toList(growable: false);
+    List<Instantiator> elementMakers =
+        node.elements.map(visit).toList(growable: false);
     return (arguments) {
       List<Expression> elements = elementMakers
           .map((Instantiator instantiator) => instantiator(arguments))
           .toList(growable: false);
       return new ArrayInitializer(elements);
     };
   }
 
   Instantiator visitArrayHole(ArrayHole node) {
     return (arguments) => new ArrayHole();
@@ skipping 46 matching lines @@
   }
 
   Instantiator visitClassDeclaration(ClassDeclaration node) {
     Instantiator makeClass = visit(node.classExpr);
     return (arguments) {
       return new ClassDeclaration(makeClass(arguments));
     };
   }
 
   Instantiator visitClassExpression(ClassExpression node) {
-    List<Instantiator> makeMethods = node.methods.map(visitSplayableExpression)
-        .toList(growable: true);
+    List<Instantiator> makeMethods =
+        node.methods.map(visitSplayableExpression).toList(growable: true);
     Instantiator makeName = visit(node.name);
     Instantiator makeHeritage = visit(node.heritage);
 
     return (arguments) {
       var methods = <Method>[];
       for (Instantiator instantiator in makeMethods) {
         var result = instantiator(arguments);
         if (result is Iterable) {
           methods.addAll(result);
         } else {
           methods.add(result);
         }
       }
       return new ClassExpression(
           makeName(arguments), makeHeritage(arguments), methods);
     };
   }
 
   Instantiator visitMethod(Method node) {
     Instantiator makeName = visit(node.name);
     Instantiator makeFunction = visit(node.function);
     return (arguments) {
-      return new Method(
-          makeName(arguments),
-          makeFunction(arguments),
+      return new Method(makeName(arguments), makeFunction(arguments),
           isGetter: node.isGetter,
           isSetter: node.isSetter,
           isStatic: node.isStatic);
     };
   }
 
   Instantiator visitComment(Comment node) =>
       (arguments) => new Comment(node.comment);
 
   Instantiator visitCommentExpression(CommentExpression node) {
     Instantiator makeExpr = visit(node.expression);
     return (arguments) {
       return new CommentExpression(node.comment, makeExpr(arguments));
     };
   }
 
   Instantiator visitAwait(Await node) {
     Instantiator makeExpression = visit(node.expression);
     return (arguments) {
       return new Await(makeExpression(arguments));
     };
   }
+
+  // Note: these are not supported yet in the interpolation grammar.
+  Instantiator visitModule(Module node) => throw new UnimplementedError();
+  Instantiator visitNameSpecifier(NameSpecifier node) =>
+      throw new UnimplementedError();
+
+  Instantiator visitImportDeclaration(ImportDeclaration node) =>
+      throw new UnimplementedError();
+
+  Instantiator visitExportDeclaration(ExportDeclaration node) =>
+      throw new UnimplementedError();
+
+  Instantiator visitExportClause(ExportClause node) =>
+      throw new UnimplementedError();
 }
 
 /**
  * InterpolatedNodeAnalysis determines which AST trees contain
  * [InterpolatedNode]s, and the names of the named interpolated nodes.
  */
 class InterpolatedNodeAnalysis extends BaseVisitor {
   final Set<Node> containsInterpolatedNode = new Set<Node>();
   final Set<String> holeNames = new Set<String>();
   int count = 0;
@@ skipping 13 matching lines @@
     if (count != before) containsInterpolatedNode.add(node);
     return null;
   }
 
   visitInterpolatedNode(InterpolatedNode node) {
     containsInterpolatedNode.add(node);
     if (node.isNamed) holeNames.add(node.nameOrPosition);
     ++count;
   }
 }