Fine. Deduplicate prefix-scope requirement recording

Record import-prefix lookups only once per identifier during a single
requirements run. This avoids repeatedly writing the same
`exportedTopLevels` entries for every imported library when the same
name is looked up multiple times.

Key changes:
- Introduce `PrefixScopeRequirementState` and pass it to
  `RequirementsManifest.record_importPrefixScope_lookup`. The method
  now records requirements for a given `id` only on the first lookup
  seen by that state.
- Add `InstanceElementRequirementState` and
  `LibraryElementRequirementState` to cache per-owner lookups inside
  `_getInstanceItem`, `_getInterfaceItem`, and `_getLibraryRequirements`,
  reducing map churn.
- Add `RequirementsManifest.stopRecording()` and call it after
  analysis/linking to dispose per-run state and reclaim memory.
- Update call sites:
  - `PrefixScope.lookup()` now supplies a persistent state.
  - `record_library_exportScope_get()` uses a one-shot state for
    direct library export-scope queries.

Impact:
- Lowers the cost of requirement recording from ~6% to ~1.74% of total
  analysis time in observed profiles.
- Preserves correctness: all needed exported IDs are still recorded;
  we simply suppress duplicates.
- Trade-off: a small, transient per-run memory footprint for the
  dedup sets and caches, cleared via `stopRecording()`.

Rationale: Repeated name lookups were causing redundant `Map` writes
(often writing the same `null`/ID values many times). By binding
prefix-scope recording to a per-run state and caching element/library
requirement slots, we remove hot-path duplication without sacrificing
precision.

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

Author: scheglov

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

