Dart 3.4 dependency and fix linter issues.

analysis_options.yaml

@@ -17,6 +17,7 @@ linter:
     - comment_references
     - directives_ordering
     - invalid_case_patterns
+    - missing_code_block_language_in_doc_comment
     - no_self_assignments
     - no_wildcard_variable_uses
     - omit_local_variable_types
@@ -33,6 +34,7 @@ linter:
     - unnecessary_await_in_return
     - unnecessary_breaks
     - unnecessary_lambdas
+    - unnecessary_library_name
     - unnecessary_null_aware_operator_on_extension_on_nullable
     - unnecessary_null_checks
     - unnecessary_parenthesis

example/calc.dart

@@ -1,5 +1,5 @@
 /// Calculator from the tutorial.
-library calc;
+library;
 
 import 'dart:io';
 import 'dart:math';

lib/context.dart

@@ -1,6 +1,6 @@
 /// This package contains the representation of parse results.
 @Deprecated('Use `import petitparser:core` instead')
-library context;
+library;
 
 export 'src/core/context.dart';
 export 'src/core/result.dart';

lib/core.dart

@@ -1,7 +1,7 @@
 /// This package contains the core classes of the framework.
 ///
 /// {@canonicalFor parser.Parser}
-library core;
+library;
 
 export 'src/core/context.dart';
 export 'src/core/exception.dart';

lib/debug.dart

@@ -1,5 +1,5 @@
 /// This package contains some simple debugging tools.
-library debug;
+library;
 
 export 'src/debug/profile.dart';
 export 'src/debug/progress.dart';

lib/definition.dart

@@ -1,5 +1,5 @@
 /// This package simplifies the creation of complicated recursive grammars.
-library definition;
+library;
 
 export 'src/definition/grammar.dart';
 export 'src/definition/parser.dart';

lib/expression.dart

@@ -1,5 +1,5 @@
 /// This package simplifies the creation of expression parsers.
-library expression;
+library;
 
 export 'src/expression/builder.dart';
 export 'src/expression/group.dart';

lib/indent.dart

@@ -1,4 +1,4 @@
 /// This package simplifies the creation of indention based parsers.
-library indent;
+library;
 
 export 'src/indent/indent.dart';

lib/matcher.dart

@@ -1,5 +1,5 @@
 /// This package contains helpers to simplify parsing and data extraction.
-library matcher;
+library;
 
 export 'src/matcher/accept.dart';
 export 'src/matcher/matches.dart';

lib/parser.dart

@@ -1,5 +1,5 @@
 /// This package contains the standard parser implementations.
-library parser;
+library;
 
 export 'src/core/parser.dart';
 export 'src/parser/action/cast.dart';

lib/petitparser.dart

@@ -1,6 +1,6 @@
 /// This package exports the core library of PetitParser, a dynamic parser
 /// combinator framework.
-library petitparser;
+library;
 
 export 'core.dart';
 export 'definition.dart';

lib/reflection.dart

@@ -1,5 +1,5 @@
 /// This package contains tools to reflect on and transform parsers.
-library reflection;
+library;
 
 export 'src/reflection/analyzer.dart';
 export 'src/reflection/iterable.dart';

lib/src/core/parser.dart

