Analyzer Pluginを試してみた

ui → application → domain ← infra

app/
├── analysis_options.yaml
├── pubspec.yaml
└── packages/
    └── app_lints/
        ├── pubspec.yaml
        ├── lib/
        │   ├── main.dart
        │   └── src/
        │       └── rules/
        │           └── layer_dependency.dart
        └── test/
            └── rules/
                └── layer_dependency_test.dart

name: app_lints
publish_to: none
resolution: workspace

dependencies:
  analysis_server_plugin: ^0.3.14
  analyzer: ^12.1.0

dev_dependencies:
  analyzer_testing: ^0.2.5
  test_reflective_loader: ^0.4.0

workspace:
  - packages/app_lints

final plugin = AppLintsPlugin();

class AppLintsPlugin extends Plugin {
  @override
  String get name => 'app_lints';

  @override
  void register(PluginRegistry registry) {
    // warningルールはデフォルトで有効（analysis optionsで個別に無効化は可能）。
    // registerLintRuleはその逆で、利用側が明示的に有効化しないと動かない。
    // チーム全員に効かせたい規約なので、入れた時点で効く前者を使う。
    registry.registerWarningRule(LayerDependency());
  }
}

plugins:
  app_lints:
    path: packages/app_lints

class LayerDependency extends AnalysisRule {
  LayerDependency()
    : super(
        name: 'layer_dependency',
        description: 'レイヤー間の依存方向規約に違反するimportを検出します。',
      );

  static const LintCode code = LintCode(
    'layer_dependency',
    "'{0}' レイヤーから '{1}' レイヤーへのimportは依存方向規約に違反しています。",
    severity: DiagnosticSeverity.WARNING,
  );

  @override
  DiagnosticCode get diagnosticCode => code;

  @override
  void registerNodeProcessors(
    RuleVisitorRegistry registry,
    RuleContext context,
  ) {
    registry.addImportDirective(this, _Visitor(this, context));
  }
}

const allowedDependencies = <String, Set<String>>{
  'domain': {'domain'},
  'infra': {'domain', 'infra'},
  'application': {'domain', 'application'},
  'ui': {'domain', 'application', 'ui'},
};

class _Visitor extends SimpleAstVisitor<void> {
  _Visitor(this._rule, this._context);

  final LayerDependency _rule;
  final RuleContext _context;

  @override
  void visitImportDirective(ImportDirective node) {
    // 自ファイル側のURIはRuleContextから取る。
    final currentUri = _context.libraryElement?.uri;
    // importedLibrary?.uriはimportの「解決結果」。'../../infra/...'のような
    // 相対importも'package:app/infra/...'に正規化されるため、
    // 文字列マッチの実装にありがちな抜け道ができない。
    final importedUri = node.libraryImport?.importedLibrary?.uri;
    final fromLayer = _layerOf(currentUri);
    final toLayer = _layerOf(importedUri);
    // main.dartやgen/のようなレイヤー外のファイルは_layerOfがnullを返すので、
    // ここで対象外になる（DIの配線をするmain.dartのinfra importは素通し）。
    if (currentUri == null ||
        importedUri == null ||
        fromLayer == null ||
        toLayer == null) {
      return;
    }
    // 同一パッケージ内のみ検査（外部パッケージのlib/構成は関知しない）。
    if (currentUri.pathSegments.first != importedUri.pathSegments.first) {
      return;
    }
    if (allowedDependencies[fromLayer]!.contains(toLayer)) {
      return;
    }
    _rule.reportAtNode(node.uri, arguments: [fromLayer, toLayer]);
  }

  String? _layerOf(Uri? uri) {
    if (uri == null || !uri.isScheme('package')) {
      return null;
    }
    final segments = uri.pathSegments;
    if (segments.length < 2) {
      return null;
    }
    final layer = segments[1];
    return allowedDependencies.containsKey(layer) ? layer : null;
  }
}

@reflectiveTest
class LayerDependencyTest extends AnalysisRuleTest {
  @override
  void setUp() {
    rule = LayerDependency();
    super.setUp();
    newFile(
      '$testPackageLibPath/infra/user/user_repository_impl.dart',
      'class UserRepositoryImpl {}',
    );
  }

  Future<void> test_uiToInfra_reported() async {
    const uri = "'package:test/infra/user/user_repository_impl.dart'";
    const content =
        '''
import $uri;

final repository = UserRepositoryImpl();
''';
    final path = '$testPackageLibPath/ui/user/user_page.dart';
    newFile(path, content);
    await assertDiagnosticsInFile(path, [
      lint(content.indexOf(uri), uri.length),
    ]);
  }
}

$ dart analyze lib/ui/user/user_page.dart
warning - user_page.dart:2:8 - 'ui' レイヤーから 'infra' レイヤーへのimportは
依存方向規約に違反しています。 - layer_dependency