Elements. Move more properties from TypeParameterFragmentImpl into TypeParameterElementImpl.

This change moves core properties like `bound`, `defaultType`, and
`variance` from `TypeParameterFragmentImpl` to the
`TypeParameterElementImpl` class.

Previously, the element often delegated property access to its
`firstFragment`. This refactoring centralizes the data, making the
element the single source of truth for its own properties. This change
simplifies the data model and improves code clarity by reducing the
tight coupling between the element and fragment implementations.

All call sites have been updated to reflect this new ownership,
accessing properties directly from the element instance.

Change-Id: I4f37f0d35aaa86e8f461020c0f5ad72b02627d0f
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/445125
Reviewed-by: Johnni Winther <[email protected]>
Commit-Queue: Konstantin Shcheglov <[email protected]>
Reviewed-by: Samuel Rawlins <[email protected]>

Author: scheglov

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

@@ -10,7 +10,6 @@ import 'package:analyzer/dart/element/type.dart';
 import 'package:analyzer/src/dart/element/element.dart';
 import 'package:analyzer/src/dart/element/type.dart';
 import 'package:analyzer/src/dart/element/type_algebra.dart';
-import 'package:analyzer/src/utilities/extensions/element.dart';
 
 /// A class that builds a "display string" for [Element]s and [DartType]s.
 class ElementDisplayStringBuilder {
@@ -601,9 +600,9 @@ class ElementDisplayStringBuilder {
         name = typeParameter.name! + subscript;
       }
 
-      var newTypeParameter = TypeParameterFragmentImpl(name: name);
+      var newTypeParameter = TypeParameterElementImpl.synthetic(name: name);
       newTypeParameter.bound = typeParameter.bound;
-      newTypeParameters.add(newTypeParameter.asElement2);
+      newTypeParameters.add(newTypeParameter);
     }
 
     return replaceTypeParameters(type, newTypeParameters);

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

