fix(parser): only allow alphaNum ranges

Char ranges like /[a-z]/ are only allowed for alphanumeric characters.
I.e. [a-z], [0-9], [A-Z] or any sub-ranges of those. Also, turns out
if you have [a-] then the dash is interpreted literally.

Remaining parse error in parser benchmark: 144/749

Author: gruhn

src/regex-parser.ts

@@ -44,6 +44,8 @@ const wildcard = P.string('.').map(
 
 const unescapedChar = P.satisfy(Range.neverMustBeEscaped)
 
+const alphaNumChar = P.satisfy(char => /^[a-zA-Z0-9]$/.test(char))
+
 const unescapedCharInsideBrackets = P.satisfy(Range.mustBeEscapedOrInBrackets)
   .map(CharSet.singleton)
 
@@ -73,19 +75,38 @@ const escapeSequence = P.string('\\').andThen(_ => P.anyChar).map(escapedChar =>
   }
 })
 
-const codePointRange: P.Parser<CharSet.CharSet> =
-  unescapedChar.andThen(start =>
-    P.optional(P.string('-').andThen(_ => unescapedChar))
-     .map(end => CharSet.charRange(start, end ?? start))
-  )
+// E.g. "a-z", "0-9", "A-Z"
+const alphaNumRange: P.Parser<CharSet.CharSet> = alphaNumChar.andThen(start =>
+  P.optional(P.string('-')).andThen(dash => {
+    if (dash === undefined) {
+      // e.g. [a]
+      return P.pure(CharSet.singleton(start))
+    } else {
+      return P.optional(alphaNumChar).map(end => {
+        if (end === undefined) {
+          // e.g. [a-] so dash is interpreted literally
+          return CharSet.fromArray([start, dash])
+        } else {
+          // e.g. [a-z]
+          return CharSet.charRange(start, end)
+        }
+      })
+    }
+  })
+)
 
 const charSet = P.choice([
   P.between(
     // QUESTION: can brackets be nested?
     P.string('['),
     P.string(']'),
     P.optional(P.string('^')).andThen(negated =>
-      P.many(P.choice([escapeSequence, codePointRange, unescapedCharInsideBrackets])).map(
+      P.many(P.choice([
+        escapeSequence, // e.g. "\$", "\]"
+        alphaNumRange, // e.g. "a-z", "0-9" (will also match just "a", "3")
+        unescapedCharInsideBrackets, // e.g. "$", "."
+        unescapedChar.map(CharSet.singleton), // e.g. "#", "%"
+      ])).map(
         sets => {
           if (negated === undefined)
             return sets.reduce(CharSet.union, CharSet.empty)

test/regex-parser.spec.ts

@@ -31,6 +31,7 @@ describe('parseRegexString', () => {
     [/^\.$/, RE.literal(CharSet.singleton('.'))],
     // char class from range:
     [/^[a-z]$/, RE.literal(CharSet.charRange('a', 'z'))],
+    [/^[a-]$/, RE.literal(CharSet.fromArray(['a', '-']))],
     // negative char class:
     [/^[^abc]$/, RE.literal(CharSet.complement(CharSet.fromArray(['a', 'b', 'c'])))],
     // non-capturing groups
@@ -52,14 +53,19 @@ describe('parseRegexString', () => {
     // other special chars need escape even inside brackets:
     [/^[\\\]\/]$/, RE.literal(CharSet.fromArray([...'\\]/']))],
   ])('can parse %s', (regexp, expected) => {
-    expect(parseRegExp(regexp)).toEqual(expected)
+    expect(parseRegExp(regexp).hash).toBe(expected.hash)
   })
 
   it.each([
-    ['a+*'],
+    // unclosed parenthesis:
     ['(a'],
+    // combined quantifiers:
+    ['a+*'],
     ['a?{2}'],
     ['a+{2}'],
+    // TODO: invalid ranges:
+    // ['[a-#]'],
+    // ['[%-#]'],
   ])('rejects invalid regex /%s/', (regexStr) => {
     expect(() => parseRegexString(regexStr)).toThrowError(ParseError)
   })