Add some more strict linter rules.

analysis_options.yaml

@@ -9,7 +9,11 @@ linter:
     # - avoid_dynamic_calls
     - avoid_final_parameters
     - avoid_print
+    - avoid_unused_constructor_parameters
     - camel_case_types
+    - combinators_ordering
+    - comment_references
+    - dangling_library_doc_comments
     - implicit_call_tearoffs
     - invalid_case_patterns
     - no_self_assignments
@@ -19,13 +23,30 @@ linter:
     - prefer_const_constructors_in_immutables
     - prefer_const_declarations
     - prefer_const_literals_to_create_immutables
+    - prefer_expression_function_bodies
+    - prefer_final_fields
+    - prefer_final_in_for_each
+    - prefer_final_locals
+    - prefer_for_elements_to_map_fromIterable
     - prefer_function_declarations_over_variables
+    - prefer_if_elements_to_conditional_expressions
     - prefer_relative_imports
-    - sort_constructors_first
     - type_literal_in_constant_pattern
+    - unnecessary_await_in_return
+    - unnecessary_brace_in_string_interps
     - unnecessary_breaks
+    - unnecessary_const
+    - unnecessary_constructor_name
+    - unnecessary_getters_setters
+    # - unnecessary_lambdas
     - unnecessary_late
-    - unnecessary_library_directive
+    - unnecessary_new
+    - unnecessary_null_aware_assignments
+    - unnecessary_null_aware_operator_on_extension_on_nullable
+    - unnecessary_null_checks
+    - unnecessary_null_in_if_null_operators
+    - unnecessary_parenthesis
     - unnecessary_statements
+    - unnecessary_to_list_in_spreads
     - unreachable_from_main
     - use_super_parameters

bin/benchmark/util/runner.dart

@@ -8,14 +8,13 @@ import 'package:petitparser/petitparser.dart';
 
 import 'benchmark.dart';
 