@@ -4762,7 +4762,6 @@ abstract class InterfaceElementImpl extends InstanceElementImpl
   InterfaceTypeImpl get thisType {
     if (_thisType == null) {
       List<TypeImpl> typeArguments;
-      var typeParameters = firstFragment.typeParameters;
       if (typeParameters.isNotEmpty) {
         typeArguments =
             typeParameters.map<TypeImpl>((t) {
@@ -9877,6 +9876,23 @@ class TypeParameterElementImpl extends ElementImpl
   @override
   final String? name;
 
+  /// The value representing the variance modifier keyword, or `null` if
+  /// there is no explicit variance modifier, meaning legacy covariance.
+  shared.Variance? _variance;
+
+  /// The type representing the bound associated with this type parameter,
+  /// or `null` if this type parameter does not have an explicit bound.
+  ///
+  /// Being able to distinguish between an implicit and explicit bound is
+  /// needed by the instantiate to bounds algorithm.
+  @override
+  TypeImpl? bound;
+
+  /// The default value of the type parameter. It is used to provide the
+  /// corresponding missing type argument in type annotations and as the
+  /// fall-back type value in type inference.
+  TypeImpl? defaultType;
+
   TypeParameterElementImpl({required this.firstFragment})
     : name = firstFragment.name {
     firstFragment.element = this;
@@ -9890,21 +9906,9 @@ class TypeParameterElementImpl extends ElementImpl
   @override
   TypeParameterElementImpl get baseElement => this;
 
-  @override
-  TypeImpl? get bound => firstFragment.bound;
-
-  set bound(TypeImpl? value) {
-    firstFragment.bound = value;
-  }
-
   @override
   TypeImpl? get boundShared => bound;
 
-  /// The default value of the type parameter. It is used to provide the
-  /// corresponding missing type argument in type annotations and as the
-  /// fall-back type value in type inference.
-  TypeImpl? get defaultType => firstFragment.defaultType;
-
   @override
   Element? get enclosingElement {
     return firstFragment.enclosingFragment?.element;
@@ -9926,7 +9930,9 @@ class TypeParameterElementImpl extends ElementImpl
     ];
   }
 
-  bool get isLegacyCovariant => firstFragment.isLegacyCovariant;
+  bool get isLegacyCovariant {
+    return _variance == null;
+  }
 
   @override
   bool get isSynthetic {
@@ -9957,12 +9963,12 @@ class TypeParameterElementImpl extends ElementImpl
   @override
   String? get name3 => name;
 
-  shared.Variance get variance => firstFragment.variance;
-
-  set variance(shared.Variance? value) {
-    firstFragment.variance = value;
+  shared.Variance get variance {
+    return _variance ?? shared.Variance.covariant;
   }
 
+  set variance(shared.Variance? newVariance) => _variance = newVariance;
+
   @override
   T? accept<T>(ElementVisitor2<T> visitor) {
     return visitor.visitTypeParameterElement(this);
@@ -9977,6 +9983,52 @@ class TypeParameterElementImpl extends ElementImpl
     builder.writeTypeParameterElement(this);
   }
 
+  /// Computes the variance of the type parameters in the [type].
+  shared.Variance computeVarianceInType(DartType type) {
+    if (type is TypeParameterTypeImpl) {
+      if (type.element == this) {
+        return shared.Variance.covariant;
+      } else {
+        return shared.Variance.unrelated;
+      }
+    } else if (type is InterfaceTypeImpl) {
+      var result = shared.Variance.unrelated;
+      for (int i = 0; i < type.typeArguments.length; ++i) {
+        var argument = type.typeArguments[i];
+        var parameter = type.element.typeParameters[i];
+
+        var parameterVariance = parameter.variance;
+        result = result.meet(
+          parameterVariance.combine(computeVarianceInType(argument)),
+        );
+      }
+      return result;
+    } else if (type is FunctionType) {
+      var result = computeVarianceInType(type.returnType);
+
+      for (var parameter in type.typeParameters) {
+        // If [parameter] is referenced in the bound at all, it makes the
+        // variance of [parameter] in the entire type invariant.  The invocation
+        // of [computeVariance] below is made to simply figure out if [variable]
+        // occurs in the bound.
+        var bound = parameter.bound;
+        if (bound != null && !computeVarianceInType(bound).isUnrelated) {
+          result = shared.Variance.invariant;
+        }
+      }
+
+      for (var formalParameter in type.formalParameters) {
+        result = result.meet(
+          shared.Variance.contravariant.combine(
+            computeVarianceInType(formalParameter.type),
+          ),
+        );
+      }
+      return result;
+    }
+    return shared.Variance.unrelated;
+  }
+
   @override
   TypeParameterTypeImpl instantiate({
     required NullabilitySuffix nullabilitySuffix,
@@ -10003,19 +10055,6 @@ class TypeParameterFragmentImpl extends FragmentImpl
   @override
   int? nameOffset;
 
-  /// The default value of the type parameter. It is used to provide the
-  /// corresponding missing type argument in type annotations and as the
-  /// fall-back type value in type inference.
-  TypeImpl? defaultType;
-
-  /// The type representing the bound associated with this parameter, or `null`
-  /// if this parameter does not have an explicit bound.
-  TypeImpl? _bound;
-
-  /// The value representing the variance modifier keyword, or `null` if
-  /// there is no explicit variance modifier, meaning legacy covariance.
-  shared.Variance? _variance;
-
   /// The element corresponding to this fragment.
   TypeParameterElementImpl? _element;
 
@@ -10030,25 +10069,6 @@ class TypeParameterFragmentImpl extends FragmentImpl
     isSynthetic = true;
   }
 
-  /// The type representing the bound associated with this parameter, or `null`
-  /// if this parameter does not have an explicit bound. Being able to
-  /// distinguish between an implicit and explicit bound is needed by the
-  /// instantiate to bounds algorithm.
-  TypeImpl? get bound {
-    return _bound;
-  }
-
-  set bound(DartType? bound) {
-    // TODO(paulberry): Change the type of the parameter `bound` so that this
-    // cast isn't needed.
-    _bound = bound as TypeImpl?;
-    if (_element case var element?) {
-      if (!identical(element.bound, bound)) {
-        element.bound = bound;
-      }
-    }
-  }
-
   @override
   List<Fragment> get children => const [];
 
@@ -10082,10 +10102,6 @@ class TypeParameterFragmentImpl extends FragmentImpl
     _element = element;
   }
 
-  bool get isLegacyCovariant {
-    return _variance == null;
-  }
-
   @override
   LibraryFragment? get libraryFragment {
     return enclosingFragment?.libraryFragment;
@@ -10105,66 +10121,6 @@ class TypeParameterFragmentImpl extends FragmentImpl
   @override
   // TODO(augmentations): Support chaining between the fragments.
   TypeParameterFragmentImpl? get previousFragment => null;
-
-  shared.Variance get variance {
-    return _variance ?? shared.Variance.covariant;
-  }
-
-  set variance(shared.Variance? newVariance) => _variance = newVariance;
-
-  /// Computes the variance of the type parameters in the [type].
-  shared.Variance computeVarianceInType(DartType type) {
-    if (type is TypeParameterTypeImpl) {
-      if (type.element == element) {
-        return shared.Variance.covariant;
-      } else {
-        return shared.Variance.unrelated;
-      }
-    } else if (type is InterfaceTypeImpl) {
-      var result = shared.Variance.unrelated;
-      for (int i = 0; i < type.typeArguments.length; ++i) {
-        var argument = type.typeArguments[i];
-        var parameter = type.element.typeParameters[i];
-
-        var parameterVariance = parameter.variance;
-        result = result.meet(
-          parameterVariance.combine(computeVarianceInType(argument)),
-        );
-      }
-      return result;
-    } else if (type is FunctionType) {
-      var result = computeVarianceInType(type.returnType);
-
-      for (var parameter in type.typeParameters) {
-        // If [parameter] is referenced in the bound at all, it makes the
-        // variance of [parameter] in the entire type invariant.  The invocation
-        // of [computeVariance] below is made to simply figure out if [variable]
-        // occurs in the bound.
-        var bound = parameter.bound;
-        if (bound != null && !computeVarianceInType(bound).isUnrelated) {
-          result = shared.Variance.invariant;
-        }
-      }
-
-      for (var formalParameter in type.formalParameters) {
-        result = result.meet(
-          shared.Variance.contravariant.combine(
-            computeVarianceInType(formalParameter.type),
-          ),
-        );
-      }
-      return result;
-    }
-    return shared.Variance.unrelated;
-  }
-
-  /// Creates the [TypeParameterType] with the given [nullabilitySuffix] for
-  /// this type parameter.
-  TypeParameterTypeImpl instantiate({
-    required NullabilitySuffix nullabilitySuffix,
-  }) {
-    return element.instantiate(nullabilitySuffix: nullabilitySuffix);
-  }
 }
 
 /// Mixin representing an element which can have type parameters.

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

@@ -44,9 +44,9 @@ class NormalizeHelper {
   FunctionTypeImpl _functionType(FunctionTypeImpl functionType) {
     var fresh = getFreshTypeParameters(functionType.typeParameters);
     for (var typeParameter in fresh.freshTypeParameters) {
-      var bound = typeParameter.firstFragment.bound;
+      var bound = typeParameter.bound;
       if (bound != null) {
-        typeParameter.firstFragment.bound = _normalize(bound);
+        typeParameter.bound = _normalize(bound);
       }
     }
 

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

@@ -348,7 +348,6 @@ class TopMergeHelper {
         bBound = bSubstitution.substituteType(bBound);
         var newBound = topMerge(aBound, bBound);
         newParameters[i].bound = newBound;
-        newParameters[i].firstFragment.bound = newBound;
       } else {
         return null;
       }

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

@@ -15,6 +15,7 @@ import 'package:analyzer/src/dart/element/member.dart';
 import 'package:analyzer/src/dart/element/type_algebra.dart';
 import 'package:analyzer/src/dart/element/type_system.dart';
 import 'package:analyzer/src/utilities/extensions/collection.dart';
+import 'package:analyzer/src/utilities/extensions/element.dart';
 import 'package:collection/collection.dart';
 
 /// Returns a [List] of fixed length with given types.
@@ -443,9 +444,7 @@ class FunctionTypeImpl extends TypeImpl
     for (int i = 0; i < count; i++) {
       TypeParameterElement p1 = params1[i];
       TypeParameterElement p2 = params2[i];
-      TypeParameterFragmentImpl pFresh = TypeParameterFragmentImpl.synthetic(
-        name: p2.name,
-      );
+      var pFresh = p2.freshCopy();
 
       TypeParameterTypeImpl variableFresh = pFresh.instantiate(
         nullabilitySuffix: NullabilitySuffix.none,
@@ -470,7 +469,7 @@ class FunctionTypeImpl extends TypeImpl
       }
 
       if (bound2 is! DynamicType) {
-        pFresh.bound = bound2;
+        pFresh.bound = bound2 as TypeImpl;
       }
     }
     return variablesFresh;

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

@@ -46,13 +46,13 @@ FreshTypeParameters getFreshTypeParameters(
     // variance is added to the interface.
     var typeParameter = typeParameters[i] as TypeParameterElementImpl;
     if (!typeParameter.isLegacyCovariant) {
-      freshParameters[i].firstFragment.variance = typeParameter.variance;
+      freshParameters[i].variance = typeParameter.variance;
     }
 
     var bound = typeParameter.bound;
     if (bound != null) {
       var newBound = substitution.substituteType(bound);
-      freshParameters[i].firstFragment.bound = newBound;
+      freshParameters[i].bound = newBound;
     }
   }
 
@@ -262,15 +262,15 @@ class _FreshTypeParametersSubstitutor extends _TypeSubstitutor {
 
     var freshElements = List.generate(elements.length, (index) {
       var element = elements[index];
-      var freshElement = TypeParameterFragmentImpl(name: element.name);
+      var freshElement = element.freshCopy();
       var freshType = freshElement.instantiate(
         nullabilitySuffix: NullabilitySuffix.none,
       );
       substitution[element] = freshType;
       if (!element.isLegacyCovariant) {
         freshElement.variance = element.variance;
       }
-      return freshElement.asElement2;
+      return freshElement;
     }, growable: false);
 
     for (var i = 0; i < freshElements.length; i++) {

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

@@ -275,13 +275,13 @@ class TypeConstraintGatherer
     // not contain any variables from `L`.
     var newTypeParameters = <TypeParameterElementImpl>[];
     for (var i = 0; i < P.typeParameters.length; i++) {
-      var Z = TypeParameterFragmentImpl(name: 'Z$i');
+      var Z = TypeParameterElementImpl.synthetic(name: 'Z$i');
       if (leftSchema) {
         Z.bound = P.typeParameters[i].bound;
       } else {
         Z.bound = Q.typeParameters[i].bound;
       }
-      newTypeParameters.add(Z.element);
+      newTypeParameters.add(Z);
     }
 
     // And `F0[Z0/T0, ..., Zn/Tn]` is a subtype match for

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

@@ -1419,7 +1419,7 @@ class ResolutionVisitor extends RecursiveAstVisitor<void> {
     if (boundNode != null) {
       boundNode.accept(this);
       if (_elementWalker == null) {
-        fragment.bound = boundNode.type;
+        fragment.element.bound = boundNode.type;
       }
     }
   }