[GR-19220] Fix encoding related error messages for CRuby 3.2 (#3107)

eregon · eregon · commit 6554576c5900 · 2023-07-28T13:14:37.000Z
PullRequest: truffleruby/3886
diff --git a/spec/ruby/core/string/index_spec.rb b/spec/ruby/core/string/index_spec.rb
@@ -167,6 +167,13 @@
   it "handles a substring in a subset encoding" do
     'été'.index('t'.force_encoding(Encoding::US_ASCII)).should == 1
   end
+
+  it "raises an Encoding::CompatibilityError if the encodings are incompatible" do
+    str = 'abc'.force_encoding("ISO-2022-JP")
+    pattern = 'b'.force_encoding("EUC-JP")
+
+    -> { str.index(pattern) }.should raise_error(Encoding::CompatibilityError, "incompatible character encodings: ISO-2022-JP and EUC-JP")
+  end
 end
 
 describe "String#index with Regexp" do
@@ -312,6 +319,17 @@
     "われわわれ".index(/わ/, 3).should == 3
   end
 
+  ruby_bug "#19763", ""..."3.3.0" do
+    it "raises an Encoding::CompatibilityError if the encodings are incompatible" do
+      re = Regexp.new "れ".encode(Encoding::EUC_JP)
+      -> do
+        "あれ".index re
+      end.should raise_error(Encoding::CompatibilityError, "incompatible encoding regexp match (EUC-JP regexp with UTF-8 string)")
+    end
+  end
+
+  # The exception message was incorrectly "incompatible character encodings: UTF-8 and EUC-JP" before 3.3.0
+  # Still test that the right exception class is used before that.
   it "raises an Encoding::CompatibilityError if the encodings are incompatible" do
     re = Regexp.new "れ".encode(Encoding::EUC_JP)
     -> do
diff --git a/spec/ruby/core/string/rindex_spec.rb b/spec/ruby/core/string/rindex_spec.rb
@@ -204,6 +204,13 @@ def obj.method_missing(*args) 5 end
   it "handles a substring in a subset encoding" do
     'été'.rindex('t'.force_encoding(Encoding::US_ASCII)).should == 1
   end
+
+  it "raises an Encoding::CompatibilityError if the encodings are incompatible" do
+    str = 'abc'.force_encoding("ISO-2022-JP")
+    pattern = 'b'.force_encoding("EUC-JP")
+
+    -> { str.rindex(pattern) }.should raise_error(Encoding::CompatibilityError, "incompatible character encodings: ISO-2022-JP and EUC-JP")
+  end
 end
 
 describe "String#rindex with Regexp" do
@@ -373,6 +380,6 @@ def obj.method_missing(*args); 5; end
     re = Regexp.new "れ".encode(Encoding::EUC_JP)
     -> do
       "あれ".rindex re
-    end.should raise_error(Encoding::CompatibilityError)
+    end.should raise_error(Encoding::CompatibilityError, "incompatible encoding regexp match (EUC-JP regexp with UTF-8 string)")
   end
 end
diff --git a/spec/ruby/core/string/upto_spec.rb b/spec/ruby/core/string/upto_spec.rb
@@ -80,6 +80,12 @@ def other.to_str() "abd" end
     a.should == ["Σ", "Τ", "Υ", "Φ", "Χ", "Ψ", "Ω"]
   end
 
+  it "raises Encoding::CompatibilityError when incompatible characters are given" do
+    char1 = 'a'.force_encoding("EUC-JP")
+    char2 = 'b'.force_encoding("ISO-2022-JP")
+    -> { char1.upto(char2) {} }.should raise_error(Encoding::CompatibilityError, "incompatible character encodings: EUC-JP and ISO-2022-JP")
+  end
+
   describe "on sequence of numbers" do
     it "calls the block as Integer#upto"  do
       "8".upto("11").to_a.should == 8.upto(11).map(&:to_s)
diff --git a/spec/tags/core/string/byteindex_tags.txt b/spec/tags/core/string/byteindex_tags.txt
diff --git a/spec/tags/core/string/byterindex_tags.txt b/spec/tags/core/string/byterindex_tags.txt
diff --git a/src/main/java/org/truffleruby/core/regexp/TruffleRegexpNodes.java b/src/main/java/org/truffleruby/core/regexp/TruffleRegexpNodes.java
@@ -109,15 +109,28 @@ private static void instrumentMatch(ConcurrentHashMap<MatchInfo, AtomicInteger>
         }
     }
 
+    @Primitive(name = "regexp_check_encoding")
+    public abstract static class RegexpCheckEncodingNode extends PrimitiveArrayArgumentsNode {
+        @Specialization
+        protected static RubyEncoding regexpPrepareEncoding(RubyRegexp regexp, Object string,
+                @Cached PrepareRegexpEncodingNode prepareRegexpEncodingNode,
+                @Bind("this") Node node) {
+            return prepareRegexpEncodingNode.executePrepare(node, regexp, string);
+
+        }
+    }
+
     // MRI: rb_reg_prepare_enc
