[GR-45621] Add Regex.linear_time? method

PullRequest: truffleruby/4209

Author: andrykonchin

CHANGELOG.md

@@ -10,9 +10,9 @@ Bug fixes:
 
 Compatibility:
 * Move `IO#wait_readable`, `IO#wait_writable`, `IO#wait_priority` and `IO#wait` into core library (@andrykonchin).
-
 * Change assignment evaluation order for fully qualified constant and evaluate left-hand-side before right-hand-side (#3039, @andrykonchin).
 * Fix evaluation order for multi-assignment and evaluate left-hand-side before right-hand-side (@andrykonchin).
+* Add `Regexp.linear_time?` method (#3039, @andrykonchin).
 
 Performance:
 

spec/tags/core/regexp/linear_time_tags.txt

@@ -30,7 +30,6 @@
 import com.oracle.truffle.api.dsl.GenerateInline;
 import com.oracle.truffle.api.dsl.ImportStatic;
 import com.oracle.truffle.api.dsl.NeverDefault;
-import com.oracle.truffle.api.interop.InteropException;
 import com.oracle.truffle.api.interop.InteropLibrary;
 import com.oracle.truffle.api.library.CachedLibrary;
 import com.oracle.truffle.api.profiles.InlinedBranchProfile;
@@ -68,6 +67,7 @@
 import org.truffleruby.core.string.StringNodes.StringAppendPrimitiveNode;
 import org.truffleruby.core.string.StringOperations;
 import org.truffleruby.core.string.StringUtils;
+import org.truffleruby.interop.InteropNodes;
 import org.truffleruby.interop.TranslateInteropExceptionNode;
 import org.truffleruby.language.LazyWarnNode;
 import org.truffleruby.language.RubyBaseNode;
@@ -965,16 +965,18 @@ static Object matchInRegionTRegex(
                 tstringToMatch = tstring;
                 execMethod = "execBoolean";
             }
-            final Object result = invoke(node, regexInterop, tRegex, execMethod, translateInteropExceptionNode,
-                    tstringToMatch, fromIndex);
+
+            final Object[] arguments = new Object[]{ tstringToMatch, fromIndex };
+            final Object result = InteropNodes.invokeMember(node, regexInterop, tRegex, execMethod, arguments,
+                    translateInteropExceptionNode);
 
             if (createMatchDataProfile.profile(node, createMatchData)) {
-                final boolean isMatch = (boolean) readMember(node, resultInterop, result, "isMatch",
+                final boolean isMatch = (boolean) InteropNodes.readMember(node, resultInterop, result, "isMatch",
                         translateInteropExceptionNode);
 
                 if (matchFoundProfile.profile(node, isMatch)) {
                     final int groupCount = groupCountProfile
-                            .profile(node, (int) readMember(node, regexInterop, tRegex, "groupCount",
+                            .profile(node, (int) InteropNodes.readMember(node, regexInterop, tRegex, "groupCount",
                                     translateInteropExceptionNode));
                     final Region region = new Region(groupCount);
 
@@ -1033,26 +1035,30 @@ private static Object createMatchData(Node node, RubyRegexp regexp, Object strin
             return matchData;
         }
 
-        private static Object readMember(Node node, InteropLibrary interop, Object receiver, String name,
-                TranslateInteropExceptionNode translateInteropExceptionNode) {
-            try {
-                return interop.readMember(receiver, name);
-            } catch (InteropException e) {
-                throw translateInteropExceptionNode.execute(node, e);
-            }
+        private static Object dupString(Object string, DispatchNode stringDupNode) {
+            return stringDupNode.call(string, "dup");
         }
+    }
 
-        private static Object invoke(Node node, InteropLibrary interop, Object receiver, String member,
-                TranslateInteropExceptionNode translateInteropExceptionNode, Object... args) {
-            try {
-                return interop.invokeMember(receiver, member, args);
-            } catch (InteropException e) {
-                throw translateInteropExceptionNode.executeInInvokeMember(node, e, receiver, args);
+    @CoreMethod(names = "linear_time?", onSingleton = true, required = 1)
+    public abstract static class IsLinearTimeNode extends CoreMethodArrayArgumentsNode {
+
+        @Specialization
+        Object isLinearTime(RubyRegexp regexp,
+                @Cached InlinedConditionProfile tRegexCouldNotCompileProfile,
+                @Cached TRegexCompileNode tRegexCompileNode,
+                @CachedLibrary(limit = "getInteropCacheLimit()") InteropLibrary regexInterop,
+                @Cached TranslateInteropExceptionNode translateInteropExceptionNode,
+                @Bind("this") Node node) {
+            final Object compiledRegex = tRegexCompileNode.executeTRegexCompile(regexp, false, regexp.encoding);
+
+            if (tRegexCouldNotCompileProfile.profile(node, compiledRegex == nil)) {
+                return nil;
             }
-        }
 
-        private static Object dupString(Object string, DispatchNode stringDupNode) {
-            return stringDupNode.call(string, "dup");
+            boolean isBacktracking = (boolean) InteropNodes.readMember(node, regexInterop, compiledRegex,
+                    "isBacktracking", translateInteropExceptionNode);
+            return !isBacktracking;
         }
     }
 

src/main/java/org/truffleruby/core/regexp/TruffleRegexpNodes.java

@@ -98,6 +98,22 @@ def self.last_match(index = nil)
     end
   end
 
+  def self.linear_time?(regexp, options = undefined)
+    if Primitive.is_a?(regexp, Regexp)
+      unless Primitive.undefined?(options)
+        warn('flags ignored', uplevel: 1)
+      end
+    else
+      if Primitive.undefined?(options)
+        options = 0
+      end
+
+      regexp = Regexp.new(regexp, options) # expect String source to be passed
+    end
+
+    Truffle::RegexpOperations.linear_time?(regexp)
+  end
+
   def self.union(*patterns)
     case patterns.size
     when 0