Run dartfmt on js_ast

pkg/js_ast/lib/src/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}) {
     assert(this.isExpression ? ast is Expression : ast is Statement);
     _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 18 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 Node 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 66 matching lines @@
     if (node is InterpolatedExpression) {
       var nameOrPosition = node.nameOrPosition;
       return (arguments) {
         var value = arguments[nameOrPosition];
         Expression toExpression(item) {
           if (item is Expression) return item;
           if (item is String) return convertStringToVariableUse(item);
           return error('Interpolated value #$nameOrPosition is not '
               'an Expression or List of Expressions: $value');
         }
+
         if (value is Iterable) return value.map(toExpression);
         return toExpression(value);
       };
     }
     return visit(node);
   }
 
   Instantiator visitInterpolatedLiteral(InterpolatedLiteral node) {
     var nameOrPosition = node.nameOrPosition;
     return (arguments) {
       var value = arguments[nameOrPosition];
       if (value is Literal) return value;
       error('Interpolated value #$nameOrPosition is not a Literal: $value');
     };
   }
 
   Instantiator visitInterpolatedParameter(InterpolatedParameter node) {
     var nameOrPosition = node.nameOrPosition;
     return (arguments) {
       var value = arguments[nameOrPosition];
 
       Parameter toParameter(item) {
         if (item is Parameter) return item;
         if (item is String) return new Parameter(item);
         return error('Interpolated value #$nameOrPosition is not a Parameter or'
-                     ' List of Parameters: $value');
+            ' List of Parameters: $value');
       }
+
       if (value is Iterable) return value.map(toParameter);
       return toParameter(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`.
     var nameOrPosition = node.nameOrPosition;
@@ skipping 14 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();
     return (arguments) {
       List<Statement> statements = <Statement>[];
       void add(node) {
         if (node is EmptyStatement) return;
         if (node is Iterable) {
           statements.addAll(node);
         } else {
           statements.add(node.toStatement());
         }
       }
+
       for (Instantiator instantiator in instantiators) {
         add(instantiator(arguments));
       }
       return new Program(statements);
     };
   }
 
   Instantiator visitBlock(Block node) {
     List instantiators = node.statements.map(visitSplayableStatement).toList();
     return (arguments) {
       List<Statement> statements = <Statement>[];
       void add(node) {
         if (node is EmptyStatement) return;
         if (node is Iterable) {
           statements.addAll(node);
         } else if (node is Block) {
           statements.addAll(node.statements);
         } else {
           statements.add(node.toStatement());
         }
       }
+
       for (Instantiator instantiator in instantiators) {
         add(instantiator(arguments));
       }
       return new Block(statements);
     };
   }
 
   Instantiator visitExpressionStatement(ExpressionStatement node) {
     Instantiator buildExpression = visit(node.expression);
     return (arguments) {
@@ skipping 13 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 convertStringToVariableUse(value);;
+        if (value is String) return convertStringToVariableUse(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));
     };
   }
 
   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(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 78 matching lines @@
       }
       Statement body = makeBody(arguments);
       return new Fun(params, body);
     };
   }
 
   Instantiator visitDeferredExpression(DeferredExpression node) => same(node);
 
   Instantiator visitDeferredNumber(DeferredNumber node) => same(node);
 
-  Instantiator visitDeferredString(DeferredString node) =>
-      (arguments) => node;
+  Instantiator visitDeferredString(DeferredString node) => (arguments) => 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) =>
       (arguments) => new LiteralNull();
 
   Instantiator visitStringConcatenation(StringConcatenation node) {
-    List<Instantiator> partMakers = node.parts
-        .map(visit)
-        .toList(growable: false);
+    List<Instantiator> partMakers =
+        node.parts.map(visit).toList(growable: false);
     return (arguments) {
       List<Literal> parts = partMakers
           .map((Instantiator instantiator) => instantiator(arguments))
           .toList(growable: false);
       return new StringConcatenation(parts);
     };
   }
 
   Instantiator visitName(Name node) => same(node);
 
   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 61 matching lines @@
     node.visitChildren(this);
     if (count != before) containsInterpolatedNode.add(node);
   }
 
   visitInterpolatedNode(InterpolatedNode node) {
     containsInterpolatedNode.add(node);
     if (node.isNamed) holeNames.add(node.nameOrPosition);
     ++count;
   }
 }