use js_ast instead of strings to generate JS

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>();
 
@@ skipping 242 matching lines @@
 
   Instantiator visitInterpolatedStatement(InterpolatedStatement node) {
     var nameOrPosition = node.nameOrPosition;
     return (arguments) {
       var value = arguments[nameOrPosition];
       if (value is Node) return value.toStatement();
       error('Interpolated value #$nameOrPosition is not a Statement: $value');
     };
   }
 
+  Instantiator visitInterpolatedMethod(InterpolatedMethod node) {
+    var nameOrPosition = node.nameOrPosition;
+    return (arguments) {
+      var value = arguments[nameOrPosition];
+      Method toMethod(item) {
+        if (item is Method) return item;
+        return error('Interpolated value #$nameOrPosition is not a Method '
+            'or List of Methods: $value');
+      }
+      if (value is Iterable) return value.map(toMethod);
+      return toMethod(value);
+    };
+  }
+
+  Instantiator visitInterpolatedPropertyName(InterpolatedPropertyName node) {
+    var nameOrPosition = node.nameOrPosition;
+    return (arguments) {
+      var item = arguments[nameOrPosition];
+      if (item is PropertyName) return item;
+      if (item is String) return new PropertyName(item);
+      return error('Interpolated value #$nameOrPosition is not a '
+          'PropertyName or String: $item');
+    };
+  }
+
+  Instantiator visitInterpolatedVariableDeclaration(
+        InterpolatedVariableDeclaration node) {
+    var nameOrPosition = node.nameOrPosition;
+    return (arguments) {
+      var item = arguments[nameOrPosition];
+      if (item is VariableDeclaration) return item;
+      if (item is String) return new VariableDeclaration(item);
+      return error('Interpolated value #$nameOrPosition is not a '
+          'VariableDeclaration or String: $item');
+    };
+  }
+
   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();;
           return error('Interpolated value #$nameOrPosition is not '
                        'a Statement or List of Statements: $value');
@@ skipping 124 matching lines @@
     Instantiator makeObject = visit(node.object);
     Instantiator makeBody = visit(node.body);
     return (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),
