Add Regex.linear_time? method

Author: andrykonchin

CHANGELOG.md

@@ -9,9 +9,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

@@ -1056,6 +1056,38 @@ private static Object dupString(Object string, DispatchNode stringDupNode) {
         }
     }
 
+    @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;
+            }
+
+            Object isBacktracking = readMember(node, regexInterop, compiledRegex, "isBacktracking",
+                    translateInteropExceptionNode);
+            return !(boolean) isBacktracking;
+        }
+
+        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);
+            }
+        }
+    }
+
+
     public abstract static class MatchNode extends RubyBaseNode {
 
         @Child private DispatchNode dupNode = DispatchNode.create();

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