fix: support excludes and conditional imports for check-unused-code (#654)

* fix: support excludes and conditional imports for check-unused-code

* chore: update changelog

* fix: track usage even for excluded files

Author: incendial

CHANGELOG.md

@@ -1,5 +1,9 @@
 # Changelog
 
+## Unreleased
+
+* fix: support excludes and conditional imports for `check-unused-code` command.
+
 ## 4.10.0-dev.1
 
 * feat: add check unused code command.

analysis_options.yaml

@@ -5,7 +5,6 @@ analyzer:
     - test/resources/*
     - test/resources/unused_files_analyzer/**
     - test/resources/unused_l10n_analyzer/**
-    - test/resources/unused_code_analyzer/**
     - test/**/examples/**
   language:
     strict-inference: true

lib/src/analyzers/unused_code_analyzer/models/file_elements_usage.dart

@@ -1,10 +1,12 @@
 import 'package:analyzer/dart/element/element.dart';
 
+import 'prefix_element_usage.dart';
+
 /// A container with information about used imports prefixes and used imported
 /// elements.
 class FileElementsUsage {
   /// The map of referenced prefix elements and the elements that they prefix.
-  final Map<PrefixElement, List<Element>> prefixMap = {};
+  final Map<PrefixElement, PrefixElementUsage> prefixMap = {};
 
   /// The set of referenced top-level elements.
   final Set<Element> elements = {};

lib/src/analyzers/unused_code_analyzer/models/prefix_element_usage.dart

@@ -0,0 +1,17 @@
+import 'package:analyzer/dart/element/element.dart';
+
+/// A container with information about used imports prefixes.
+class PrefixElementUsage {
+  /// The paths to imported files.
+  /// Used for conditional imports to track all conditional paths.
+  final Iterable<String> paths;
+
+  /// The set of referenced elements.
+  final Set<Element> elements;
+
+  const PrefixElementUsage(this.paths, this.elements);
+
+  void add(Element element) {
+    elements.add(element);
+  }
+}

lib/src/analyzers/unused_code_analyzer/unused_code_analyzer.dart

@@ -6,6 +6,7 @@ import 'package:analyzer/dart/analysis/utilities.dart';
 import 'package:analyzer/dart/element/element.dart';
 // ignore: implementation_imports
 import 'package:analyzer/src/dart/element/element.dart';
+import 'package:glob/glob.dart';
 import 'package:path/path.dart';
 import 'package:source_span/source_span.dart';
 
@@ -57,28 +58,34 @@ class UnusedCodeAnalyzer {
       final unusedCodeAnalysisConfig =
           await _getAnalysisConfig(context, rootFolder, config);
 
-      final filePaths =
-          _getFilePaths(folders, context, rootFolder, unusedCodeAnalysisConfig);
+      final excludes = unusedCodeAnalysisConfig.globalExcludes
+          .followedBy(unusedCodeAnalysisConfig.analyzerExcludedPatterns);
+      final filePaths = _getFilePaths(folders, context, rootFolder, excludes);
 
       final analyzedFiles =
           filePaths.intersection(context.contextRoot.analyzedFiles().toSet());
-      await _analyseFiles(
-        analyzedFiles,
-        context.currentSession.getResolvedUnit,
-        codeUsages,
-        publicCode,
-      );
+      for (final filePath in analyzedFiles) {
+        final unit = await context.currentSession.getResolvedUnit(filePath);
+
+        final codeUsage = _analyzeFileCodeUsages(unit);
+        if (codeUsage != null) {
+          codeUsages.merge(codeUsage);
+        }
+
+        publicCode[filePath] = _analyzeFilePublicCode(unit);
+      }
 
       final notAnalyzedFiles = filePaths.difference(analyzedFiles);
-      await _analyseFiles(
-        notAnalyzedFiles,
-        (filePath) => resolveFile2(path: filePath),
-        codeUsages,
-        publicCode,
-        shouldAnalyse: (filePath) => unusedCodeAnalysisConfig
-            .analyzerExcludedPatterns
-            .any((pattern) => pattern.matches(filePath)),
-      );
+      for (final filePath in notAnalyzedFiles) {
+        if (excludes.any((pattern) => pattern.matches(filePath))) {
+          final unit = await resolveFile2(path: filePath);
+
+          final codeUsage = _analyzeFileCodeUsages(unit);
+          if (codeUsage != null) {
+            codeUsages.merge(codeUsage);
+          }
+        }
+      }
     }
 
     codeUsages.exports.forEach(publicCode.remove);
@@ -105,18 +112,14 @@ class UnusedCodeAnalyzer {
     Iterable<String> folders,
     AnalysisContext context,
     String rootFolder,
-    UnusedCodeAnalysisConfig unusedCodeAnalysisConfig,
+    Iterable<Glob> excludes,
   ) {
     final contextFolders = folders
         .where((path) => normalize(join(rootFolder, path))
             .startsWith(context.contextRoot.root.path))
         .toList();
 
-    return extractDartFilesFromFolders(
-      contextFolders,
-      rootFolder,
-      unusedCodeAnalysisConfig.globalExcludes,
-    );
+    return extractDartFilesFromFolders(contextFolders, rootFolder, excludes);
   }
 
   FileElementsUsage? _analyzeFileCodeUsages(SomeResolvedUnitResult unit) {
@@ -141,27 +144,6 @@ class UnusedCodeAnalyzer {
     return {};
   }
 
-  Future<void> _analyseFiles(
-    Set<String> files,
-    Future<SomeResolvedUnitResult> Function(String) unitExtractor,
-    FileElementsUsage codeUsages,
-    Map<String, Set<Element>> publicCode, {
-    bool Function(String)? shouldAnalyse,
-  }) async {
-    for (final filePath in files) {
-      if (shouldAnalyse == null || shouldAnalyse(filePath)) {
-        final unit = await unitExtractor(filePath);
-
-        final codeUsage = _analyzeFileCodeUsages(unit);
-        if (codeUsage != null) {
-          codeUsages.merge(codeUsage);
-        }
-
-        publicCode[filePath] = _analyzeFilePublicCode(unit);
-      }
-    }
-  }
-
   Iterable<UnusedCodeFileReport> _getReports(
     FileElementsUsage codeUsages,
     Map<String, Set<Element>> publicCodeElements,
@@ -173,10 +155,7 @@ class UnusedCodeAnalyzer {
       final issues = <UnusedCodeIssue>[];
 
       for (final element in elements) {
-        if (!codeUsages.elements
-                .any((usedElement) => _isUsed(usedElement, element)) &&
-            !codeUsages.usedExtensions
-                .any((usedElement) => _isUsed(usedElement, element))) {
+        if (_isUnused(codeUsages, path, element)) {
           final unit = element.thisOrAncestorOfType<CompilationUnitElement>();
           if (unit != null) {
             issues.add(_createUnusedCodeIssue(element as ElementImpl, unit));
@@ -202,6 +181,26 @@ class UnusedCodeAnalyzer {
       element == usedElement ||
       element is PropertyInducingElement && element.getter == usedElement;
 
+  bool _isUnused(
+    FileElementsUsage codeUsages,
+    String path,
+    Element element,
+  ) =>
+      !codeUsages.elements.any(
+        (usedElement) => _isUsed(usedElement, element),
+      ) &&
+      !codeUsages.usedExtensions.any(
+        (usedElement) => _isUsed(usedElement, element),
+      ) &&
+      !codeUsages.prefixMap.values.any(
+        (usage) =>
+            usage.paths.contains(path) &&
+            usage.elements.any((usedElement) =>
+                _isUsed(usedElement, element) ||
+                (usedElement.name == element.name &&
+                    usedElement.kind == element.kind)),
+      );
+
   UnusedCodeIssue _createUnusedCodeIssue(
     ElementImpl element,
     CompilationUnitElement unit,

lib/src/analyzers/unused_code_analyzer/used_code_visitor.dart

@@ -3,7 +3,9 @@
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/visitor.dart';
 import 'package:analyzer/dart/element/element.dart';
+
 import 'models/file_elements_usage.dart';
+import 'models/prefix_element_usage.dart';
 
 // Copied from https://github.com/dart-lang/sdk/blob/main/pkg/analyzer/lib/src/error/imports_verifier.dart#L15
 
@@ -100,8 +102,10 @@ class UsedCodeVisitor extends RecursiveAstVisitor<void> {
       if (target is SimpleIdentifier) {
         final targetElement = target.staticElement;
         if (targetElement is PrefixElement) {
-          (fileElementsUsage.prefixMap
-              .putIfAbsent(targetElement, () => <Element>[])).add(element);
+          (fileElementsUsage.prefixMap.putIfAbsent(
+            targetElement,
+            () => PrefixElementUsage(_getPrefixUsagePaths(target), {}),
+          )).add(element);
 
           return true;
         }
@@ -162,7 +166,10 @@ class UsedCodeVisitor extends RecursiveAstVisitor<void> {
 
       return;
     } else if (element is PrefixElement) {
-      fileElementsUsage.prefixMap.putIfAbsent(element, () => <Element>[]);
+      fileElementsUsage.prefixMap.putIfAbsent(
+        element,
+        () => PrefixElementUsage(_getPrefixUsagePaths(identifier), {}),
+      );
     } else if (element is MultiplyDefinedElement) {
       // If the element is multiply defined then call this method recursively
       // for each of the conflicting elements.
@@ -174,4 +181,25 @@ class UsedCodeVisitor extends RecursiveAstVisitor<void> {
       }
     }
   }
+
+  Iterable<String> _getPrefixUsagePaths(SimpleIdentifier target) {
+    final root = target.root;
+
+    if (root is! CompilationUnit) {
+      return [];
+    }
+
+    return root.directives.fold<List<String>>([], (previousValue, directive) {
+      if (directive is ImportDirective &&
+          directive.prefix?.name == target.name) {
+        previousValue.add(directive.uriSource.toString());
+
+        for (final config in directive.configurations) {
+          previousValue.add(config.uriSource.toString());
+        }
+      }
+
+      return previousValue;
+    });
+  }
 }

test/resources/unused_code_analyzer/conditional_file.dart

@@ -0,0 +1,6 @@
+// ignore: prefer_expression_function_bodies
+String calculateResults() {
+  return 'conditional results';
+}
+
+bool hello() => false; // LINT

test/resources/unused_code_analyzer/generated/some_file.freezed.dart

@@ -0,0 +1,3 @@
+void freeze() {
+  print('brr');
+}

test/resources/unused_code_analyzer/not_used.dart

@@ -2,4 +2,5 @@ class NotUsed {} // LINT
 
 const int value = 15; // LINT
 
+// ignore: no-empty-block
 void someFunction() {} // LINT

test/resources/unused_code_analyzer/public_members.dart

@@ -1,3 +1,5 @@
+// ignore_for_file: avoid_positional_boolean_parameters, library_private_types_in_public_api, override_on_non_overriding_member, unused_local_variable, no-empty-block
+
 // LINT
 void printInteger(int aNumber) {
   print('The number is $aNumber.'); // Print to console.
@@ -37,7 +39,7 @@ class _MyWidgetState extends BaseState<MyWidget> {
 
   void myMethod() {
     setState(() {
-      myString = "Hello";
+      myString = 'Hello';
     });
   }
 
@@ -152,7 +154,7 @@ enum SomeOtherEnum {
   world,
 }
 
-class Mixin {}
+mixin Mixin {}
 
 typedef Hello = String;