@@ -1395,6 +1395,7 @@ class AnalysisDriver {
 
         if (withFineDependencies) {
           assert(requirements!.assertSerialization());
+          globalResultRequirements?.stopRecording();
           globalResultRequirements = null;
         }
 

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

@@ -332,6 +332,7 @@ class LibraryContext {
             elementFactory: elementFactory,
             libraryUriSet: cycle.libraryUris,
           );
+          globalResultRequirements?.stopRecording();
           globalResultRequirements = null;
           requirements.removeReqForLibs(cycle.libraryUris);
           assert(requirements.assertSerialization());

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

@@ -4221,6 +4221,10 @@ abstract class InstanceElementImpl extends ElementImpl
   List<SetterElementImpl> _setters = [];
   List<MethodElementImpl> _methods = [];
 
+  @trackedInternal
+  InstanceElementRequirementState requirementState =
+      InstanceElementRequirementState();
+
   @override
   @trackedIncludedInId
   InstanceElement get baseElement => this;
@@ -5999,6 +6003,10 @@ class LibraryElementImpl extends ElementImpl
   @trackedInternal
   LibraryManifest? manifest;
 
+  @trackedInternal
+  LibraryElementRequirementState requirementState =
+      LibraryElementRequirementState();
+
   @trackedInternal
   late final LibraryElementImplInternal internal = LibraryElementImplInternal(
     this,

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

@@ -518,6 +518,9 @@ class PrefixScope implements Scope {
 
   ImportsTrackingOfPrefix? _importsTracking;
 
+  final PrefixScopeRequirementState _requirementState =
+      PrefixScopeRequirementState();
+
   PrefixScope({
     required this.libraryFragment,
     required this.parent,
@@ -579,6 +582,7 @@ class PrefixScope implements Scope {
 
     if (globalResultRequirements case var resultRequirements?) {
       resultRequirements.record_importPrefixScope_lookup(
+        state: _requirementState,
         importedLibraries: _importedLibraries,
         id: id,
       );

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

@@ -2,6 +2,7 @@
 // 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 'dart:collection';
 import 'dart:typed_data';
 
 import 'package:analyzer/dart/element/element.dart';
@@ -191,6 +192,27 @@ final class ExportRequirementShowCombinator
   }
 }
 
+class InstanceElementRequirementState {
+  RequirementsManifest? _owner;
+  _InstanceItemWithRequirements? _instanceResult;
+  _InterfaceItemWithRequirements? _interfaceResult;
+
+  void _dispose() {
+    _owner = null;
+    _instanceResult = null;
+    _interfaceResult = null;
+  }
+
+  void _ensureFor(RequirementsManifest owner) {
+    if (!identical(_owner, owner)) {
+      owner._instanceElementStates.add(this);
+      _owner = owner;
+      _instanceResult = null;
+      _interfaceResult = null;
+    }
+  }
+}
+
 /// Requirements for [InstanceElementImpl].
 ///
 /// If [InterfaceElementImpl], there are additional requirements in form
@@ -330,6 +352,24 @@ class InterfaceItemRequirements {
   }
 }
 
+class LibraryElementRequirementState {
+  RequirementsManifest? _owner;
+  LibraryRequirements? _result;
+
+  void _dispose() {
+    _owner = null;
+    _result = null;
+  }
+
+  void _ensureFor(RequirementsManifest owner) {
+    if (!identical(_owner, owner)) {
+      owner._libraryElementStates.add(this);
+      _owner = owner;
+      _result = null;
+    }
+  }
+}
+
 /// Requirements for all `export`s of a library.
 @visibleForTesting
 class LibraryExportRequirements {
@@ -701,6 +741,29 @@ class OpaqueApiUse {
   }
 }
 
+/// Mutable state [RequirementsManifest] uses whenever a prefix-scope lookup
+/// happens. It binds to the current [RequirementsManifest] and suppresses
+/// duplicate recordings for the same identifier during that run.
+class PrefixScopeRequirementState {
+  RequirementsManifest? _owner;
+
+  /// The set of names for which we already recorded requirements.
+  HashSet<String> _idSet = HashSet();
+
+  void _dispose() {
+    _owner = null;
+    _idSet = HashSet();
+  }
+
+  void _ensureFor(RequirementsManifest owner) {
+    if (!identical(_owner, owner)) {
+      owner._prefixScopeStates.add(this);
+      _owner = owner;
+      _idSet = HashSet();
+    }
+  }
+}
+
 class RequirementsManifest {
   /// LibraryUri => LibraryRequirements
   final Map<Uri, LibraryRequirements> libraries = {};
@@ -714,6 +777,10 @@ class RequirementsManifest {
 
   int _recordingLockLevel = 0;
 
+  final List<InstanceElementRequirementState> _instanceElementStates = [];
+  final List<LibraryElementRequirementState> _libraryElementStates = [];
+  final List<PrefixScopeRequirementState> _prefixScopeStates = [];
+
   RequirementsManifest();
 
   factory RequirementsManifest.read(SummaryDataReader reader) {
@@ -1486,6 +1553,7 @@ class RequirementsManifest {
   /// Record that [id] was looked up in the import prefix scope that
   /// imports [importedLibraries].
   void record_importPrefixScope_lookup({
+    required PrefixScopeRequirementState state,
     required List<LibraryElementImpl> importedLibraries,
     required String id,
   }) {
@@ -1495,6 +1563,11 @@ class RequirementsManifest {
       return;
     }
 
+    state._ensureFor(this);
+    if (!state._idSet.add(id)) {
+      return;
+    }
+
     var getterLookupName = id.asLookupName;
     var setterLookupName = '$id='.asLookupName;
 
@@ -1990,6 +2063,7 @@ class RequirementsManifest {
     required String name,
   }) {
     record_importPrefixScope_lookup(
+      state: PrefixScopeRequirementState(),
       importedLibraries: [element],
       id: name.removeSuffix('=') ?? name,
     );
@@ -2305,6 +2379,23 @@ class RequirementsManifest {
     }
   }
 
+  void stopRecording() {
+    for (var state in _instanceElementStates) {
+      state._dispose();
+    }
+    _instanceElementStates.clear();
+
+    for (var state in _libraryElementStates) {
+      state._dispose();
+    }
+    _libraryElementStates.clear();
+
+    for (var state in _prefixScopeStates) {
+      state._dispose();
+    }
+    _prefixScopeStates.clear();
+  }
+
   void write(BufferedSink sink) {
     sink.writeMap(
       libraries,
@@ -2321,6 +2412,11 @@ class RequirementsManifest {
   }
 
   _InstanceItemWithRequirements? _getInstanceItem(InstanceElementImpl element) {
+    var state = element.requirementState.._ensureFor(this);
+    if (state._instanceResult case var result?) {
+      return result;
+    }
+
     var libraryElement = element.library;
     var manifest = libraryElement.manifest;
 
@@ -2349,16 +2445,21 @@ class RequirementsManifest {
 
     var requirements = instancesMap[instanceName] ??=
         InstanceItemRequirements.empty();
-
-    return _InstanceItemWithRequirements(
+    var result = _InstanceItemWithRequirements(
       item: instanceItem,
       requirements: requirements,
     );
+    return state._instanceResult = result;
   }
 
   _InterfaceItemWithRequirements? _getInterfaceItem(
     InterfaceElementImpl element,
   ) {
+    var state = element.requirementState.._ensureFor(this);
+    if (state._interfaceResult case var result?) {
+      return result;
+    }
+
     var libraryElement = element.library;
     var manifest = libraryElement.manifest;
 
@@ -2386,14 +2487,21 @@ class RequirementsManifest {
 
     var requirements = interfacesMap[interfaceName] ??=
         InterfaceItemRequirements.empty();
-    return _InterfaceItemWithRequirements(
+    var result = _InterfaceItemWithRequirements(
       item: interfaceItem,
       requirements: requirements,
     );
+    return state._interfaceResult = result;
   }
 
   LibraryRequirements _getLibraryRequirements(LibraryElementImpl element) {
-    return libraries[element.uri] ??= LibraryRequirements.empty();
+    var state = element.requirementState.._ensureFor(this);
+    if (state._result case var result?) {
+      return result;
+    }
+
+    var result = libraries[element.uri] ??= LibraryRequirements.empty();
+    return state._result = result;
   }
 
   String _qualifiedMethodName(