Fine. Record class modifiers in manifests.

Capture Dart class modifiers as part of the fine-grained manifest so ID
matching and reuse reflect API-relevant changes. Modifiers like
`abstract`, `base`, `final`, `interface`, `mixin class`, `mixin
application`, and `sealed` affect subtyping and visibility rules; they
must therefore participate in identity, matching, and dumps.

Changes:
- Extend `ClassItem` with boolean flags:
  `isAbstract`, `isBase`, `isFinal`, `isInterface`,
  `isMixinApplication`, `isMixinClass`, `isSealed`.
- Include these flags in encode/decode/write and in `match(...)`.
- Print a `flags:` block for classes in `LibraryManifestPrinter` when
  `withElementManifests` is enabled.
- Bump `AnalysisDriver.DATA_VERSION` to 530 to invalidate caches and
  avoid reusing bundles with the old manifest layout.
- Add tests exercising ID churn when modifiers change and updating
  expect output where flags are now printed.

Impact:
- Prevents stale ID reuse when class modifiers change.
- Ensures downstream libraries re-link when modifier changes affect
  inheritance and implementability.
- Improves diagnostic correctness and manifest transparency.

Change-Id: I8914e4a9be18ea4fc0c6978029061e16aeb33e20
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/447962
Reviewed-by: Johnni Winther <[email protected]>
Commit-Queue: Konstantin Shcheglov <[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 = 529;
+  static const int DATA_VERSION = 530;
 
   /// 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_item.dart

@@ -16,6 +16,14 @@ import 'package:collection/collection.dart';
 import 'package:meta/meta.dart';
 
 class ClassItem extends InterfaceItem<ClassElementImpl> {
+  final bool isAbstract;
+  final bool isBase;
+  final bool isFinal;
+  final bool isInterface;
+  final bool isMixinApplication;
+  final bool isMixinClass;
+  final bool isSealed;
+
   ClassItem({
     required super.id,
     required super.metadata,
@@ -31,6 +39,13 @@ class ClassItem extends InterfaceItem<ClassElementImpl> {
     required super.mixins,
     required super.interfaces,
     required super.interface,
+    required this.isAbstract,
+    required this.isBase,
+    required this.isFinal,
+    required this.isInterface,
+    required this.isMixinApplication,
+    required this.isMixinClass,
+    required this.isSealed,
   });
 
   factory ClassItem.fromElement({
@@ -54,6 +69,13 @@ class ClassItem extends InterfaceItem<ClassElementImpl> {
         mixins: element.mixins.encode(context),
         interfaces: element.interfaces.encode(context),
         interface: ManifestInterface.empty(),
+        isAbstract: element.isAbstract,
+        isBase: element.isBase,
+        isFinal: element.isFinal,
+        isInterface: element.isInterface,
+        isMixinApplication: element.isMixinApplication,
+        isMixinClass: element.isMixinClass,
+        isSealed: element.isSealed,
       );
     });
   }
@@ -74,8 +96,39 @@ class ClassItem extends InterfaceItem<ClassElementImpl> {
       mixins: ManifestType.readList(reader),
       interfaces: ManifestType.readList(reader),
       interface: ManifestInterface.read(reader),
+      isAbstract: reader.readBool(),
+      isBase: reader.readBool(),
+      isFinal: reader.readBool(),
+      isInterface: reader.readBool(),
+      isMixinApplication: reader.readBool(),
+      isMixinClass: reader.readBool(),
+      isSealed: reader.readBool(),
     );
   }
+
+  @override
+  bool match(MatchContext context, ClassElementImpl element) {
+    return super.match(context, element) &&
+        isAbstract == element.isAbstract &&
+        isBase == element.isBase &&
+        isFinal == element.isFinal &&
+        isInterface == element.isInterface &&
+        isMixinApplication == element.isMixinApplication &&
+        isMixinClass == element.isMixinClass &&
+        isSealed == element.isSealed;
+  }
+
+  @override
+  void write(BufferedSink sink) {
+    super.write(sink);
+    sink.writeBool(isAbstract);
+    sink.writeBool(isBase);
+    sink.writeBool(isFinal);
+    sink.writeBool(isInterface);
+    sink.writeBool(isMixinApplication);
+    sink.writeBool(isMixinClass);
+    sink.writeBool(isSealed);
+  }
 }
 
 class EnumItem extends InterfaceItem<EnumElementImpl> {