Put a TypeProvider on the TypeSystem implementations.

pkg/analyzer/lib/src/task/strong/checker.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.
 
 // TODO(jmesserly): this was ported from package:dev_compiler, and needs to be
 // refactored to fit into analyzer.
 library analyzer.src.task.strong.checker;
 
 import 'package:analyzer/analyzer.dart';
 import 'package:analyzer/dart/ast/ast.dart';
@@ skipping 20 matching lines @@
 /// interested in the expression's own type, it can often be a "strict arrow"
 /// because we know it evaluates to a specific, concrete function, and we can
 /// treat "dynamic" as top for that case, which is more permissive.
 DartType getDefiniteType(
     Expression expression, TypeSystem typeSystem, TypeProvider typeProvider) {
   DartType type = expression.staticType ?? DynamicTypeImpl.instance;
   if (typeSystem is StrongTypeSystemImpl &&
       type is FunctionType &&
       _hasStrictArrow(expression)) {
     // Remove fuzzy arrow if possible.
-    return typeSystem.functionTypeToConcreteType(typeProvider, type);
+    return typeSystem.functionTypeToConcreteType(type);
   }
   return type;
 }
 
 bool isKnownFunction(Expression expression) {
   var element = _getKnownElement(expression);
   // First class functions and static methods, where we know the original
   // declaration, will have an exact type, so we know a downcast will fail.
   return element is FunctionElement ||
       element is MethodElement && element.isStatic;
@@ skipping 646 matching lines @@
       var functionType = methodElement.type;
       var paramTypes = functionType.normalParameterTypes;
       assert(paramTypes.length == 1);
       assert(functionType.namedParameterTypes.isEmpty);
       assert(functionType.optionalParameterTypes.isEmpty);
 
       // Refine the return type.
       var rhsType = _getDefiniteType(expr.rightHandSide);
       var lhsType = _getDefiniteType(expr.leftHandSide);
       var returnType = rules.refineBinaryExpressionType(
-          typeProvider, lhsType, op, rhsType, functionType.returnType);
+          lhsType, op, rhsType, functionType.returnType);
 
       // Check the argument for an implicit cast.
       _checkImplicitCast(expr.rightHandSide, paramTypes[0], from: rhsType);
 
       // Check the return type for an implicit cast.
       //
       // If needed, mark the assignment to indicate a down cast when we assign
       // back to it. So these two implicit casts are equivalent:
       //
       //     y = /*implicit cast*/(y + 42);
@@ skipping 175 matching lines @@
         // that the user defined method accepts an `int` as the RHS.
         //
         // We assume Analyzer has done this already (in ErrorVerifier).
         //
         // However, we also need to check the return type.
 
         // Refine the return type.
         var functionType = element.type;
         var rhsType = typeProvider.intType;
         var lhsType = _getDefiniteType(operand);
-        var returnType = rules.refineBinaryExpressionType(typeProvider, lhsType,
-            TokenType.PLUS, rhsType, functionType.returnType);
+        var returnType = rules.refineBinaryExpressionType(
+            lhsType, TokenType.PLUS, rhsType, functionType.returnType);
 
         // Skip the argument check - `int` cannot be downcast.
         //
         // Check the return type for an implicit cast.
         //
         // If needed, mark the assignment to indicate a down cast when we assign
         // back to it. So these two implicit casts are equivalent:
         //
         //     y = /*implicit cast*/(y + 1);
         //     /*implicit assignment cast*/y++;
@@ skipping 584 matching lines @@
     var visited = new Set<InterfaceType>();
     do {
       visited.add(current);
       current.mixins.reversed.forEach(
           (m) => _checkIndividualOverridesFromClass(node, m, seen, true));
       _checkIndividualOverridesFromClass(node, current.superclass, seen, true);
       current = current.superclass;
     } while (!current.isObject && !visited.contains(current));
   }
 }