Fine. Record and match type-parameter variance in manifests.

Capture declaration-site variance for generic declarations in the fine
manifests and use it during matching. Previously, manifests ignored
variance, so declarations that differed only by variance could be
incorrectly considered equivalent (or vice versa). Including variance
closes that correctness gap and prevents unstable reuse decisions.

Key changes:
- Encode variance on each ManifestTypeParameter (using shared.Variance)
  and persist it in the wire format (written before the bound).
- Compare variance when matching type parameters, affecting classes,
  mixins, function types, and type aliases.
- Consider type parameters when matching TypeAliasItem to avoid
  false-positive matches of otherwise identical aliases.
- Switch withTypeParameters and match sites to work with
  TypeParameterElementImpl so variance is available everywhere.
- Update the result printer to display type-parameter variance with
  ordinal indices.
- Bump AnalysisDriver.DATA_VERSION to 531 to invalidate stale caches.

Notes:
- Default (implicit) covariant parameters and explicit `out` parameters
  are treated equivalently, ensuring stable IDs in that case.
- This is an internal format change; no public API surface is altered.

Rationale: Storing and matching variance makes manifest-based reuse
sensitive to a semantically observable part of generic APIs. This yields
more accurate incremental analysis decisions and avoids reusing results
across variance-incompatible declarations.

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

Author: scheglov

pkg/analyzer/lib/src/dart/analysis/driver.dart

