Elements. Migrate type_algebra_test.dart

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

Author: scheglov

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

@@ -151,6 +151,25 @@ DartType substitute(
   return Substitution.fromMap(substitution).substituteType(type);
 }
 
+/// Returns a type where all occurrences of the given type parameters have been
+/// replaced with the corresponding types.
+///
+/// This will copy only the sub-terms of [type] that contain substituted
+/// variables; all other [DartType] objects will be reused.
+///
+/// In particular, if no type parameters were substituted, this is guaranteed
+/// to return the [type] instance (not a copy), so the caller may use
+/// [identical] to efficiently check if a distinct type was created.
+DartType substitute2(
+  DartType type,
+  Map<TypeParameterElement2, DartType> substitution,
+) {
+  if (substitution.isEmpty) {
+    return type;
+  }
+  return Substitution.fromMap2(substitution).substituteType(type);
+}
+
 ///  1. Substituting T=X! into T! yields X!
 ///  3. Substituting T=X? into T! yields X?
 ///  7. Substituting T=X! into T? yields X?
@@ -284,26 +303,6 @@ abstract class Substitution {
     var fragments = parameters.map((e) => e.asElement).toList();
     return fromPairs(fragments, types);
   }
-
-  /// Substitutes all occurrences of the given type parameters with the
-  /// corresponding upper or lower bound, depending on the variance of the
-  /// context where it occurs.
-  ///
-  /// For example the type `(T) => T` with the bounds `bottom <: T <: num`
-  /// becomes `(bottom) => num` (in this example, `num` is the upper bound,
-  /// and `bottom` is the lower bound).
-  ///
-  /// This is a way to obtain an upper bound for a type while eliminating all
-  /// references to certain type variables.
-  static Substitution fromUpperAndLowerBounds(
-    Map<TypeParameterElement, DartType> upper,
-    Map<TypeParameterElement, DartType> lower,
-  ) {
-    if (upper.isEmpty && lower.isEmpty) {
-      return _NullSubstitution.instance;
-    }
-    return _UpperLowerBoundsSubstitution(upper, lower);
-  }
 }
 
 class _CombinedSubstitution extends Substitution {
@@ -696,18 +695,3 @@ abstract class _TypeSubstitutor
     return types.map((e) => e.accept(this)).toFixedList();
   }
 }
-
-class _UpperLowerBoundsSubstitution extends Substitution {
-  final Map<TypeParameterElement, DartType> upper;
-  final Map<TypeParameterElement, DartType> lower;
-
-  _UpperLowerBoundsSubstitution(this.upper, this.lower);
-
-  @override
-  DartType? getSubstitute(TypeParameterElement parameter, bool upperBound) {
-    return upperBound ? upper[parameter] : lower[parameter];
-  }
-
-  @override
-  String toString() => '_UpperLowerBoundsSubstitution($upper, $lower)';
-}

pkg/analyzer/lib/src/utilities/extensions/collection.dart

@@ -108,6 +108,13 @@ extension MapExtension<K, V> on Map<K, V> {
     return keys.firstOrNull;
   }
 
+  Map<K2, V> mapKey<K2>(K2 Function(K) convert) {
+    return map((key, value) {
+      var key2 = convert(key);
+      return MapEntry(key2, value);
+    });
+  }
+
   Map<K, V2> mapValue<V2>(V2 Function(V) convert) {
     return map((key, value) {
       var value2 = convert(value);

pkg/analyzer/lib/src/utilities/extensions/element.dart

@@ -637,6 +637,12 @@ extension TypeParameterElement2Extension on TypeParameterElement2 {
 
 extension TypeParameterElementExtension on TypeParameterElement {
   TypeParameterElement2 get asElement2 {
-    return (this as TypeParameterElementImpl).element;
+    return (this as TypeParameterElementImpl).asElement2;
+  }
+}
+
+extension TypeParameterElementImplExtension on TypeParameterElementImpl {
+  TypeParameterElementImpl2 get asElement2 {
+    return element;
   }
 }

pkg/analyzer/test/generated/elements_types_mixin.dart

@@ -686,6 +686,22 @@ mixin ElementsTypesMixin {
     return fragment;
   }
 
+  TypeAliasElementImpl2 typeAlias2({
+    required String name,
+    required List<TypeParameterElementImpl2> typeParameters,
+    required DartType aliasedType,
+  }) {
+    var fragment = TypeAliasElementImpl(name, 0);
+    fragment.name2 = name;
+    fragment.enclosingElement3 = testLibrary.definingCompilationUnit;
+    fragment.typeParameters = typeParameters
+        .map((e) => e.asElement as TypeParameterElementImpl)
+        .toList();
+    fragment.aliasedType = aliasedType;
+
+    return TypeAliasElementImpl2(Reference.root(), fragment);
+  }
+
   TypeImpl typeAliasTypeNone(
     TypeAliasElementImpl element, {
     List<DartType> typeArguments = const [],
@@ -696,6 +712,16 @@ mixin ElementsTypesMixin {
     );
   }
 
+  TypeImpl typeAliasTypeNone2(
+    TypeAliasElementImpl2 element, {
+    List<DartType> typeArguments = const [],
+  }) {
+    return element.instantiate(
+      typeArguments: typeArguments,
+      nullabilitySuffix: NullabilitySuffix.none,
+    );
+  }
+
   TypeParameterElementImpl typeParameter(String name,
       {DartType? bound, Variance? variance}) {
     var element = TypeParameterElementImpl.synthetic(name);
@@ -704,7 +730,7 @@ mixin ElementsTypesMixin {
     return element;
   }
 
-  TypeParameterElement2 typeParameter2(String name,
+  TypeParameterElementImpl2 typeParameter2(String name,
       {DartType? bound, Variance? variance}) {
     return typeParameter(name, bound: bound, variance: variance).asElement2;
   }

pkg/analyzer/test/src/dart/element/least_greatest_closure_test.dart

@@ -26,7 +26,7 @@ class GreatestClosureTest extends AbstractTypeSystemTest {
   void setUp() {
     super.setUp();
 
-    T = typeParameter2('T') as TypeParameterElementImpl2;
+    T = typeParameter2('T');
     T_none = typeParameterTypeNone2(T);
     T_question = typeParameterTypeQuestion2(T);
   }