Elements. Use TypeImpl in more places.

Change-Id: Ie48ade90d01eaad80dc1842ca41cc25ca56c56ad
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/411882
Reviewed-by: Paul Berry <[email protected]>
Commit-Queue: Konstantin Shcheglov <[email protected]>

Author: scheglov

pkg/analyzer/lib/src/dart/constant/constant_verifier.dart

@@ -518,7 +518,7 @@ class ConstantVerifier extends RecursiveAstVisitor<void> {
   /// equality.
   bool _canBeEqual(DartType constantType, DartType valueType) {
     if (constantType is InterfaceType) {
-      if (valueType is InterfaceType) {
+      if (valueType is InterfaceTypeImpl) {
         if (constantType.isDartCoreInt && valueType.isDartCoreDouble) {
           return true;
         }

pkg/analyzer/lib/src/dart/element/least_greatest_closure.dart

@@ -11,9 +11,9 @@ import 'package:analyzer/src/dart/element/type_system.dart';
 
 class LeastGreatestClosureHelper extends ReplacementVisitor {
   final TypeSystemImpl typeSystem;
-  final DartType topType;
-  final DartType topFunctionType;
-  final DartType bottomType;
+  final TypeImpl topType;
+  final TypeImpl topFunctionType;
+  final TypeImpl bottomType;
   final Set<TypeParameterElementImpl2> eliminationTargets;
 
   late final bool _isLeastClosure;
@@ -27,14 +27,14 @@ class LeastGreatestClosureHelper extends ReplacementVisitor {
     required this.eliminationTargets,
   });
 
-  DartType get _functionReplacement {
+  TypeImpl get _functionReplacement {
     return _isLeastClosure && _isCovariant ||
             (!_isLeastClosure && !_isCovariant)
         ? bottomType
         : topFunctionType;
   }
 
-  DartType get _typeParameterReplacement {
+  TypeImpl get _typeParameterReplacement {
     return _isLeastClosure && _isCovariant ||
             (!_isLeastClosure && !_isCovariant)
         ? bottomType
@@ -47,27 +47,21 @@ class LeastGreatestClosureHelper extends ReplacementVisitor {
   }
 
   /// Returns a supertype of [type] for all values of [eliminationTargets].
-  TypeImpl eliminateToGreatest(DartType type) {
+  TypeImpl eliminateToGreatest(TypeImpl type) {
     _isCovariant = true;
     _isLeastClosure = false;
-    // TODO(paulberry): make this cast unnecessary by changing the type of
-    // `type` and by changing `ReplacementVisitor` to implement
-    // `TypeVisitor<TypeImpl?>`.
-    return (type.accept(this) ?? type) as TypeImpl;
+    return type.accept(this) ?? type;
   }
 
   /// Returns a subtype of [type] for all values of [eliminationTargets].
-  TypeImpl eliminateToLeast(DartType type) {
+  TypeImpl eliminateToLeast(TypeImpl type) {
     _isCovariant = true;
     _isLeastClosure = true;
-    // TODO(paulberry): make this cast unnecessary by changing the type of
-    // `type` and by changing `ReplacementVisitor` to implement
-    // `TypeVisitor<TypeImpl?>`.
-    return (type.accept(this) ?? type) as TypeImpl;
+    return type.accept(this) ?? type;
   }
 
   @override
-  DartType? visitFunctionType(FunctionType node) {
+  TypeImpl? visitFunctionType(FunctionType node) {
     // - if `S` is
     //   `T Function<X0 extends B0, ...., Xk extends Bk>(T0 x0, ...., Tn xn,
     //       [Tn+1 xn+1, ..., Tm xm])`
@@ -87,9 +81,9 @@ class LeastGreatestClosureHelper extends ReplacementVisitor {
   }
 
   @override
-  DartType? visitTypeParameterType(TypeParameterType type) {
+  TypeImpl? visitTypeParameterType(TypeParameterType type) {
     if (eliminationTargets.contains(type.element3)) {
-      var replacement = _typeParameterReplacement as TypeImpl;
+      var replacement = _typeParameterReplacement;
       return replacement.withNullability(
         uniteNullabilities(
           replacement.nullabilitySuffix,
@@ -117,13 +111,13 @@ class PatternGreatestClosureHelper extends ReplacementVisitor {
   }
 
   /// Returns a supertype of [type] for all values of type parameters.
-  DartType eliminateToGreatest(DartType type) {
+  TypeImpl eliminateToGreatest(TypeImpl type) {
     _isCovariant = true;
     return type.accept(this) ?? type;
   }
 
   @override
-  DartType? visitTypeParameterType(TypeParameterType type) {
+  TypeImpl? visitTypeParameterType(TypeParameterType type) {
     var replacement = _isCovariant ? topType : bottomType;
     return replacement.withNullability(
       uniteNullabilities(

pkg/analyzer/lib/src/dart/element/least_upper_bound.dart

@@ -846,7 +846,7 @@ class LeastUpperBoundHelper {
   }
 
   /// Return the promoted or declared bound of the type parameter.
-  DartType _typeParameterBound(TypeParameterTypeImpl type) {
+  TypeImpl _typeParameterBound(TypeParameterTypeImpl type) {
     var bound = type.promotedBound ?? type.element3.bound;
     if (bound != null) {
       return bound;

pkg/analyzer/lib/src/dart/element/normalize.dart

@@ -5,6 +5,7 @@
 import 'package:analyzer/dart/element/element2.dart';
 import 'package:analyzer/dart/element/nullability_suffix.dart';
 import 'package:analyzer/dart/element/type.dart';
+import 'package:analyzer/src/dart/element/element.dart';
 import 'package:analyzer/src/dart/element/extensions.dart';
 import 'package:analyzer/src/dart/element/type.dart';
 import 'package:analyzer/src/dart/element/type_algebra.dart';
@@ -24,15 +25,15 @@ class NormalizeHelper {
 
   NormalizeHelper(this.typeSystem) : typeProvider = typeSystem.typeProvider;
 
-  DartType normalize(DartType T) {
+  TypeImpl normalize(TypeImpl T) {
     return _normalize(T);
   }
 
   /// `NORM(R Function<X extends B>(S)) = R1 Function(X extends B1>(S1)`
   ///   * where R1 = NORM(R)
   ///   * and B1 = NORM(B)
   ///   * and S1 = NORM(S)
-  FunctionTypeImpl _functionType(FunctionType functionType) {
+  FunctionTypeImpl _functionType(FunctionTypeImpl functionType) {
     var fresh = getFreshTypeParameters2(functionType.typeParameters);
     for (var typeParameter in fresh.freshTypeParameters) {
       var bound = typeParameter.firstFragment.bound;
@@ -56,7 +57,7 @@ class NormalizeHelper {
   }
 
   /// `NORM(FutureOr<T>)`
-  DartType _futureOr(InterfaceType T) {
+  TypeImpl _futureOr(InterfaceTypeImpl T) {
     // * let S be NORM(T)
     var S = _normalize(T.typeArguments[0]);
     var S_nullability = S.nullabilitySuffix;
@@ -96,7 +97,7 @@ class NormalizeHelper {
     );
   }
 
-  DartType _normalize(DartType T) {
+  TypeImpl _normalize(TypeImpl T) {
     var T_nullability = T.nullabilitySuffix;
 
     // NORM(T) = T if T is primitive
@@ -105,14 +106,14 @@ class NormalizeHelper {
         identical(T, NeverTypeImpl.instance) ||
         identical(T, VoidTypeImpl.instance) ||
         T_nullability == NullabilitySuffix.none &&
-            T is InterfaceType &&
+            T is InterfaceTypeImpl &&
             T.typeArguments.isEmpty) {
       return T;
     }
 
     // NORM(FutureOr<T>)
     if (T_nullability == NullabilitySuffix.none &&
-        T is InterfaceType &&
+        T is InterfaceTypeImpl &&
         T.isDartAsyncFutureOr) {
       return _futureOr(T);
     }
@@ -131,7 +132,7 @@ class NormalizeHelper {
     }
 
     // NORM(C<T0, ..., Tn>) = C<R0, ..., Rn> where Ri is NORM(Ti)
-    if (T is InterfaceType) {
+    if (T is InterfaceTypeImpl) {
       return T.element3.instantiate(
         typeArguments: T.typeArguments.map(_normalize).toFixedList(),
         nullabilitySuffix: NullabilitySuffix.none,
@@ -157,13 +158,13 @@ class NormalizeHelper {
     }
 
     // NORM(R Function<X extends B>(S)) = R1 Function(X extends B1>(S1)
-    return _functionType(T as FunctionType);
+    return _functionType(T as FunctionTypeImpl);
   }
 
   /// NORM(T?)
-  DartType _nullabilityQuestion(DartType T) {
+  TypeImpl _nullabilityQuestion(TypeImpl T) {
     // * let S be NORM(T)
-    var T_none = (T as TypeImpl).withNullability(NullabilitySuffix.none);
+    var T_none = T.withNullability(NullabilitySuffix.none);
     var S = _normalize(T_none);
     var S_nullability = S.nullabilitySuffix;
 
@@ -184,7 +185,7 @@ class NormalizeHelper {
 
     // * if S is FutureOr<R> and R is nullable then S
     if (S_nullability == NullabilitySuffix.none &&
-        S is InterfaceType &&
+        S is InterfaceTypeImpl &&
         S.isDartAsyncFutureOr) {
       var R = S.typeArguments[0];
       if (typeSystem.isNullable(R)) {
@@ -194,12 +195,12 @@ class NormalizeHelper {
 
     // * if S is R? then R?
     // * else S?
-    return (S as TypeImpl).withNullability(NullabilitySuffix.question);
+    return S.withNullability(NullabilitySuffix.question);
   }
 
   /// NORM(X & T)
   /// NORM(X extends T)
-  DartType _typeParameterType(TypeParameterTypeImpl T) {
+  TypeImpl _typeParameterType(TypeParameterTypeImpl T) {
     var element = T.element3;
 
     // NORM(X & T)
@@ -235,7 +236,8 @@ class NormalizeHelper {
 
   /// NORM(X & T)
   /// * let S be NORM(T)
-  DartType _typeParameterType_promoted(TypeParameterElement2 X, DartType S) {
+  TypeImpl _typeParameterType_promoted(
+      TypeParameterElementImpl2 X, DartType S) {
     // * if S is Never then Never
     if (identical(S, NeverTypeImpl.instance)) {
       return NeverTypeImpl.instance;