Turn RegexpOperations.match_in_region into multiple simpler Primitives

eregon · eregon · commit 2409d9712a01 · 2025-05-15T16:34:56.000+02:00
diff --git a/lib/truffle/strscan.rb b/lib/truffle/strscan.rb
@@ -386,7 +386,11 @@ def peep(len)
       md = scan_internal_string_pattern(pattern, only_match_at_start)
     else
       start = @fixed_anchor ? 0 : @pos
-      md = Truffle::RegexpOperations.match_in_region pattern, @string, @pos, @string.bytesize, only_match_at_start, start
+      if only_match_at_start
+        md = Primitive.regexp_match_at_start(pattern, @string, @pos, start)
+      else
+        md = Primitive.regexp_search_with_start(pattern, @string, @pos, start)
+      end
     end
 
     if md
diff --git a/spec/truffle/splitting_spec.rb b/spec/truffle/splitting_spec.rb
@@ -35,8 +35,6 @@
   Regexp.instance_method(:match?),
   Truffle::RegexpOperations.method(:match),
   Truffle::RegexpOperations.method(:match?),
-  Truffle::RegexpOperations.method(:search_region),
-  Truffle::RegexpOperations.method(:match_in_region),
 
   String.instance_method(:[]),
   Truffle::StringOperations.method(:subpattern),
diff --git a/src/main/java/org/truffleruby/core/regexp/TruffleRegexpNodes.java b/src/main/java/org/truffleruby/core/regexp/TruffleRegexpNodes.java
@@ -782,17 +782,62 @@ private <K, V> void buildAndSetDistributionHash(HashStoreLibrary hashStoreLibrar
         }
     }
 
