refactor(ast): unify positive/negative lookahead

gruhn · gruhn · commit 8e8f5274b631 · 2025-09-18T22:15:19.000+02:00
diff --git a/src/ast.ts b/src/ast.ts
@@ -23,8 +23,7 @@ export type RegExpAST =
   | { type: "optional", inner: RegExpAST }
   | { type: "repeat", inner: RegExpAST, bounds: RepeatBounds }
   | { type: "capture-group", name?: string, inner: RegExpAST }
-  | { type: "positive-lookahead", inner: RegExpAST, right: RegExpAST }
-  | { type: "negative-lookahead", inner: RegExpAST, right: RegExpAST }
+  | { type: "lookahead", isPositive: boolean, inner: RegExpAST, right: RegExpAST }
   | { type: "start-anchor", left: RegExpAST, right: RegExpAST }
   | { type: "end-anchor", left: RegExpAST, right: RegExpAST  }
 
@@ -56,8 +55,7 @@ function isNullable(ast: RegExpAST): boolean {
       }
     }
     case "capture-group": return isNullable(ast.inner)
-    case "positive-lookahead": return isNullable(ast.inner) && isNullable(ast.right)
-    case "negative-lookahead": return !isNullable(ast.inner) && isNullable(ast.right)
+    case "lookahead": return isNullable(ast.inner) && isNullable(ast.right)
     case "start-anchor": return isNullable(ast.left) && isNullable(ast.right)
     case "end-anchor": return isNullable(ast.left) && isNullable(ast.right)
   }
@@ -80,8 +78,7 @@ function desugar(ast: RegExpAST): RegExpAST {
     case 'star': return star(desugar(ast.inner))
     case 'start-anchor': return startAnchor(desugar(ast.left), desugar(ast.right))
     case 'end-anchor': return endAnchor(desugar(ast.left), desugar(ast.right))
-    case 'positive-lookahead': return positiveLookahead(desugar(ast.inner), desugar(ast.right))   
-    case 'negative-lookahead': return negativeLookahead(desugar(ast.inner), desugar(ast.right))   
+    case 'lookahead': return lookahead(ast.isPositive, desugar(ast.inner), desugar(ast.right))   
     // sugar nodes:
     case 'capture-group': return desugar(ast.inner)
     case 'plus': {
@@ -243,26 +240,15 @@ function pullUpStartAnchor(ast: RegExpAST): RegExpAST {
         return endAnchor(left, undefined)
       }
     }
-    case "positive-lookahead": {
+    case "lookahead": {
       const inner = pullUpStartAnchor(ast.inner)
       const right = pullUpStartAnchor(ast.right)
       if (inner.type === 'start-anchor') {
-        throw new UnsupportedSyntaxError('start anchors (^) inside lookaheads are not supported')
+        throw new UnsupportedSyntaxError('start anchors inside lookaheads like (?=^a) are not supported')
       } else if (right.type === 'start-anchor') {
-        return startAnchor(undefined, positiveLookahead(ast.inner, right.right))
+        return startAnchor(undefined, lookahead(ast.isPositive, ast.inner, right.right))
       } else {
-        return positiveLookahead(ast.inner, right)
-      }
-    }
-    case "negative-lookahead": {
-      const inner = pullUpStartAnchor(ast.inner)
-      const right = pullUpStartAnchor(ast.right)
-      if (inner.type === 'start-anchor') {
-        throw new UnsupportedSyntaxError('start anchors (^) inside lookaheads are not supported')
-      } else if (right.type === 'start-anchor') {
-        return startAnchor(undefined, negativeLookahead(ast.inner, right.right))
-      } else {
-        return negativeLookahead(ast.inner, right)
+        return lookahead(ast.isPositive, ast.inner, right)
       }
     }
   }
@@ -392,26 +378,15 @@ function pullUpEndAnchor(ast: RegExpAST): RegExpAST {
         return endAnchor(left, undefined) // i.e. `l$`
       }
     }
-    case "positive-lookahead": {
+    case "lookahead": {
       const inner = pullUpEndAnchor(ast.inner)
       const right = pullUpEndAnchor(ast.right)
       if (inner.type === 'end-anchor') {
-        throw new UnsupportedSyntaxError('end anchors ($) inside lookaheads are not supported')
+        throw new UnsupportedSyntaxError('end anchors inside lookaheads like (?=a$) are not supported')
       } else if (right.type === 'end-anchor') {
-        return endAnchor(positiveLookahead(ast.inner, right.left), undefined)
+        return endAnchor(lookahead(ast.isPositive, ast.inner, right.left), undefined)
       } else {
-        return positiveLookahead(ast.inner, right)
-      }
-    }
-    case "negative-lookahead": {
-      const inner = pullUpEndAnchor(ast.inner)
-      const right = pullUpEndAnchor(ast.right)
-      if (inner.type === 'end-anchor') {
-        throw new UnsupportedSyntaxError('end anchors ($) inside lookaheads are not supported')
-      } else if (right.type === 'end-anchor') {
-        return endAnchor(negativeLookahead(ast.inner, right.right), undefined)
-      } else {
-        return negativeLookahead(ast.inner, right)
+        return lookahead(ast.isPositive, ast.inner, right)
       }
     }
   }