@@ -120,9 +120,11 @@ abstract class Parser<R> {
   /// parser that accepts a digit. The resulting `example` parser accepts one
   /// or more digits.
   ///
-  ///     final letter = letter();
-  ///     final example = letter.plus();
-  ///     example.replace(letter, digit());
+  /// ```dart
+  /// final letter = letter();
+  /// final example = letter.plus();
+  /// example.replace(letter, digit());
+  /// ```
   ///
   /// Override this method and [Parser.children] in all subclasses that
   /// reference other parsers.

lib/src/debug/profile.dart

@@ -10,15 +10,19 @@ import '../shared/types.dart';
 ///
 /// For example, the snippet
 ///
-///     final parser = letter() & word().star();
-///     profile(parser).parse('f1234567890');
+/// ```dart
+/// final parser = letter() & word().star();
+/// profile(parser).parse('f1234567890');
+/// ```
 ///
 /// prints the following output:
 ///
+/// ```text
 ///      1  2006  SequenceParser
 ///      1   697  PossessiveRepeatingParser[0..*]
 ///     11   406  SingleCharacterParser[letter or digit expected]
 ///      1   947  SingleCharacterParser[letter expected]
+/// ```
 ///
 /// The first number refers to the number of activations of each parser, and
 /// the second number is the microseconds spent in this parser and all its

lib/src/debug/progress.dart

@@ -11,18 +11,22 @@ import '../shared/types.dart';
 ///
 /// For example, the snippet
 ///
-///     final parser = letter() & word().star();
-///     progress(parser).parse('f123');
+/// ```dart
+/// final parser = letter() & word().star();
+/// progress(parser).parse('f123');
+/// ```
 ///
 /// prints the following output:
 ///
-///     * SequenceParser
-///     * SingleCharacterParser[letter expected]
-///     ** PossessiveRepeatingParser[0..*]
-///     ** SingleCharacterParser[letter or digit expected]
-///     *** SingleCharacterParser[letter or digit expected]
-///     **** SingleCharacterParser[letter or digit expected]
-///     ***** SingleCharacterParser[letter or digit expected]
+/// ```text
+/// * SequenceParser
+/// * SingleCharacterParser[letter expected]
+/// ** PossessiveRepeatingParser[0..*]
+/// ** SingleCharacterParser[letter or digit expected]
+/// *** SingleCharacterParser[letter or digit expected]
+/// **** SingleCharacterParser[letter or digit expected]
+/// ***** SingleCharacterParser[letter or digit expected]
+/// ```
 ///
 /// Jumps backwards mean that the parser is back-tracking. Often choices can
 /// be reordered to avoid such expensive parses.

lib/src/debug/trace.dart

@@ -12,21 +12,25 @@ import '../shared/types.dart';
 ///
 /// For example, the snippet
 ///
-///     final parser = letter() & word().star();
-///     trace(parser).parse('f1');
+/// ```dart
+/// final parser = letter() & word().star();
+/// trace(parser).parse('f1');
+/// ```
 ///
 /// produces the following output:
 ///
-///     SequenceParser<dynamic>
-///       SingleCharacterParser[letter expected]
-///       Success[1:2]: f
-///       PossessiveRepeatingParser<String>[0..*]
-///         SingleCharacterParser[letter or digit expected]
-///         Success[1:3]: 1
-///         SingleCharacterParser[letter or digit expected]
-///         Failure[1:3]: letter or digit expected
-///       Success[1:3]: [1]
-///     Success[1:3]: [f, [1]]
+/// ```text
+/// SequenceParser<dynamic>
+///   SingleCharacterParser[letter expected]
+///   Success[1:2]: f
+///   PossessiveRepeatingParser<String>[0..*]
+///     SingleCharacterParser[letter or digit expected]
+///     Success[1:3]: 1
+///     SingleCharacterParser[letter or digit expected]
+///     Failure[1:3]: letter or digit expected
+///   Success[1:3]: [1]
+/// Success[1:3]: [f, [1]]
+/// ```
 ///
 /// Indentation signifies the activation of a parser object. Reverse indentation
 /// signifies the returning of a parse result either with a success or failure

lib/src/definition/grammar.dart

@@ -15,12 +15,14 @@ import 'resolve.dart';
 ///
 /// Consider the following example to parse a list of numbers:
 ///
-///     class ListGrammarDefinition extends GrammarDefinition {
-///       Parser start()   => ref0(list).end();
-///       Parser list()    => ref0(element) & char(',') & ref0(list)
-///                         | ref0(element);
-///       Parser element() => digit().plus().flatten();
-///     }
+/// ```dart
+/// class ListGrammarDefinition extends GrammarDefinition {
+///   Parser start()   => ref0(list).end();
+///   Parser list()    => ref0(element) & char(',') & ref0(list)
+///                     | ref0(element);
+///   Parser element() => digit().plus().flatten();
+/// }
+/// ```
 ///
 /// Since this is plain Dart code, common refactorings such as renaming a
 /// production updates all references correctly. Also code navigation and code
@@ -30,35 +32,40 @@ import 'resolve.dart';
 /// grammar definition and override overriding the necessary productions defined
 /// in the superclass:
 ///
-///     class ListParserDefinition extends ListGrammarDefinition {
-///       Parser element() => super.element().map((value) => int.parse(value));
-///     }
+/// ```dart
+/// class ListParserDefinition extends ListGrammarDefinition {
+///   Parser element() => super.element().map((value) => int.parse(value));
+/// }
+/// ```
 ///
 /// Note that productions can be parametrized. Define such productions with
 /// positional arguments, and refer to them using [ref1], [ref2], ... where
 /// the number corresponds to the argument count.
 ///
 /// Consider extending the above grammar with a parametrized token production:
 ///
-///     class TokenizedListGrammarDefinition extends GrammarDefinition {
-///       Parser start() => ref0(list).end();
-///       Parser list() => ref0(element) & ref1(token, char(',')) & ref0(list)
-///                      | ref0(element);
-///       Parser element() => ref1(token, digit().plus());
-///       Parser token(Parser parser)  => parser.token().trim();
-///     }
+/// ```dart
+/// class TokenizedListGrammarDefinition extends GrammarDefinition {
+///   Parser start() => ref0(list).end();
+///   Parser list() => ref0(element) & ref1(token, char(',')) & ref0(list)
+///                  | ref0(element);
+///   Parser element() => ref1(token, digit().plus());
+///   Parser token(Parser parser)  => parser.token().trim();
+/// }
+/// ```
 ///
 /// To get a runnable parser call the [build] method on the definition. It
 /// resolves recursive references and returns an efficient parser that can be
 /// further composed. The optional `start` reference specifies a different
 /// starting production within the grammar. The optional `arguments`
 /// parametrize the start production.
 ///
-///     final parser = new ListParserDefinition().build();
-///
-///     parser.parse('1');          // [1]
-///     parser.parse('1,2,3');      // [1, 2, 3]
+/// ```dart
+/// final parser = new ListParserDefinition().build();
 ///
+/// parser.parse('1');          // [1]
+/// parser.parse('1,2,3');      // [1, 2, 3]
+/// ```
 @optionalTypeArgs
 abstract class GrammarDefinition<R> {
   const GrammarDefinition();

lib/src/expression/builder.dart

@@ -12,60 +12,71 @@ import 'utils.dart';
 /// The following code creates the empty expression builder producing values of
 /// type [num]:
 ///
-///     final builder = ExpressionBuilder<num>();
+/// ```dart
+/// final builder = ExpressionBuilder<num>();
+/// ```
 ///
 /// Every [ExpressionBuilder] needs to define at least one primitive type to
 /// parse. In this example these are the literal numbers. The mapping function
 /// converts the string input into an actual number.
 ///
-///     builder.primitive(digit()
-///         .plus()
-///         .seq(char('.').seq(digit().plus()).optional())
-///         .flatten()
-///         .trim()
-///         .map(num.parse));
+/// ```dart
+/// builder.primitive(digit()
+///     .plus()
+///     .seq(char('.').seq(digit().plus()).optional())
+///     .flatten()
+///     .trim()
+///     .map(num.parse));
+/// ```dart
 ///
 /// Then we define the operator-groups in descending precedence. The highest
 /// precedence have parentheses. The mapping function receives both the opening
 /// parenthesis, the value, and the closing parenthesis as arguments:
 ///
-///     builder.group().wrapper(
-///         char('(').trim(), char(')').trim(), (left, value, right) => value);
+/// ```dart
+/// builder.group().wrapper(
+///     char('(').trim(), char(')').trim(), (left, value, right) => value);
+/// ```
 ///
 /// Then come the normal arithmetic operators. We are using
 /// [cascade notation](https://dart.dev/guides/language/language-tour#cascade-notation)
 /// to define multiple operators on the same precedence-group. The mapping
 /// functions receive both, the terms and the parsed operator in the order they
 /// appear in the parsed input:
 ///
-///     // Negation is a prefix operator.
-///     builder.group().prefix(char('-').trim(), (operator, value) => -value);
+/// ```dart
+/// // Negation is a prefix operator.
+/// builder.group().prefix(char('-').trim(), (operator, value) => -value);
 ///
-///     // Power is right-associative.
-///     builder.group().right(char('^').trim(), (left, operator, right) => math.pow(left, right));
+/// // Power is right-associative.
+/// builder.group().right(char('^').trim(), (left, operator, right) => math.pow(left, right));
 ///
-///     // Multiplication and addition are left-associative, multiplication has
-///     // higher priority than addition.
-///     builder.group()
-///       ..left(char('*').trim(), (left, operator, right) => left * right)
-///       ..left(char('/').trim(), (left, operator, right) => left / right);
-///     builder.group()
-///       ..left(char('+').trim(), (left, operator, right) => left + right)
-///       ..left(char('-').trim(), (left, operator, right) => left - right);
+/// // Multiplication and addition are left-associative, multiplication has
+/// // higher priority than addition.
+/// builder.group()
+///   ..left(char('*').trim(), (left, operator, right) => left * right)
+///   ..left(char('/').trim(), (left, operator, right) => left / right);
+/// builder.group()
+///   ..left(char('+').trim(), (left, operator, right) => left + right)
+///   ..left(char('-').trim(), (left, operator, right) => left - right);
+/// ```
 ///
 /// Finally we can build the parser:
 ///
-///     final parser = builder.build();
+/// ```dart
+/// final parser = builder.build();
+/// ```
 ///
 /// After executing the above code we get an efficient parser that correctly
 /// evaluates expressions like:
 ///
-///     parser.parse('-8');      // -8
-///     parser.parse('1+2*3');   // 7
-///     parser.parse('1*2+3');   // 5
-///     parser.parse('8/4/2');   // 2
-///     parser.parse('2^2^3');   // 256
-///
+/// ```dart
+/// parser.parse('-8');      // -8
+/// parser.parse('1+2*3');   // 7
+/// parser.parse('1*2+3');   // 5
+/// parser.parse('8/4/2');   // 2
+/// parser.parse('2^2^3');   // 256
+/// ```
 class ExpressionBuilder<T> {
   final List<Parser<T>> _primitives = [];
   final List<ExpressionGroup<T>> _groups = [];

lib/src/matcher/matches.dart

@@ -12,7 +12,9 @@ extension MatchesParserExtension<T> on Parser<T> {
   ///
   /// For example, with the parser
   ///
-  ///     final parser = letter().plus().flatten();
+  /// ```dart
+  /// final parser = letter().plus().flatten();
+  /// ```
   ///
   /// `parser.allMatches('abc de')` results in the iterable `['abc', 'de']`; and
   /// `parser.allMatches('abc de', overlapping: true)` results in the iterable