Make analyzer strong-mode clean

pkg/analyzer/test/generated/strong_mode_test.dart

 // Copyright (c) 2016, 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 analyzer.test.generated.strong_mode_test;
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/element/element.dart';
 import 'package:analyzer/dart/element/type.dart';
 import 'package:analyzer/src/dart/element/element.dart';
@@ skipping 204 matching lines @@
       BlockFunctionBody body = test.body;
       YieldStatement stmt = body.block.statements[0];
       Expression exp = stmt.expression;
       typeTest(exp.staticType);
     }
 
     check("g0", _isListOf(_isDynamic));
     check("g1", _isStreamOf([_isDynamic]));
 
     check("g2", _isListOf(_isInt));
-    check("g3", _isStreamOf([_isListOf(_isInt)]));
+    check("g3", _isStreamOf([(DartType type) => _isListOf(_isInt)(type)]));
   }
 
   void test_async_star_propagation() {
     String code = r'''
       import "dart:async";
 
       Stream g0() async* { yield []; }
       Stream g1() async* { yield* new Stream(); }
 
       Stream<List<int>> g2() async* { yield []; }
       Stream<List<int>> g3() async* { yield* new Stream(); }
    ''';
     CompilationUnit unit = resolveSource(code);
 
     void check(String name, Asserter<InterfaceType> typeTest) {
       FunctionDeclaration test = AstFinder.getTopLevelFunction(unit, name);
       BlockFunctionBody body = test.functionExpression.body;
       YieldStatement stmt = body.block.statements[0];
       Expression exp = stmt.expression;
       typeTest(exp.staticType);
     }
 
     check("g0", _isListOf(_isDynamic));
     check("g1", _isStreamOf([_isDynamic]));
 
     check("g2", _isListOf(_isInt));
-    check("g3", _isStreamOf([_isListOf(_isInt)]));
+    check("g3", _isStreamOf([(DartType type) => _isListOf(_isInt)(type)]));
   }
 
   void test_cascadeExpression() {
     String code = r'''
       class A<T> {
         List<T> map(T a, List<T> mapper(T x)) => mapper(a);
       }
 
       void main () {
         A<int> a = new A()..map(0, (x) => [x]);
@@ skipping 428 matching lines @@
         var map = { 42: [] };
       }
       class C extends A {
         get map => { 43: [] };
       }
    ''';
     CompilationUnit unit = resolveSource(code);
 
     Asserter<InterfaceType> assertListOfInt = _isListOf(_isInt);
     Asserter<InterfaceType> assertMapOfIntToListOfInt =
-        _isMapOf(_isInt, assertListOfInt);
+        _isMapOf(_isInt, (DartType type) => assertListOfInt(type));
 
     VariableDeclaration mapB = AstFinder.getFieldInClass(unit, "B", "map");
     MethodDeclaration mapC = AstFinder.getMethodInClass(unit, "C", "map");
     assertMapOfIntToListOfInt(mapB.element.type);
     assertMapOfIntToListOfInt(mapC.element.returnType);
 
     MapLiteral mapLiteralB = mapB.initializer;
     MapLiteral mapLiteralC = (mapC.body as ExpressionFunctionBody).expression;
     assertMapOfIntToListOfInt(mapLiteralB.staticType);
     assertMapOfIntToListOfInt(mapLiteralC.staticType);
@@ skipping 236 matching lines @@
     List<Statement> statements =
         AstFinder.getStatementsInTopLevelFunction(unit, "main");
     ListLiteral literal(int i) {
       VariableDeclarationStatement stmt = statements[i];
       VariableDeclaration decl = stmt.variables.variables[0];
       ListLiteral exp = decl.initializer;
       return exp;
     }
 
     Asserter<InterfaceType> assertListOfInt = _isListOf(_isInt);
-    Asserter<InterfaceType> assertListOfListOfInt = _isListOf(assertListOfInt);
+    Asserter<InterfaceType> assertListOfListOfInt =
+        _isListOf((DartType type) => assertListOfInt(type));
 
     assertListOfListOfInt(literal(0).staticType);
     assertListOfListOfInt(literal(1).staticType);
     assertListOfListOfInt(literal(2).staticType);
     assertListOfListOfInt(literal(3).staticType);
 
     assertListOfInt(literal(1).elements[0].staticType);
     assertListOfInt(literal(2).elements[0].staticType);
     assertListOfInt(literal(3).elements[0].staticType);
   }
