Access the resolved unit?

[dmrickey]

I don't see that there's any way to access the resolved the unit in an individual lint rule. run doesn't return a future, so I can't await resolver.getResolvedUnitResult() without getting a bunch of errors (and no linting). The best I can do seems to be override startup and copy DartLintRule's startup into my rule (including _stateKey), then setting its resolved unit to a class field. Then I can access the resolved unit just fine in run. However, this also requires me to use custom_lint_core's LinterVisitor and context.registry.nodeLintRegistry which are both supposed to be internal to the package.

Overall the goal is to run a regex on a whole file to pull out some very specific cases that I can't find any other way to cover.

[rrousselGit]

You're not meant to access the ResolvedUnit directly. Instead use context.registry to listen to what you care about.

This is a much more efficient way of listening to AstNodes.

[dmrickey]

The problem with that is that a single line of code still has a lot of nodes in it. But searching through the file as a single string won't match the same thing multiple times. I don't see that either of your suggestions help accomplish that

[rrousselGit]

I don't not understand what you're referring to. Do you have an example maybe?

[dmrickey]

Here's a generic rule that scans a file using a regex and allows deleting/replacing the found code. (note: this only works when only one of these "regex" rules is being run, if multiple are run then it has problems because of the unit variable but it should be indicative enough of what I'm trying to do)

import 'package:analyzer/dart/analysis/results.dart';
import 'package:analyzer/error/error.dart';
import 'package:analyzer/error/listener.dart';
import 'package:analyzer/source/source_range.dart';
import 'package:custom_lint_builder/custom_lint_builder.dart';
import 'package:custom_lint_core/src/node_lint_visitor.dart';

abstract class RegexLintRule extends DartLintRule {
  ResolvedUnitResult? unit = null;

  RegexLintRule({
    required this.regex,
    required super.code,
    this.lintFix = null,
  });

  final RegExp regex;
  final LintFix? lintFix;

  /** copied from DartLintRule, but assigning unit to a field variable */
  static final _stateKey = Object();
  @override
  Future<void> startUp(
    CustomLintResolver resolver,
    CustomLintContext context,
  ) async {
    // Relying on shared state to execute all linters in a single AstVisitor
    if (context.sharedState.containsKey(_stateKey)) return;
    context.sharedState[_stateKey] = Object();

    unit = await resolver.getResolvedUnitResult();

    context.addPostRunCallback(() {
      final linterVisitor = LinterVisitor(context.registry.nodeLintRegistry);
      unit!.unit.accept(linterVisitor);
    });
  }
  /** end copy */

  @override
  void run(
    final CustomLintResolver resolver,
    final ErrorReporter reporter,
    final CustomLintContext context,
  ) {
    final matches = regex.allMatches(unit!.content);
    for (final match in matches) {
      reporter.reportErrorForOffset(code, match.start, match.end - match.start);
    }
  }

  @override
  List<Fix> getFixes() => lintFix == null ? [] : [_RegexLintFix(lintFix: lintFix!, regex: regex)];
}

class _RegexLintFix extends DartFix {
  ResolvedUnitResult? unit = null;
  final LintFix lintFix;
  final RegExp regex;
  _RegexLintFix({required this.lintFix, required this.regex});

  /** copied from DartFix, but assigning unit to a field variable */
  static final _stateKey = Object();
  @override
  Future<void> startUp(
    CustomLintResolver resolver,
    CustomLintContext context,
  ) async {
    // Relying on shared state to execute all linters in a single AstVisitor
    if (context.sharedState.containsKey(_stateKey)) return;
    context.sharedState[_stateKey] = Object();

    unit = await resolver.getResolvedUnitResult();

    context.addPostRunCallback(() {
      final linterVisitor = LinterVisitor(context.registry.nodeLintRegistry);

      unit!.unit.accept(linterVisitor);
    });
  }
  /** end copy */

  @override
  void run(
    final CustomLintResolver resolver,
    final ChangeReporter reporter,
    final CustomLintContext context,
    final AnalysisError analysisError,
    final List<AnalysisError> others,
  ) {
    final matches = regex.allMatches(unit!.content);
    for (final match in matches) {
      final matchRange = SourceRange(match.start, match.end - match.start);
      if (!analysisError.sourceRange.intersects(matchRange)) continue;

      reporter.createChangeBuilder(
        message: lintFix.hint,
        priority: 1,
      )..addDartFileEdit((final builder) {
          switch (lintFix) {
            case ReplacementLintFix(:var replacement):
              builder.addSimpleReplacement(analysisError.sourceRange, replacement);
            case DeleteLintFix():
              builder.addDeletion(analysisError.sourceRange);
          }
        });
    });
  }
}