@@ -458,15 +433,13 @@ function toExtRegexAux(ast: RegExpAST): RE.ExtRegex {
     case 'concat': return RE.concat(toExtRegexAux(ast.left), toExtRegexAux(ast.right))
     case 'union': return RE.union(toExtRegexAux(ast.left), toExtRegexAux(ast.right))
     case 'star': return RE.star(toExtRegexAux(ast.inner))
-    case 'positive-lookahead': {
-      const inner = toExtRegexAux(ast.inner)
-      const right = toExtRegexAux(ast.right)
-      return RE.intersection(inner, right)
-    }
-    case 'negative-lookahead': {
+    case 'lookahead': {
       const inner = toExtRegexAux(ast.inner)
       const right = toExtRegexAux(ast.right)
-      return RE.intersection(RE.complement(inner), right)
+      if (ast.isPositive) 
+        return RE.intersection(inner, right)
+      else
+        return RE.intersection(RE.complement(inner), right)
     }
   }
   checkedAllCases(ast.type)
@@ -525,18 +498,12 @@ export function captureGroup(inner: RegExpAST, name?: string): RegExpAST {
   return { type: 'capture-group', inner, name }
 }
 
-export function positiveLookahead(
-  inner: RegExpAST,
-  right: RegExpAST,
-): RegExpAST {
-  return { type: 'positive-lookahead', inner, right }
-}
-
-export function negativeLookahead(
+export function lookahead(
+  isPositive: boolean,
   inner: RegExpAST,
   right: RegExpAST,
 ): RegExpAST {
-  return { type: 'negative-lookahead', inner, right }
+  return { type: 'lookahead', isPositive, inner, right }
 }
 
 //////////////////////////////////////////////
@@ -587,10 +554,8 @@ function debugShow_(ast: RegExpAST): unknown {
       return { type: 'repeat', inner: debugShow_(ast.inner), bounds: ast.bounds }
     case 'capture-group':
       return { type: 'capture-group', name: ast.name, inner: debugShow_(ast.inner) }
-    case 'positive-lookahead':
-      return { type: 'positive-lookahead', inner: debugShow_(ast.inner) }
-    case 'negative-lookahead':
-      return { type: 'negative-lookahead', inner: debugShow_(ast.inner) }
+    case 'lookahead':
+      return { type: 'lookahead', isPositive: ast.isPositive, inner: debugShow_(ast.inner) }
   }
   checkedAllCases(ast)
 }
@@ -644,10 +609,14 @@ export function toString(ast: RegExpAST, options: RenderOptions): string {
 
     case 'capture-group':
       return captureGroupToString(ast.name, ast.inner, options)
-    case 'positive-lookahead':
-      return '(?=' + toString(ast.inner, options) + ')' + maybeWithParens(ast.right, ast, options)
-    case 'negative-lookahead':
-      return '(?!' + toString(ast.inner, options) + ')' + maybeWithParens(ast.right, ast, options)
+    case 'lookahead': {
+      const inner = toString(ast.inner, options)
+      const right = maybeWithParens(ast.right, ast, options)
+      if (ast.isPositive)
+        return '(?=' + inner + ')' + right
+      else
+        return '(?!' + inner + ')' + right
+    }
   }
   checkedAllCases(ast)
 }