@@ skipping 119 matching lines @@
         AstFinder.getStatementsInTopLevelFunction(unit, "main");
     MapLiteral literal(int i) {
       VariableDeclarationStatement stmt = statements[i];
       VariableDeclaration decl = stmt.variables.variables[0];
       MapLiteral exp = decl.initializer;
       return exp;
     }
 
     Asserter<InterfaceType> assertListOfString = _isListOf(_isString);
     Asserter<InterfaceType> assertMapOfIntToListOfString =
-        _isMapOf(_isInt, assertListOfString);
+        _isMapOf(_isInt, (DartType type) => assertListOfString(type));
 
     assertMapOfIntToListOfString(literal(0).staticType);
     assertMapOfIntToListOfString(literal(1).staticType);
     assertMapOfIntToListOfString(literal(2).staticType);
     assertMapOfIntToListOfString(literal(3).staticType);
     assertMapOfIntToListOfString(literal(4).staticType);
 
     assertListOfString(literal(1).entries[0].value.staticType);
     assertListOfString(literal(2).entries[0].value.staticType);
     assertListOfString(literal(3).entries[0].value.staticType);
@@ skipping 133 matching lines @@
       BlockFunctionBody body = test.body;
       YieldStatement stmt = body.block.statements[0];
       Expression exp = stmt.expression;
       typeTest(exp.staticType);
     }
 
     check("f0", _isListOf(_isDynamic));
     check("f1", _isListOf(_isDynamic));
 
     check("f2", _isListOf(_isInt));
-    check("f3", _isListOf(_isListOf(_isInt)));
+    check("f3", _isListOf((DartType type) => _isListOf(_isInt)(type)));
   }
 
   void test_sync_star_propagation() {
     String code = r'''
       import "dart:async";
 
       Iterable f0() sync* { yield []; }
       Iterable f1() sync* { yield* new List(); }
 
       Iterable<List<int>> f2() sync* { yield []; }
       Iterable<List<int>> f3() sync* { yield* new List(); }
    ''';
     CompilationUnit unit = resolveSource(code);
 
     void check(String name, Asserter<InterfaceType> typeTest) {
       FunctionDeclaration test = AstFinder.getTopLevelFunction(unit, name);
       BlockFunctionBody body = test.functionExpression.body;
       YieldStatement stmt = body.block.statements[0];
       Expression exp = stmt.expression;
       typeTest(exp.staticType);
     }
 
     check("f0", _isListOf(_isDynamic));
     check("f1", _isListOf(_isDynamic));
 
     check("f2", _isListOf(_isInt));
-    check("f3", _isListOf(_isListOf(_isInt)));
+    check("f3", _isListOf((DartType type) => _isListOf(_isInt)(type)));
   }
 }
 
 /**
  * Strong mode static analyzer end to end tests
  */
 @reflectiveTest
 class StrongModeStaticTypeAnalyzer2Test extends StaticTypeAnalyzer2TestShared {
   void fail_genericMethod_tearoff_instantiated() {
     resolveTestUnit(r'''
@@ skipping 1017 matching lines @@
 main() {
   var v = x;
   v; // marker
 }
 int x = 3;
 ''';
     assertPropagatedAssignedType(code, typeProvider.intType, null);
     assertTypeOfMarkedExpression(code, typeProvider.intType, null);
   }
 }