fix(parser): allow empty groups like /(?:)/

Author: gruhn

benchmark/regex_handwritten.ts

@@ -1,6 +1,8 @@
 import fs from 'fs'
 
 function* readHandWrittenDataset() {
+  // dataset obtained from regex101.com using this script:
+  // https://github.com/dataunitylab/semantic-regex/blob/ece59e827cc05b907883aace30d72e02e31e2a9b/download_patterns.sh
   const jsonStr = fs.readFileSync('./benchmark/regex-dataset.json', 'utf-8')
 
   for (const item of JSON.parse(jsonStr)) {

src/regex-parser.ts

@@ -241,7 +241,7 @@ function lookAheadOp(): P.Expr.BinaryOperator<AST.RegExpAST | undefined, AST.Reg
 }
 
 function regex(): P.Parser<AST.RegExpAST> {
-  return P.lazy(() => P.Expr.makeExprParser<AST.RegExpAST>(
+  const nonEmptyRegex = P.lazy(() => P.Expr.makeExprParser<AST.RegExpAST>(
     regexTerm(),
     [
       { type: 'postfix', op: P.string('*').map(_ => AST.star) },
@@ -255,6 +255,13 @@ function regex(): P.Parser<AST.RegExpAST> {
       { type: 'infixRightOptional', op: P.string('|').map(_ => AST.union) },
     ]
   ))
+
+  return P.optional(nonEmptyRegex).map(ast => {
+    if (ast === undefined)
+      return AST.epsilon
+    else
+      return ast
+  })
 }
 
 export function parseRegExpString(

test/arbitrary-regex.ts

@@ -1,5 +1,4 @@
 import fc from 'fast-check'
-import * as AST from '../src/ast'
 import * as CharSet from '../src/char-set'
 import * as RE from '../src/regex'
 

test/regex-parser.spec.ts

@@ -52,8 +52,11 @@ describe('parseRegExp', () => {
     [/[a-]/, AST.literal(CharSet.fromArray(['a', '-']))],
     // negative char class:
     [/[^abc]/, AST.literal(CharSet.complement(CharSet.fromArray(['a', 'b', 'c'])))],
+    // regular capturing groups:
+    [/()/, group(AST.epsilon)],
     // non-capturing groups
     [/(?:ab)/, str('ab')],
+    [/(?:)/, AST.epsilon],
     // named capturing groups
     [/(?<abc_012_ABC>abc)/, group(str('abc'), 'abc_012_ABC')],
     [/(?<ABC>abc)/, group(str('abc'), 'ABC')],
@@ -63,16 +66,19 @@ describe('parseRegExp', () => {
     [/a^b/, AST.startMarker(char('a'), str('b'))],
     [/^a|^b/, AST.union(AST.startMarker(undefined, str('a')), AST.startMarker(undefined, char('b')))],
     [/^abc$/, AST.startMarker(undefined, AST.endMarker(str('abc'), undefined))],
+    [/$a^/, AST.startMarker(AST.endMarker(undefined, char('a')), undefined)],
     // positive lookahead - now parsed as lookahead AST nodes, not intersections
     [/(?=a)b/, AST.positiveLookahead(char('a'), char('b'))], 
     [/(?=a)(?:b)/, AST.positiveLookahead(char('a'), char('b'))], 
     [/(?=a)(?=b)c/, AST.positiveLookahead(char('a'), AST.positiveLookahead(char('b'), char('c')))], 
     [/a(?=b)c/, AST.concat(char('a'), AST.positiveLookahead(char('b'), char('c')))], 
     [/a(?=b)/, AST.concat(char('a'), AST.positiveLookahead(char('b'), AST.epsilon))], 
     [/a(?=b)c(?=d)e/, AST.concat(char('a'), AST.positiveLookahead(char('b'), AST.concat(char('c'), AST.positiveLookahead(char('d'), char('e')))))], 
+    [/(?=)/, AST.positiveLookahead(AST.epsilon, AST.epsilon)], 
     // negative lookahead
     [/(?!a)b/, AST.negativeLookahead(char('a'), char('b'))], 
     [/(?!a)b|c/, AST.union(AST.negativeLookahead(char('a'), char('b')), char('c'))],
+    [/(?!)/, AST.negativeLookahead(AST.epsilon, AST.epsilon)],
     // TODO: positive lookbehind
     // [/(?<=a)/, AST.positiveLookbehind(char('a'))], 
     // TODO: negative lookbehind

test/regex.spec.ts

@@ -275,6 +275,8 @@ describe('fromRegExpAST', () => {
       // the whole expression to empty set:
       [/(a^b|c)/, RE.seq([dotStar, RE.singleChar('c'), dotStar])],
       [/^(a^b|c)/, RE.seq([RE.singleChar('c'), dotStar])],
+      // Contradictory regex describes empty set:
+      [/$.^/, RE.empty],
 
       [/(^a|)^b/, RE.seq([RE.singleChar('b'), dotStar])],
       [/^a(b^|c)/, RE.seq([RE.string('ac'), dotStar]) ],