+    @GenerateCached(false)
+    @GenerateInline
     public abstract static class PrepareRegexpEncodingNode extends RubyBaseNode {
 
-        public abstract RubyEncoding executePrepare(RubyRegexp regexp, Object matchString);
+        public abstract RubyEncoding executePrepare(Node node, RubyRegexp regexp, Object matchString);
 
         @Specialization(guards = "stringLibrary.isRubyString(matchString)", limit = "1")
-        protected static RubyEncoding regexpPrepareEncoding(RubyRegexp regexp, Object matchString,
+        protected static RubyEncoding regexpPrepareEncoding(Node node, RubyRegexp regexp, Object matchString,
                 @Cached RubyStringLibrary stringLibrary,
-                @Cached TruffleString.GetByteCodeRangeNode codeRangeNode,
+                @Cached(inline = false) TruffleString.GetByteCodeRangeNode codeRangeNode,
                 @Cached InlinedBranchProfile asciiOnlyProfile,
                 @Cached InlinedBranchProfile asciiIncompatibleFixedRegexpEncodingProfile,
                 @Cached InlinedBranchProfile asciiIncompatibleMatchStringEncodingProfile,
@@ -129,8 +142,7 @@ protected static RubyEncoding regexpPrepareEncoding(RubyRegexp regexp, Object ma
                 @Cached InlinedBranchProfile sameEncodingProfile,
                 @Cached InlinedBranchProfile validBinaryMatchStringProfile,
                 @Cached InlinedBranchProfile validUtf8MatchStringProfile,
-                @Cached LazyWarnNode lazyWarnNode,
-                @Bind("this") Node node) {
+                @Cached LazyWarnNode lazyWarnNode) {
             final RubyEncoding regexpEncoding = regexp.encoding;
             final RubyEncoding matchStringEncoding = stringLibrary.getEncoding(matchString);
             var tstring = stringLibrary.getTString(matchString);
@@ -801,7 +813,7 @@ protected static Object matchInRegion(
                 @Cached RubyStringLibrary libString,
                 @Bind("this") Node node) {
             Regex regex = regexp.regex;
-            final RubyEncoding negotiatedEncoding = prepareRegexpEncodingNode.executePrepare(regexp, string);
+            final RubyEncoding negotiatedEncoding = prepareRegexpEncodingNode.executePrepare(node, regexp, string);
 
             if (encodingMismatchProfile.profile(node, regexp.encoding != negotiatedEncoding)) {
                 final EncodingCache encodingCache = regexp.cachedEncodings;
@@ -898,7 +910,7 @@ protected static Object matchInRegionTRegex(
                 @Cached LazyTruffleStringSubstringByteIndexNode substringByteIndexNode,
                 @Bind("this") Node node) {
             final Object tRegex;
-            final RubyEncoding negotiatedEncoding = prepareRegexpEncodingNode.executePrepare(regexp, string);
+            final RubyEncoding negotiatedEncoding = prepareRegexpEncodingNode.executePrepare(node, regexp, string);
             var tstring = switchEncodingNode.execute(libString.getTString(string), negotiatedEncoding.tencoding);
             final int byteLength = tstring.byteLength(negotiatedEncoding.tencoding);
 
diff --git a/src/main/ruby/truffleruby/core/string.rb b/src/main/ruby/truffleruby/core/string.rb
@@ -617,6 +617,8 @@ def upto(stop, exclusive = false)
       end
     else
       unless stop.size < size
+        Primitive.encoding_ensure_compatible(self.encoding, stop.encoding)
+
         after_stop = exclusive ? stop : stop.succ
         current = self
 
@@ -1071,7 +1073,7 @@ def index(str, start = undefined)
     end
 
     if Primitive.is_a?(str, Regexp)
-      Primitive.encoding_ensure_compatible self, str
+      Primitive.regexp_check_encoding(str, self)
 
       start = Primitive.character_index_to_byte_index(self, start)
       if match = Truffle::RegexpOperations.match_from(str, self, start)
@@ -1115,7 +1117,7 @@ def rindex(sub, finish = undefined)
     byte_finish = Primitive.character_index_to_byte_index(self, finish)
 
     if Primitive.is_a?(sub, Regexp)
-      Primitive.encoding_ensure_compatible self, sub
+      Primitive.regexp_check_encoding(sub, self)
 
       match_data = Truffle::RegexpOperations.search_region(sub, self, 0, byte_finish, false, true)
       Primitive.regexp_last_match_set(Primitive.caller_special_variables, match_data)
@@ -1159,7 +1161,7 @@ def byteindex(str, start = 0)
     end
 
     if is_regex_pattern
-      Primitive.encoding_ensure_compatible(self, str)
+      Primitive.regexp_check_encoding(str, self)
 
       match = Truffle::RegexpOperations.match_from(str, self, start)
       Primitive.regexp_last_match_set(Primitive.caller_special_variables, match)
@@ -1186,7 +1188,7 @@ def byterindex(str, finish = bytesize)
     end
 
     if Primitive.is_a?(str, Regexp)
-      Primitive.encoding_ensure_compatible(self, str)
+      Primitive.regexp_check_encoding(str, self)
 
       match = Truffle::RegexpOperations.search_region(str, self, 0, finish, false, true)
       Primitive.regexp_last_match_set(Primitive.caller_special_variables, match)
