chore: revert analyzer-plugin (#941)

dkrutskikh · web-flow · commit 4eba330ab474 · 2022-07-26T21:41:06.000+03:00
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -12,6 +12,8 @@
 * feat: add suppressions for [`check-unused-code`](https://dartcodemetrics.dev/docs/cli/check-unused-code), [`check-unused-files`](https://dartcodemetrics.dev/docs/cli/check-unused-files), [`check-unnecessary-nullable`](https://dartcodemetrics.dev/docs/cli/check-unnecessary-nullable) commands.
 * fix: add zero exit to command runner.
 * fix: show lint issue in [html report](https://dartcodemetrics.dev/docs/cli/analyze#html).
+* chore: restrict `analyzer` version to `>=4.0.0 <4.4.0`.
+* chore: revert `analyzer_plugin` version to `>=0.10.0 <0.11.0`.
 
 ## 4.17.0-dev.1
 
diff --git a/lib/src/analyzer_plugin/analyzer_plugin.dart b/lib/src/analyzer_plugin/analyzer_plugin.dart
@@ -1,10 +1,17 @@
 // ignore_for_file: public_member_api_docs
+
 import 'dart:async';
 
-import 'package:analyzer/dart/analysis/analysis_context.dart';
-import 'package:analyzer/dart/analysis/analysis_context_collection.dart';
+import 'package:analyzer/dart/analysis/context_locator.dart';
 import 'package:analyzer/dart/analysis/results.dart';
 import 'package:analyzer/file_system/file_system.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;
 
@@ -14,14 +21,18 @@ 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 = <String, LintAnalysisConfig>{};
+  final _configs = <AnalysisDriverGeneric, LintAnalysisConfig>{};
 
-  AnalysisContextCollection? _contextCollection;
+  var _filesFromSetPriorityFilesRequest = <String>[];
 
   @override
   String get contactInfo =>
@@ -36,101 +47,172 @@ class AnalyzerPlugin extends ServerPlugin {
   @override
   String get version => '1.0.0-alpha.0';
 
-  AnalyzerPlugin({
-    required ResourceProvider resourceProvider,
-  }) : super(resourceProvider: resourceProvider);
+  AnalyzerPlugin(ResourceProvider provider) : super(provider);
 
   @override
-  Future<void> afterNewContextCollection({
-    required AnalysisContextCollection contextCollection,
-  }) {
-    _contextCollection = contextCollection;
-
-    contextCollection.contexts.forEach(_createConfig);
-
-    return super
-        .afterNewContextCollection(contextCollection: contextCollection);
+  void contentChanged(String path) {
+    super.driverForPath(path)?.addFile(path);
   }
 
   @override
-  Future<void> analyzeFile({
-    required AnalysisContext analysisContext,
-    required String path,
-  }) async {
-    try {
-      final resolvedUnit =
-          await analysisContext.currentSession.getResolvedUnit(path);
+  AnalysisDriverGeneric createAnalysisDriver(plugin.ContextRoot contextRoot) {
+    final rootPath = contextRoot.root;
+    final locator =
+        ContextLocator(resourceProvider: resourceProvider).locateRoots(
+      includedPaths: [rootPath],
+      excludedPaths: contextRoot.exclude,
+      optionsFile: contextRoot.optionsFile,
+    );
 
-      if (resolvedUnit is ResolvedUnitResult) {
-        final analysisErrors = _getErrorsForResolvedUnit(
-          resolvedUnit,
-          analysisContext.contextRoot.root.path,
-        );
+    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.AnalysisErrorsParams(
-            path,
-            analysisErrors.map((analysisError) => analysisError.error).toList(),
-          ).toNotification(),
-        );
-      } else {
-        channel.sendNotification(
-          plugin.AnalysisErrorsParams(path, []).toNotification(),
+          plugin.PluginErrorParams(false, e.toString(), stackTrace.toString())
+              .toNotification(),
         );
+      },
+    );
+
+    return dartDriver;
+  }
+
+  @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();
+
+    return result;
+  }
+
+  @override
+  Future<plugin.AnalysisSetPriorityFilesResult> handleAnalysisSetPriorityFiles(
+    plugin.AnalysisSetPriorityFilesParams parameters,
+  ) async {
+    _filesFromSetPriorityFilesRequest = parameters.files;
+    _updatePriorityFiles();
+
+    return plugin.AnalysisSetPriorityFilesResult();
+  }
+
+  @override
+  Future<plugin.EditGetFixesResult> handleEditGetFixes(
+    plugin.EditGetFixesParams parameters,
+  ) 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 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();
+
+      return plugin.EditGetFixesResult(fixes);
     } on Exception catch (e, stackTrace) {
       channel.sendNotification(
         plugin.PluginErrorParams(false, e.toString(), stackTrace.toString())
             .toNotification(),
       );
+
+      return plugin.EditGetFixesResult([]);
     }
   }
 
-  @override
-  Future<plugin.EditGetFixesResult> handleEditGetFixes(
-    plugin.EditGetFixesParams parameters,
-  ) async {
+  void _processResult(
+    AnalysisDriver driver,
+    ResolvedUnitResult analysisResult,
+  ) {
     try {
-      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);
+      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(),
+        );
       }
     } on Exception catch (e, stackTrace) {
       channel.sendNotification(
         plugin.PluginErrorParams(false, e.toString(), stackTrace.toString())
             .toNotification(),
       );
     }
-
-    return plugin.EditGetFixesResult([]);
   }
 
