[RegExp] Fix escaping in character classes

Author: renggli

lib/src/regexp/classes.dart

@@ -0,0 +1,36 @@
+import 'node.dart';
+
+final escapeChars = <String, String>{
+  't': '\t',
+  'n': '\n',
+  'r': '\r',
+  'f': '\f',
+  'e': '\x1b',
+};
+
+final escapeClasses = <String, Node>{
+  's': _spaceCharClass,
+  'S': ComplementNode(_spaceCharClass),
+  'd': _digitCharClass,
+  'D': ComplementNode(_digitCharClass),
+  'w': _wordCharClass,
+  'W': ComplementNode(_wordCharClass),
+};
+
+final _spaceCharClass = <Node>[
+  LiteralNode(' '),
+  LiteralNode('\t'),
+  LiteralNode('\n'),
+  LiteralNode('\r'),
+  LiteralNode('\f'),
+  LiteralNode('\v'),
+].reduce(AlternationNode.new);
+
+final _digitCharClass = RangeNode('0', '9');
+
+final _wordCharClass = <Node>[
+  RangeNode('a', 'z'),
+  RangeNode('A', 'Z'),
+  RangeNode('0', '9'),
+  LiteralNode('_'),
+].reduce(AlternationNode.new);

lib/src/regexp/escape.dart

@@ -2,13 +2,17 @@ import 'package:petitparser/definition.dart';
 import 'package:petitparser/expression.dart';
 import 'package:petitparser/parser.dart';
 
-import 'classes.dart';
+import 'escape.dart';
 import 'node.dart';
 
 class RegexpParserDefinition extends GrammarDefinition<Node> {
   Parser<Node> escape() => any()
       .skip(before: char(r'\'))
-      .map((char) => escapeClasses[char] ?? LiteralNode(char));
+      .map(
+        (char) => escapeClasses.containsKey(char)
+            ? escapeClasses[char]!
+            : LiteralNode(escapeChars[char] ?? char),
+      );
   Parser<Node> dot() => char('.').map((_) => DotNode());
   Parser<Node> startAnchor() => char('^').map((_) => StartAnchorNode());
   Parser<Node> endAnchor() => char(r'$').map((_) => EndAnchorNode());
@@ -20,16 +24,19 @@ class RegexpParserDefinition extends GrammarDefinition<Node> {
   Parser<Node> charClassItems() => ref0(
     charClassItem,
   ).plus().map((items) => items.reduce(AlternationNode.new));
-  Parser<Node> charClassItem() => [
-    ref0(charClassRange),
-    ref0(escape),
-    noneOf(']').map((char) => LiteralNode(char)),
+  Parser<String> charClassChar() => [
+    any().skip(before: char(r'\')).map((char) => escapeChars[char] ?? char),
+    noneOf(']'),
   ].toChoiceParser();
   Parser<Node> charClassRange() => seq3(
-    any(),
+    ref0(charClassChar),
     char('-'),
-    any(),
+    ref0(charClassChar),
   ).map3((start, _, end) => RangeNode(start, end));
+  Parser<Node> charClassItem() => [
+    ref0(charClassRange),
+    ref0(charClassChar).map(LiteralNode.new),
+  ].toChoiceParser();
 
   Parser<int> integer() => digit().plusString().trim().map(int.parse);
   Parser<({int min, int? max})> range() =>

lib/src/regexp/parser.dart

@@ -1,6 +1,5 @@
 import 'package:petitparser/reflection.dart';
 import 'package:petitparser_examples/regexp.dart';
-import 'package:petitparser_examples/src/regexp/classes.dart';
 import 'package:test/test.dart';
 
 void expectedEqual(Node actual, Node expected) {
@@ -39,12 +38,12 @@ void main() {
       expectedEqual(Node.fromString(r'\e'), LiteralNode('\x1b'));
     });
     test('escape classes', () {
-      expectedEqual(Node.fromString(r'\s'), spaceCharClass);
-      expectedEqual(Node.fromString(r'\S'), ComplementNode(spaceCharClass));
-      expectedEqual(Node.fromString(r'\d'), digitCharClass);
-      expectedEqual(Node.fromString(r'\D'), ComplementNode(digitCharClass));
-      expectedEqual(Node.fromString(r'\w'), wordCharClass);
-      expectedEqual(Node.fromString(r'\W'), ComplementNode(wordCharClass));
+      expect(Node.fromString(r'\s'), isA<AlternationNode>());
+      expect(Node.fromString(r'\S'), isA<ComplementNode>());
+      expect(Node.fromString(r'\d'), isA<RangeNode>());
+      expect(Node.fromString(r'\D'), isA<ComplementNode>());
+      expect(Node.fromString(r'\w'), isA<AlternationNode>());
+      expect(Node.fromString(r'\W'), isA<ComplementNode>());
     });
     test('escape other', () {
       expectedEqual(Node.fromString(r'\.'), LiteralNode('.'));
@@ -80,6 +79,7 @@ void main() {
         AlternationNode(AlternationNode(la, lb), lc),
       );
       expectedEqual(Node.fromString(r'[a-c]'), RangeNode('a', 'c'));
+      expectedEqual(Node.fromString(r'[\t-z]'), RangeNode('\t', 'z'));
       expectedEqual(Node.fromString(r'[^a]'), ComplementNode(la));
       expectedEqual(
         Node.fromString(r'[^ab]'),