sealed class LintFix {
  final String hint;
  LintFix({required this.hint});
}

class ReplacementLintFix extends LintFix {
  final String replacement;
  final int regexGroupToReplace;

  ReplacementLintFix({
    required this.replacement,
    required super.hint,
    this.regexGroupToReplace = 1,
  });
}

class DeleteLintFix extends LintFix {
  DeleteLintFix({required super.hint});
}

class AnotherRegexImplRuleWithDeleteFix extends RegexLintRule {
  AnotherRegexImplRuleWithDeleteFix()
      : super(
            regex: RegExp('eat.*meat'),
            lintFix: DeleteLintFix(hint: 'Delete me'),
            code: const LintCode(
              name: 'another_do_not_eat_meat',
              problemMessage: 'RegexImplRuleWithDeleteFix',
              correctionMessage: 'RegexImplRuleWithDeleteFix',
              errorSeverity: ErrorSeverity.ERROR,
            ));
}

class AnotherRegexImplRuleWithReplaceFix extends RegexLintRule {
  AnotherRegexImplRuleWithReplaceFix()
      : super(
            regex: RegExp('eat.*veggies'),
            lintFix: ReplacementLintFix(hint: 'Replace me', replacement: 'eat lots of cookies!'),
            code: const LintCode(
              name: 'another_do_not_eat_veggies',
              problemMessage: 'RegexImplRuleWithReplaceFix',
              correctionMessage: 'RegexImplRuleWithReplaceFix',
              errorSeverity: ErrorSeverity.ERROR,
            ));
}

And some example code to lint

class OtherClass {
  void foo() {
    print('do not eat food with meat');

    print('also do not eat this food with meat');

    print("but it's ok to eat lots of veggies");
  }
}

[rrousselGit]

Technically, the source of a dart file is available in the CompilationUnit. You don't need the ResolvedUnit for this.

[rrousselGit]

All Elements also have access to the LibraryElementtoo, which also has access to the file source.

[dmrickey]

Somewhat related question - you said You should never use regexes to show parse Dart code and show lints. Was that hyperbole or should I legitimately never use regex? I for some reason I want to make sure that SomeExternalLibary.somStaticMethod is never called -- how should I write a lint rule for that if not with regex?

e.g. Is this not a correct way to add a lint error?

    context.registry.addMethodInvocation((final node) {
      final name = node.toString();
      if (regex.hasMatch(name)) {
        reporter.reportErrorForNode(code, node);
      }
    });

[dmrickey]

So for the above example I should do this?

    context.registry.addMethodInvocation((final node) {
      if (node.target.toString() == 'SomeExternalLibary' && node.methodName.toString() == 'somStaticMethod' ) {
        reporter.reportErrorForNode(code, node);
      }
    });

[rrousselGit]

In general, you should avoid relying on toString, because analyzer can break this at any time.
Instead you should find properties in the object which matches with what you want.

You may have to perform type checks in some cases.
But anyway, you can check methodName.lexeme == 'someStaticMethod'

I don't remember how to do it for target. But I'd suggest placing a breakpoint and checking the content.

[rrousselGit]

Another thing to consider:

You may want to verify that SomeExternalLibrary and someStaticMethod are correctly from the package you think they are.

It's very much possible that a user-defined a class with the same name/method, but which isn't from said package.
You likely don't want to warn in this case.

[dmrickey]

In general, you should avoid relying on toString, because analyzer can break this at any time.
Instead you should find properties in the object which matches with what you want.

I don't understand. At some point I have to compare it to something. So if I'm trying to find a specific method, then what's the option if not comparing it to a string?

If I'm looking for specific properties (..on a method, I guess), then once I have a reference to those properties -- what do I compare against to find the specific property I'm looking for (again, if it's not a string)?

[rrousselGit]

So if I'm trying to find a specific method, then what's the option if not comparing it to a string?

You do check against a string. I'm referring specifically to the toString method. That one, no. Along with getDisplayString, those two methods are not reliable.

I gave you one alternative: methodName.lexeme. It returns a String of the method name, but that's not using toString.