feat: migrate to new plugins api (#1020)

* feat: migrate to new plugins api

* chore: fix analyzer

* build: update min sdk version

* build: update analyzer version

* chore: remove unsued analyzer ignores

Author: incendial

.github/workflows/package_analyze.yaml

@@ -130,10 +130,10 @@ jobs:
     runs-on: ubuntu-latest
 
     steps:
-      - name: Install Dart 2.17.1
+      - name: Install Dart 2.18.0
         uses: dart-lang/setup-dart@v1
         with:
-          sdk: "2.17.1"
+          sdk: "2.18.0"
 
       - name: Checkout
         uses: actions/checkout@v3

CHANGELOG.md

@@ -3,7 +3,9 @@
 ## Unreleased
 
 * feat: add logger and progress indication.
-* chore: changed min `SDK` version to `2.17.1`.
+* chore: changed min `SDK` version to `2.18.0`.
+* chore: restrict `analyzer` version to `>=5.1.0 <5.2.0`.
+* chore: restrict `analyzer_plugin` version to `>=0.11.0 <0.12.0`.
 
 ## 4.19.1
 

lib/src/analyzer_plugin/analyzer_plugin.dart

@@ -1,16 +1,9 @@
 // ignore_for_file: public_member_api_docs
-
 import 'dart:async';
 
-import 'package:analyzer/dart/analysis/context_locator.dart';
+import 'package:analyzer/dart/analysis/analysis_context.dart';
+import 'package:analyzer/dart/analysis/analysis_context_collection.dart';
 import 'package:analyzer/dart/analysis/results.dart';
-import 'package:analyzer/file_system/physical_file_system.dart';
-// ignore: implementation_imports
-import 'package:analyzer/src/analysis_options/analysis_options_provider.dart';
-// ignore: implementation_imports
-import 'package:analyzer/src/dart/analysis/context_builder.dart';
-// ignore: implementation_imports
-import 'package:analyzer/src/dart/analysis/driver.dart';
 import 'package:analyzer_plugin/plugin/plugin.dart';
 import 'package:analyzer_plugin/protocol/protocol_generated.dart' as plugin;
 
@@ -20,18 +13,14 @@ import '../analyzers/lint_analyzer/metrics/metrics_list/number_of_parameters_met
 import '../analyzers/lint_analyzer/metrics/metrics_list/source_lines_of_code/source_lines_of_code_metric.dart';
 import '../config_builder/config_builder.dart';
 import '../config_builder/models/analysis_options.dart';
-import '../utils/analyzer_utils.dart';
-import '../utils/yaml_utils.dart';
 import 'analyzer_plugin_utils.dart';
 
-final _byteStore = createByteStore(PhysicalResourceProvider.INSTANCE);
-
 class AnalyzerPlugin extends ServerPlugin {
   static const _analyzer = LintAnalyzer();
 
-  final _configs = <AnalysisDriverGeneric, LintAnalysisConfig>{};
+  final _configs = <String, LintAnalysisConfig>{};
 
-  var _filesFromSetPriorityFilesRequest = <String>[];
+  AnalysisContextCollection? _contextCollection;
 
   @override
   String get contactInfo =>
@@ -46,172 +35,101 @@ class AnalyzerPlugin extends ServerPlugin {
   @override
   String get version => '1.0.0-alpha.0';
 
-  AnalyzerPlugin(super.resourceProvider);
-
-  @override
-  void contentChanged(String path) {
-    super.driverForPath(path)?.addFile(path);
-  }
-
-  @override
-  AnalysisDriverGeneric createAnalysisDriver(plugin.ContextRoot contextRoot) {
-    final rootPath = contextRoot.root;
-    final locator =
-        ContextLocator(resourceProvider: resourceProvider).locateRoots(
-      includedPaths: [rootPath],
-      excludedPaths: contextRoot.exclude,
-      optionsFile: contextRoot.optionsFile,
-    );
-
-    if (locator.isEmpty) {
-      final error = StateError('Unexpected empty context');
-      channel.sendNotification(plugin.PluginErrorParams(
-        true,
-        error.message,
-        error.stackTrace.toString(),
-      ).toNotification());
-
-      throw error;
-    }
-
-    final builder = ContextBuilderImpl(resourceProvider: resourceProvider);
-    final context = builder.createContext(
-      contextRoot: locator.first,
-      byteStore: _byteStore,
-    );
-    final dartDriver = context.driver;
-    final config = _createConfig(dartDriver, rootPath);
-
-    if (config == null) {
-      return dartDriver;
-    }
-
-    // Temporary disable deprecation check
-    //
-    // final deprecations = checkConfigDeprecatedOptions(
-    //   config,
-    //   deprecatedOptions,
-    //   contextRoot.optionsFile!,
-    // );
-    // if (deprecations.isNotEmpty) {
-    //   channel.sendNotification(plugin.AnalysisErrorsParams(
-    //     contextRoot.optionsFile!,
-    //     deprecations.map((deprecation) => deprecation.error).toList(),
-    //   ).toNotification());
-    // }
-
-    runZonedGuarded(
-      () {
-        dartDriver.results.listen((analysisResult) {
-          if (analysisResult is ResolvedUnitResult) {
-            _processResult(dartDriver, analysisResult);
-          }
-        });
-      },
-      (e, stackTrace) {
-        channel.sendNotification(
-          plugin.PluginErrorParams(false, e.toString(), stackTrace.toString())
-              .toNotification(),
-        );
-      },
-    );
-
-    return dartDriver;
-  }
+  AnalyzerPlugin({
+    required super.resourceProvider,
+  });
 
   @override
-  Future<plugin.AnalysisSetContextRootsResult> handleAnalysisSetContextRoots(
-    plugin.AnalysisSetContextRootsParams parameters,
-  ) async {
-    final result = await super.handleAnalysisSetContextRoots(parameters);
-    // The super-call adds files to the driver, so we need to prioritize them so they get analyzed.
-    _updatePriorityFiles();
+  Future<void> afterNewContextCollection({
+    required AnalysisContextCollection contextCollection,
+  }) {
+    _contextCollection = contextCollection;
 
-    return result;
-  }
+    contextCollection.contexts.forEach(_createConfig);
 
-  @override
-  Future<plugin.AnalysisSetPriorityFilesResult> handleAnalysisSetPriorityFiles(
-    plugin.AnalysisSetPriorityFilesParams parameters,
-  ) async {
-    _filesFromSetPriorityFilesRequest = parameters.files;
-    _updatePriorityFiles();
-
-    return plugin.AnalysisSetPriorityFilesResult();
+    return super
+        .afterNewContextCollection(contextCollection: contextCollection);
   }
 
   @override
-  Future<plugin.EditGetFixesResult> handleEditGetFixes(
-    plugin.EditGetFixesParams parameters,
-  ) async {
+  Future<void> analyzeFile({
+    required AnalysisContext analysisContext,
+    required String path,
+  }) async {
     try {
-      final driver = driverForPath(parameters.file) as AnalysisDriver;
-      // ignore: deprecated_member_use
-      final analysisResult = await driver.getResult2(parameters.file);
-
-      if (analysisResult is! ResolvedUnitResult) {
-        return plugin.EditGetFixesResult([]);
-      }
+      final resolvedUnit =
+          await analysisContext.currentSession.getResolvedUnit(path);
 
-      final fixes = _check(driver, analysisResult).where((fix) {
-        final location = fix.error.location;
-
-        return location.file == parameters.file &&
-            location.offset <= parameters.offset &&
-            parameters.offset <= location.offset + location.length &&
-            fix.fixes.isNotEmpty;
-      }).toList();
+      if (resolvedUnit is ResolvedUnitResult) {
+        final analysisErrors = _getErrorsForResolvedUnit(
+          resolvedUnit,
+          analysisContext.contextRoot.root.path,
+        );
 
-      return plugin.EditGetFixesResult(fixes);
+        channel.sendNotification(
+          plugin.AnalysisErrorsParams(
+            path,
+            analysisErrors.map((analysisError) => analysisError.error).toList(),
+          ).toNotification(),
+        );
+      } else {
+        channel.sendNotification(
+          plugin.AnalysisErrorsParams(path, []).toNotification(),
+        );
+      }
     } on Exception catch (e, stackTrace) {
       channel.sendNotification(
         plugin.PluginErrorParams(false, e.toString(), stackTrace.toString())
             .toNotification(),
       );
-
-      return plugin.EditGetFixesResult([]);
     }
   }
 
-  void _processResult(
-    AnalysisDriver driver,
-    ResolvedUnitResult analysisResult,
-  ) {
+  @override
+  Future<plugin.EditGetFixesResult> handleEditGetFixes(
+    plugin.EditGetFixesParams parameters,
+  ) async {
     try {
-      if (driver.analysisContext?.contextRoot.isAnalyzed(analysisResult.path) ??
-          false) {
-        final fixes = _check(driver, analysisResult);
-
-        channel.sendNotification(
-          plugin.AnalysisErrorsParams(
-            analysisResult.path,
-            fixes.map((fix) => fix.error).toList(),
-          ).toNotification(),
-        );
-      } else {
-        channel.sendNotification(
-          plugin.AnalysisErrorsParams(analysisResult.path, []).toNotification(),
-        );
+      final path = parameters.file;
+      final analysisContext = _contextCollection?.contextFor(path);
+      final resolvedUnit =
+          await analysisContext?.currentSession.getResolvedUnit(path);
+
+      if (analysisContext != null && resolvedUnit is ResolvedUnitResult) {
+        final analysisErrors = _getErrorsForResolvedUnit(
+          resolvedUnit,
+          analysisContext.contextRoot.root.path,
+        ).where((analysisError) {
+          final location = analysisError.error.location;
+
+          return location.file == parameters.file &&
+              location.offset <= parameters.offset &&
+              parameters.offset <= location.offset + location.length &&
+              analysisError.fixes.isNotEmpty;
+        }).toList();
+
+        return plugin.EditGetFixesResult(analysisErrors);
       }
     } on Exception catch (e, stackTrace) {
       channel.sendNotification(
         plugin.PluginErrorParams(false, e.toString(), stackTrace.toString())
             .toNotification(),
       );
     }
+
+    return plugin.EditGetFixesResult([]);
   }
 
-  Iterable<plugin.AnalysisErrorFixes> _check(
-    AnalysisDriver driver,
+  Iterable<plugin.AnalysisErrorFixes> _getErrorsForResolvedUnit(
     ResolvedUnitResult analysisResult,
+    String rootPath,
   ) {
     final result = <plugin.AnalysisErrorFixes>[];
-    final config = _configs[driver];
+    final config = _configs[rootPath];
 
     if (config != null) {
-      final root = driver.analysisContext?.contextRoot.root.path;
-
-      final report = _analyzer.runPluginAnalysis(analysisResult, config, root!);
+      final report =
+          _analyzer.runPluginAnalysis(analysisResult, config, rootPath);
 
       if (report != null) {
         result.addAll([
@@ -237,69 +155,26 @@ class AnalyzerPlugin extends ServerPlugin {
     return result;
   }
 
-  LintAnalysisConfig? _createConfig(AnalysisDriver driver, String rootPath) {
-    final file = driver.analysisContext?.contextRoot.optionsFile;
+  void _createConfig(AnalysisContext analysisContext) {
+    final rootPath = analysisContext.contextRoot.root.path;
+    final file = analysisContext.contextRoot.optionsFile;
+
     if (file != null && file.exists) {
-      final options = AnalysisOptions(
-        file.path,
-        yamlMapToDartMap(
-          AnalysisOptionsProvider(driver.sourceFactory)
-              .getOptionsFromFile(file),
-        ),
-      );
-      final config = ConfigBuilder.getLintConfigFromOptions(options);
+      final analysisOptions = analysisOptionsFromContext(analysisContext) ??
+          analysisOptionsFromFilePath(file.parent.path, analysisContext);
+      final config = ConfigBuilder.getLintConfigFromOptions(analysisOptions);
+
       final lintConfig = ConfigBuilder.getLintAnalysisConfig(
         config,
-        options.folderPath ?? rootPath,
+        analysisOptions.folderPath ?? rootPath,
         classMetrics: const [],
         functionMetrics: [
           NumberOfParametersMetric(config: config.metrics),
           SourceLinesOfCodeMetric(config: config.metrics),
         ],
       );
 
-      _configs[driver] = lintConfig;
-
-      return lintConfig;
-    }
-
-    return null;
-  }
-
-  /// AnalysisDriver doesn't fully resolve files that are added via `addFile`; they need to be either explicitly requested
-  /// via `getResult`/etc, or added to `priorityFiles`.
-  ///
-  /// This method updates `priorityFiles` on the driver to include:
-  ///
-  /// - Any files prioritized by the analysis server via [handleAnalysisSetPriorityFiles]
-  /// - All other files the driver has been told to analyze via addFile (in [ServerPlugin.handleAnalysisSetContextRoots])
-  ///
-  /// As a result, [_processResult] will get called with resolved units, and thus all of our diagnostics
-  /// will get run on all files in the repo instead of only the currently open/edited ones!
-  void _updatePriorityFiles() {
-    final filesToFullyResolve = {
-      // Ensure these go first, since they're actually considered priority; ...
-      ..._filesFromSetPriorityFilesRequest,
-
-      // ... all other files need to be analyzed, but don't trump priority
-      for (final driver2 in driverMap.values)
-        ...(driver2 as AnalysisDriver).addedFiles,
-    };
-
-    // From ServerPlugin.handleAnalysisSetPriorityFiles.
-    final filesByDriver = <AnalysisDriverGeneric, List<String>>{};
-    for (final file in filesToFullyResolve) {
-      final contextRoot = contextRootContaining(file);
-      if (contextRoot != null) {
-        // TODO(dkrutskikh): Which driver should we use if there is no context root?
-        final driver = driverMap[contextRoot];
-        if (driver != null) {
-          filesByDriver.putIfAbsent(driver, () => <String>[]).add(file);
-        }
-      }
+      _configs[rootPath] = lintConfig;
     }
-    filesByDriver.forEach((driver, files) {
-      driver.priorityFiles = files;
-    });
   }
 }

lib/src/analyzer_plugin/analyzer_plugin_starter.dart

@@ -6,6 +6,7 @@ import 'package:analyzer_plugin/starter.dart';
 import 'analyzer_plugin.dart';
 
 void start(Iterable<String> _, SendPort sendPort) {
-  ServerPluginStarter(AnalyzerPlugin(PhysicalResourceProvider.INSTANCE))
-      .start(sendPort);
+  ServerPluginStarter(
+    AnalyzerPlugin(resourceProvider: PhysicalResourceProvider.INSTANCE),
+  ).start(sendPort);
 }