Fine. Add a few tests that ask element model manually.

These tests just record requirements, but don't verify that these
requirements cause re-computation of the result if changed. My current
thinking is that we might have two main axis of tests: library manifests
that verify that we give new IDs to changed elements; and requirements
that verify that asking a piece of data from the element model is
recorded as a requirement (or not, if this piece of data already cause
the element ID to change).

We need at least one test for each requirement kind that verifies that
such requirement does cause re-computation. But we don't need to do this
in every test. So, we avoid combinatorial explosion of cases? E.g. if
there are two requirements recorded, we don't want to try all 4
combinations how they change.

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

Author: scheglov

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

@@ -8,7 +8,6 @@ import 'dart:typed_data';
 import 'package:analyzer/dart/analysis/analysis_options.dart';
 import 'package:analyzer/dart/analysis/declared_variables.dart';
 import 'package:analyzer/dart/analysis/results.dart';
-import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/diagnostic/diagnostic.dart';
 import 'package:analyzer/error/error.dart';
 import 'package:analyzer/error/listener.dart';
@@ -36,6 +35,7 @@ import 'package:analyzer/src/dart/analysis/session.dart';
 import 'package:analyzer/src/dart/analysis/status.dart';
 import 'package:analyzer/src/dart/analysis/testing_data.dart';
 import 'package:analyzer/src/dart/analysis/unlinked_unit_store.dart';
+import 'package:analyzer/src/dart/ast/ast.dart';
 import 'package:analyzer/src/dart/element/element.dart';
 import 'package:analyzer/src/dart/resolver/flow_analysis_visitor.dart';
 import 'package:analyzer/src/dartdoc/dartdoc_directive_info.dart';
@@ -65,6 +65,15 @@ import 'package:analyzer/src/workspace/pub.dart';
 import 'package:collection/collection.dart';
 import 'package:meta/meta.dart';
 
+/// This function is used to test recording requirements during analysis.
+///
+/// Some [ElementImpl2] APIs are not trivial, or maybe even impossible, to
+/// trigger. For example because this API is not used during normal resolution
+/// of Dart code, but can be used by a linter rule.
+@visibleForTesting
+void Function(List<CompilationUnitImpl> units)?
+testFineAfterLibraryAnalyzerHook;
+
 /// This class computes analysis results for Dart files.
 ///
 /// Let the set of "explicitly analyzed files" denote the set of paths that have
@@ -1376,6 +1385,12 @@ class AnalysisDriver {
           ).analyze();
         });
 
+        // Invoke the test only hook to trigger additional requirements.
+        if (testFineAfterLibraryAnalyzerHook case var hook?) {
+          var units = results.map((result) => result.unit).toList();
+          hook(units);
+        }
+
         if (withFineDependencies) {
           globalResultRequirements = null;
         }

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

@@ -15,6 +15,7 @@ import 'package:analyzer/src/dart/analysis/driver_event.dart' as driver_events;
 import 'package:analyzer/src/dart/analysis/file_state.dart';
 import 'package:analyzer/src/dart/analysis/status.dart';
 import 'package:analyzer/src/dart/ast/ast.dart';
+import 'package:analyzer/src/dart/element/element.dart';
 import 'package:analyzer/src/error/codes.dart';
 import 'package:analyzer/src/fine/requirements.dart';
 import 'package:analyzer/src/lint/linter.dart';
@@ -5450,6 +5451,7 @@ class FineAnalysisDriverTest extends PubPackageResolutionTest
 
   @override
   Future<void> tearDown() async {
+    testFineAfterLibraryAnalyzerHook = null;
     withFineDependencies = false;
     return super.tearDown();
   }
@@ -36890,6 +36892,251 @@ int get b => 0;
     );
   }
 
