encoding_conversion is always true for match_in_region and select_encoding

Author: eregon

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

@@ -16,7 +16,6 @@
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.atomic.AtomicInteger;
 
-import com.oracle.truffle.api.CompilerDirectives;
 import com.oracle.truffle.api.library.CachedLibrary;
 import com.oracle.truffle.api.profiles.BranchProfile;
 import com.oracle.truffle.api.source.Source;
@@ -240,28 +239,15 @@ public RubyRegexp createRegexp(Rope pattern) throws DeferredRaiseException {
         }
     }
 
-    @CoreMethod(names = "select_encoding", onSingleton = true, required = 3)
+    @CoreMethod(names = "select_encoding", onSingleton = true, required = 2)
     public abstract static class SelectEncodingNode extends CoreMethodArrayArgumentsNode {
 
-        @Child CheckEncodingNode checkEncodingNode;
-
         @Specialization(guards = "libString.isRubyString(str)")
-        protected RubyEncoding selectEncoding(RubyRegexp re, Object str, boolean encodingConversion,
+        protected RubyEncoding selectEncoding(RubyRegexp re, Object str,
                 @Cached EncodingNodes.GetRubyEncodingNode getRubyEncodingNode,
-                @Cached TruffleRegexpNodes.CheckEncodingNode checkEncodingNode,
+                @Cached CheckEncodingNode checkEncodingNode,
                 @CachedLibrary(limit = "2") RubyStringLibrary libString) {
-            Encoding encoding;
-            if (encodingConversion) {
-                if (checkEncodingNode == null) {
-                    CompilerDirectives.transferToInterpreterAndInvalidate();
-                    checkEncodingNode = insert(CheckEncodingNode.create());
-                }
-
-                encoding = checkEncodingNode.executeCheckEncoding(re, str);
-            } else {
-                encoding = re.regex.getEncoding();
-            }
-
+            final Encoding encoding = checkEncodingNode.executeCheckEncoding(re, str);
             return getRubyEncodingNode.executeGetRubyEncoding(encoding);
         }
     }
@@ -429,8 +415,8 @@ protected Object matchInRegion(
                 RubyRegexp regexp, Object string, int fromPos, int toPos, boolean atStart, int startPos,
                 @Cached ConditionProfile encodingMismatchProfile,
                 @Cached RopeNodes.BytesNode bytesNode,
-                @Cached TruffleRegexpNodes.MatchNode matchNode,
-                @Cached TruffleRegexpNodes.CheckEncodingNode checkEncodingNode,
+                @Cached MatchNode matchNode,
+                @Cached CheckEncodingNode checkEncodingNode,
                 @CachedLibrary(limit = "2") RubyStringLibrary libString) {
             final Rope rope = libString.getRope(string);
             final Encoding enc = checkEncodingNode.executeCheckEncoding(regexp, string);

src/main/ruby/truffleruby/core/truffle/regexp_operations.rb

@@ -31,15 +31,15 @@ def self.search_region(re, str, start_index, end_index, forward)
         from = end_index
         to = start_index
       end
-      match_in_region(re, str, from, to, false, true, 0)
+      match_in_region(re, str, from, to, false, 0)
     end
 
     # This path is used by some string and scanner methods and allows
     # for at_start to be specified on the matcher.  FIXME it might be
     # possible to refactor search region to offer the ability to
     # specify at start, we should investigate this at some point.
     def self.match_onwards(re, str, from, at_start)
-      md = match_in_region(re, str, from, str.bytesize, at_start, true, from)
+      md = match_in_region(re, str, from, str.bytesize, at_start, from)
       Primitive.matchdata_fixup_positions(md, from) if md
       md
     end
@@ -72,19 +72,19 @@ def self.match_from(re, str, pos)
       end
     end
 
-    def self.match_in_region(re, str, from, to, at_start, encoding_conversion, start)
+    def self.match_in_region(re, str, from, to, at_start, start)
       if COMPARE_ENGINES
-        match_in_region_compare_engines(re, str, from, to, at_start, encoding_conversion, start)
+        match_in_region_compare_engines(re, str, from, to, at_start, start)
       elsif USE_TRUFFLE_REGEX
-        match_in_region_tregex(re, str, from, to, at_start, encoding_conversion, start)
+        match_in_region_tregex(re, str, from, to, at_start, start)
       else
         Primitive.regexp_match_in_region(re, str, from, to, at_start, start)
       end
     end
 
-    def self.match_in_region_compare_engines(re, str, from, to, at_start, encoding_conversion, start)
+    def self.match_in_region_compare_engines(re, str, from, to, at_start, start)
       begin
-        md1 = match_in_region_tregex(re, str, from, to, at_start, encoding_conversion, start)
+        md1 = match_in_region_tregex(re, str, from, to, at_start, start)
       rescue => e
         md1 = e
       end
@@ -96,18 +96,18 @@ def self.match_in_region_compare_engines(re, str, from, to, at_start, encoding_c
       if self.results_match?(md1, md2)
         return self.return_match_data(md1)
       else
-        $stderr.puts "match_in_region(/#{re}/, \"#{str}\"@#{str.encoding}, #{from}, #{to}, #{at_start}, #{encoding_conversion}, #{start}) gate"
+        $stderr.puts "match_in_region(/#{re}/, \"#{str}\"@#{str.encoding}, #{from}, #{to}, #{at_start}, #{start}) gate"
         self.print_match_data(md1)
         $stderr.puts 'but we expected'
         self.print_match_data(md2)
         return self.return_match_data(md2)
       end
     end
 
-    def self.match_in_region_tregex(re, str, from, to, at_start, encoding_conversion, start)
+    def self.match_in_region_tregex(re, str, from, to, at_start, start)
       bail_out = to < from || to != str.bytesize || start != 0 || from < 0
       if !bail_out
-        compiled_regex = tregex_compile(re, at_start, select_encoding(re, str, encoding_conversion))
+        compiled_regex = tregex_compile(re, at_start, select_encoding(re, str))
         bail_out = compiled_regex.nil?
       end
       if !bail_out