-  Iterable<plugin.AnalysisErrorFixes> _getErrorsForResolvedUnit(
+  Iterable<plugin.AnalysisErrorFixes> _check(
+    AnalysisDriver driver,
     ResolvedUnitResult analysisResult,
-    String rootPath,
   ) {
     final result = <plugin.AnalysisErrorFixes>[];
-    final config = _configs[rootPath];
+    final config = _configs[driver];
 
     if (config != null) {
-      final report =
-          _analyzer.runPluginAnalysis(analysisResult, config, rootPath);
+      final root = driver.analysisContext?.contextRoot.root.path;
+
+      final report = _analyzer.runPluginAnalysis(analysisResult, config, root!);
 
       if (report != null) {
         result.addAll([
@@ -156,26 +238,69 @@ class AnalyzerPlugin extends ServerPlugin {
     return result;
   }
 
-  void _createConfig(AnalysisContext analysisContext) {
-    final rootPath = analysisContext.contextRoot.root.path;
-    final file = analysisContext.contextRoot.optionsFile;
-
+  LintAnalysisConfig? _createConfig(AnalysisDriver driver, String rootPath) {
+    final file = driver.analysisContext?.contextRoot.optionsFile;
     if (file != null && file.exists) {
-      final analysisOptions = analysisOptionsFromContext(analysisContext) ??
-          analysisOptionsFromFilePath(file.parent.path, analysisContext);
-      final config = ConfigBuilder.getLintConfigFromOptions(analysisOptions);
-
+      final options = AnalysisOptions(
+        file.path,
+        yamlMapToDartMap(
+          AnalysisOptionsProvider(driver.sourceFactory)
+              .getOptionsFromFile(file),
+        ),
+      );
+      final config = ConfigBuilder.getLintConfigFromOptions(options);
       final lintConfig = ConfigBuilder.getLintAnalysisConfig(
         config,
-        analysisOptions.folderPath ?? rootPath,
+        options.folderPath ?? rootPath,
         classMetrics: const [],
         functionMetrics: [
           NumberOfParametersMetric(config: config.metrics),
           SourceLinesOfCodeMetric(config: config.metrics),
         ],
       );
 
-      _configs[rootPath] = lintConfig;
+      _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);
+        }
+      }
     }
+    filesByDriver.forEach((driver, files) {
+      driver.priorityFiles = files;
+    });
   }
 }
diff --git a/lib/src/analyzer_plugin/analyzer_plugin_starter.dart b/lib/src/analyzer_plugin/analyzer_plugin_starter.dart
@@ -6,7 +6,6 @@ import 'package:analyzer_plugin/starter.dart';
 import 'analyzer_plugin.dart';
 
 void start(Iterable<String> _, SendPort sendPort) {
-  ServerPluginStarter(
-    AnalyzerPlugin(resourceProvider: PhysicalResourceProvider.INSTANCE),
-  ).start(sendPort);
+  ServerPluginStarter(AnalyzerPlugin(PhysicalResourceProvider.INSTANCE))
+      .start(sendPort);
 }
diff --git a/lib/src/analyzers/lint_analyzer/rules/rules_list/avoid_global_state/visitor.dart b/lib/src/analyzers/lint_analyzer/rules/rules_list/avoid_global_state/visitor.dart
@@ -9,6 +9,7 @@ class _Visitor extends RecursiveAstVisitor<void> {
   void visitVariableDeclaration(VariableDeclaration node) {
     super.visitVariableDeclaration(node);
 
+    // ignore: deprecated_member_use
     if (node.declaredElement?.enclosingElement is CompilationUnitElement) {
       if (_isNodeValid(node)) {
         _declarations.add(node);
diff --git a/lib/src/analyzers/unused_code_analyzer/used_code_visitor.dart b/lib/src/analyzers/unused_code_analyzer/used_code_visitor.dart
@@ -89,6 +89,7 @@ class UsedCodeVisitor extends RecursiveAstVisitor<void> {
 
   void _recordIfExtensionMember(Element? element) {
     if (element != null) {
+      // ignore: deprecated_member_use
       final enclosingElement = element.enclosingElement;
       if (enclosingElement is ExtensionElement) {
         _recordUsedExtension(enclosingElement);
@@ -165,6 +166,7 @@ class UsedCodeVisitor extends RecursiveAstVisitor<void> {
       return;
     }
 
+    // ignore: deprecated_member_use
     final enclosingElement = element.enclosingElement;
     if (enclosingElement is CompilationUnitElement) {
       _recordUsedElement(element);
diff --git a/lib/src/analyzers/unused_l10n_analyzer/unused_l10n_visitor.dart b/lib/src/analyzers/unused_l10n_analyzer/unused_l10n_visitor.dart
diff --git a/pubspec.yaml b/pubspec.yaml

Original file line number	Diff line number	Diff line change
`@@ -6,7 +6,6 @@ import 'package:analyzer_plugin/starter.dart';`
`6`	`6`	`import 'analyzer_plugin.dart';`
`7`	`7`
`8`	`8`	`void start(Iterable<String> _, SendPort sendPort) {`
`9`		`- ServerPluginStarter(`
`10`		`- AnalyzerPlugin(resourceProvider: PhysicalResourceProvider.INSTANCE),`
`11`		`- ).start(sendPort);`
	`9`	`+ ServerPluginStarter(AnalyzerPlugin(PhysicalResourceProvider.INSTANCE))`
	`10`	`+ .start(sendPort);`
`12`	`11`	`}`