Address Truffle deprecations

Author: eregon

doc/contributor/interop.md

@@ -58,8 +58,8 @@ exception like
 it raises corresponding Ruby exception available in `Truffle::Interop` module.
 The names are the same, e.g. `Truffle::Interop::UnsupportedMessageException`.
 These exceptions inherit from `Exception`, therefore they are not caught by
-default in `rescue` (which catches descendants of `StandardError`). Only `Truffle::Interop::ArityException`takes an
-argument, an `Integer` to describe the number of expected arguments.
+default in `rescue` (which catches descendants of `StandardError`). Only `Truffle::Interop::ArityException`takes
+arguments, two `Integer`s to describe the minimum and maximum number of expected arguments.
 
 The detailed definitions of the behavior can be found in
 [another document](interop_details.md).

src/main/java/org/truffleruby/core/exception/CoreExceptions.java

@@ -209,6 +209,17 @@ public RubyException argumentError(int passed, int required, int optional, Node
                 required + optional), currentNode);
     }
 
+    @TruffleBoundary
+    public RubyException argumentErrorMinMaxArity(int passed, int minArity, int maxArity, Node currentNode) {
+        if (minArity == maxArity) {
+            return argumentError(passed, minArity, currentNode);
+        } else if (maxArity < 0) {
+            return argumentErrorPlus(passed, minArity, currentNode);
+        } else {
+            return argumentError(passed, minArity, maxArity - minArity, currentNode);
+        }
+    }
+
     public RubyException argumentErrorEmptyVarargs(Node currentNode) {
         return argumentError(coreStrings().WRONG_ARGS_ZERO_PLUS_ONE.getRope(), currentNode, null);
     }

src/main/java/org/truffleruby/interop/TranslateInteropExceptionNode.java

@@ -125,9 +125,10 @@ protected RuntimeException handle(ArityException exception, boolean inInvokeMemb
             @CachedContext(RubyLanguage.class) RubyContext context) {
         return new RaiseException(
                 context,
-                context.getCoreExceptions().argumentError(
+                context.getCoreExceptions().argumentErrorMinMaxArity(
                         exception.getActualArity(),
-                        exception.getExpectedArity(),
+                        exception.getExpectedMinArity(),
+                        exception.getExpectedMaxArity(),
                         this),
                 exception);
     }

src/main/java/org/truffleruby/interop/TranslateInteropRubyExceptionNode.java

@@ -151,8 +151,9 @@ protected AssertionError arityExceptionClass(
             @Cached DispatchNode dispatch,
             @Cached IntegerCastNode intCastNode,
             @Cached @Shared("logicalClassNode") LogicalClassNode logicalClassNode) throws ArityException {
-        int expected = intCastNode.executeCastInt(dispatch.call(exception.getException(), "expected"));
-        throw ArityException.create(expected, arguments.length, exception);
+        int minExpected = intCastNode.executeCastInt(dispatch.call(exception.getException(), "min_expected"));
+        int maxExpected = intCastNode.executeCastInt(dispatch.call(exception.getException(), "max_expected"));
+        throw ArityException.create(minExpected, maxExpected, arguments.length, exception);
     }
 
     @Specialization(

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

@@ -23,11 +23,13 @@ class UnknownIdentifierException < InteropException; end
     class UnsupportedTypeException < InteropException; end
     class UnknownKeyException < InteropException; end
     class ArityException < InteropException
-      attr_reader :expected
+      attr_reader :min_expected, :max_expected
 
-      def initialize(expected)
-        @expected = expected
-        raise ArgumentError unless expected.is_a? Integer
+      def initialize(min_expected, max_expected = min_expected)
+        raise ArgumentError unless Primitive.object_kind_of?(min_expected, Integer)
+        raise ArgumentError unless Primitive.object_kind_of?(max_expected, Integer)
+        @min_expected = min_expected
+        @max_expected = max_expected
       end
     end