+  test_req_instanceElement_getGetter() async {
+    newFile('$testPackageLibPath/a.dart', r'''
+class A {
+  static int get foo {}
+}
+''');
+
+    newFile(testFile.path, r'''
+import 'a.dart';
+''');
+
+    _ManualRequirements.install((state) {
+      var A = state.singleUnit.scopeInstanceElement('A');
+      A.getGetter2('foo');
+    });
+
+    await _runManualRequirementsRecording(
+      expectedEvents: r'''
+[status] working
+[operation] linkLibraryCycle SDK
+[operation] linkLibraryCycle
+  package:test/a.dart
+    manifest
+      A: #M0
+        declaredMembers
+          foo.getter: #M1
+  requirements
+    topLevels
+      dart:core
+        int: #M2
+[operation] linkLibraryCycle
+  package:test/test.dart
+  requirements
+[operation] analyzedLibrary
+  file: /home/test/lib/test.dart
+  requirements
+    topLevels
+      dart:core
+        A: <null>
+      package:test/a.dart
+        A: #M0
+    instances
+      package:test/a.dart
+        A
+          requestedMethods
+            foo: #M1
+[status] idle
+''',
+    );
+  }
+
+  test_req_instanceElement_getMethod() async {
+    newFile('$testPackageLibPath/a.dart', r'''
+class A {
+  static int foo() {}
+}
+''');
+
+    newFile(testFile.path, r'''
+import 'a.dart';
+''');
+
+    _ManualRequirements.install((state) {
+      var A = state.singleUnit.scopeInstanceElement('A');
+      A.getMethod2('foo');
+    });
+
+    await _runManualRequirementsRecording(
+      expectedEvents: r'''
+[status] working
+[operation] linkLibraryCycle SDK
+[operation] linkLibraryCycle
+  package:test/a.dart
+    manifest
+      A: #M0
+        declaredMembers
+          foo.method: #M1
+  requirements
+    topLevels
+      dart:core
+        int: #M2
+[operation] linkLibraryCycle
+  package:test/test.dart
+  requirements
+[operation] analyzedLibrary
+  file: /home/test/lib/test.dart
+  requirements
+    topLevels
+      dart:core
+        A: <null>
+      package:test/a.dart
+        A: #M0
+    instances
+      package:test/a.dart
+        A
+          requestedMethods
+            foo: #M1
+[status] idle
+''',
+    );
+  }
+
+  test_req_instanceElement_getMethod_doesNotExist() async {
+    newFile('$testPackageLibPath/a.dart', r'''
+class A {}
+''');
+
+    newFile(testFile.path, r'''
+import 'a.dart';
+''');
+
+    _ManualRequirements.install((state) {
+      var A = state.singleUnit.scopeInstanceElement('A');
+      A.getMethod2('foo');
+    });
+
+    await _runManualRequirementsRecording(
+      expectedEvents: r'''
+[status] working
+[operation] linkLibraryCycle SDK
+[operation] linkLibraryCycle
+  package:test/a.dart
+    manifest
+      A: #M0
+  requirements
+[operation] linkLibraryCycle
+  package:test/test.dart
+  requirements
+[operation] analyzedLibrary
+  file: /home/test/lib/test.dart
+  requirements
+    topLevels
+      dart:core
+        A: <null>
+      package:test/a.dart
+        A: #M0
+    instances
+      package:test/a.dart
+        A
+          requestedMethods
+            foo: <null>
+[status] idle
+''',
+    );
+  }
+
+  test_req_instanceElement_getSetter() async {
+    newFile('$testPackageLibPath/a.dart', r'''
+class A {
+  static set foo(int _) {}
+}
+''');
+
+    newFile(testFile.path, r'''
+import 'a.dart';
+''');
+
+    _ManualRequirements.install((state) {
+      var A = state.singleUnit.scopeInstanceElement('A');
+      A.getSetter2('foo');
+    });
+
+    await _runManualRequirementsRecording(
+      expectedEvents: r'''
+[status] working
+[operation] linkLibraryCycle SDK
+[operation] linkLibraryCycle
+  package:test/a.dart
+    manifest
+      A: #M0
+        declaredMembers
+          foo.setter: #M1
+  requirements
+    topLevels
+      dart:core
+        int: #M2
+[operation] linkLibraryCycle
+  package:test/test.dart
+  requirements
+[operation] analyzedLibrary
+  file: /home/test/lib/test.dart
+  requirements
+    topLevels
+      dart:core
+        A: <null>
+      package:test/a.dart
+        A: #M0
+    instances
+      package:test/a.dart
+        A
+          requestedMethods
+            foo=: #M1
+[status] idle
+''',
+    );
+  }
+
+  test_req_interfaceElement_getConstructor_named() async {
+    newFile('$testPackageLibPath/a.dart', r'''
+class A {
+  A.named();
+}
+''');
+
+    newFile(testFile.path, r'''
+import 'a.dart';
+''');
+
+    _ManualRequirements.install((state) {
+      var A = state.singleUnit.scopeInterfaceElement('A');
+      A.getNamedConstructor2('named');
+    });
+
+    await _runManualRequirementsRecording(
+      expectedEvents: r'''
+[status] working
+[operation] linkLibraryCycle SDK
+[operation] linkLibraryCycle
+  package:test/a.dart
+    manifest
+      A: #M0
+        declaredMembers
+          named.constructor: #M1
+  requirements
+[operation] linkLibraryCycle
+  package:test/test.dart
+  requirements
+[operation] analyzedLibrary
+  file: /home/test/lib/test.dart
+  requirements
+    topLevels
+      dart:core
+        A: <null>
+      package:test/a.dart
+        A: #M0
+    interfaces
+      package:test/a.dart
+        A
+          constructors
+            named: #M1
+[status] idle
+''',
+    );
+  }
+
   Future<void> _runChangeScenario({
     required _FineOperation operation,
     String? expectedInitialEvents,
@@ -37031,6 +37278,27 @@ int get b => 0;
       assertDriverStateString(testFile, expectedUpdatedDriverState);
     }
   }