@@ -666,8 +635,7 @@ function precLevel(nodeType: RegExpAST['type']) {
 
     case 'concat': return 4
 
-    case 'positive-lookahead': return 3
-    case 'negative-lookahead': return 3
+    case 'lookahead': return 3
 
     case 'start-anchor': return 2
     case 'end-anchor': return 2
diff --git a/src/regex-parser.ts b/src/regex-parser.ts
@@ -195,7 +195,7 @@ function positiveLookAhead(): P.Expr.UnaryOperator<AST.RegExpAST> {
     // FIXME: that allows ^/$ inside lookaheads but that isn't
     // handled correctly right now.
     regex(),
-  ).map(inner => right => AST.positiveLookahead(inner, right))
+  ).map(inner => right => AST.lookahead(true, inner, right))
 }
 
 function negativeLookAhead(): P.Expr.UnaryOperator<AST.RegExpAST> {
@@ -205,7 +205,7 @@ function negativeLookAhead(): P.Expr.UnaryOperator<AST.RegExpAST> {
     // FIXME: that allows ^/$ inside lookaheads but that isn't
     // handled correctly right now.
     regex(),    
-  ).map(inner => right => AST.negativeLookahead(inner, right))
+  ).map(inner => right => AST.lookahead(false, inner, right))
 }
 
 /**
diff --git a/test/arbitrary-ast.ts b/test/arbitrary-ast.ts
@@ -61,14 +61,9 @@ function captureGroup(innerArb: () => fc.Arbitrary<AST.RegExpAST>): fc.Arbitrary
     .map(([inner, name]) => AST.captureGroup(inner, name))
 }
 
-function positiveLookahead(childArb: () => fc.Arbitrary<AST.RegExpAST>): fc.Arbitrary<AST.RegExpAST> {
-  return fc.tuple(childArb(), childArb())
-    .map(([inner, right]) => AST.positiveLookahead(inner, right))
-}
-
-function negativeLookahead(childArb: () => fc.Arbitrary<AST.RegExpAST>): fc.Arbitrary<AST.RegExpAST> {
-  return fc.tuple(childArb(), childArb())
-    .map(([inner, right]) => AST.negativeLookahead(inner, right))
+function lookahead(childArb: () => fc.Arbitrary<AST.RegExpAST>): fc.Arbitrary<AST.RegExpAST> {
+  return fc.tuple(fc.boolean(), childArb(), childArb())
+    .map(([isPositive, inner, right]) => AST.lookahead(isPositive, inner, right))
 }
 
 function startAnchor(childArb: () => fc.Arbitrary<AST.RegExpAST>): fc.Arbitrary<AST.RegExpAST> {
@@ -128,10 +123,8 @@ export function makeCaptureGroupNamesUnique(ast: AST.RegExpAST): AST.RegExpAST {
           return AST.captureGroup(innerProcessed, nameProcessed)
         }
       }
-      case 'positive-lookahead':
-        return AST.positiveLookahead(traverse(node.inner), traverse(node.right))
-      case 'negative-lookahead':
-        return AST.negativeLookahead(traverse(node.inner), traverse(node.right))
+      case 'lookahead':
+        return AST.lookahead(node.isPositive, traverse(node.inner), traverse(node.right))
       case 'start-anchor':
         return AST.startAnchor(traverse(node.left), traverse(node.right))
       case 'end-anchor':
@@ -165,8 +158,7 @@ function regexpAST_(size: number): fc.Arbitrary<AST.RegExpAST> {
       { arbitrary: optional(() => regexpAST_(childSize)), weight: 1 },
       { arbitrary: repeat(() => regexpAST_(childSize)), weight: 1 },
       { arbitrary: captureGroup(() => regexpAST_(childSize)), weight: 2 },
-      { arbitrary: positiveLookahead(() => regexpAST_(childSize)), weight: 1 },
-      { arbitrary: negativeLookahead(() => regexpAST_(childSize)), weight: 1 },
+      { arbitrary: lookahead(() => regexpAST_(childSize)), weight: 1 },
       { arbitrary: startAnchor(() => regexpAST_(childSize)), weight: 1 },
       { arbitrary: endAnchor(() => regexpAST_(childSize)), weight: 1 }
     )
diff --git a/test/regex-parser.spec.ts b/test/regex-parser.spec.ts
@@ -72,17 +72,17 @@ describe('parseRegExp', () => {
     [/^abc$/, AST.startAnchor(undefined, AST.endAnchor(str('abc'), undefined))],
     [/$a^/, AST.startAnchor(AST.endAnchor(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)], 
+    [/(?=a)b/, AST.lookahead(true, char('a'), char('b'))], 
+    [/(?=a)(?:b)/, AST.lookahead(true, char('a'), char('b'))], 
+    [/(?=a)(?=b)c/, AST.lookahead(true, char('a'), AST.lookahead(true, char('b'), char('c')))], 
+    [/a(?=b)c/, AST.concat(char('a'), AST.lookahead(true, char('b'), char('c')))], 
+    [/a(?=b)/, AST.concat(char('a'), AST.lookahead(true, char('b'), AST.epsilon))], 
+    [/a(?=b)c(?=d)e/, AST.concat(char('a'), AST.lookahead(true, char('b'), AST.concat(char('c'), AST.lookahead(true, char('d'), char('e')))))], 
+    [/(?=)/, AST.lookahead(true, 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)],
+    [/(?!a)b/, AST.lookahead(false, char('a'), char('b'))], 
+    [/(?!a)b|c/, AST.union(AST.lookahead(false, char('a'), char('b')), char('c'))],
+    [/(?!)/, AST.lookahead(false, AST.epsilon, AST.epsilon)],
     // TODO: positive lookbehind
     // [/(?<=a)/, AST.positiveLookbehind(char('a'))], 
     // TODO: negative lookbehind