-    @Primitive(name = "regexp_match_in_region", lowerFixnum = { 2, 3, 5 })
-    public abstract static class MatchInRegionNode extends PrimitiveArrayArgumentsNode {
+    @Primitive(name = "regexp_search", lowerFixnum = 2)
+    public abstract static class RegexpSearchNode extends PrimitiveArrayArgumentsNode {
+        @Specialization
+        Object match(RubyRegexp regexp, Object string, int from,
+                @Cached RubyStringLibrary libString,
+                @Cached MatchInRegionNode matchInRegionNode) {
+            int to = libString.byteLength(this, string);
+            return matchInRegionNode.execute(regexp, string, from, to, false, 0, true);
+        }
+    }
 
-        @NeverDefault
-        public static MatchInRegionNode create() {
-            return TruffleRegexpNodesFactory.MatchInRegionNodeFactory.create(null);
+    @Primitive(name = "regexp_search?", lowerFixnum = 2)
+    public abstract static class RegexpSearchPredicateNode extends PrimitiveArrayArgumentsNode {
+        @Specialization
+        boolean match(RubyRegexp regexp, Object string, int from,
+                @Cached RubyStringLibrary libString,
+                @Cached MatchInRegionNode matchInRegionNode) {
+            int to = libString.byteLength(this, string);
+            return (boolean) matchInRegionNode.execute(regexp, string, from, to, false, 0, false);
+        }
+    }
+
+    @Primitive(name = "regexp_search_backward", lowerFixnum = 2)
+    public abstract static class RegexpSearchBackwardNode extends PrimitiveArrayArgumentsNode {
+        @Specialization
+        Object match(RubyRegexp regexp, Object string, int end,
+                @Cached MatchInRegionNode matchInRegionNode) {
+            return matchInRegionNode.execute(regexp, string, end, 0, false, 0, true);
+        }
+    }
+
+    @Primitive(name = "regexp_search_with_start", lowerFixnum = { 2, 3 }, isPublic = true)
+    public abstract static class RegexpSearchWithStartNode extends PrimitiveArrayArgumentsNode {
+        @Specialization
+        Object match(RubyRegexp regexp, Object string, int from, int start,
+                @Cached RubyStringLibrary libString,
+                @Cached MatchInRegionNode matchInRegionNode) {
+            int to = libString.byteLength(this, string);
+            return matchInRegionNode.execute(regexp, string, from, to, false, start, true);
         }
+    }
 
-        public abstract Object executeMatchInRegion(RubyRegexp regexp, Object string, int from, int to,
-                boolean onlyMatchAtStart, int start, boolean createMatchData);
+    @Primitive(name = "regexp_match_at_start", lowerFixnum = { 2, 3 }, isPublic = true)
+    public abstract static class RegexpMatchAtStartNode extends PrimitiveArrayArgumentsNode {
+        @Specialization
+        Object match(RubyRegexp regexp, Object string, int from, int start,
+                @Cached RubyStringLibrary libString,
+                @Cached MatchInRegionNode matchInRegionNode) {
+            int to = libString.byteLength(this, string);
+            return matchInRegionNode.execute(regexp, string, from, to, true, start, true);
+        }
+    }
 
+    /** This node has many complicated arguments, so instead of exposing it as a Primitive we expose multiple simpler
+     * Primitives. */
+    public abstract static class MatchInRegionNode extends RubyBaseNode {
         /** Matches a regular expression against a string over the specified range of characters.
          *
          * @param regexp The regexp to match
@@ -806,12 +851,56 @@ public abstract Object executeMatchInRegion(RubyRegexp regexp, Object string, in
          * @param onlyMatchAtStart Whether to only match at the beginning of the string, if false then the regexp can
          *            have any amount of prematch.
          *
-         * @param start The position within the string which the matcher should consider the start. Setting this to the
-         *            from position allows scanners to match starting part-way through a string while still setting
-         *            onlyMatchAtStart and thus forcing the match to be at the specific starting position.
+         * @param start The position within the string which the matcher should consider the "start" for \A, ^ and
+         *            onlyMatchAtStart. It is functionally equivalent to matching against a substring of string starting
+         *            at start, but also returning the correct offsets in the MatchData. The value can only be 0 or
+         *            equal to from. Setting this to the from position allows StringScanner to match starting part-way
+         *            through a string while still setting onlyMatchAtStart and thus forcing the match to start at the
+         *            specific starting position.
          *
          * @param createMatchData Whether to create a Ruby `MatchData` object with the results of the match or return a
          *            simple Boolean value indicating a successful match (true: match; false: mismatch). */
+        public abstract Object execute(RubyRegexp regexp, Object string, int from, int to, boolean onlyMatchAtStart,
+                int start, boolean createMatchData);
+
+        @Specialization
+        Object match(
+                RubyRegexp regexp,
+                Object string,
+                int from,
+                int to,
+                boolean onlyMatchAtStart,
+                int start,
+                boolean createMatchData,
+                @Cached LazyMatchInRegionJoniNode matchInRegionJoniNode,
+                @Cached MatchInRegionTRegexNode matchInRegionTRegexNode,
+                @Cached LazyDispatchNode callCompareEngines) {
+            if (getContext().getOptions().COMPARE_REGEX_ENGINES) {
+                return callCompareEngines.get(this).call(coreLibrary().truffleRegexpOperationsModule,
+                        "match_in_region_compare_engines",
+                        new Object[]{ regexp, string, from, to, onlyMatchAtStart, start, createMatchData });
+            } else if (getContext().getOptions().USE_TRUFFLE_REGEX) {
+                return matchInRegionTRegexNode.execute(regexp, string, from, to, onlyMatchAtStart, start,
+                        createMatchData);
+            } else {
+                return matchInRegionJoniNode.get(this).execute(regexp, string, from, to, onlyMatchAtStart, start,
+                        createMatchData);
+            }
+        }
+    }
+
+    @Primitive(name = "regexp_match_in_region_joni", lowerFixnum = { 2, 3, 5 })
+    public abstract static class MatchInRegionJoniNode extends PrimitiveArrayArgumentsNode {
+
+        @NeverDefault
+        public static MatchInRegionJoniNode create() {
+            return TruffleRegexpNodesFactory.MatchInRegionJoniNodeFactory.create(null);
+        }
+
+        public abstract Object execute(RubyRegexp regexp, Object string, int from, int to, boolean onlyMatchAtStart,
+                int start, boolean createMatchData);
+
+        /** See {@link MatchInRegionNode#match} for parameters documentation */
         @Specialization
         static Object matchInRegion(
                 RubyRegexp regexp,
@@ -862,17 +951,17 @@ static Object matchInRegion(
 
     @GenerateCached(false)
     @GenerateInline
-    public abstract static class LazyMatchInRegionNode extends RubyBaseNode {
+    public abstract static class LazyMatchInRegionJoniNode extends RubyBaseNode {
 
-        public final MatchInRegionNode get(Node node) {
+        public final MatchInRegionJoniNode get(Node node) {
             return execute(node);
         }
 
-        protected abstract MatchInRegionNode execute(Node node);
+        protected abstract MatchInRegionJoniNode execute(Node node);
 
         @Specialization
-        static MatchInRegionNode doLazy(
-                @Cached(inline = false) MatchInRegionNode matchInRegionNode) {
+        static MatchInRegionJoniNode doLazy(
+                @Cached(inline = false) MatchInRegionJoniNode matchInRegionNode) {
             return matchInRegionNode;
         }
     }
@@ -897,8 +986,15 @@ static TruffleString.SubstringByteIndexNode doLazy(
     @Primitive(name = "regexp_match_in_region_tregex", lowerFixnum = { 2, 3, 5 })
     public abstract static class MatchInRegionTRegexNode extends PrimitiveArrayArgumentsNode {
 
+        @NeverDefault
+        public static MatchInRegionTRegexNode create() {
+            return TruffleRegexpNodesFactory.MatchInRegionTRegexNodeFactory.create(null);
+        }
+
+        public abstract Object execute(RubyRegexp regexp, Object string, int from, int to, boolean onlyMatchAtStart,
+                int start, boolean createMatchData);
 
-        /** See {@link MatchInRegionNode#matchInRegion} for parameters documentation */
+        /** See {@link MatchInRegionNode#match} for parameters documentation */
         @Specialization
         static Object matchInRegionTRegex(
                 RubyRegexp regexp,
@@ -925,7 +1021,7 @@ static Object matchInRegionTRegex(
                 @Cached LazyDispatchNode warnOnFallbackNode,
                 @Cached LazyDispatchNode stringDupNode,
                 @Cached TranslateInteropExceptionNode translateInteropExceptionNode,
-                @Cached LazyMatchInRegionNode fallbackMatchInRegionNode,
+                @Cached LazyMatchInRegionJoniNode fallbackMatchInRegionJoniNode,
                 @Cached LazyTruffleStringSubstringByteIndexNode substringByteIndexNode,
                 @Cached InlinedConditionProfile nonZeroStart,
                 @Cached FixupMatchDataStartNode fixupMatchDataStartNode,
@@ -953,7 +1049,7 @@ static Object matchInRegionTRegex(
                         start,
                         createMatchData,
                         warnOnFallbackNode,
-                        fallbackMatchInRegionNode.get(node));
+                        fallbackMatchInRegionJoniNode.get(node));
             }
 
             if (getContext(node).getOptions().REGEXP_INSTRUMENT_MATCH) {
@@ -1013,8 +1109,8 @@ static Object matchInRegionTRegex(
                         profileAndReportLoopCount(node, loopProfile, groupCount);
                     }
 
-                    var matchData = createMatchData(node, regexp, dupString(string, stringDupNode.get(node)), region,
-                            result);
+                    var dupedString = stringDupNode.get(node).call(string, "dup");
+                    var matchData = createMatchData(node, regexp, dupedString, region, result);
                     if (nonZeroStart.profile(node, start != 0)) {
                         fixupMatchDataStartNode.execute(node, matchData, start);
                     }
@@ -1029,7 +1125,7 @@ static Object matchInRegionTRegex(
 
         private static Object fallbackToJoni(Node node, RubyRegexp regexp, Object string, RubyEncoding encoding,
                 int from, int to, boolean onlyMatchAtStart, int start, boolean createMatchData,
-                LazyDispatchNode warnOnFallbackNode, MatchInRegionNode fallbackMatchInRegionNode) {
+                LazyDispatchNode warnOnFallbackNode, MatchInRegionJoniNode fallbackMatchInRegionJoniNode) {
             if (getContext(node).getOptions().WARN_TRUFFLE_REGEX_MATCH_FALLBACK) {
 
                 warnOnFallbackNode.get(node).call(
@@ -1045,8 +1141,8 @@ private static Object fallbackToJoni(Node node, RubyRegexp regexp, Object string
                                 start });
             }
 
-            return fallbackMatchInRegionNode
-                    .executeMatchInRegion(regexp, string, from, to, onlyMatchAtStart, start, createMatchData);
+            return fallbackMatchInRegionJoniNode
+                    .execute(regexp, string, from, to, onlyMatchAtStart, start, createMatchData);
         }
 
         private static RubyMatchData createMatchData(Node node, RubyRegexp regexp, Object string, MultiRegion region,
@@ -1062,9 +1158,6 @@ private static RubyMatchData createMatchData(Node node, RubyRegexp regexp, Objec
             return matchData;
         }
 
-        private static Object dupString(Object string, DispatchNode stringDupNode) {
-            return stringDupNode.call(string, "dup");
-        }
     }
 
     @CoreMethod(names = "linear_time?", onSingleton = true, required = 1)
@@ -1091,15 +1184,12 @@ Object isLinearTime(RubyRegexp regexp,
 
     public abstract static class MatchNode extends RubyBaseNode {
 
-        @Child private DispatchNode dupNode = DispatchNode.create();
-
         public abstract Object execute(RubyRegexp regexp, Object string, Matcher matcher,
                 int from, int to, boolean onlyMatchAtStart, int start, boolean createMatchData);
 
         // Creating a MatchData will store a copy of the source string. It's tempting to use a rope here, but a bit
         // inconvenient because we can't work with ropes directly in Ruby and some MatchData methods are nicely
-        // implemented using the source string data. Likewise, we need to taint objects based on the source string's
-        // taint state. We mustn't allow the source string's contents to change, however, so we must ensure that we have
+        // implemented using the source string data. We mustn't allow the source string's contents to change, however, so we must ensure that we have
         // a private copy of that string. Since the source string would otherwise be a reference to string held outside
         // the MatchData object, it would be possible for the source string to be modified externally.
         //
@@ -1117,6 +1207,7 @@ Object match(
                 boolean onlyMatchAtStart,
                 int start,
                 boolean createMatchData,
+                @Cached LazyDispatchNode stringDupNode,
                 @Cached InlinedConditionProfile createMatchDataProfile,
                 @Cached InlinedConditionProfile mismatchProfile,
                 @Cached InlinedConditionProfile nonZeroStart,
@@ -1142,7 +1233,7 @@ Object match(
                 final MultiRegion region = getMatcherEagerRegion(matcher);
                 assert assertValidRegion(region);
 
-                final RubyString dupedString = (RubyString) dupNode.call(string, "dup");
+                var dupedString = stringDupNode.get(this).call(string, "dup");
                 RubyMatchData result = new RubyMatchData(
                         coreLibrary().matchDataClass,
                         getLanguage().matchDataShape,
diff --git a/src/main/ruby/truffleruby/core/string.rb b/src/main/ruby/truffleruby/core/string.rb
@@ -149,7 +149,7 @@ def self.try_convert(obj)
   def =~(pattern)
     case pattern
     when Regexp
-      match_data = Truffle::RegexpOperations.search_region(pattern, self, 0, bytesize, true, true)
+      match_data = Primitive.regexp_search(pattern, self, 0)
       Primitive.regexp_last_match_set(Primitive.caller_special_variables, match_data)
       return match_data.begin(0) if match_data
     when String
@@ -280,7 +280,7 @@ def partition(pattern = nil)
 
   def rpartition(pattern)
     if Primitive.is_a?(pattern, Regexp)
-      if m = Truffle::RegexpOperations.search_region(pattern, self, 0, bytesize, false, true)
+      if m = Primitive.regexp_search_backward(pattern, self, bytesize)
         Primitive.regexp_last_match_set(Primitive.caller_special_variables, m)
         return [m.pre_match, m[0], m.post_match]
       end
@@ -1153,7 +1153,7 @@ def rindex(sub, finish = undefined)
     if Primitive.is_a?(sub, Regexp)
       Primitive.regexp_check_encoding(sub, self)
 
-      match_data = Truffle::RegexpOperations.search_region(sub, self, 0, byte_finish, false, true)
+      match_data = Primitive.regexp_search_backward(sub, self, byte_finish)
       Primitive.regexp_last_match_set(Primitive.caller_special_variables, match_data)
       return match_data.begin(0) if match_data
 
@@ -1224,7 +1224,7 @@ def byterindex(str, finish = bytesize)
     if Primitive.is_a?(str, Regexp)
       Primitive.regexp_check_encoding(str, self)
 
-      match = Truffle::RegexpOperations.search_region(str, self, 0, finish, false, true)
+      match = Primitive.regexp_search_backward(str, self, finish)
       Primitive.regexp_last_match_set(Primitive.caller_special_variables, match)
       return match ? Primitive.match_data_byte_begin(match, 0) : nil
     end
@@ -1253,7 +1253,7 @@ def start_with?(*prefixes)
     prefixes.each do |original_prefix|
       case original_prefix
       when Regexp
-        match_data = Truffle::RegexpOperations.match_in_region(original_prefix, self, 0, bytesize, true, 0)
+        match_data = Primitive.regexp_match_at_start(original_prefix, self, 0, 0)
         Primitive.regexp_last_match_set(storage, match_data)
         return true if match_data
       else
diff --git a/src/main/ruby/truffleruby/core/symbol.rb b/src/main/ruby/truffleruby/core/symbol.rb
@@ -95,7 +95,7 @@ def =~(pattern)
 
     case pattern
     when Regexp
-      match_data = Truffle::RegexpOperations.search_region(pattern, str, 0, str.bytesize, true, true)
+      match_data = Primitive.regexp_search(pattern, str, 0)
       Primitive.regexp_last_match_set(Primitive.caller_special_variables, match_data)
       Primitive.match_data_byte_begin(match_data, 0) if match_data
     when String
@@ -146,7 +146,7 @@ def [](index, other = undefined)
       end
 
       str = to_s
-      match_data = Truffle::RegexpOperations.search_region(index, str, 0, str.bytesize, true, true)
+      match_data = Primitive.regexp_search(index, str, 0)
       Primitive.regexp_last_match_set(Primitive.caller_special_variables, match_data)
       if match_data
         result = match_data.to_s
diff --git a/src/main/ruby/truffleruby/core/truffle/regexp_operations.rb b/src/main/ruby/truffleruby/core/truffle/regexp_operations.rb
diff --git a/src/main/ruby/truffleruby/core/truffle/string_operations.rb b/src/main/ruby/truffleruby/core/truffle/string_operations.rb
