Fine. Avoid opaque API uses when lazily loading class members.

Lazy loading of a class’s members inadvertently recorded opaque API uses
via `ClassElementImpl.fragments`/`firstFragment`. This polluted result
requirements with non-API dependencies and could trigger unnecessary
rebuilds when reading from cached bundles.

This change removes those spurious dependencies:

- Add `ClassElementImpl._fragments` to iterate fragments without touching
  the tracked `fragments` getter.
- Add `ClassElementImpl.ensureReadMembersForFragments()` and use it in
  `BundleReader` when materializing a class’s members, avoiding any
  dependency on `fragments` during deserialization.
- Simplify `LinkedElementFactory` by calling
  `parentElement.ensureReadMembers()` instead of poking constructor lists
  to force member loading.
- Keep the public `fragments` getter behavior (including opaque tracking)
  for true API reads; internal reads now use the private helper.

A regression test exercises a scenario where class `B` references `A` in
a default parameter. Linking after a cache reload no longer records
opaque uses of `A`/`B` members, preserving dependency precision.

Found with https://dart-review.googlesource.com/c/sdk/+/446480

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

Author: scheglov

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

@@ -214,14 +214,7 @@ class ClassElementImpl extends InterfaceElementImpl implements ClassElement {
   @trackedDirectlyOpaque
   List<ClassFragmentImpl> get fragments {
     globalResultRequirements?.recordOpaqueApiUse(this, 'fragments');
-    return [
-      for (
-        ClassFragmentImpl? fragment = _firstFragment;
-        fragment != null;
-        fragment = fragment.nextFragment
-      )
-        fragment,
-    ];
+    return _fragments;
   }
 
   @trackedIndirectly
@@ -362,6 +355,17 @@ class ClassElementImpl extends InterfaceElementImpl implements ClassElement {
   @trackedIncludedInId
   ElementKind get kind => ElementKind.CLASS;
 
+  List<ClassFragmentImpl> get _fragments {
+    return [
+      for (
+        ClassFragmentImpl? fragment = _firstFragment;
+        fragment != null;
+        fragment = fragment.nextFragment
+      )
+        fragment,
+    ];
+  }
+
   @override
   @trackedDirectlyOpaque
   T? accept<T>(ElementVisitor2<T> visitor) {
@@ -381,6 +385,12 @@ class ClassElementImpl extends InterfaceElementImpl implements ClassElement {
     builder.writeClassElement(this);
   }
 
+  void ensureReadMembersForFragments() {
+    for (var fragment in _fragments) {
+      fragment.ensureReadMembers();
+    }
+  }
+
   @Deprecated('Use isExtendableOutside instead')
   @override
   @trackedIndirectly

pkg/analyzer/lib/src/summary2/bundle_reader.dart

@@ -272,16 +272,16 @@ class LibraryReader {
       _lazyRead((offset) {
         element.deferReadMembers(() {
           _reader.runAtOffset(offset, () {
-            for (var fragment in element.fragments) {
-              fragment.ensureReadMembers();
-            }
-
+            element.ensureReadMembersForFragments();
             element.fields = _readFieldElements();
             element.getters = _readGetterElements();
             element.setters = _readSetterElements();
             _readVariableGetterSetterLinking();
             element.methods = _readMethodElements();
-            if (!element.isMixinApplication) {
+            if (element.isMixinApplication) {
+              // Create synthetic constructors and associate with references.
+              element.constructors;
+            } else {
               element.constructors = _readConstructorElements();
             }
           });

pkg/analyzer/lib/src/summary2/linked_element_factory.dart

@@ -144,10 +144,7 @@ class LinkedElementFactory {
 
     // Only classes delay creating children.
     if (parentElement is ClassElementImpl) {
-      var firstFragment = parentElement.firstFragment;
-      // TODO(scheglov): directly ask to read all?
-      firstFragment.constructors;
-      parentElement.constructors;
+      parentElement.ensureReadMembers();
     }
 
     var element = reference.element;

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

@@ -55949,6 +55949,105 @@ int get b => 0;
     );
   }
 
+  test_precision_noOpaqueApiUse() async {
+    // Lowest layer: `A` is used by `B`.
+    var a = newFile('$testPackageLibPath/a.dart', r'''
+class A {
+  const A();
+}
+''');
+
+    // Middle layer: `B` references `A` in a default value.
+    newFile('$testPackageLibPath/b.dart', r'''
+import 'a.dart';
+
+class B {
+  const B([Object? x = const A()]);
+}
+''');
+
+    configuration
+      ..withSchedulerStatus = false
+      ..withGetLibraryByUri = false
+      ..withLinkBundleEvents = true
+      ..withLibraryManifest = true
+      ..withResultRequirements = true;
+
+    var driver = driverFor(testFile);
+    var collector = DriverEventCollector(driver, idProvider: idProvider);
+
+    // 1) Link `a.dart` and `b.dart`.
+    collector.getLibraryByUri('B1', 'package:test/b.dart');
+    await assertEventsText(collector, r'''
+[operation] linkLibraryCycle SDK
+[operation] linkLibraryCycle
+  package:test/a.dart
+    declaredClasses
+      A: #M0
+        interface: #M1
+  requirements
+[operation] linkLibraryCycle
+  package:test/b.dart
+    declaredClasses
+      B: #M2
+        interface: #M3
+  requirements
+    libraries
+      package:test/a.dart
+        exportedTopLevels
+          A: #M0
+          Object: <null>
+        interfaces
+          A
+            requestedConstructors
+              new: #M4
+''');
+
+    // 2) Touch the lowest layer: unload both `a.dart` and `b.dart`.
+    modifyFile2(a, r'''
+class A {
+  const A(); // comment
+}
+''');
+    driver.changeFile2(a);
+
+    // 3) Top layer: `test.dart` depends on `B`, and so `A` transitively.
+    newFile(testFile.path, r'''
+import 'b.dart';
+final v = B();
+''');
+
+    // Link `test.dart`. During linking, we will need formal parameters of the
+    // constructor `B()`, which will trigger loading resolution data for its
+    // formal parameter `x = const A()`. This will require loading members,
+    // specifically constructors, of `A`.
+    //
+    // There was a bug when loading members of `A` and `B` caused recording
+    // opaque API use (`firstFragment` and `fragments`).
+    collector.getLibraryByUri('T1', 'package:test/test.dart');
+    await assertEventsText(collector, r'''
+[operation] readLibraryCycleBundle
+  package:test/a.dart
+[operation] readLibraryCycleBundle
+  package:test/b.dart
+[operation] linkLibraryCycle
+  package:test/test.dart
+    declaredGetters
+      v: #M5
+    declaredVariables
+      v: #M6
+  requirements
+    libraries
+      package:test/b.dart
+        exportedTopLevels
+          B: #M2
+        interfaces
+          B
+            requestedConstructors
+              new: #M7
+''');
+  }
+
   test_req_classElement_noName() async {
     newFile(testFile.path, r'''
 class {}

pkg/analyzer/test/src/summary/elements/class_test.dart

@@ -19065,6 +19065,70 @@ library
 ''');
   }
 
+  test_classAlias_constructors_reading() async {
+    newFile('$testPackageLibPath/a.dart', r'''
+mixin M {}
+
+class A {
+  const A.named();
+}
+
+class B = A with M;
+''');
+
+    var library = await buildLibrary('''
+import 'a.dart';
+const x = B.named();
+''');
+    checkElementText(library, r'''
+library
+  reference: <testLibrary>
+  fragments
+    #F0 <testLibraryFragment>
+      element: <testLibrary>
+      libraryImports
+        package:test/a.dart
+      topLevelVariables
+        #F1 hasInitializer x (nameOffset:23) (firstTokenOffset:23) (offset:23)
+          element: <testLibrary>::@topLevelVariable::x
+          initializer: expression_0
+            InstanceCreationExpression
+              constructorName: ConstructorName
+                type: NamedType
+                  name: B @27
+                  element2: package:test/a.dart::@class::B
+                  type: B
+                period: . @28
+                name: SimpleIdentifier
+                  token: named @29
+                  element: package:test/a.dart::@class::B::@constructor::named
+                  staticType: null
+                element: package:test/a.dart::@class::B::@constructor::named
+              argumentList: ArgumentList
+                leftParenthesis: ( @34
+                rightParenthesis: ) @35
+              staticType: B
+      getters
+        #F2 synthetic x (nameOffset:<null>) (firstTokenOffset:<null>) (offset:23)
+          element: <testLibrary>::@getter::x
+  topLevelVariables
+    const hasInitializer x
+      reference: <testLibrary>::@topLevelVariable::x
+      firstFragment: #F1
+      type: B
+      constantInitializer
+        fragment: #F1
+        expression: expression_0
+      getter: <testLibrary>::@getter::x
+  getters
+    synthetic static x
+      reference: <testLibrary>::@getter::x
+      firstFragment: #F2
+      returnType: B
+      variable: <testLibrary>::@topLevelVariable::x
+''');
+  }
+
   test_classAlias_constructors_requiredParameters() async {
     var library = await buildLibrary('''
 class A<T extends num> {