@@ -106,7 +106,7 @@ testFineAfterLibraryAnalyzerHook;
 // TODO(scheglov): Clean up the list of implicitly analyzed files.
 class AnalysisDriver {
   /// The version of data format, should be incremented on every format change.
-  static const int DATA_VERSION = 530;
+  static const int DATA_VERSION = 531;
 
   /// The number of exception contexts allowed to write. Once this field is
   /// zero, we stop writing any new exception contexts in this process.

pkg/analyzer/lib/src/fine/manifest_context.dart

@@ -3,6 +3,7 @@
 // BSD-style license that can be found in the LICENSE file.
 
 import 'package:analyzer/dart/element/element.dart';
+import 'package:analyzer/src/dart/element/element.dart';
 import 'package:analyzer/src/fine/lookup_name.dart';
 import 'package:analyzer/src/fine/manifest_id.dart';
 import 'package:analyzer/src/fine/manifest_item.dart';
@@ -56,7 +57,7 @@ class EncodeContext {
   }
 
   T withTypeParameters<T>(
-    List<TypeParameterElement> typeParameters,
+    List<TypeParameterElementImpl> typeParameters,
     T Function(List<ManifestTypeParameter> typeParameters) operation,
   ) {
     for (var typeParameter in typeParameters) {

pkg/analyzer/lib/src/fine/manifest_item.dart

@@ -1498,6 +1498,7 @@ class TypeAliasItem extends TopLevelItem<TypeAliasElementImpl> {
   bool match(MatchContext context, TypeAliasElementImpl element) {
     context.addTypeParameters(element.typeParameters);
     return super.match(context, element) &&
+        typeParameters.match(context, element.typeParameters) &&
         aliasedType.match(context, element.aliasedType);
   }
 

pkg/analyzer/lib/src/fine/manifest_type.dart

@@ -2,7 +2,9 @@
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
-import 'package:analyzer/dart/element/element.dart';
+import 'package:_fe_analyzer_shared/src/types/shared_type.dart'
+    as shared
+    show Variance;
 import 'package:analyzer/dart/element/nullability_suffix.dart';
 import 'package:analyzer/dart/element/type.dart';
 import 'package:analyzer/src/dart/element/element.dart';
@@ -539,26 +541,34 @@ sealed class ManifestType {
 }
 
 class ManifestTypeParameter {
+  final shared.Variance variance;
   final ManifestType? bound;
 
   factory ManifestTypeParameter.encode(
     EncodeContext context,
-    TypeParameterElement element,
+    TypeParameterElementImpl element,
   ) {
-    return ManifestTypeParameter._(bound: element.bound?.encode(context));
+    return ManifestTypeParameter._(
+      variance: element.variance,
+      bound: element.bound?.encode(context),
+    );
   }
 
   factory ManifestTypeParameter.read(SummaryDataReader reader) {
-    return ManifestTypeParameter._(bound: ManifestType.readOptional(reader));
+    return ManifestTypeParameter._(
+      variance: reader.readEnum(shared.Variance.values),
+      bound: ManifestType.readOptional(reader),
+    );
   }
 
-  ManifestTypeParameter._({required this.bound});
+  ManifestTypeParameter._({required this.variance, required this.bound});
 
-  bool match(MatchContext context, TypeParameterElement element) {
-    return bound.match(context, element.bound);
+  bool match(MatchContext context, TypeParameterElementImpl element) {
+    return element.variance == variance && bound.match(context, element.bound);
   }
 
   void write(BufferedSink sink) {
+    sink.writeEnum(variance);
     bound.writeOptional(sink);
   }
 
@@ -702,7 +712,7 @@ extension ListOfManifestTypeExtension on List<ManifestType> {
 }
 
 extension ListOfManifestTypeParameterExtension on List<ManifestTypeParameter> {
-  bool match(MatchContext context, List<TypeParameterElement> elements) {
+  bool match(MatchContext context, List<TypeParameterElementImpl> elements) {
     if (elements.length != length) {
       return false;
     }

pkg/analyzer/test/src/dart/analysis/driver_test.dart

@@ -44150,13 +44150,15 @@ class A<T> {
     declaredClasses
       A: #M0
         typeParameters
-          bound: <null>
+          #0 covariant
+            bound: <null>
         supertype: Object @ dart:core
         declaredMethods
           foo: #M1
             functionType: FunctionType
               typeParameters
-                bound: <null>
+                #0 covariant
+                  bound: <null>
               returnType: Map @ dart:core
                 typeParameter#1
                 typeParameter#0
@@ -44176,7 +44178,8 @@ class A<T> {
     declaredClasses
       A: #M0
         typeParameters
-          bound: <null>
+          #0 covariant
+            bound: <null>
         supertype: Object @ dart:core
         declaredMethods
           bar: #M3
@@ -44185,7 +44188,8 @@ class A<T> {
           foo: #M1
             functionType: FunctionType
               typeParameters
-                bound: <null>
+                #0 covariant
+                  bound: <null>
               returnType: Map @ dart:core
                 typeParameter#1
                 typeParameter#0
@@ -46008,6 +46012,82 @@ class A<T> {}
     );
   }
 
+  test_manifest_class_typeParameters_variance() async {
+    await _runLibraryManifestScenario(
+      initialCode: r'''
+class A<in T> {}
+class B<out T> {}
+class C<in T> {}
+class D<out T> {}
+''',
+      expectedInitialEvents: r'''
+[operation] linkLibraryCycle SDK
+[operation] linkLibraryCycle
+  package:test/test.dart
+    declaredClasses
+      A: #M0
+        interface: #M1
+      B: #M2
+        interface: #M3
+      C: #M4
+        interface: #M5
+      D: #M6
+        interface: #M7
+''',
+      updatedCode: r'''
+class A<in T> {}
+class B<out T> {}
+class C<out T> {}
+class D<in T> {}
+''',
+      expectedUpdatedEvents: r'''
+[operation] linkLibraryCycle
+  package:test/test.dart
+    declaredClasses
+      A: #M0
+        interface: #M1
+      B: #M2
+        interface: #M3
+      C: #M8
+        interface: #M9
+      D: #M10
+        interface: #M11
+''',
+    );
+  }
+
+  test_manifest_class_typeParameters_variance_legacyCovariant() async {
+    await _runLibraryManifestScenario(
+      initialCode: r'''
+class A<T> {}
+class B<out T> {}
+''',
+      expectedInitialEvents: r'''
+[operation] linkLibraryCycle SDK
+[operation] linkLibraryCycle
+  package:test/test.dart
+    declaredClasses
+      A: #M0
+        interface: #M1
+      B: #M2
+        interface: #M3
+''',
+      updatedCode: r'''
+class A<out T> {}
+class B<T> {}
+''',
+      expectedUpdatedEvents: r'''
+[operation] linkLibraryCycle
+  package:test/test.dart
+    declaredClasses
+      A: #M0
+        interface: #M1
+      B: #M2
+        interface: #M3
+''',
+    );
+  }
+
   test_manifest_classTypeAlias_constructors_add() async {
     await _runLibraryManifestScenario(
       initialCode: r'''
@@ -53238,14 +53318,16 @@ mixin A<T> {
     declaredMixins
       A: #M0
         typeParameters
-          bound: <null>
+          #0 covariant
+            bound: <null>
         superclassConstraints
           Object @ dart:core
         declaredMethods
           foo: #M1
             functionType: FunctionType
               typeParameters
-                bound: <null>
+                #0 covariant
+                  bound: <null>
               returnType: Map @ dart:core
                 typeParameter#1
                 typeParameter#0
@@ -53265,7 +53347,8 @@ mixin A<T> {
     declaredMixins
       A: #M0
         typeParameters
-          bound: <null>
+          #0 covariant
+            bound: <null>
         superclassConstraints
           Object @ dart:core
         declaredMethods
@@ -53275,7 +53358,8 @@ mixin A<T> {
           foo: #M1
             functionType: FunctionType
               typeParameters
-                bound: <null>
+                #0 covariant
+                  bound: <null>
               returnType: Map @ dart:core
                 typeParameter#1
                 typeParameter#0
@@ -54182,6 +54266,50 @@ mixin A<T, U> {}
     );
   }
 
+  test_manifest_mixin_typeParameters_variance() async {
+    await _runLibraryManifestScenario(
+      initialCode: r'''
+mixin A<in T> {}
+mixin B<out T> {}
+mixin C<in T> {}
+mixin D<out T> {}
+''',
+      expectedInitialEvents: r'''
+[operation] linkLibraryCycle SDK
+[operation] linkLibraryCycle
+  package:test/test.dart
+    declaredMixins
+      A: #M0
+        interface: #M1
+      B: #M2
+        interface: #M3
+      C: #M4
+        interface: #M5
+      D: #M6
+        interface: #M7
+''',
+      updatedCode: r'''
+mixin A<in T> {}
+mixin B<out T> {}
+mixin C<out T> {}
+mixin D<in T> {}
+''',
+      expectedUpdatedEvents: r'''
+[operation] linkLibraryCycle
+  package:test/test.dart
+    declaredMixins
+      A: #M0
+        interface: #M1
+      B: #M2
+        interface: #M3
+      C: #M8
+        interface: #M9
+      D: #M10
+        interface: #M11
+''',
+    );
+  }
+
   test_manifest_topLevelFunction_add() async {
     await _runLibraryManifestScenario(
       initialCode: r'''
@@ -57207,6 +57335,65 @@ typedef B = int;
     );
   }
 
+  test_manifest_typeAlias_typeParameters_bound() async {
+    configuration.withElementManifests = true;
+    await _runLibraryManifestScenario(
+      initialCode: r'''
+typedef F<X extends num> = List<X>;
+''',
+      expectedInitialEvents: r'''
+[operation] linkLibraryCycle SDK
+[operation] linkLibraryCycle
+  package:test/test.dart
+    declaredTypeAliases
+      F: #M0
+        typeParameters
+          #0 covariant
+            bound: num @ dart:core
+        aliasedType: List @ dart:core
+          typeParameter#0
+''',
+      updatedCode: r'''
+typedef F<X extends int> = List<X>;
+''',
+      expectedUpdatedEvents: r'''
+[operation] linkLibraryCycle
+  package:test/test.dart
+    declaredTypeAliases
+      F: #M1
+        typeParameters
+          #0 covariant
+            bound: int @ dart:core
+        aliasedType: List @ dart:core
+          typeParameter#0
+''',
+    );
+  }
+
+  test_manifest_typeAlias_typeParameters_name() async {
+    await _runLibraryManifestScenario(
+      initialCode: r'''
+typedef F<X> = List<X>;
+''',
+      expectedInitialEvents: r'''
+[operation] linkLibraryCycle SDK
+[operation] linkLibraryCycle
+  package:test/test.dart
+    declaredTypeAliases
+      F: #M0
+''',
+      updatedCode: r'''
+typedef F<Y> = List<Y>;
+''',
+      expectedUpdatedEvents: r'''
+[operation] linkLibraryCycle
+  package:test/test.dart
+    declaredTypeAliases
+      F: #M0
+''',
+    );
+  }
+
   test_operation_addFile_changeImported_affected() async {
     configuration.withCheckLibraryDiagnosticsRequirements = true;
 

pkg/analyzer/test/src/dart/analysis/result_printer.dart

@@ -1567,8 +1567,16 @@ class LibraryManifestPrinter {
   }
 
   void _writeTypeParameters(List<ManifestTypeParameter> typeParameters) {
-    sink.writeElements('typeParameters', typeParameters, (typeParameter) {
-      _writeNamedType('bound', typeParameter.bound);
+    var indexed = typeParameters.indexed.toList();
+    sink.writeElements('typeParameters', indexed, (pair) {
+      var typeParameter = pair.$2;
+      sink.writeIndentedLine(() {
+        sink.write('#${pair.$1} ');
+        sink.write(typeParameter.variance.name);
+      });
+      sink.withIndent(() {
+        _writeNamedType('bound', typeParameter.bound);
+      });
     });
   }
 }