+
+  /// Works together with [_ManualRequirements] to execute manual requests to
+  /// the element model, and observe which requirements are recorded.
+  Future<void> _runManualRequirementsRecording({
+    required String expectedEvents,
+  }) async {
+    withFineDependencies = true;
+    configuration
+      ..withAnalyzeFileEvents = false
+      ..withLibraryManifest = true
+      ..withLinkBundleEvents = true
+      ..withGetErrorsEvents = false
+      ..withResultRequirements = true
+      ..withStreamResolvedUnitResults = false;
+
+    var driver = driverFor(testFile);
+    var collector = DriverEventCollector(driver, idProvider: idProvider);
+
+    collector.getErrors('T1', testFile);
+    await assertEventsText(collector, expectedEvents);
+  }
 }
 
 /// A lint that is always reported for all linted files.
@@ -37122,6 +37390,52 @@ final class _FineOperationTestFileGetErrors extends _FineOperation {
   const _FineOperationTestFileGetErrors();
 }
 
+/// Helper for triggering requirements manually.
+///
+/// Some [Element] APIs are not trivial, or maybe even impossible, to
+/// trigger. For example because this API is not used during normal resolution
+/// of Dart code, but can be used by a linter rule.
+class _ManualRequirements {
+  final List<CompilationUnitImpl> units;
+
+  _ManualRequirements(this.units);
+
+  _ManualRequirementsUnit get singleUnit {
+    var unit = units.single;
+    return _ManualRequirementsUnit(unit);
+  }
+
+  static void install(void Function(_ManualRequirements) operation) {
+    testFineAfterLibraryAnalyzerHook = (units) {
+      var self = _ManualRequirements(units);
+      operation(self);
+    };
+  }
+}
+
+class _ManualRequirementsUnit {
+  final CompilationUnitImpl unit;
+
+  _ManualRequirementsUnit(this.unit);
+
+  LibraryFragmentImpl get libraryFragment {
+    return unit.declaredFragment!;
+  }
+
+  ClassElementImpl2 scopeClassElement(String name) {
+    return scopeInterfaceElement(name) as ClassElementImpl2;
+  }
+
+  InstanceElementImpl2 scopeInstanceElement(String name) {
+    var lookupResult = libraryFragment.scope.lookup(name);
+    return lookupResult.getter2 as InstanceElementImpl2;
+  }
+
+  InterfaceElementImpl2 scopeInterfaceElement(String name) {
+    return scopeInstanceElement(name) as InterfaceElementImpl2;
+  }
+}
+
 extension on AnalysisDriver {
   Future<void> assertFilesDefiningClassMemberName(
     String name,