format with dart_style 0.2.0-rc.3

lib/src/codegen/ast_builder.dart

 // Copyright (c) 2015, 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.
 
 library dev_compiler.src.codegen.ast_builder;
 
 import 'package:analyzer/src/generated/ast.dart';
 import 'package:analyzer/src/generated/scanner.dart';
 import 'package:analyzer/src/generated/utilities_dart.dart';
 import 'package:logging/logging.dart' as logger;
@@ skipping 31 matching lines @@
   static ArgumentList argumentList(List<Expression> args) {
     return RawAstBuilder.argumentList(args);
   }
 
   static TypeName typeName(Identifier id, List<TypeName> args) {
     TypeArgumentList argList = null;
     if (args != null && args.length > 0) argList = typeArgumentList(args);
     return RawAstBuilder.typeName(id, argList);
   }
 
-  static FunctionTypeAlias functionTypeAlias(TypeName ret,
-      SimpleIdentifier name, List<TypeParameter> tParams,
+  static FunctionTypeAlias functionTypeAlias(
+      TypeName ret,
+      SimpleIdentifier name,
+      List<TypeParameter> tParams,
       List<FormalParameter> params) {
     TypeParameterList tps =
         (tParams.length == 0) ? null : typeParameterList(tParams);
     FormalParameterList fps = formalParameterList(params);
     return RawAstBuilder.functionTypeAlias(ret, name, tps, fps);
   }
 
   static BooleanLiteral booleanLiteral(bool b) {
     return RawAstBuilder.booleanLiteral(b);
   }
@@ skipping 180 matching lines @@
   }
 
   static FormalParameterList formalParameterList(List<FormalParameter> params) {
     return RawAstBuilder.formalParameterList(params);
   }
 
   static Block block(List<Statement> statements) {
     return RawAstBuilder.block(statements);
   }
 
-  static MethodDeclaration blockMethodDeclaration(TypeName rt,
-      SimpleIdentifier m, List<FormalParameter> params,
-      List<Statement> statements, {bool isStatic: false}) {
+  static MethodDeclaration blockMethodDeclaration(
+      TypeName rt,
+      SimpleIdentifier m,
+      List<FormalParameter> params,
+      List<Statement> statements,
+      {bool isStatic: false}) {
     FormalParameterList fl = formalParameterList(params);
     Block b = block(statements);
     BlockFunctionBody body = RawAstBuilder.blockFunctionBody(b);
     return RawAstBuilder.methodDeclaration(rt, m, fl, body, isStatic: isStatic);
   }
 
-  static FunctionDeclaration blockFunctionDeclaration(TypeName rt,
-      SimpleIdentifier f, List<FormalParameter> params,
+  static FunctionDeclaration blockFunctionDeclaration(
+      TypeName rt,
+      SimpleIdentifier f,
+      List<FormalParameter> params,
       List<Statement> statements) {
     FunctionExpression fexp = blockFunction(params, statements);
     return RawAstBuilder.functionDeclaration(rt, f, fexp);
   }
 
   static FunctionExpression blockFunction(
       List<FormalParameter> params, List<Statement> statements) {
     FormalParameterList fl = formalParameterList(params);
     Block b = block(statements);
     BlockFunctionBody body = RawAstBuilder.blockFunctionBody(b);
     return RawAstBuilder.functionExpression(fl, body);
   }
 
   static FunctionExpression expressionFunction(
-      List<FormalParameter> params, Expression body, [bool decl = false]) {
+      List<FormalParameter> params, Expression body,
+      [bool decl = false]) {
     FormalParameterList fl = formalParameterList(params);
     ExpressionFunctionBody b = RawAstBuilder.expressionFunctionBody(body, decl);
     return RawAstBuilder.functionExpression(fl, b);
   }
 
   static FunctionDeclarationStatement functionDeclarationStatement(
       TypeName rType, SimpleIdentifier name, FunctionExpression fe) {
     var fd = RawAstBuilder.functionDeclaration(rType, name, fe);
     return RawAstBuilder.functionDeclarationStatement(fd);
   }
@@ skipping 211 matching lines @@
     Token semi = (decl) ? new Token(TokenType.SEMICOLON, 0) : null;
     return new ExpressionFunctionBody(null, null, body, semi);
   }
 
   static FunctionDeclaration functionDeclaration(
       TypeName rt, SimpleIdentifier f, FunctionExpression fexp) {
     return new FunctionDeclaration(null, null, null, rt, null, f, fexp);
   }
 
   static MethodDeclaration methodDeclaration(TypeName rt, SimpleIdentifier m,
-      FormalParameterList fl, FunctionBody body, {bool isStatic: false}) {
+      FormalParameterList fl, FunctionBody body,
+      {bool isStatic: false}) {
     Token st = isStatic ? new KeywordToken(Keyword.STATIC, 0) : null;
     return new MethodDeclaration(
         null, null, null, st, rt, null, null, m, null, fl, body);
   }
 
   static FunctionExpression functionExpression(
       FormalParameterList fl, FunctionBody body) {
     return new FunctionExpression(null, fl, body);
   }
 
@@ skipping 39 matching lines @@
     Label l = new Label(s, new Token(TokenType.COLON, 0));
     return new NamedExpression(l, e);
   }
 
   static VariableDeclarationStatement variableDeclarationStatement(
       VariableDeclarationList varDecl) {
     var semi = new Token(TokenType.SEMICOLON, 0);
     return new VariableDeclarationStatement(varDecl, semi);
   }
 }