Format all dart dev compiler files

pkg/dev_compiler/lib/src/js_ast/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 182 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 new Identifier(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 toIdentifier(item) {
         if (item is Parameter) return item;
         if (item is String) return new Identifier(item);
         return error('Interpolated value #$nameOrPosition is not an Identifier'
             ' 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`.
     var nameOrPosition = node.nameOrPosition;
@@ skipping 16 matching lines @@
 
   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 visitInterpolatedIdentifier(InterpolatedIdentifier node) {
     var nameOrPosition = node.nameOrPosition;
     return (arguments) {
       var item = arguments[nameOrPosition];
       if (item is Identifier) return item;
       if (item is String) return new Identifier(item);
       return error('Interpolated value #$nameOrPosition is not a '
           'Identifier 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');
         }
+
         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) {
           for (var n in node) statements.add(n);
         } 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) {
           for (var n in node) statements.add(n);
         } 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 18 matching lines @@
       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');
       };
     }
+
     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);
@@ skipping 178 matching lines @@
   }
 
   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));
   }
 
-  Instantiator visitNew(New node) =>
-      handleCallOrNew(node, (target, arguments) =>
-          new New(target, arguments as List<Expression>));
+  Instantiator visitNew(New node) => handleCallOrNew(node,
+      (target, arguments) => new New(target, arguments as List<Expression>));
 
-  Instantiator visitCall(Call node) =>
-      handleCallOrNew(node, (target, arguments) =>
-          new Call(target, arguments as List<Expression>));
+  Instantiator visitCall(Call node) => handleCallOrNew(node,
+      (target, arguments) => new Call(target, arguments as List<Expression>));
 
   Instantiator handleCallOrNew(Call node, finish(target, arguments)) {
     Instantiator makeTarget = visit(node.target);
     Iterable<Instantiator> argumentMakers =
         node.arguments.map(visitSplayableExpression).toList();
 
     // TODO(sra): Avoid copying call arguments if no interpolation or forced
     // copying.
     return (arguments) {
       Node target = makeTarget(arguments);
@@ skipping 320 matching lines @@
     if (count != before) containsInterpolatedNode.add(node);
     return null;
   }
 
   visitInterpolatedNode(InterpolatedNode node) {
     containsInterpolatedNode.add(node);
     if (node.isNamed) holeNames.add(node.nameOrPosition);
     ++count;
   }
 }