Fix the exception type raised when type coercion via to_ary raises a NoMethodError.

Author: nirvdrum

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

src/main/java/org/truffleruby/core/cast/ToAryNode.java

@@ -12,13 +12,11 @@
 import com.oracle.truffle.api.dsl.NeverDefault;
 import org.truffleruby.core.array.RubyArray;
 import org.truffleruby.language.RubyBaseNodeWithExecute;
-import org.truffleruby.language.control.RaiseException;
-import org.truffleruby.language.dispatch.DispatchNode;
 
 import com.oracle.truffle.api.dsl.Cached;
 import com.oracle.truffle.api.dsl.NodeChild;
 import com.oracle.truffle.api.dsl.Specialization;
-import com.oracle.truffle.api.profiles.BranchProfile;
+import org.truffleruby.language.dispatch.DispatchNode;
 
 @NodeChild(value = "childNode", type = RubyBaseNodeWithExecute.class)
 public abstract class ToAryNode extends RubyBaseNodeWithExecute {
@@ -43,30 +41,13 @@ protected RubyArray coerceRubyArray(RubyArray array) {
 
     @Specialization(guards = "!isRubyArray(object)")
     protected RubyArray coerceObject(Object object,
-            @Cached BranchProfile errorProfile,
             @Cached DispatchNode toAryNode) {
-        final Object coerced;
-        try {
-            coerced = toAryNode.call(object, "to_ary");
-        } catch (RaiseException e) {
-            errorProfile.enter();
-            if (e.getException().getLogicalClass() == coreLibrary().noMethodErrorClass) {
-                throw new RaiseException(
-                        getContext(),
-                        coreExceptions().typeErrorNoImplicitConversion(object, "Array", this));
-            } else {
-                throw e;
-            }
-        }
-
-        if (coerced instanceof RubyArray) {
-            return (RubyArray) coerced;
-        } else {
-            errorProfile.enter();
-            throw new RaiseException(
-                    getContext(),
-                    coreExceptions().typeErrorBadCoercion(object, "Array", "to_ary", coerced, this));
-        }
+        return (RubyArray) toAryNode.call(
+                coreLibrary().truffleTypeModule,
+                "rb_convert_type",
+                object,
+                coreLibrary().arrayClass,
+                coreSymbols().TO_ARY);
     }
 
     @Override