-final defaultCharsInput =
-    List.generate(0xff, (value) => String.fromCharCode(value));
+final defaultCharsInput = List.generate(0xff, String.fromCharCode);
 final defaultStringInput = defaultCharsInput.join();
 
 final List<MapEntry<String, Benchmark>> _benchmarkEntries = (() {
   Future.delayed(const Duration(milliseconds: 1)).then((_) {
     stdout.writeln(['name', 'parser', 'accept', 'native'].join('\t'));
-    for (var benchmarkEntry in _benchmarkEntries) {
+    for (final benchmarkEntry in _benchmarkEntries) {
       benchmarkEntry.value();
     }
   });

bin/prolog/prolog.dart

@@ -35,7 +35,7 @@ void main(List<String> arguments) {
   stdin
       .transform(systemEncoding.decoder)
       .transform(const LineSplitter())
-      .map((query) => Term.parse(query))
+      .map(Term.parse)
       .asyncMap((goal) async {
     await db.query(goal).forEach(stdout.writeln);
   }).forEach((each) => stdout.write('?- '));

lib/dart.dart

@@ -2,4 +2,6 @@
 ///
 /// The grammar is adapted from [Dart programming language specification](https://www.ecma-international.org/publications-and-standards/standards/ecma-408/).
 /// Unfortunately, it is unable to parse all valid Dart programs yet.
+library dart;
+
 export 'src/dart/grammar.dart';

lib/json.dart

@@ -1,4 +1,6 @@
 /// This package contains a complete implementation of [JSON](https://json.org/).
+library json;
+
 import 'src/json/definition.dart';
 import 'src/json/types.dart';
 

lib/lisp.dart

@@ -2,6 +2,8 @@
 ///
 /// The code is reasonably complete to run and evaluate reasonably complex
 /// programs from the console or the web browser.
+library lisp;
+
 export 'src/lisp/cons.dart';
 export 'src/lisp/environment.dart';
 export 'src/lisp/evaluator.dart';

lib/math.dart

@@ -1,4 +1,6 @@
 /// This package contains a simple expression parser.
+library math;
+
 export 'src/math/ast.dart';
 export 'src/math/common.dart';
 export 'src/math/parser.dart';

lib/prolog.dart

@@ -3,6 +3,8 @@
 ///
 /// The code is reasonably complete to run and evaluate reasonably complex
 /// programs from the console or the web browser.
+library prolog;
+
 export 'src/prolog/evaluator.dart';
 export 'src/prolog/grammar.dart';
 export 'src/prolog/parser.dart';

lib/regexp.dart

@@ -3,6 +3,8 @@
 // Based on the following blog posts:
 // - http://xysun.github.io/posts/regex-parsing-thompsons-algorithm.html
 // - https://deniskyashif.com/2019/02/17/implementing-a-regular-expression-engine/.
+library regexp;
+
 export 'src/regexp/nfa.dart';
 export 'src/regexp/node.dart';
 export 'src/regexp/parser.dart';

lib/smalltalk.dart

@@ -1,6 +1,8 @@
 /// This package contains the complete grammar of Smalltalk.
 ///
 /// It was automatically exported from PetitParser for Smalltalk.
+library smalltalk;
+
 export 'src/smalltalk/ast.dart';
 export 'src/smalltalk/grammar.dart';
 export 'src/smalltalk/parser.dart';

lib/src/lisp/native.dart

@@ -58,27 +58,23 @@ class NativeEnvironment extends Environment {
     throw ArgumentError('Invalid define: $args');
   }
 
-  static Lambda _lambda(Environment lambdaEnv, dynamic lambdaArgs) {
-    return (evalEnv, evalArgs) {
-      final inner = lambdaEnv.create();
-      var names = lambdaArgs.head;
-      var values = evalArguments(evalEnv, evalArgs);
-      while (names != null && values != null) {
-        inner.define(names.head, values.head);
-        names = names.tail;
-        values = values.tail;
-      }
-      return evalList(inner, lambdaArgs.tail);
-    };
-  }
-
-  static dynamic _quote(Environment env, dynamic args) {
-    return args.head;
-  }
-
-  static dynamic _eval(Environment env, dynamic args) {
-    return eval(env.create(), eval(env, args.head));
-  }
+  static Lambda _lambda(Environment lambdaEnv, dynamic lambdaArgs) =>
+      (evalEnv, evalArgs) {
+        final inner = lambdaEnv.create();
+        var names = lambdaArgs.head;
+        var values = evalArguments(evalEnv, evalArgs);
+        while (names != null && values != null) {
+          inner.define(names.head, values.head);
+          names = names.tail;
+          values = values.tail;
+        }
+        return evalList(inner, lambdaArgs.tail);
+      };
+
+  static dynamic _quote(Environment env, dynamic args) => args.head;
+
+  static dynamic _eval(Environment env, dynamic args) =>
+      eval(env.create(), eval(env, args.head));
 
   static dynamic _apply(Environment env, dynamic args) {
     final Function function = eval(env, args.head);
@@ -100,9 +96,8 @@ class NativeEnvironment extends Environment {
     return evalList(inner, args.tail);
   }
 
-  static dynamic _set(Environment env, dynamic args) {
-    return env[args.head] = eval(env, args.tail.head);
-  }
+  static dynamic _set(Environment env, dynamic args) =>
+      env[args.head] = eval(env, args.tail.head);
 
   static dynamic _print(Environment env, dynamic args) {
     final buffer = StringBuffer();
@@ -156,9 +151,7 @@ class NativeEnvironment extends Environment {
     return false;
   }
 
-  static dynamic _not(Environment env, dynamic args) {
-    return !eval(env, args.head);
-  }
+  static dynamic _not(Environment env, dynamic args) => !eval(env, args.head);
 
   static dynamic _plus(Environment env, dynamic args) {
     num value = eval(env, args.head);

lib/src/math/parser.dart

@@ -41,7 +41,7 @@ final parser = () {
   builder.group()
     ..left(char('+').trim(), (a, op, b) => Binary('+', a, b, (x, y) => x + y))
     ..left(char('-').trim(), (a, op, b) => Binary('-', a, b, (x, y) => x - y));
-  return builder.build().end();
+  return resolve(builder.build()).end();
 }();
 
 Expression _createValue(String value) => Value(num.parse(value));

lib/src/regexp/nfa.dart

@@ -33,7 +33,7 @@ class Nfa extends RegexpPattern {
 
   void _addStates(NfaState state, Set<NfaState> states) {
     if (!states.add(state)) return;
-    for (var other in state.epsilons) {
+    for (final other in state.epsilons) {
       _addStates(other, states);
     }
   }

lib/src/regexp/parser.dart

@@ -1,3 +1,4 @@
+import 'package:petitparser/definition.dart';
 import 'package:petitparser/expression.dart';
 import 'package:petitparser/parser.dart';
 
@@ -8,9 +9,8 @@ final nodeParser = () {
 
   const meta = r'\.()!*+?|&';
   builder
-    ..primitive(noneOf(meta).map((char) => LiteralNode(char)))
-    ..primitive(
-        anyOf(meta).skip(before: char(r'\')).map((char) => LiteralNode(char)))
+    ..primitive(noneOf(meta).map(LiteralNode.new))
+    ..primitive(anyOf(meta).skip(before: char(r'\')).map(LiteralNode.new))
     ..primitive(char('.').map((_) => DotNode()));
 
   builder.group().wrapper(char('('), char(')'), (_, value, __) => value);
@@ -38,5 +38,5 @@ final nodeParser = () {
     ..left(char('|'), (left, _, right) => AlternationNode(left, right))
     ..left(char('&'), (left, _, right) => IntersectionNode(left, right));
 
-  return builder.build().end();
+  return resolve(builder.build()).end();
 }();

lib/src/smalltalk/objects.dart

@@ -104,5 +104,5 @@ void bootstrap() {
   arrayBehavior.addMethod(
       'at:put:', (self, index, object) => self[index] = object);
 
-  classBehavior.addMethod('new', (self) => SmalltalkObject(self));
+  classBehavior.addMethod('new', SmalltalkObject.new);
 }

lib/src/smalltalk/parser.dart

@@ -133,12 +133,10 @@ ArrayNode buildArray(List statements) {
   return result;
 }
 
-ValueNode buildAssignment(ValueNode node, List parts) {
-  return parts.reversed.fold(
-      node,
-      (result, variableAndToken) =>
-          AssignmentNode(variableAndToken[0], variableAndToken[1], result));
-}
+ValueNode buildAssignment(ValueNode node, List parts) => parts.reversed.fold(
+    node,
+    (result, variableAndToken) =>
+        AssignmentNode(variableAndToken[0], variableAndToken[1], result));
 
 ValueNode buildBlock(List arguments, SequenceNode body) {
   final result = BlockNode(body);
@@ -161,16 +159,14 @@ ValueNode buildCascade(ValueNode value, List parts) {
   return value;
 }
 
-ValueNode buildMessage(ValueNode receiver, List parts) {
-  return parts
-      .where((selectorAndArguments) => selectorAndArguments.isNotEmpty)
-      .fold(receiver, (receiver, selectorAndArguments) {
-    final message = MessageNode(receiver);
-    addTo<Token>(message.selectorToken, selectorAndArguments);
-    addTo<ValueNode>(message.arguments, selectorAndArguments);
-    return message;
-  });
-}
+ValueNode buildMessage(ValueNode receiver, List parts) => parts
+        .where((selectorAndArguments) => selectorAndArguments.isNotEmpty)
+        .fold(receiver, (receiver, selectorAndArguments) {
+      final message = MessageNode(receiver);
+      addTo<Token>(message.selectorToken, selectorAndArguments);
+      addTo<ValueNode>(message.arguments, selectorAndArguments);
+      return message;
+    });
 
 MethodNode buildMethod(List parts) {
   final result = MethodNode();

lib/src/uri/authority.dart

@@ -1,6 +1,8 @@
 /// Further parse the URI authority into username, password, hostname and port.
 ///
 /// Accepts input of the form "[username[:password]@]hostname[:port]".
+library authority;
+
 import 'package:petitparser/petitparser.dart';
 
 final authority = seq3(

lib/src/uri/query.dart

@@ -1,6 +1,8 @@
 /// Parsers an URI query.
 ///
 /// Accepts input of the form "{key[=value]}&...".
+library query;
+
 import 'package:petitparser/petitparser.dart';
 
 final query = _param.plusSeparated('&'.toParser()).map(

lib/uri.dart

@@ -2,6 +2,8 @@
 ///
 /// The accepted inputs and decomposition matches the example given in
 /// Appendix B of the standard: https://tools.ietf.org/html/rfc3986#appendix-B.
+library uri;
+
 import 'package:petitparser/petitparser.dart';
 
 import 'src/uri/authority.dart' as lib_authority;

test/lisp_test.dart

@@ -13,9 +13,8 @@ void main() {
   final native = NativeEnvironment();
   final standard = StandardEnvironment(native);
 
-  dynamic exec(String value, [Environment? env]) {
-    return evalString(lispParser, env ?? standard.create(), value);
-  }
+  dynamic exec(String value, [Environment? env]) =>
+      evalString(lispParser, env ?? standard.create(), value);
 
   group('Cell', () {
     test('Name', () {

test/smalltalk_test.dart

@@ -76,7 +76,7 @@ TypeMatcher<SequenceNode> isSequenceNode(
         List<Matcher> statements = const []}) =>
     isA<SequenceNode>()
         .having((node) => node.temporaries, 'temporaries',
-            temporaries.map((each) => isVariableNode(each)))
+            temporaries.map(isVariableNode))
         .having((node) => node.statements, 'statements', statements);
 
 TypeMatcher<ReturnNode> isReturnNode(Matcher value) =>
@@ -88,7 +88,7 @@ TypeMatcher<BlockNode> isBlockNode(
         List<Matcher> statements = const []}) =>
     isA<BlockNode>()
         .having((node) => node.arguments, 'arguments',
-            arguments.map((each) => isVariableNode(each)))
+            arguments.map(isVariableNode))
         .having((node) => node.body, 'body',
             isSequenceNode(temporaries: temporaries, statements: statements));
 
@@ -108,7 +108,7 @@ TypeMatcher<MethodNode> isMethodNode(String selector, SelectorType selectorType,
         .having((node) => node.selector, 'selector', selector)
         .having((node) => node.selectorType, 'selectorType', selectorType)
         .having((node) => node.arguments, 'arguments',
-            arguments.map((each) => isVariableNode(each)))
+            arguments.map(isVariableNode))
         .having((node) => node.pragmas, 'pragmas', pragmas)
         .having((node) => node.body, 'body',
             isSequenceNode(temporaries: temporaries, statements: statements));