Support the analysis server compiled as AOT.

This change adds a build target (see utils/analysis_server/BUILD.gn)
called 'analysis_server_aot'. This new target is _not_ included in the
Dart SDK (the create_sdk target). It's "opt-in" "for development."

The name of the new output file matches that of other snapshots (see
the dartdevc snapshots).

Then we do special work in the plugin manager if "we are AOT." An
analysis server running as AOT cannot spawn Isolates from a dart
source files; we must first compile a dart source file to AOT as well,
then we can spawn an Isolate to that AOT file.

_Then_ when we run pub, we can no longer rely on using
`Platform.executable`. `dartaotruntime pub get` is not a thing. We
must instead find the `dart` tool on disk. To do that, we copy some
complex discovery code from dartdev.

Work towards #53402

Work towards #53576

Work towards #50498

Manually tested:

* [+] analysis_server JIT snapshot works in IDE.
* [+] analysis_server JIT snapshot works in IDE, with a legacy
      plugin (custom_lint).
* [+] analysis_server JIT snapshot works at commandline.
* [+] analysis_server AOT snapshot works in IDE.
* [x] analysis_server AOT snapshot works in IDE, with a legacy
      plugin (custom_lint) - BROKEN. Need similar work that is done
      for new plugins.
* [x] analysis_server AOT snapshot works at commandline - BROKEN.
      I think a fair bit of refactoring is required in dartdev
      lib/src/analysis_server.dart to use `VmInteropHandler.run` or
      similar.

Change-Id: I53173c716fa2a763331ef524a96304f62165810e
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/417942
Commit-Queue: Samuel Rawlins <[email protected]>
Reviewed-by: Siva Annamalai <[email protected]>

Author: srawlins

pkg/analysis_server/lib/src/plugin/plugin_manager.dart

@@ -13,6 +13,7 @@ import 'dart:io' show Platform, Process, ProcessResult;
 
 import 'package:analysis_server/src/analytics/percentile_calculator.dart';
 import 'package:analysis_server/src/plugin/notification_manager.dart';
+import 'package:analysis_server/src/utilities/sdk.dart';
 import 'package:analyzer/dart/analysis/context_root.dart' as analyzer;
 import 'package:analyzer/exception/exception.dart';
 import 'package:analyzer/file_system/file_system.dart';
@@ -36,6 +37,8 @@ import 'package:meta/meta.dart';
 import 'package:watcher/watcher.dart' as watcher;
 import 'package:yaml/yaml.dart';
 
+const _builtAsAot = bool.fromEnvironment('built_as_aot');
+
 /// Information about a plugin that is built-in.
 class BuiltInPluginInfo extends PluginInfo {
   /// The entry point function that will be executed in the plugin's isolate.
@@ -685,6 +688,29 @@ class PluginManager {
     );
   }
 
+  /// Compiles [entrypoint] to an AOT snapshot and records timing to the
+  /// instrumentation log.
+  ProcessResult _compileAotSnapshot(String entrypoint) {
+    instrumentationService.logInfo(
+      'Running "dart compile aot-snapshot $entrypoint".',
+    );
+
+    var stopwatch = Stopwatch()..start();
+    var result = Process.runSync(
+      sdk.dart,
+      ['compile', 'aot-snapshot', entrypoint],
+      stderrEncoding: utf8,
+      stdoutEncoding: utf8,
+    );
+    stopwatch.stop();
+
+    instrumentationService.logInfo(
+      'Running "dart compile aot-snapshot" took ${stopwatch.elapsed}.',
+    );
+
+    return result;
+  }
+
   /// Computes the plugin files, given that the plugin should exist in
   /// [pluginFolder].
   ///
