Kernel#sprintf: fix %c - convert argument to String and Integer properly

Author: andrykonchin

spec/ruby/core/kernel/shared/sprintf.rb

@@ -301,6 +301,12 @@ def obj.to_i; 10; end
         }.should raise_error(ArgumentError, /%c requires a character/)
       end
 
+      it "raises TypeError if argument is not String or Integer and cannot be converted to them" do
+        -> {
+          @method.call("%c", [])
+        }.should raise_error(TypeError, /no implicit conversion of Array into Integer/)
+      end
+
       it "raises TypeError if argument is nil" do
         -> {
           @method.call("%c", nil)
@@ -315,6 +321,37 @@ def obj.to_str
 
         @method.call("%c", obj).should == "a"
       end
+
+      it "tries to convert argument to Integer with to_int" do
+        obj = BasicObject.new
+        def obj.to_int
+          90
+        end
+
+        @method.call("%c", obj).should == "Z"
+      end
+
+      it "raises TypeError if converting to String with to_str returns non-String" do
+        obj = BasicObject.new
+        def obj.to_str
+          :foo
+        end
+
+        -> {
+          @method.call("%c", obj)
+        }.should raise_error(TypeError, /can't convert BasicObject to String/)
+      end
+
+      it "raises TypeError if converting to Integer with to_int returns non-Integer" do
+        obj = BasicObject.new
+        def obj.to_str
+          :foo
+        end
+
+        -> {
+          @method.call("%c", obj)
+        }.should raise_error(TypeError, /can't convert BasicObject to String/)
+      end
     end
 
     describe "p" do

src/main/java/org/truffleruby/core/format/convert/ToStrNode.java

@@ -0,0 +1,68 @@
+/*
+ * Copyright (c) 2015, 2021 Oracle and/or its affiliates. All rights reserved. This
+ * code is released under a tri EPL/GPL/LGPL license. You can use it,
+ * redistribute it and/or modify it under the terms of the:
+ *
+ * Eclipse Public License version 2.0, or
+ * GNU General Public License version 2, or
+ * GNU Lesser General Public License version 2.1.
+ */
+package org.truffleruby.core.format.convert;
+
+import com.oracle.truffle.api.dsl.Cached;
+import com.oracle.truffle.api.profiles.BranchProfile;
+import org.truffleruby.core.format.FormatNode;
+import org.truffleruby.core.format.exceptions.NoImplicitConversionException;
+import org.truffleruby.core.string.ImmutableRubyString;
+import org.truffleruby.core.string.RubyString;
+import org.truffleruby.language.control.RaiseException;
+import org.truffleruby.language.dispatch.DispatchNode;
+
+import com.oracle.truffle.api.dsl.NodeChild;
+import com.oracle.truffle.api.dsl.Specialization;
+import org.truffleruby.language.library.RubyStringLibrary;
+
+@NodeChild("value")
+public abstract class ToStrNode extends FormatNode {
+
+    public abstract Object execute(Object object);
+
+    @Specialization
+    protected RubyString coerceRubyString(RubyString string) {
+        return string;
+    }
+
+    @Specialization
+    protected ImmutableRubyString coerceImmutableRubyString(ImmutableRubyString string) {
+        return string;
+    }
+
+    @Specialization(guards = "isNotRubyString(object)")
+    protected Object coerceObject(Object object,
+            @Cached BranchProfile errorProfile,
+            @Cached DispatchNode toStrNode,
+            @Cached RubyStringLibrary libString) {
+        final Object coerced;
+
+        try {
+            coerced = toStrNode.call(object, "to_str");
+        } catch (RaiseException e) {
+            errorProfile.enter();
+            if (e.getException().getLogicalClass() == coreLibrary().noMethodErrorClass) {
+                throw new NoImplicitConversionException(object, "String");
+            } else {
+                throw e;
+            }
+        }
+
+        if (libString.isRubyString(coerced)) {
+            return coerced;
+        } else {
+            errorProfile.enter();
+            throw new RaiseException(
+                    getContext(),
+                    coreExceptions().typeErrorBadCoercion(object, "String", "to_str", coerced, this));
+        }
+    }
+
+}

src/main/java/org/truffleruby/core/format/format/FormatCharacterNode.java

@@ -18,8 +18,8 @@
 import org.truffleruby.core.cast.ToIntNodeGen;
 import org.truffleruby.core.encoding.RubyEncoding;
 import org.truffleruby.core.format.FormatNode;
-import org.truffleruby.core.format.convert.ToStringNode;
-import org.truffleruby.core.format.convert.ToStringNodeGen;
+import org.truffleruby.core.format.convert.ToStrNode;
+import org.truffleruby.core.format.convert.ToStrNodeGen;
 import org.truffleruby.core.format.exceptions.NoImplicitConversionException;
 import org.truffleruby.core.string.RubyString;
 import org.truffleruby.language.RubyGuards;
@@ -38,7 +38,7 @@ public abstract class FormatCharacterNode extends FormatNode {
     private final RubyEncoding encoding;
 
     @Child private ToIntNode toIntegerNode;
-    @Child private ToStringNode toStringNode;
+    @Child private ToStrNode toStrNode;
     @Child private FromCodePointNode fromCodePointNode;
     @Child private CodePointLengthNode codePointLengthNode;
     @Child private ForceEncodingNode forceEncodingNode;
@@ -60,7 +60,7 @@ protected TruffleString getCharacter(Object value, RubyStringLibrary strings) {
 
         Object stringArgument;
         try {
-            stringArgument = toStringNode().executeToString(value);
+            stringArgument = toStrNode().execute(value);
         } catch (NoImplicitConversionException e) {
             stringArgument = null;
         }
@@ -93,13 +93,13 @@ protected TruffleString getCharacter(Object value, RubyStringLibrary strings) {
         return character;
     }
 
-    private ToStringNode toStringNode() {
-        if (toStringNode == null) {
+    private ToStrNode toStrNode() {
+        if (toStrNode == null) {
             CompilerDirectives.transferToInterpreterAndInvalidate();
-            toStringNode = insert(ToStringNodeGen.create(false, "to_str", false, null, null));
+            toStrNode = insert(ToStrNodeGen.create(null));
         }
 
-        return toStringNode;
+        return toStrNode;
     }
 
     private ToIntNode toIntegerNode() {