anchor.diff:  }
   
   @isTestGroup
  -void tableTestParser<R extends AstNode>(
  +void tableTestParser<R, N extends AstNode>(
     String description, {
     @required Map<String, R> table,
  +  @required N Function(R raw, SourceSpan fullSpan) astMapper,
     @required Parser parser,
   }) {
     assert(table != null);
     assert(parser != null);
   
  -  tableTest<String, R>(
  +  tableTest<String, N>(
       description,
  -    table: table,
  +    table: table.map((key, value) {
  +      return MapEntry(key, astMapper(value, SourceSpan(0, key.length)));
  +    }),
       converter: (source) {
         final result = parser.parse(source);
         expect(result.isSuccess, isTrue);
  
positive.code:           '1_0_0': 100,
            '1000': 1000,
            '1_000': 1000,
          }.map((key, value) {
            final newValue = Literal(
              IntegerLiteralToken(value, span: SourceSpan(0, key.length)),
            );
            return MapEntry(key, newValue);
          }),
        );
        tableTestExpressionParser<Literal<int>>(
          'hexadecimal',
          table: {
            '0x0': 0,
  
negative.code:           '0b1_0_0': 0x4,
            '0b1000': 0x8,
            '0b1_000': 0x8,
          },
          astMapper: (value, fullSpan) =>
              Literal(IntegerLiteralToken(value, span: fullSpan)),
        );
      });
      tableTestExpressionParser<bool, Literal<bool>>(
        'BooleanLiteral',
        table: {
          'true': true,
          'false': false,
        },
        astMapper: (value, fullSpan) =>
            Literal(BooleanLiteralToken(value, span: fullSpan)),
      );
    });
  }
  