+          makeBody(arguments));
+    };
+  }
+
   TODO(String name) {
     throw new UnimplementedError('$this.$name');
   }
 
   Instantiator visitWhile(While node) {
     Instantiator makeCondition = visit(node.condition);
     Instantiator makeBody = visit(node.body);
     return (arguments) {
       return new While(makeCondition(arguments), makeBody(arguments));
     };
@@ skipping 87 matching lines @@
 
   Instantiator visitVariableDeclarationList(VariableDeclarationList node) {
     List<Instantiator> declarationMakers =
         node.declarations.map(visit).toList();
     return (arguments) {
       List<VariableInitialization> declarations = <VariableInitialization>[];
       for (Instantiator instantiator in declarationMakers) {
         var result = instantiator(arguments);
         declarations.add(result);
       }
-      return new VariableDeclarationList(declarations);
+      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),
@@ skipping 66 matching lines @@
   Instantiator visitPostfix(Postfix node) {
     Instantiator makeOperand = visit(node.argument);
     String op = node.op;
     return (arguments) => new Postfix(op, makeOperand(arguments));
   }
 
   Instantiator visitVariableUse(VariableUse node) =>
       (arguments) => new VariableUse(node.name);
 
   Instantiator visitThis(This node) => (arguments) => new This();
+  Instantiator visitSuper(Super node) => (arguments) => new Super();
 
   Instantiator visitVariableDeclaration(VariableDeclaration node) =>
       (arguments) => new VariableDeclaration(node.name);
 
   Instantiator visitParameter(Parameter node) =>
       (arguments) => new Parameter(node.name);
 
   Instantiator visitAccess(PropertyAccess node) {
     Instantiator makeReceiver = visit(node.receiver);
     Instantiator makeSelector = visit(node.selector);
     return (arguments) =>
         new PropertyAccess(makeReceiver(arguments), makeSelector(arguments));
   }
 
   Instantiator visitNamedFunction(NamedFunction node) {
     Instantiator makeDeclaration = visit(node.name);
     Instantiator makeFunction = visit(node.function);
     return (arguments) =>
         new NamedFunction(makeDeclaration(arguments), makeFunction(arguments));
   }
 
-  Instantiator visitFun(Fun node) {
+  Instantiator visitFunctionExpression(FunctionExpression node) {
     List<Instantiator> paramMakers = node.params.map(visitSplayable).toList();
     Instantiator makeBody = visit(node.body);
     // TODO(sra): Avoid copying params if no interpolation or forced copying.
     return (arguments) {
       List<Parameter> params = <Parameter>[];
       for (Instantiator instantiator in paramMakers) {
         var result = instantiator(arguments);
         if (result is Iterable) {
           params.addAll(result);
         } else {
           params.add(result);
         }
       }
-      Statement body = makeBody(arguments);
-      return new Fun(params, body);
+      var body = makeBody(arguments);
+      if (node is ArrowFun) {
+        return new ArrowFun(params, body);
+      } else if (node is Fun) {
+        return new Fun(params, body);
+      } else {
+        throw "Unknown FunctionExpression type ${node.runtimeType}: $node";
+      }
     };
   }
 
+  Instantiator visitFun(Fun node) => visitFunctionExpression(node);
+
+  Instantiator visitArrowFun(ArrowFun node) => visitFunctionExpression(node);
+
   Instantiator visitLiteralBool(LiteralBool node) =>
       (arguments) => new LiteralBool(node.value);
 
   Instantiator visitLiteralString(LiteralString node) =>
       (arguments) => new LiteralString(node.value);
 
   Instantiator visitLiteralNumber(LiteralNumber node) =>
       (arguments) => new LiteralNumber(node.value);
 
   Instantiator visitLiteralNull(LiteralNull node) =>
@@ skipping 12 matching lines @@
     };
   }
 
   Instantiator visitArrayHole(ArrayHole node) {
     return (arguments) => new ArrayHole();
   }
 
   Instantiator visitObjectInitializer(ObjectInitializer node) {
     List<Instantiator> propertyMakers =
         node.properties.map(visitSplayable).toList();
-    bool isOneLiner = node.isOneLiner;
     return (arguments) {
       List<Property> properties = <Property>[];
       for (Instantiator instantiator in propertyMakers) {
         var result = instantiator(arguments);
         if (result is Iterable) {
           properties.addAll(result);
         } else {
           properties.add(result);
         }
       }
-      return new ObjectInitializer(properties, isOneLiner: isOneLiner);
+      return new ObjectInitializer(properties);
     };
   }
 
   Instantiator visitProperty(Property node) {
     Instantiator makeName = visit(node.name);
     Instantiator makeValue = visit(node.value);
     return (arguments) {
       return new Property(makeName(arguments), makeValue(arguments));
     };
   }
 
+  Instantiator visitPropertyName(PropertyName node) =>
+      (arguments) => new PropertyName(node.name);
+
   Instantiator visitRegExpLiteral(RegExpLiteral node) =>
       (arguments) => new RegExpLiteral(node.pattern);
 
-  Instantiator visitComment(Comment node) => TODO('visitComment');
+  Instantiator visitTemplateString(TemplateString node) {
+    Iterable makeElements =
+        node.elements.map((e) => e is String ? e : visit(e));
+    return (arguments) {
+      return new TemplateString(makeElements
+          .map((m) => m is String ? m : m(arguments))
+          .toList(growable: false));
+    };
+  }
+
+  Instantiator visitTaggedTemplate(TaggedTemplate node) {
+    Instantiator makeTag = visit(node.tag);
+    Instantiator makeTemplate = visit(node.template);
+    return (arguments) {
+      return new TaggedTemplate(makeTag(arguments), makeTemplate(arguments));
+    };
+  }
+
+  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);
+    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),
+          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));
     };
   }
 }
 
 /**
@@ skipping 20 matching lines @@
     if (count != before) containsInterpolatedNode.add(node);
     return null;
   }
 
   visitInterpolatedNode(InterpolatedNode node) {
     containsInterpolatedNode.add(node);
     if (node.isNamed) holeNames.add(node.nameOrPosition);
     ++count;
   }
 }