[GR-20446] Implement rb_make_exception

PullRequest: truffleruby/2211

Author: bjfish

CHANGELOG.md

@@ -30,6 +30,7 @@ Compatibility:
 * `Kernel#lambda` with no block in a method called with a block raises an exception (#2004, @ssnickolay).
 * Implemented `BigDecimal` as C extension to improve compatibility.
 * Comment lines can be placed between fluent dot now (#2004, @ssnickolay).
+* Implemented `rb_make_exception`.
 
 Performance:
 

lib/truffle/truffle/cext.rb

@@ -1053,6 +1053,10 @@ def rb_set_errinfo(error)
     Truffle::Type.set_last_exception(error)
   end
 
+  def rb_make_exception(args)
+    Truffle::ExceptionOperations.make_exception(args)
+  end
+
   def rb_errinfo
     $!
   end

spec/ruby/optional/capi/exception_spec.rb

@@ -55,4 +55,49 @@
       -> { @s.rb_set_errinfo("error") }.should raise_error(TypeError)
     end
   end
+
+  describe "rb_make_exception" do
+    it "returns a RuntimeError when given a String argument" do
+      e = @s.rb_make_exception(["Message"])
+      e.class.should == RuntimeError
+      e.message.should == "Message"
+    end
+
+    it "returns the exception when given an Exception argument" do
+      exc = Exception.new
+      e = @s.rb_make_exception([exc])
+      e.should == exc
+    end
+
+    it "returns the exception with the given class and message" do
+      e = @s.rb_make_exception([Exception, "Message"])
+      e.class.should == Exception
+      e.message.should == "Message"
+    end
+
+    it "returns the exception with the given class, message, and backtrace" do
+      e = @s.rb_make_exception([Exception, "Message", ["backtrace 1"]])
+      e.class.should == Exception
+      e.message.should == "Message"
+      e.backtrace.should == ["backtrace 1"]
+    end
+
+    it "raises a TypeError for incorrect types" do
+      -> { @s.rb_make_exception([nil]) }.should raise_error(TypeError)
+      -> { @s.rb_make_exception([Object.new]) }.should raise_error(TypeError)
+      obj = Object.new
+      def obj.exception
+        "not exception type"
+      end
+      -> { @s.rb_make_exception([obj]) }.should raise_error(TypeError)
+    end
+
+    it "raises an ArgumentError for too many arguments" do
+      -> { @s.rb_make_exception([Exception, "Message", ["backtrace 1"], "extra"])  }.should raise_error(ArgumentError)
+    end
+
+    it "returns nil for empty arguments" do
+      @s.rb_make_exception([]).should == nil
+    end
+  end
 end

spec/ruby/optional/capi/ext/exception_spec.c

@@ -32,13 +32,21 @@ VALUE exception_spec_rb_set_errinfo(VALUE self, VALUE exc) {
   return Qnil;
 }
 
+
+VALUE exception_spec_rb_make_exception(VALUE self, VALUE ary) {
+  int argc = RARRAY_LENINT(ary);
+  VALUE *argv = RARRAY_PTR(ary);
+  return rb_make_exception(argc, argv);
+}
+
 void Init_exception_spec(void) {
   VALUE cls = rb_define_class("CApiExceptionSpecs", rb_cObject);
   rb_define_method(cls, "rb_exc_new", exception_spec_rb_exc_new, 1);
   rb_define_method(cls, "rb_exc_new2", exception_spec_rb_exc_new2, 1);
   rb_define_method(cls, "rb_exc_new3", exception_spec_rb_exc_new3, 1);
   rb_define_method(cls, "rb_exc_raise", exception_spec_rb_exc_raise, 1);
   rb_define_method(cls, "rb_set_errinfo", exception_spec_rb_set_errinfo, 1);
+  rb_define_method(cls, "rb_make_exception", exception_spec_rb_make_exception, 1);
 }
 
 #ifdef __cplusplus

src/main/c/cext/exception.c

@@ -128,6 +128,10 @@ void rb_bug(const char *fmt, ...) {
   rb_tr_error("rb_bug not yet implemented");
 }
 
+VALUE rb_make_exception(int argc, const VALUE *argv) {
+  return RUBY_CEXT_INVOKE("rb_make_exception", rb_ary_new4(argc, argv));
+}
+
 void rb_tr_init_exception(void) {
   cext_rb_protect = polyglot_get_member(rb_tr_cext, "rb_protect");
   cext_rb_ensure = polyglot_get_member(rb_tr_cext, "rb_ensure");

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

@@ -29,6 +29,31 @@ def self.build_exception_for_raise(exc, msg)
       end
     end
 
+    def self.make_exception(args)
+      case args.size
+      when 0
+        nil
+      when 1
+        converted = Truffle::Type.rb_check_convert_type(args[0], String, :to_str)
+        return RuntimeError.new(converted) unless Primitive.nil?(converted)
+        call_exception(args[0])
+      when 2
+        call_exception(args[0], args[1])
+      when 3
+        exc = call_exception(args[0], args[1])
+        exc.set_backtrace(args[2])
+        exc
+      else
+        Truffle::Type.check_arity(args.size, 0, 3)
+      end
+    end
+
+    def self.call_exception(exc, *args)
+      res = Truffle::Type.check_funcall(exc, :exception, args)
+      raise TypeError, 'exception class/object expected' if Primitive.undefined?(res) || !Primitive.object_kind_of?(res, Exception)
+      res
+    end
+
     # Avoid using #raise here to prevent infinite recursion
     def self.exception_class_object_expected!
       exc = ::TypeError.new('exception class/object expected')