[GR-19220] Fix implicit type coercion

PullRequest: truffleruby/3742

Author: andrykonchin

CHANGELOG.md

@@ -46,6 +46,7 @@ Bug fixes:
 * Fix `Monitor#exit` to raise `ThreadError` when monitor not owned by the current thread (#2922, @andrykonchin).
 * Fix `MatchData#[]` to support negative `length` argument (#2929, @andrykonchin).
 * Fix `IO` line reading calls when using a multi-byte delimiter (`IO#{each,gets,readline,readlines,etc.}) (#2961, @vinistock, @nirvdrum).
+* Fix the exception type raised when type coercion raises a `NoMethodError` (#2903, @paracycle, @nirvdrum).
 
 Compatibility:
 

spec/ruby/core/array/plus_spec.rb

@@ -14,10 +14,23 @@
     (ary + ary).should == [1, 2, 3, 1, 2, 3]
   end
 
-  it "tries to convert the passed argument to an Array using #to_ary" do
-    obj = mock('["x", "y"]')
-    obj.should_receive(:to_ary).and_return(["x", "y"])
-    ([1, 2, 3] + obj).should == [1, 2, 3, "x", "y"]
+  describe "converts the passed argument to an Array using #to_ary" do
+    it "successfully concatenates the resulting array from the #to_ary call" do
+      obj = mock('["x", "y"]')
+      obj.should_receive(:to_ary).and_return(["x", "y"])
+      ([1, 2, 3] + obj).should == [1, 2, 3, "x", "y"]
+    end
+
+    it "raises a Typeerror if the given argument can't be converted to an array" do
+      -> { [1, 2, 3] + nil }.should raise_error(TypeError)
+      -> { [1, 2, 3] + "abc" }.should raise_error(TypeError)
+    end
+
+    it "raises a NoMethodError if the given argument raises a NoMethodError during type coercion to an Array" do
+      obj = mock("hello")
+      obj.should_receive(:to_ary).and_raise(NoMethodError)
+      -> { [1, 2, 3] + obj }.should raise_error(NoMethodError)
+    end
   end
 
   it "properly handles recursive arrays" do

spec/ruby/core/kernel/method_spec.rb

@@ -29,7 +29,7 @@
     m.call.should == :defined
   end
 
-  it "can be called even if we only repond_to_missing? method, true" do
+  it "can be called even if we only respond_to_missing? method, true" do
     m = KernelSpecs::RespondViaMissing.new.method(:handled_privately)
     m.should be_an_instance_of(Method)
     m.call(1, 2, 3).should == "Done handled_privately([1, 2, 3])"
@@ -58,4 +58,23 @@ def method_missing(m)
     m = cls.new.method(:bar)
     m.call.should == :bar
   end
+
+  describe "converts the given name to a String using #to_str" do
+    it "calls #to_str to convert the given name to a String" do
+      name = mock("method-name")
+      name.should_receive(:to_str).and_return("hash")
+      Object.method(name).should == Object.method(:hash)
+    end
+
+    it "raises a TypeError if the given name can't be converted to a String" do
+      -> { Object.method(nil) }.should raise_error(TypeError)
+      -> { Object.method([])  }.should raise_error(TypeError)
+    end
+
+    it "raises a NoMethodError if the given argument raises a NoMethodError during type coercion to a String" do
+      name = mock("method-name")
+      name.should_receive(:to_str).and_raise(NoMethodError)
+      -> { Object.method(name) }.should raise_error(NoMethodError)
+    end
+  end
 end

spec/ruby/core/math/cos_spec.rb

@@ -15,7 +15,6 @@
     Math.cos(2*Math::PI).should be_close(1.0, TOLERANCE)
   end
 
-
   it "raises a TypeError unless the argument is Numeric and has #to_f" do
     -> { Math.cos("test") }.should raise_error(TypeError)
   end
@@ -24,14 +23,23 @@
     Math.cos(nan_value).nan?.should be_true
   end
 
-  it "raises a TypeError if the argument is nil" do
-    -> { Math.cos(nil) }.should raise_error(TypeError)
-  end
-
-  it "coerces its argument with #to_f" do
-    f = mock_numeric('8.2')
-    f.should_receive(:to_f).and_return(8.2)
-    Math.cos(f).should == Math.cos(8.2)
+  describe "coerces its argument with #to_f" do
+    it "coerces its argument with #to_f" do
+      f = mock_numeric('8.2')
+      f.should_receive(:to_f).and_return(8.2)
+      Math.cos(f).should == Math.cos(8.2)
+    end
+
+    it "raises a TypeError if the given argument can't be converted to a Float" do
+      -> { Math.cos(nil) }.should raise_error(TypeError)
+      -> { Math.cos(:abc) }.should raise_error(TypeError)
+    end
+
+    it "raises a NoMethodError if the given argument raises a NoMethodError during type coercion to a Float" do
+      object = mock_numeric('mock-float')
+      object.should_receive(:to_f).and_raise(NoMethodError)
+      -> { Math.cos(object) }.should raise_error(NoMethodError)
+    end
   end
 end
 

spec/ruby/core/module/alias_method_spec.rb

@@ -81,6 +81,12 @@ def uno_refined_method
     -> { @class.make_alias mock('x'), :public_one }.should raise_error(TypeError)
   end
 
+  it "raises a NoMethodError if the given name raises a NoMethodError during type coercion using to_str" do
+    obj = mock("mock-name")
+    obj.should_receive(:to_str).and_raise(NoMethodError)
+    -> { @class.make_alias obj, :public_one }.should raise_error(NoMethodError)
+  end
+
   it "is a public method" do
     Module.should have_public_instance_method(:alias_method, false)
   end

spec/ruby/core/module/const_defined_spec.rb

@@ -80,10 +80,23 @@
     ConstantSpecs::ClassA.const_defined?(:CS_CONSTX).should == false
   end
 
-  it "calls #to_str to convert the given name to a String" do
-    name = mock("ClassA")
-    name.should_receive(:to_str).and_return("ClassA")
-    ConstantSpecs.const_defined?(name).should == true
+  describe "converts the given name to a String using #to_str" do
+    it "calls #to_str to convert the given name to a String" do
+      name = mock("ClassA")
+      name.should_receive(:to_str).and_return("ClassA")
+      ConstantSpecs.const_defined?(name).should == true
+    end
+
+    it "raises a TypeError if the given name can't be converted to a String" do
+      -> { ConstantSpecs.const_defined?(nil) }.should raise_error(TypeError)
+      -> { ConstantSpecs.const_defined?([])  }.should raise_error(TypeError)
+    end
+
+    it "raises a NoMethodError if the given argument raises a NoMethodError during type coercion to a String" do
+      name = mock("classA")
+      name.should_receive(:to_str).and_raise(NoMethodError)
+      -> { ConstantSpecs.const_defined?(name) }.should raise_error(NoMethodError)
+    end
   end
 
   it "special cases Object and checks it's included Modules" do

spec/ruby/core/queue/initialize_spec.rb

@@ -22,16 +22,29 @@
       q.should.empty?
     end
 
-    it "uses #to_a on the provided Enumerable" do
-      enumerable = MockObject.new('mock-enumerable')
-      enumerable.should_receive(:to_a).and_return([1, 2, 3])
-      q = Queue.new(enumerable)
-      q.size.should == 3
-      q.should_not.empty?
-      q.pop.should == 1
-      q.pop.should == 2
-      q.pop.should == 3
-      q.should.empty?
+    describe "converts the given argument to an Array using #to_a" do
+      it "uses #to_a on the provided Enumerable" do
+        enumerable = MockObject.new('mock-enumerable')
+        enumerable.should_receive(:to_a).and_return([1, 2, 3])
+        q = Queue.new(enumerable)
+        q.size.should == 3
+        q.should_not.empty?
+        q.pop.should == 1
+        q.pop.should == 2
+        q.pop.should == 3
+        q.should.empty?
+      end
+
+      it "raises a TypeError if the given argument can't be converted to an Array" do
+        -> { Queue.new(42) }.should raise_error(TypeError)
+        -> { Queue.new(:abc) }.should raise_error(TypeError)
+      end
+
+      it "raises a NoMethodError if the given argument raises a NoMethodError during type coercion to an Array" do
+        enumerable = MockObject.new('mock-enumerable')
+        enumerable.should_receive(:to_a).and_raise(NoMethodError)
+        -> { Queue.new(enumerable) }.should raise_error(NoMethodError)
+      end
     end
 
     it "raises TypeError if the provided Enumerable does not respond to #to_a" do

spec/ruby/core/string/append_spec.rb

@@ -5,6 +5,7 @@
 describe "String#<<" do
   it_behaves_like :string_concat, :<<
   it_behaves_like :string_concat_encoding, :<<
+  it_behaves_like :string_concat_type_coercion, :<<
 
   it "raises an ArgumentError when given the incorrect number of arguments" do
     -> { "hello".send(:<<) }.should raise_error(ArgumentError)

spec/ruby/core/string/concat_spec.rb

@@ -5,6 +5,7 @@
 describe "String#concat" do
   it_behaves_like :string_concat, :concat
   it_behaves_like :string_concat_encoding, :concat
+  it_behaves_like :string_concat_type_coercion, :concat
 
   it "takes multiple arguments" do
     str = "hello "

spec/ruby/core/string/plus_spec.rb

@@ -3,6 +3,9 @@
 require_relative 'shared/concat'
 
 describe "String#+" do
+  it_behaves_like :string_concat_encoding, :+
+  it_behaves_like :string_concat_type_coercion, :+
+
   it "returns a new string containing the given string concatenated to self" do
     ("" + "").should == ""
     ("" + "Hello").should == "Hello"
@@ -31,6 +34,4 @@
     ("hello" + StringSpecs::MyString.new("foo")).should be_an_instance_of(String)
     ("hello" + StringSpecs::MyString.new("")).should be_an_instance_of(String)
   end
-
-  it_behaves_like :string_concat_encoding, :+
 end