TRegex: Fix look around merging with empty transition.

Author: zaclegarssure

regex/src/com.oracle.truffle.regex.test/src/com/oracle/truffle/regex/tregex/test/JsTests.java

@@ -311,6 +311,14 @@ public void gr56676() {
         test("(?<!a)", "digyus", "x\uDE40", 2, true, 2, 2);
     }
 
+    @Test
+    public void emptyTransitionMergedWithLookAhead() {
+        test("a(?=b(?<=ab)()|)", "", "ab", 0, true, 0, 1, 2, 2);
+        test("a(?=b(?<=ab)()|)", "", "ac", 0, true, 0, 1, -1, -1);
+        test("a(?=b(?<=ab)()|)", "", "a", 0, true, 0, 1, -1, -1);
+        test("a?(?=b(?<=ab)()|)", "", "a", 0, true, 0, 1, -1, -1);
+    }
+
     @Test
     public void generatedTests() {
         /* GENERATED CODE BEGIN - KEEP THIS MARKER FOR AUTOMATIC UPDATES */

regex/src/com.oracle.truffle.regex/src/com/oracle/truffle/regex/tregex/nfa/NFAGenerator.java

@@ -59,6 +59,7 @@
 import com.oracle.truffle.regex.tregex.buffer.CompilationBuffer;
 import com.oracle.truffle.regex.tregex.parser.Counter;
 import com.oracle.truffle.regex.tregex.parser.ast.CharacterClass;
+import com.oracle.truffle.regex.tregex.parser.ast.GroupBoundaries;
 import com.oracle.truffle.regex.tregex.parser.ast.LookBehindAssertion;
 import com.oracle.truffle.regex.tregex.parser.ast.MatchFound;
 import com.oracle.truffle.regex.tregex.parser.ast.PositionAssertion;
@@ -76,6 +77,7 @@ public final class NFAGenerator {
     private final NFAState dummyInitialState;
     private final NFAState[] anchoredInitialStates;
     private final NFAState[] initialStates;
+    private NFAState checkFinalTransitionState;
     /**
      * These are like {@link #initialStates}, but with {@code mustAdvance} set to {@code false},
      * i.e. we have already advanced when we are in these states. In a regular expression with
@@ -153,6 +155,14 @@ private NFAGenerator(RegexAST ast, CompilationBuffer compilationBuffer) {
         dummyInitialState.setPredecessors(dummyInitPrev);
     }
 
+    private NFAState getFinalCheckedTransitionState() {
+        if (checkFinalTransitionState == null) {
+            checkFinalTransitionState = createFinalState(StateSet.create(ast, ast.getRoot().getSubTreeParent().getMatchFoundChecked()), ast.getOptions().isMustAdvance());
+            checkFinalTransitionState.setSuccessors(new NFAStateTransition[]{createNoCGTransition(checkFinalTransitionState, finalState, ast.getEncoding().getFullSet())}, true);
+        }
+        return checkFinalTransitionState;
+    }
+
     public static NFA createNFA(RegexAST ast, CompilationBuffer compilationBuffer) {
         return new NFAGenerator(ast, compilationBuffer).doCreateNFA();
     }
@@ -301,12 +311,23 @@ private NFAStateTransition[] createNFATransitions(NFAState sourceState, ASTStep
                         }
                     } else if (stateSetCC == null) {
                         if (containsMatchFound) {
-                            transitionsBuffer.add(createTransition(sourceState, finalState, ast.getEncoding().getFullSet()));
-                            // Transitions dominated by a transition to a final state will never end
-                            // up being used, so we can skip generating them and return the current
-                            // list of transitions.
-                            clearGroupBoundaries();
-                            return transitionsBuffer.toArray(new NFAStateTransition[transitionsBuffer.size()]);
+                            if (mergeBuilder.getCodePointSet().matchesEverything(ast.getEncoding())) {
+                                transitionsBuffer.add(createTransition(sourceState, finalState, ast.getEncoding().getFullSet()));
+                                // Transitions dominated by a transition to a final state will never
+                                // end up being used, so we can skip generating them and return the
+                                // current list of transitions.
+                                clearGroupBoundaries();
+                                return transitionsBuffer.toArray(new NFAStateTransition[transitionsBuffer.size()]);
+                            }
+                            // This case is only reachable when merging a lookbehind with an empty
+                            // transition to the final state.
+                            // The issue is that the priority between transitions after running the
+                            // canonicalizer is lost, but that doesn't matter since
+                            // they have disjoint code point sets. But when the transition reaches
+                            // the final state, then it's cps is not checked.
+                            // In that case we use this special checkFinalTransitionState, which
+                            // will still check that last code point set matches.
+                            transitionsBuffer.add(createTransition(sourceState, getFinalCheckedTransitionState(), mergeBuilder.getCodePointSet()));
                         }
                     } else {
                         if (containsMatchFound && allCCInLookBehind) {
@@ -343,6 +364,10 @@ private NFAStateTransition createTransition(NFAState source, NFAState target, Co
         return new NFAStateTransition((short) transitionID.inc(), source, target, codePointSet, ast.createGroupBoundaries(transitionGBUpdateIndices, transitionGBClearIndices, -1, lastGroup));
     }
 
+    private NFAStateTransition createNoCGTransition(NFAState source, NFAState target, CodePointSet codePointSet) {
+        return new NFAStateTransition((short) transitionID.inc(), source, target, codePointSet, GroupBoundaries.getEmptyInstance(ast.getLanguage()));
+    }
+
     private NFAState registerMatcherState(StateSet<RegexAST, CharacterClass> stateSetCC,
                     StateSet<RegexAST, LookBehindAssertion> finishedLookBehinds,
                     boolean containsPrefixStates,

regex/src/com.oracle.truffle.regex/src/com/oracle/truffle/regex/tregex/parser/ast/RegexAST.java

@@ -392,7 +392,7 @@ public AtomicGroup createAtomicGroup() {
     }
 
     public void createNFAHelperNodes(RegexASTSubtreeRootNode rootNode) {
-        nodeCount.inc(4);
+        nodeCount.inc(5);
         PositionAssertion anchored = new PositionAssertion(PositionAssertion.Type.CARET);
         rootNode.setAnchoredInitialState(anchored);
         MatchFound unAnchored = new MatchFound();
@@ -401,6 +401,8 @@ public void createNFAHelperNodes(RegexASTSubtreeRootNode rootNode) {
         rootNode.setMatchFound(end);
         PositionAssertion anchoredEnd = new PositionAssertion(PositionAssertion.Type.DOLLAR);
         rootNode.setAnchoredFinalState(anchoredEnd);
+        MatchFound endChecked = new MatchFound();
+        rootNode.setMatchFoundChecked(endChecked);
     }
 
     public PositionAssertion createPositionAssertion(PositionAssertion.Type type) {

regex/src/com.oracle.truffle.regex/src/com/oracle/truffle/regex/tregex/parser/ast/RegexASTSubtreeRootNode.java

@@ -61,6 +61,7 @@ public abstract class RegexASTSubtreeRootNode extends Term implements RegexASTVi
     private MatchFound unAnchoredInitialState;
     private PositionAssertion anchoredFinalState;
     private MatchFound matchFound;
+    private MatchFound matchFoundChecked;
     private boolean visitorGroupVisited = false;
 
     private final SubTreeIndex subtrees = new SubTreeIndex();
@@ -230,4 +231,13 @@ public String toString() {
     protected JsonObject toJson(String typeName) {
         return super.toJson(typeName).append(Json.prop("group", astNodeId(group)));
     }
+
+    public void setMatchFoundChecked(MatchFound matchFoundChecked) {
+        this.matchFoundChecked = matchFoundChecked;
+    }
+
+    public MatchFound getMatchFoundChecked() {
+        assert matchFoundChecked != null;
+        return matchFoundChecked;
+    }
 }

regex/src/com.oracle.truffle.regex/src/com/oracle/truffle/regex/tregex/parser/ast/visitors/InitIDVisitor.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2018, 2022, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2018, 2024, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * The Universal Permissive License (UPL), Version 1.0
@@ -121,6 +121,7 @@ protected void leave(Group group) {
         if (group.getParent() instanceof RegexASTSubtreeRootNode) {
             initID(group.getSubTreeParent().getAnchoredFinalState());
             initID(group.getSubTreeParent().getMatchFound());
+            initID(group.getSubTreeParent().getMatchFoundChecked());
         }
     }