[cfe] Remove constructors for alpha renaming

In this CL methods StructuralParameterType.forAlphaRenaming,
StructuralParameterType.forAlphaRenamingFromTypeParameter,
TypeParameterType.forAlphaRenaming, and
TypeParameterType.forAlphaRenamingFromStructuralParameter are removed,
and their call sites are replaced with invocations of other
constructors of StructuralParameterType and TypeParameterType. The
reason for this change is call sites having more information for
correct computing of type nullabilities.

In addition to the primary update, the following related changes are
made in this CL.

* Method StructuralParameterType.computeDefaultNullabilityForLibrary
  is renamed into StructuralParameterType.computeDefaultNullability,
  and TypeParameterType.computeDefaultNullabilityForLibrary is renamed
  into TypeParameterType.computeDefaultNullability. The parameter
  `library` is removed from both methods, since it's no longer needed.
* The static methods named `computeNullabilityFromBound` are removed
  from `StructuralParameterType` and `TypeParameterType` and
  re-introduced as instance members in classes `StructuralParameter`
  and `TestParameter` respectively

TEST=existing

Change-Id: I26cccf17ccc9bda1e8b750196f427325b544a7ac
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/402820
Reviewed-by: Johnni Winther <[email protected]>
Reviewed-by: Mayank Patke <[email protected]>
Reviewed-by: Alexander Markov <[email protected]>

Author: chloestefantsova

pkg/compiler/lib/src/ir/scope_visitor.dart

@@ -377,7 +377,7 @@ class ScopeModelBuilder extends ir.VisitorDefault<EvaluationComplexity>
   EvaluationComplexity visitTypeParameter(ir.TypeParameter node) {
     TypeVariableTypeWithContext typeVariable(ir.Library library) =>
         TypeVariableTypeWithContext(
-          ir.TypeParameterType.withDefaultNullabilityForLibrary(node, library),
+          ir.TypeParameterType.withDefaultNullability(node),
           // If this typeParameter is part of a function type then its
           // declaration is null because it has no context. Just pass in null
           // for the context in that case.

pkg/dart2bytecode/lib/generics.dart

@@ -24,8 +24,7 @@ List<DartType> getTypeParameterTypes(List<TypeParameter> typeParameters) {
   }
   final types = List<DartType>.generate(typeParameters.length, (int i) {
     final tp = typeParameters[i];
-    return TypeParameterType(
-        tp, TypeParameterType.computeNullabilityFromBound(tp));
+    return TypeParameterType.withDefaultNullability(tp);
   });
   return types;
 }
@@ -37,8 +36,7 @@ bool _canReuseSuperclassTypeArguments(List<DartType> superTypeArgs,
     final typeParam = typeParameters[i];
     if (!(superTypeArg is TypeParameterType &&
         superTypeArg.parameter == typeParameters[i] &&
-        superTypeArg.nullability ==
-            TypeParameterType.computeNullabilityFromBound(typeParam))) {
+        superTypeArg.nullability == typeParam.computeNullabilityFromBound())) {
       return false;
     }
   }

pkg/front_end/lib/src/builder/type_parameter_builder.dart

@@ -248,8 +248,7 @@ class NominalParameterBuilder extends TypeParameterBuilder {
             kind: TypeParameterKind.fromKernel,
             bound: loader?.computeTypeBuilder(parameter.bound),
             defaultType: loader?.computeTypeBuilder(parameter.defaultType)) {
-    _nullabilityFromParameterBound =
-        TypeParameterType.computeNullabilityFromBound(parameter);
+    _nullabilityFromParameterBound = parameter.computeNullabilityFromBound();
   }
 
   @override
