Add a linter test for duplicate parsers.

Author: renggli

lib/src/reflection/internal/linter_rules.dart

@@ -49,6 +49,26 @@ class CharacterRepeater extends LinterRule {
   }
 }
 
+class DuplicateParser extends LinterRule {
+  const DuplicateParser() : super(LinterType.info, 'Duplicate parser');
+
+  @override
+  void run(Analyzer analyzer, Parser parser, LinterCallback callback) {
+    final duplicates = analyzer.parsers.where(parser.isEqualTo).toList();
+    if (duplicates.length > 1 && duplicates.first == parser) {
+      callback(
+        LinterIssue(
+          this,
+          parser,
+          '${duplicates.length} instances of the same parser exist in this '
+          'grammar. If possible, reuse the same parser instances to reduce '
+          'memory footprint and increase performance.',
+        ),
+      );
+    }
+  }
+}
+
 class LeftRecursion extends LinterRule {
   const LeftRecursion() : super(LinterType.error, 'Left recursion');
 

lib/src/reflection/linter.dart

@@ -61,6 +61,7 @@ typedef LinterCallback = void Function(LinterIssue issue);
 /// All default linter rules to be run.
 const allLinterRules = [
   CharacterRepeater(),
+  DuplicateParser(),
   LeftRecursion(),
   NestedChoice(),
   NullableRepeater(),

test/reflection_test.dart

@@ -717,6 +717,28 @@ void main() {
           expect(results, isEmpty);
         });
       });
+      group('duplicate parser', () {
+        const rules = [linter_rules.DuplicateParser()];
+        test('with issue', () {
+          final parser = seq2(digit(), digit());
+          final results = linter(parser, rules: rules);
+          expect(results, [
+            isLinterIssue(
+              parser: parser.children[0],
+              type: LinterType.info,
+              title: 'Duplicate parser',
+            ),
+          ]);
+        });
+        test('without issue', () {
+          final parser = seq2(
+            digit(message: 'first'),
+            digit(message: 'second'),
+          );
+          final results = linter(parser, rules: rules);
+          expect(results, isEmpty);
+        });
+      });
       group('left recursion', () {
         const rules = [linter_rules.LeftRecursion()];
         test('with issue', () {
@@ -1219,12 +1241,15 @@ void main() {
       group('remove duplicate', () {
         const rules = [optimize_rules.RemoveDuplicate()];
         test('with duplicate', () {
-          final parser = lowercase() & lowercase();
+          final parser = seq2(digit(), digit());
           final result = optimize(parser, rules: rules);
           expect(result.children.first, same(result.children.last));
         });
         test('without duplicate', () {
-          final parser = lowercase() & lowercase(message: 'lower');
+          final parser = seq2(
+            digit(message: 'first'),
+            digit(message: 'second'),
+          );
           final result = optimize(
             parser,
             rules: rules,