[analyzer] Stable analysis tool

Tool the - in my testing at least - is very stable in terms of
instruction counts used as reported by `perf stat`.

Only requires small changes to the analyzer and doesn't affect the part
that's covered by api.txt.

Running it on an extracted dill (with an aot-compiled tool) I get numbers like
this:

```
perf stat -e task-clock:u,cycles:u,instructions:u,branch-misses:u -r3 out/ReleaseX64/dart-sdk/bin/dartaotruntime --deterministic pkg/analyzer/tool/stable_analysis.aot /tmp/extracted_compile_dart_compile
```

```
[...]
50,853,198,745      instructions:u                   #    1.18  insn per cycle              ( +-  0.00% )
[...]
```

Running it 10 times (without `-r3`) I get this:

```
    50,853,237,614      instructions:u                   #    1.18  insn per cycle
    50,853,477,778      instructions:u                   #    1.19  insn per cycle
    50,852,534,741      instructions:u                   #    1.17  insn per cycle
    50,852,728,437      instructions:u                   #    1.18  insn per cycle
    50,853,298,284      instructions:u                   #    1.18  insn per cycle
    50,853,151,431      instructions:u                   #    1.17  insn per cycle
    50,853,754,852      instructions:u                   #    1.18  insn per cycle
    50,852,509,185      instructions:u                   #    1.17  insn per cycle
    50,853,878,495      instructions:u                   #    1.18  insn per cycle
    50,853,437,912      instructions:u                   #    1.18  insn per cycle
```

where the difference between the smallest and the largest number is <0.0027%

Change-Id: I84d616201520a50904854cac06958faf6330468b
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/449760
Reviewed-by: Johnni Winther <[email protected]>
Commit-Queue: Jens Johansen <[email protected]>

Author: jensjoha

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

@@ -589,6 +589,15 @@ class AnalysisDriver {
 
   void afterPerformWork() {}
 
+  @visibleForTesting
+  ResolvedLibraryResultImpl? analyzeFileForTesting(String path) {
+    return scheduler.accumulatedPerformance.run('analyzeFileForTesting', (
+      performance,
+    ) {
+      return _analyzeFileImpl(path: path, performance: performance);
+    });
+  }
+
   /// Return a [Future] that completes after pending file changes are applied,
   /// so that [currentSession] can be used to compute results.
   ///
@@ -1307,7 +1316,7 @@ class AnalysisDriver {
     });
   }
 
-  void _analyzeFileImpl({
+  ResolvedLibraryResultImpl? _analyzeFileImpl({
     required String path,
     required OperationPerformanceImpl performance,
   }) {
@@ -1331,7 +1340,7 @@ class AnalysisDriver {
         );
 
         if (_completeRequestsIfMissingSdkLibrary(library)) {
-          return;
+          return null;
         }
 
         performance.run('libraryContext', (performance) {
@@ -1491,7 +1500,7 @@ class AnalysisDriver {
 
         // Return the result, full or partial.
         _logger.writeln('Computed new analysis result.');
-        // return result;
+        return libraryResult;
       } catch (exception, stackTrace) {
         var contextKey = _storeExceptionContext(
           path,
@@ -1522,6 +1531,8 @@ class AnalysisDriver {
         completeWithError(_requestedLibraries.remove(library.file.path));
         _clearLibraryContextAfterException();
       }
+
+      return null;
     });
   }
 

pkg/analyzer/tool/stable_analysis.dart

@@ -0,0 +1,99 @@
+// Copyright (c) 2025, the Dart project authors.  Please see the AUTHORS file
+// 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:io';
+
+import 'package:analyzer/error/error.dart';
+import 'package:analyzer/src/dart/analysis/analysis_context_collection.dart';
+import 'package:analyzer/src/dart/analysis/driver.dart';
+import 'package:analyzer/src/dart/analysis/driver_based_analysis_context.dart';
+import 'package:analyzer/src/dart/analysis/file_state.dart';
+import 'package:analyzer/src/dart/analysis/performance_logger.dart';
+import 'package:linter/src/rules.dart' as linter;
+
+void main(List<String> args) {
+  String? dirPath;
+  bool registerLints = true;
+  bool dumpPerformanceNumbers = false;
+
+  for (String arg in args) {
+    if (arg == "--no-lints") {
+      registerLints = false;
+    } else if (arg == "--dump-performance") {
+      dumpPerformanceNumbers = true;
+    } else if (!arg.startsWith("--") && dirPath == null) {
+      dirPath = arg;
+    } else {
+      throw "Unknown argument: $arg";
+    }
+  }
+
+  if (registerLints) {
+    linter.registerLintRules();
+  }
+  if (dirPath == null) throw "Needs a directory to work on.";
+  Directory dir = Directory(dirPath);
+  List<String> filesToAnalyze = [];
+  for (FileSystemEntity entity in dir.listSync(
+    recursive: true,
+    followLinks: false,
+  )) {
+    if (entity is File && entity.path.endsWith('.dart')) {
+      filesToAnalyze.add(entity.path);
+    }
+  }
+
+  // Creating the Scheduler here, and not starting it, means it's not going to
+  // get started. It's good for stability :).
+  // To make sure the 'start' method is overwritten below.
+  PerformanceLog performanceLog = PerformanceLog(null);
+  AnalysisDriverScheduler scheduler = BypassedAnalysisDriverScheduler(
+    performanceLog,
+  );
+  AnalysisContextCollectionImpl collection = AnalysisContextCollectionImpl(
+    includedPaths: [dir.path],
+    scheduler: scheduler,
+  );
+  DriverBasedAnalysisContext context = collection.contexts[0];
+  AnalysisDriver analysisDriver = context.driver;
+  List<String> libPaths = [];
+  analysisDriver.scheduler.accumulatedPerformance.run('getFileForPath', (_) {
+    for (var path in filesToAnalyze) {
+      var file = analysisDriver.fsState.getFileForPath(path);
+      var kind = file.kind;
+      if (kind is LibraryFileKind) {
+        libPaths.add(path);
+      }
+    }
+  });
+  for (var path in libPaths) {
+    // ignore: invalid_use_of_visible_for_testing_member
+    var library = analysisDriver.analyzeFileForTesting(path);
+    if (library == null) {
+      throw 'Got null for $path';
+    } else {
+      for (var unit in library.units) {
+        for (var diagnostic in unit.diagnostics) {
+          if (diagnostic.diagnosticCode.type == DiagnosticType.TODO) continue;
+          print(diagnostic);
+        }
+      }
+    }
+  }
+
+  if (dumpPerformanceNumbers) {
+    var buffer = StringBuffer();
+    analysisDriver.scheduler.accumulatedPerformance.write(buffer: buffer);
+    print(buffer);
+  }
+}
+
+class BypassedAnalysisDriverScheduler extends AnalysisDriverScheduler {
+  BypassedAnalysisDriverScheduler(super.logger);
+
+  @override
+  void start() {
+    throw 'This scheduler should not be started.';
+  }
+}