Put a TypeProvider on the TypeSystem implementations.

pkg/analyzer/lib/src/generated/resolver.dart

 // Copyright (c) 2014, 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.src.generated.resolver;
 
 import 'dart:collection';
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/standard_resolution_map.dart';
@@ skipping 82 matching lines @@
   /**
    * Create a new instance of the [BestPracticesVerifier].
    *
    * @param errorReporter the error reporter
    */
   BestPracticesVerifier(this._errorReporter, TypeProvider typeProvider,
       this._currentLibrary, this._manager,
       {TypeSystem typeSystem})
       : _nullType = typeProvider.nullType,
         _futureNullType = typeProvider.futureNullType,
-        _typeSystem = typeSystem ?? new TypeSystemImpl() {
+        _typeSystem = typeSystem ?? new TypeSystemImpl(typeProvider) {
     inDeprecatedMember = _currentLibrary.isDeprecated;
   }
 
   @override
   Object visitAnnotation(Annotation node) {
     if (resolutionMap.elementAnnotationForAnnotation(node)?.isFactory == true) {
       AstNode parent = node.parent;
       if (parent is MethodDeclaration) {
         _checkForInvalidFactory(parent);
       } else {
@@ skipping 1777 matching lines @@
    *  The type system for this visitor
    */
   final TypeSystem _typeSystem;
 
   /**
    * Create a new instance of the [DeadCodeVerifier].
    *
    * @param errorReporter the error reporter
    */
   DeadCodeVerifier(this._errorReporter, {TypeSystem typeSystem})
-      : this._typeSystem = typeSystem ?? new TypeSystemImpl();
+      : this._typeSystem = typeSystem ?? new TypeSystemImpl(null);
 
   @override
   Object visitBinaryExpression(BinaryExpression node) {
     Token operator = node.operator;
     bool isAmpAmp = operator.type == TokenType.AMPERSAND_AMPERSAND;
     bool isBarBar = operator.type == TokenType.BAR_BAR;
     if (isAmpAmp || isBarBar) {
       Expression lhsCondition = node.leftOperand;
       if (!_isDebugConstant(lhsCondition)) {
         EvaluationResultImpl lhsResult = _getConstantBooleanValue(lhsCondition);
@@ skipping 2195 matching lines @@
    *
    * This will be used for inferring a block bodied lambda, if no context
    * type was available.
    */
   void addReturnOrYieldType(DartType type) {
     if (_returnStack.isEmpty) {
       return;
     }
 
     DartType inferred = _inferredReturn.last;
-    inferred = _typeSystem.getLeastUpperBound(_typeProvider, type, inferred);
+    inferred = _typeSystem.getLeastUpperBound(type, inferred);
     _inferredReturn[_inferredReturn.length - 1] = inferred;
   }
 
   /**
    * Match type [t1] against type [t2] as follows.
    * If `t1 = I<dynamic, ..., dynamic>`, then look for a supertype
    * of t1 of the form `K<S0, ..., Sm>` where `t2 = K<S0', ..., Sm'>`
    * If the supertype exists, use the constraints `S0 <: S0', ... Sm <: Sm'`
    * to derive a concrete instantation for I of the form `<T0, ..., Tn>`,
    * such that `I<T0, .., Tn> <: t2`
@@ skipping 2574 matching lines @@
     if (contextType is FunctionType) {
       DartType originalType = node.function.staticType;
       DartType returnContextType = InferenceContext.getContext(node);
       TypeSystem ts = typeSystem;
       if (returnContextType != null &&
           node.typeArguments == null &&
           originalType is FunctionType &&
           originalType.typeFormals.isNotEmpty &&
           ts is StrongTypeSystemImpl) {
         contextType = ts.inferGenericFunctionCall(
-            typeProvider,
             originalType,
             DartType.EMPTY_LIST,
             DartType.EMPTY_LIST,
             originalType.returnType,
             returnContextType);
       }
 
       InferenceContext.setType(node.argumentList, contextType);
     }
   }
@@ skipping 39 matching lines @@
     // If the expectedClosureType is not more specific than the static type,
     // return.
     DartType staticClosureType =
         resolutionMap.elementDeclaredByFunctionExpression(closure)?.type;
     if (staticClosureType != null &&
         !FunctionTypeImpl.relate(
             expectedClosureType,
             staticClosureType,
             (DartType t, DartType s, _, __) =>
                 (t as TypeImpl).isMoreSpecificThan(s),
-            new TypeSystemImpl().instantiateToBounds,
+            new TypeSystemImpl(typeProvider).instantiateToBounds,
             returnRelation: (s, t) => true)) {
       return;
     }
     // set propagated type for the closure
     if (!strongMode) {
       closure.propagatedType = expectedClosureType;
     }
     // set inferred types for parameters
     NodeList<FormalParameter> parameters = closure.parameters.parameters;
     List<ParameterElement> expectedParameters = expectedClosureType.parameters;
@@ skipping 2032 matching lines @@
         TypeName bound = typeParameter.bound;
         if (bound != null) {
           Element typeParameterElement = typeParameter.name.staticElement;
           if (typeParameterElement is TypeParameterElementImpl) {
             if (LibraryElementImpl.hasResolutionCapability(
                 library, LibraryResolutionCapability.resolvedTypeNames)) {
               bound.type = typeParameterElement.bound;
             } else {
               libraryScope ??= new LibraryScope(library);
               typeParametersScope ??= createTypeParametersScope();
-              typeNameResolver ??= new TypeNameResolver(new TypeSystemImpl(),
-                  typeProvider, library, source, errorListener);
+              typeNameResolver ??= new TypeNameResolver(
+                  new TypeSystemImpl(typeProvider),
+                  typeProvider,
+                  library,
+                  source,
+                  errorListener);
               typeNameResolver.nameScope = typeParametersScope;
               _resolveTypeName(bound);
               typeParameterElement.bound = bound.type;
             }
           }
         }
       }
     }
   }
 }
@@ skipping 1852 matching lines @@
 
   TypeSystem _typeSystem;
 
   _ConstantVerifier_validateInitializerExpression(
       TypeProvider typeProvider,
       ErrorReporter errorReporter,
       this.verifier,
       this.parameterElements,
       DeclaredVariables declaredVariables,
       {TypeSystem typeSystem})
-      : _typeSystem = typeSystem ?? new TypeSystemImpl(),
+      : _typeSystem = typeSystem ?? new TypeSystemImpl(typeProvider),
         super(
             new ConstantEvaluationEngine(typeProvider, declaredVariables,
                 typeSystem: typeSystem),
             errorReporter);
 
   @override
   DartObjectImpl visitSimpleIdentifier(SimpleIdentifier node) {
     Element element = node.staticElement;
     int length = parameterElements.length;
     for (int i = 0; i < length; i++) {
@@ skipping 85 matching lines @@
       return null;
     }
     if (identical(node.staticElement, variable)) {
       if (node.inSetterContext()) {
         result = true;
       }
     }
     return null;
   }
 }