Update to latest analyzer

test/codegen/language/async_await_test.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 async_await_test;
 
 import "package:unittest/unittest.dart";
 import "dart:async";
 
 main() {
@@ skipping 145 matching lines @@
     });
 
     test("async flattens futures, error", () {
       f() async {
         return new Future.error("err");  // Not awaited.
       };
       return throwsErr(f());
     });
 
     test("await for", () {
-      f(s) async {
+      f(Stream<int> s) async {
         int i = 0;
         await for (int v in s) {
           i += v;
         }
         return i;
       }
       return f(mkStream()).then((v) {
         expect(v, equals(45));  // 0 + 1 + ... + 9
       });
     });
 
     test("await for w/ await", () {
-      f(s) async {
+      f(Stream<int> s) async {
         int i = 0;
         await for (int v in s) {
           i += await new Future.value(v);
         }
         return i;
       }
       return f(mkStream()).then((v) {
         expect(v, equals(45));  // 0 + 1 + ... + 9
       });
     });
 
     test("await for empty", () {
-      f(s) async {
+      f(Stream<int> s) async {
         int v = 0;
         await for (int i in s) {
           v += i;
         }
         return v;
       }
-      var s = (new StreamController()..close()).stream;
+      var s = (new StreamController<int>()..close()).stream;
       return f(s).then((v) {
         expect(v, equals(0));
       });
     });
 
     if (checkedMode) {
       test("await for w/ await, asseert", () {
-        f(s) async {
+        f(Stream<int> s) async {
           int i = 0;
           await for (int v in s) {
             i += await new Future.microtask(() => v);
             assert(v < 8);
           }
           return i;
         }
         return f(mkStream()).then((v) {
           fail("assert didn't throw");
         }, onError: (e, s) {
@@ skipping 1571 matching lines @@
 id(v) {
   try {
     if (v != null) throw v;
   } catch (e) {
     return e;
   }
   return null;
 }
 
 // Create a stream for testing "async for-in".
-Stream mkStream() {
-  var c;
+Stream<int> mkStream() {
+  StreamController<int> c;
   int i = 0;
   next() {
     c.add(i++);
     if (i == 10) {
       c.close();
     } else {
       scheduleMicrotask(next);
     }
   }
   c = new StreamController(onListen: () {
@@ skipping 145 matching lines @@
   }
   return await inner(f);
 }
 
 /**
  * A non-standard implementation of Future with a value.
  */
 class FakeValueFuture implements Future {
   final _value;
   FakeValueFuture(this._value);
-  Future then(callback(value), {Function onError}) {
-    return new Future.microtask(() => callback(_value));
+  Future/*<S>*/ then/*<S>*/(/*=S*/ callback(value), {Function onError}) {
+    return new Future<dynamic /*=S*/>.microtask(() => callback(_value));
   }
   Future whenComplete(callback()) {
     return new Future.microtask(() { callback(); });
   }
   Future catchError(Function onError, {bool test(error)}) => this;
   Stream asStream() => (new StreamController()..add(_value)..close()).stream;
   Future timeout(Duration duration, {onTimeout()}) => this;
 }
 
 typedef BinaryFunction(a, b);
 
 /**
  * A non-standard implementation of Future with an error.
  */
 class FakeErrorFuture implements Future {
   final _error;
   FakeErrorFuture(this._error);
-  Future then(callback(value), {Function onError}) {
+  Future/*<S>*/ then/*<S>*/(/*=S*/ callback(value), {Function onError}) {
     if (onError != null) {
       if (onError is BinaryFunction) {
-        return new Future.microtask(() => onError(_error, null));
+        return new Future/*<S>*/.microtask(() => onError(_error, null));
       }
-      return new Future.microtask(() => onError(_error));
+      return new Future/*<S>*/.microtask(() => onError(_error));
     }
-    return this;
+    return new Future/*<S>*/.error(_error);
   }
   Future whenComplete(callback()) {
     return new Future.microtask(() { callback(); }).then((_) => this);
   }
   Future catchError(Function onError, {bool test(error)}) {
     return new Future.microtask(() {
       if (test != null && !test(_error)) return this;
       if (onError is BinaryFunction) {
         return onError(_error, null);
       }
       return onError(_error);
     });
   }
   Stream asStream() =>
       (new StreamController()..addError(_error)..close()).stream;
   Future timeout(Duration duration, {onTimeout()}) => this;
 }