@@ -705,17 +731,17 @@ class PluginManager {
         .getChildAssumingFile(file_paths.packageConfigJson);
 
     if (pubCommand != null) {
-      var result = _runPubCommand(pubCommand, pluginFolder);
+      var pubResult = _runPubCommand(pubCommand, pluginFolder);
       String? exceptionReason;
-      if (result.exitCode != 0) {
+      if (pubResult.exitCode != 0) {
         var buffer = StringBuffer();
         buffer.writeln(
           'An error occurred while setting up the analyzer plugin package at '
           "'${pluginFolder.path}'. The `dart pub $pubCommand` command failed:",
         );
-        buffer.writeln('  exitCode = ${result.exitCode}');
-        buffer.writeln('  stdout = ${result.stdout}');
-        buffer.writeln('  stderr = ${result.stderr}');
+        buffer.writeln('  exitCode = ${pubResult.exitCode}');
+        buffer.writeln('  stdout = ${pubResult.stdout}');
+        buffer.writeln('  stderr = ${pubResult.stderr}');
         exceptionReason = buffer.toString();
         instrumentationService.logError(exceptionReason);
         notificationManager.handlePluginError(exceptionReason);
@@ -724,6 +750,31 @@ class PluginManager {
         exceptionReason ??= 'File "${packageConfigFile.path}" does not exist.';
         throw PluginException(exceptionReason);
       }
+
+      if (_builtAsAot) {
+        // When the Dart Analysis Server is built as AOT, then all spawned
+        // Isolates must also be built as AOT.
+        var aotResult = _compileAotSnapshot(pluginFile.path);
+        if (aotResult.exitCode != 0) {
+          var buffer = StringBuffer();
+          buffer.writeln(
+            'Failed to compile "${pluginFile.path}" to an AOT snapshot.',
+          );
+          buffer.writeln('  pluginFolder = ${pluginFolder.path}');
+          buffer.writeln('  exitCode = ${aotResult.exitCode}');
+          buffer.writeln('  stdout = ${aotResult.stdout}');
+          buffer.writeln('  stderr = ${aotResult.stderr}');
+          var exceptionReason = buffer.toString();
+          instrumentationService.logError(exceptionReason);
+          throw PluginException(exceptionReason);
+        }
+
+        // Update the entrypoint path to be the AOT-compiled file.
+        pluginFile = pluginFolder
+            .getChildAssumingFolder('bin')
+            .getChildAssumingFile('plugin.aot');
+      }
+
       return PluginFiles(pluginFile, packageConfigFile);
     }
 
@@ -856,13 +907,13 @@ class PluginManager {
   /// [pubCommand] in [folder].
   ProcessResult _runPubCommand(String pubCommand, Folder folder) {
     instrumentationService.logInfo(
-      'Running "pub $pubCommand" in "${folder.path}"',
+      'Running "pub $pubCommand" in "${folder.path}".',
     );
 
     var stopwatch = Stopwatch()..start();
     var result = Process.runSync(
-      Platform.executable,
-      <String>['pub', pubCommand],
+      sdk.dart,
+      ['pub', pubCommand],
       stderrEncoding: utf8,
       stdoutEncoding: utf8,
       workingDirectory: folder.path,
@@ -871,7 +922,7 @@ class PluginManager {
     stopwatch.stop();
 
     instrumentationService.logInfo(
-      'Running "pub $pubCommand" took ${stopwatch.elapsed}',
+      'Running "pub $pubCommand" took ${stopwatch.elapsed}.',
     );
 
     return result;

pkg/analysis_server/lib/src/utilities/sdk.dart

@@ -0,0 +1,89 @@
+// 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.
+
+/// Utilities for working with the "active" Dart SDK that a given analysis
+/// server process is running on.
+///
+/// These are copied from the dartdev package's 'lib/src/sdk.dart'.
+library;
+
+import 'dart:io';
+
+import 'package:path/path.dart' as path;
+
+final Sdk sdk = Sdk._instance;
+
+/// A utility class for finding and referencing paths within the Dart SDK.
+class Sdk {
+  static final Sdk _instance = _createSingleton();
+
+  /// Path to SDK directory.
+  final String sdkPath;
+
+  final bool _runFromBuildRoot;
+
+  factory Sdk() => _instance;
+
+  Sdk._(this.sdkPath, bool runFromBuildRoot)
+    : _runFromBuildRoot = runFromBuildRoot;
+
+  /// Path to the 'dart' executable in the Dart SDK.
+  String get dart {
+    var basename = path.basename(Platform.executable);
+    // It's possible that `Platform.executable` won't include the '.exe'
+    // extension on Windows (e.g., launching `dart` from `cmd.exe` where `dart`
+    // is on the `PATH`). Append '.exe' in this case so the
+    // `checkArtifactExists` check won't fail.
+    if (Platform.isWindows && !basename.endsWith('.exe')) {
+      basename += '.exe';
+    }
+    return path.absolute(
+      _runFromBuildRoot ? sdkPath : path.absolute(sdkPath, 'bin'),
+      basename,
+    );
+  }
+
+  static bool _checkArtifactExists(String path) {
+    return FileSystemEntity.typeSync(path) != FileSystemEntityType.notFound;
+  }
+
+  static Sdk _createSingleton() {
+    // Find SDK path.
+    (String, bool)? trySDKPath(String executablePath) {
+      // The common case, and how cli_util.dart computes the Dart SDK directory,
+      // [path.dirname] called twice on Platform.executable. We confirm by
+      // asserting that the directory `./bin/snapshots/` exists in this directory:
+      var sdkPath = path.absolute(path.dirname(path.dirname(executablePath)));
+      var snapshotsDir = path.join(sdkPath, 'bin', 'snapshots');
+      var runFromBuildRoot = false;
+      var type = FileSystemEntity.typeSync(snapshotsDir);
+      if (type != FileSystemEntityType.directory &&
+          type != FileSystemEntityType.link) {
+        // This is the less common case where the user is in
+        // the checked out Dart SDK, and is executing `dart` via:
+        // ./out/ReleaseX64/dart ... or in google3.
+        sdkPath = path.absolute(path.dirname(executablePath));
+        snapshotsDir = sdkPath;
+        runFromBuildRoot = true;
+      }
+
+      // Try to locate the DartDev snapshot to determine if we're able to find
+      // the SDK snapshots with this SDK path. This is meant to handle
+      // non-standard SDK layouts that can involve symlinks (e.g., Brew
+      // installations, google3 tests, etc).
+      if (!_checkArtifactExists(
+        path.join(snapshotsDir, 'dartdev.dart.snapshot'),
+      )) {
+        return null;
+      }
+      return (sdkPath, runFromBuildRoot);
+    }
+
+    var (sdkPath, runFromBuildRoot) =
+        trySDKPath(Platform.resolvedExecutable) ??
+        trySDKPath(Platform.executable)!;
+
+    return Sdk._(sdkPath, runFromBuildRoot);
+  }
+}

tools/bots/test_matrix.json

@@ -2936,7 +2936,8 @@
           "script": "tools/build.py",
           "arguments": [
             "create_sdk",
-            "utils/dartanalyzer"
+            "utils/dartanalyzer",
+            "analysis_server_aot"
           ]
         },
         {

utils/analysis_server/BUILD.gn

@@ -2,12 +2,35 @@
 # 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("../aot_snapshot.gni")
 import("../application_snapshot.gni")
 
+aot_snapshot("analysis_server_aot") {
+  main_dart = "../../pkg/analysis_server/bin/server.dart"
+  name = "analysis_server_aot"
+  output = "$root_gen_dir/analysis_server_aot.dart.snapshot"
+  vm_args = [ "-Dbuilt_as_aot=true" ]
+}
+
+aot_snapshot("analysis_server_aot_product") {
+  main_dart = "../../pkg/analysis_server/bin/server.dart"
+  name = "analysis_server_aot_product"
+  output = "$root_gen_dir/analysis_server_aot_product.dart.snapshot"
+
+  # dartaotruntime in the dart sdk has dart_product_config applied to it,
+  # so it is built in product mode in both release and
+  # product builds, and is only built in debug mode in debug
+  # builds. The following line ensures that the dartaotruntime
+  # and dartdevc_aot snapshot in an SDK build are
+  # always compatible with each other.
+  force_product_mode = !dart_debug
+}
+
 application_snapshot("analysis_server") {
   main_dart = "../../pkg/analysis_server/bin/server.dart"
   training_args = [
     "--sdk=" + rebase_path("../../sdk/"),
     "--train-using=" + rebase_path("../../pkg/compiler/lib"),
   ]
+  vm_args = [ "-Dbuilt_as_aot=false" ]
 }

utils/aot_snapshot.gni

@@ -128,6 +128,9 @@ template("aot_snapshot") {
                   "--snapshot-kind=app-aot-elf",
                   "--elf=$abs_output",
                 ] + gen_snapshot_args
+      if (defined(invoker.vm_args)) {
+        vm_args += invoker.vm_args
+      }
 
       args = [ rebase_path(dill) ]