fix for 1.12.0-dev SDK and 0.25.1 analyzer breaking changes

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 411 matching lines @@
 
   static ConditionalExpression conditionalExpression(
       Expression cond, Expression tExp, Expression fExp) {
     var q = new Token(TokenType.QUESTION, 0);
     var c = new Token(TokenType.COLON, 0);
     return new ConditionalExpression(cond, q, tExp, c, fExp);
   }
 
   static Expression functionExpressionInvocation(
       Expression function, ArgumentList es) {
-    return new FunctionExpressionInvocation(function, es);
+    return new FunctionExpressionInvocation(function, null, es);

[Jennifer Messerly, 2015/07/09 17:03:29]

the `null` is for generic type args \o/

   }
 
   static FormalParameterList formalParameterList(List<FormalParameter> params) {
     Token lp = new BeginToken(TokenType.OPEN_PAREN, 0);
     Token rp = new Token(TokenType.CLOSE_PAREN, 0);
     bool hasOptional = params.any((p) => p.kind == ParameterKind.POSITIONAL);
     bool hasNamed = params.any((p) => p.kind == ParameterKind.NAMED);
     assert(!(hasOptional && hasNamed));
     Token ld = null;
     Token rd = null;
@@ skipping 27 matching lines @@
   static FunctionDeclaration functionDeclaration(
       TypeName rt, Identifier f, FunctionExpression fexp) {
     return new FunctionDeclaration(null, null, null, rt, null, f, fexp);
   }
 
   static MethodDeclaration methodDeclaration(
       TypeName rt, Identifier m, 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, fl, body);
+        null, null, null, st, rt, null, null, m, null, fl, body);
   }
 
   static FunctionExpression functionExpression(
       FormalParameterList fl, FunctionBody body) {
-    return new FunctionExpression(fl, body);
+    return new FunctionExpression(null, fl, body);
   }
 
   static FunctionDeclarationStatement functionDeclarationStatement(
       FunctionDeclaration fd) {
     return new FunctionDeclarationStatement(fd);
   }
 
   static Statement returnExpression([Expression e]) {
     Token ret = new KeywordToken(Keyword.RETURN, 0);
     Token semi = new Token(TokenType.SEMICOLON, 0);
     return new ReturnStatement(ret, e, semi);
   }
 
   static SimpleFormalParameter simpleFormalParameter(Identifier v, TypeName t) {
     return new SimpleFormalParameter(null, <Annotation>[], null, t, v);
   }
 
   static FunctionTypedFormalParameter functionTypedFormalParameter(
       TypeName ret, Identifier v, FormalParameterList ps) {
-    return new FunctionTypedFormalParameter(null, <Annotation>[], ret, v, ps);
+    return new FunctionTypedFormalParameter(
+        null, <Annotation>[], ret, v, null, ps);
   }
 
   static FormalParameter requiredFormalParameter(NormalFormalParameter fp) {
     return fp;
   }
 
   static FormalParameter optionalFormalParameter(NormalFormalParameter fp) {
     return new DefaultFormalParameter(fp, ParameterKind.POSITIONAL, null, null);
   }
 
   static FormalParameter namedFormalParameter(NormalFormalParameter fp) {
     return new DefaultFormalParameter(fp, ParameterKind.NAMED, null, null);
   }
 
   static NamedExpression namedParameter(Identifier s, Expression e) {
     return namedExpression(s, e);
   }
 
   static NamedExpression namedExpression(Identifier s, Expression e) {
     Label l = new Label(s, new Token(TokenType.COLON, 0));
     return new NamedExpression(l, e);
   }
 }