@@ -585,8 +584,7 @@ class StructuralParameterBuilder extends TypeParameterBuilder {
         //  parameters from kernel?
         super(parameter.name ?? "", parameter.fileOffset, null,
             kind: TypeParameterKind.fromKernel) {
-    _nullabilityFromParameterBound =
-        StructuralParameterType.computeNullabilityFromBound(parameter);
+    _nullabilityFromParameterBound = parameter.computeNullabilityFromBound();
   }
 
   @override

pkg/front_end/lib/src/fragment/method.dart

@@ -704,9 +704,8 @@ mixin _ExtensionInstanceMethodEncodingMixin implements _MethodEncoding {
     for (TypeParameter typeParameter in procedure.function.typeParameters) {
       TypeParameter newTypeParameter = new TypeParameter(typeParameter.name);
       typeParameters.add(newTypeParameter);
-      typeArguments.add(substitutionMap[typeParameter] =
-          new TypeParameterType.forAlphaRenaming(
-              typeParameter, newTypeParameter));
+      typeArguments.add(substitutionMap[typeParameter] = new TypeParameterType(
+          newTypeParameter, typeParameter.computeNullabilityFromBound()));
     }
 
     List<TypeParameter> tearOffTypeParameters = <TypeParameter>[];

pkg/front_end/lib/src/kernel/body_builder.dart

@@ -1421,8 +1421,8 @@ class BodyBuilder extends StackListenerImpl
   RedirectionTarget _getRedirectionTarget(Procedure factory) {
     List<DartType> typeArguments = new List<DartType>.generate(
         factory.function.typeParameters.length, (int i) {
-      return new TypeParameterType.withDefaultNullabilityForLibrary(
-          factory.function.typeParameters[i], factory.enclosingLibrary);
+      return new TypeParameterType.withDefaultNullability(
+          factory.function.typeParameters[i]);
     }, growable: true);
 
     // Cyclic factories are detected earlier, so we're guaranteed to

pkg/front_end/lib/src/kernel/combined_member_signature.dart

@@ -345,13 +345,10 @@ abstract class CombinedMemberSignatureBase {
       if (typeParameterCount == 0) {
         return type;
       }
-      List<DartType> types =
-          new List<DartType>.filled(typeParameterCount, dummyDartType);
-      for (int i = 0; i < typeParameterCount; i++) {
-        types[i] =
-            new TypeParameterType.forAlphaRenamingFromStructuralParameters(
-                signatureTypeParameters[i], typeParameters[i]);
-      }
+      List<DartType> types = [
+        for (TypeParameter parameter in typeParameters)
+          new TypeParameterType.withDefaultNullability(parameter)
+      ];
       FunctionTypeInstantiator instantiator =
           new FunctionTypeInstantiator.fromIterables(
               signatureTypeParameters, types);

pkg/front_end/lib/src/kernel/expression_generator_helper.dart

@@ -215,16 +215,15 @@ bool isProperRenameForTypeDeclaration(
   }
   for (int i = 0; i < fromParameters.length; ++i) {
     if (typeArguments[i] !=
-        new TypeParameterType.withDefaultNullabilityForLibrary(
-            fromParameters[i], typedefLibrary)) {
+        new TypeParameterType.withDefaultNullability(fromParameters[i])) {
       return false;
     }
   }
 
   Map<TypeParameter, DartType> substitutionMap = {};
   for (int i = 0; i < fromParameters.length; ++i) {
-    substitutionMap[fromParameters[i]] = new TypeParameterType.forAlphaRenaming(
-        fromParameters[i], toParameters[i]);
+    substitutionMap[fromParameters[i]] =
+        new TypeParameterType.withDefaultNullability(toParameters[i]);
   }
   Substitution substitution = Substitution.fromMap(substitutionMap);
   for (int i = 0; i < fromParameters.length; ++i) {

pkg/front_end/lib/src/kernel/forest.dart

@@ -671,8 +671,8 @@ class Forest {
 
   TypeParameterType createTypeParameterTypeWithDefaultNullabilityForLibrary(
       TypeParameter typeParameter, Library library) {
-    return new TypeParameterType.withDefaultNullabilityForLibrary(
-        typeParameter, library);
+    return new TypeParameterType.withDefaultNullability(
+        typeParameter);
   }
 
   Expression createExpressionInvocation(

pkg/front_end/lib/src/kernel/forwarding_node.dart

@@ -312,8 +312,7 @@ class ForwardingNode {
               type,
               function.typeParameters
                   .map((TypeParameter parameter) =>
-                      new TypeParameterType.withDefaultNullabilityForLibrary(
-                          parameter, procedure.enclosingLibrary))
+                      new TypeParameterType.withDefaultNullability(parameter))
                   .toList());
         }
         List<Expression> positionalArguments = new List.generate(
@@ -367,8 +366,7 @@ class ForwardingNode {
         }, growable: true);
         List<DartType> typeArguments = function.typeParameters
             .map<DartType>((typeParameter) =>
-                new TypeParameterType.withDefaultNullabilityForLibrary(
-                    typeParameter, libraryBuilder.library))
+                new TypeParameterType.withDefaultNullability(typeParameter))
             .toList();
         Arguments arguments = new Arguments(positionalArguments,
             types: typeArguments, named: namedArguments);

pkg/front_end/lib/src/kernel/hierarchy/mixin_inferrer.dart

@@ -157,12 +157,11 @@ class BuilderMixinInferrer {
     }
     // Bounds might mention the mixin class's type parameters so we have to
     // substitute them before calling instantiate to bounds.
-    Substitution substitution = Substitution.fromPairs(
-        mixinClass.typeParameters,
-        new List<DartType>.generate(
-            parameters.length,
-            (i) => new TypeParameterType.forAlphaRenaming(
-                mixinClass.typeParameters[i], parameters[i])));
+    Substitution substitution =
+        Substitution.fromPairs(mixinClass.typeParameters, [
+      for (TypeParameter parameter in parameters)
+        new TypeParameterType.withDefaultNullability(parameter)
+    ]);
     for (TypeParameter p in parameters) {
       p.bound = substitution.substituteType(p.bound);
     }