Declare type system fields as Dart2TypeSystem where we cast them.

[email protected]

Change-Id: I88fea5ee5ba278dbdaf350ff1db7407d2d8625d0
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/117821
Commit-Queue: Konstantin Shcheglov <[email protected]>
Reviewed-by: Brian Wilkerson <[email protected]>

Author: scheglov

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

@@ -3048,7 +3048,7 @@ class ResolverVisitor extends ScopedVisitor {
   StaticTypeAnalyzer typeAnalyzer;
 
   /// The type system in use during resolution.
-  TypeSystem typeSystem;
+  Dart2TypeSystem typeSystem;
 
   /// The class declaration representing the class containing the current node,
   /// or `null` if the current node is not contained in a class.
@@ -4813,12 +4813,10 @@ class ResolverVisitor extends ScopedVisitor {
       DartType uninstantiatedType, TypeArgumentList typeArguments,
       {AstNode errorNode, bool isConst: false}) {
     errorNode ??= inferenceNode;
-    TypeSystem ts = typeSystem;
     if (typeArguments == null &&
         uninstantiatedType is FunctionType &&
-        uninstantiatedType.typeFormals.isNotEmpty &&
-        ts is Dart2TypeSystem) {
-      var typeArguments = ts.inferGenericFunctionOrType(
+        uninstantiatedType.typeFormals.isNotEmpty) {
+      var typeArguments = typeSystem.inferGenericFunctionOrType(
         typeParameters: uninstantiatedType.typeFormals,
         parameters: const <ParameterElement>[],
         declaredReturnType: uninstantiatedType.returnType,
@@ -5862,7 +5860,7 @@ class ToDoFinder {
 ///
 /// The client must set [nameScope] before calling [resolveTypeName].
 class TypeNameResolver {
-  final TypeSystem typeSystem;
+  final Dart2TypeSystem typeSystem;
   final DartType dynamicType;
   final bool isNonNullableUnit;
   final AnalysisOptionsImpl analysisOptions;
@@ -6194,9 +6192,8 @@ class TypeNameResolver {
       }
     } else {
       if (element is GenericTypeAliasElementImpl) {
-        var ts = typeSystem as Dart2TypeSystem;
         List<DartType> typeArguments =
-            ts.instantiateTypeFormalsToBounds2(element);
+            typeSystem.instantiateTypeFormalsToBounds2(element);
         type = GenericTypeAliasElementImpl.typeAfterSubstitution(
                 element, typeArguments) ??
             dynamicType;
@@ -6312,17 +6309,15 @@ class TypeNameResolver {
       TypeName node, ClassElement typeElement) {
     AstNode constructorName = node.parent;
     AstNode enclosingConstructor = constructorName?.parent;
-    TypeSystem ts = typeSystem;
     if (constructorName is ConstructorName &&
         enclosingConstructor is ConstructorDeclaration &&
-        enclosingConstructor.redirectedConstructor == constructorName &&
-        ts is Dart2TypeSystem) {
+        enclosingConstructor.redirectedConstructor == constructorName) {
       ClassOrMixinDeclaration enclosingClassNode = enclosingConstructor.parent;
       var enclosingClassElement = enclosingClassNode.declaredElement;
       if (enclosingClassElement == typeElement) {
         return typeElement.thisType.typeArguments;
       } else {
-        return ts.inferGenericFunctionOrType(
+        return typeSystem.inferGenericFunctionOrType(
           typeParameters: typeElement.typeParameters,
           parameters: const [],
           declaredReturnType: typeElement.thisType,
@@ -6441,8 +6436,7 @@ class TypeNameResolver {
       typeArguments =
           _inferTypeArgumentsForRedirectedConstructor(node, element);
       if (typeArguments == null) {
-        var ts = typeSystem as Dart2TypeSystem;
-        typeArguments = ts.instantiateTypeFormalsToBounds2(element);
+        typeArguments = typeSystem.instantiateTypeFormalsToBounds2(element);
       }
     }
 

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

@@ -52,7 +52,7 @@ class StaticTypeAnalyzer extends SimpleAstVisitor<void> {
   /**
    * The type system in use for static type analysis.
    */
-  TypeSystem _typeSystem;
+  Dart2TypeSystem _typeSystem;
 
   /**
    * The type representing the type 'dynamic'.
@@ -124,12 +124,11 @@ class StaticTypeAnalyzer extends SimpleAstVisitor<void> {
       FormalParameterList node, DartType functionType) {
     bool inferred = false;
     if (node != null && functionType is FunctionType) {
-      var ts = _typeSystem as Dart2TypeSystem;
       void inferType(ParameterElementImpl p, DartType inferredType) {
         // Check that there is no declared type, and that we have not already
         // inferred a type in some fashion.
         if (p.hasImplicitType && (p.type == null || p.type.isDynamic)) {
-          inferredType = ts.upperBoundForType(inferredType);
+          inferredType = _typeSystem.upperBoundForType(inferredType);
           if (inferredType.isDartCoreNull) {
             inferredType = _typeProvider.objectType;
           }
@@ -202,8 +201,7 @@ class StaticTypeAnalyzer extends SimpleAstVisitor<void> {
           HintCode.INFERENCE_FAILURE_ON_COLLECTION_LITERAL, node, ['List']);
     }
 
-    var typeArguments =
-        (_typeSystem as Dart2TypeSystem).inferGenericFunctionOrType(
+    var typeArguments = _typeSystem.inferGenericFunctionOrType(
       typeParameters: typeParameters,
       parameters: parameters,
       declaredReturnType: element.thisType,
@@ -227,8 +225,7 @@ class StaticTypeAnalyzer extends SimpleAstVisitor<void> {
     }
 
     var element = _typeProvider.mapElement;
-    var typeArguments =
-        (_typeSystem as Dart2TypeSystem).inferGenericFunctionOrType(
+    var typeArguments = _typeSystem.inferGenericFunctionOrType(
       typeParameters: element.typeParameters,
       parameters: const [],
       declaredReturnType: element.thisType,
@@ -251,8 +248,7 @@ class StaticTypeAnalyzer extends SimpleAstVisitor<void> {
     }
 
     var element = _typeProvider.setElement;
-    var typeArguments =
-        (_typeSystem as Dart2TypeSystem).inferGenericFunctionOrType(
+    var typeArguments = _typeSystem.inferGenericFunctionOrType(
       typeParameters: element.typeParameters,
       parameters: const [],
       declaredReturnType: element.thisType,
@@ -1674,11 +1670,9 @@ class StaticTypeAnalyzer extends SimpleAstVisitor<void> {
       ArgumentList argumentList,
       AstNode errorNode,
       {bool isConst: false}) {
-    TypeSystem ts = _typeSystem;
     if (typeArguments == null &&
         fnType is FunctionType &&
-        fnType.typeFormals.isNotEmpty &&
-        ts is Dart2TypeSystem) {
+        fnType.typeFormals.isNotEmpty) {
       // Get the parameters that correspond to the uninstantiated generic.
       List<ParameterElement> rawParameters =
           ResolverVisitor.resolveArgumentsToParameters(
@@ -1693,7 +1687,7 @@ class StaticTypeAnalyzer extends SimpleAstVisitor<void> {
           argTypes.add(argumentList.arguments[i].staticType);
         }
       }
-      var typeArgs = ts.inferGenericFunctionOrType(
+      var typeArgs = _typeSystem.inferGenericFunctionOrType(
         typeParameters: fnType.typeFormals,
         parameters: params,
         declaredReturnType: fnType.returnType,
@@ -1996,12 +1990,9 @@ class StaticTypeAnalyzer extends SimpleAstVisitor<void> {
     SimpleIdentifier identifier,
     DartType tearOffType,
   ) {
-    TypeSystem ts = _typeSystem;
     var context = InferenceContext.getContext(expression);
-    if (context is FunctionType &&
-        tearOffType is FunctionType &&
-        ts is Dart2TypeSystem) {
-      var typeArguments = ts.inferFunctionTypeInstantiation(
+    if (context is FunctionType && tearOffType is FunctionType) {
+      var typeArguments = _typeSystem.inferFunctionTypeInstantiation(
         context,
         tearOffType,
         errorReporter: _resolver.errorReporter,
@@ -2134,8 +2125,7 @@ class StaticTypeAnalyzer extends SimpleAstVisitor<void> {
       argumentTypes[2 * i + 1] = inferredTypes[i].valueType ?? dynamicType;
     }
 
-    var typeArguments =
-        (_typeSystem as Dart2TypeSystem).inferGenericFunctionOrType(
+    var typeArguments = _typeSystem.inferGenericFunctionOrType(
       typeParameters: typeParameters,
       parameters: parameters,
       declaredReturnType: element.thisType,
@@ -2166,8 +2156,7 @@ class StaticTypeAnalyzer extends SimpleAstVisitor<void> {
       argumentTypes[i] = inferredTypes[i].elementType ?? dynamicType;
     }
 
-    var typeArguments =
-        (_typeSystem as Dart2TypeSystem).inferGenericFunctionOrType(
+    var typeArguments = _typeSystem.inferGenericFunctionOrType(
       typeParameters: typeParameters,
       parameters: parameters,
       declaredReturnType: element.thisType,