Merge pull request jruby#8533 from headius/spec_fixes

Fixes and impls for Ruby 3.4 specs

Author: headius

core/src/main/java/org/jruby/Ruby.java

@@ -401,7 +401,9 @@ private Ruby(RubyInstanceConfig config) {
         // Initialize all the core classes
         comparableModule = RubyComparable.createComparable(context);
         enumerableModule = RubyEnumerable.createEnumerableModule(context);
+
         stringClass = RubyString.createStringClass(context, objectClass, comparableModule);
+        emptyFrozenString = freezeAndDedupString(newEmptyString(context));
 
         falseString = Create.newString(context, FALSE_BYTES);
         falseString.setFrozen(true);
@@ -3528,6 +3530,10 @@ public RubyArray getEmptyFrozenArray() {
         return emptyFrozenArray;
     }
 
+    public RubyString getEmptyFrozenString() {
+        return emptyFrozenString;
+    }
+
     public RubyBoolean newBoolean(boolean value) {
         return value ? trueObject : falseObject;
     }
@@ -4448,7 +4454,7 @@ public RaiseException newStopIteration(IRubyObject result, String message) {
         RubyException ex = RubyStopIteration.newInstance(context, result, message);
 
         if (!RubyInstanceConfig.STOPITERATION_BACKTRACE) {
-            ex.setBacktrace(disabledBacktrace());
+            ex.setBacktrace(context, disabledBacktrace());
         }
 
         return ex.toThrowable();
@@ -5207,7 +5213,7 @@ public interface RecursiveFunctionEx<T> extends ThreadContext.RecursiveFunctionE
     public interface RecursiveFunction extends MRIRecursionGuard.RecursiveFunction {}
 
     /**
-     * @deprecated Use ThreadContext.safeRecurse
+     * @deprecated Use {@link ThreadContext#safeRecurse(ThreadContext.RecursiveFunctionEx, Object, IRubyObject, String, boolean)}
      */
     @Deprecated
     public <T> IRubyObject safeRecurse(RecursiveFunctionEx<T> func, ThreadContext context, T state, IRubyObject obj, String name, boolean outer) {
@@ -5915,6 +5921,7 @@ public int applyAsInt(ThreadContext context) {
     }
 
     private final RubyArray emptyFrozenArray;
+    private final RubyString emptyFrozenString;
 
     /**
      * A map from Ruby string data to a pre-frozen global version of that string.

core/src/main/java/org/jruby/RubyArray.java

@@ -1402,6 +1402,13 @@ public IRubyObject subseq_step(ThreadContext context, RubyArithmeticSequence arg
         len = realLength;
 
         if (step < 0) {
+            if (aseqExcl && !aseqEnd.isNil()) {
+                /* Handle exclusion before range reversal */
+                aseqEnd = asFixnum(context, aseqEnd.convertToInteger().getIntValue() + 1);
+
+                /* Don't exclude the previous beginning */
+                aseqExcl = false;
+            }
             IRubyObject tmp = aseqBeg;
             aseqBeg = aseqEnd;
             aseqEnd = tmp;

core/src/main/java/org/jruby/RubyBasicObject.java

@@ -2207,7 +2207,7 @@ public IRubyObject display(ThreadContext context, IRubyObject[] args) {
      *
      *  <em>produces:</em>
      *
-     *     prog.rb:3:in `&lt;&lt;': can't modify frozen array (TypeError)
+     *     prog.rb:3:in '&lt;&lt;': can't modify frozen array (TypeError)
      *     	from prog.rb:3
      */
     public IRubyObject freeze(ThreadContext context) {

core/src/main/java/org/jruby/RubyBignum.java

@@ -198,7 +198,7 @@ public static long big2long(RubyBignum val) {
         BigInteger big = val.value;
 
         if (big.compareTo(LONG_MIN) < 0 || big.compareTo(LONG_MAX) > 0) {
-            throw val.getRuntime().newRangeError("bignum too big to convert into `long'");
+            throw val.getRuntime().newRangeError("bignum too big to convert into 'long'");
         }
         return big.longValue();
     }
@@ -216,7 +216,7 @@ public static long big2ulong(RubyBignum value) {
 
     public static long big2ulong(Ruby runtime, BigInteger big) {
         if (big.compareTo(BigInteger.ZERO) < 0 || big.compareTo(ULONG_MAX) > 0) {
-            throw runtime.newRangeError("bignum out of range for `ulong'");
+            throw runtime.newRangeError("bignum out of range for 'ulong'");
         }
 
         return big.longValue();
@@ -706,9 +706,8 @@ public IRubyObject op_pow(ThreadContext context, IRubyObject other) {
                 RubyComplex complex = RubyComplex.newComplexRaw(context.runtime, this);
                 return sites(context).op_exp.call(context, complex, complex, other);
             }
-        } else if (other instanceof RubyBignum bignum) {
-            d = bignum.getDoubleValue();
-            warn(context, "in a**b, b may be too big");
+        } else if (other instanceof RubyBignum) {
+            throw argumentError(context, "exponent is too large");
         } else if (other instanceof RubyFixnum fixnum) {
             return op_pow(context, fixnum.value);
         } else {
@@ -737,8 +736,7 @@ public final IRubyObject op_pow(final ThreadContext context, final long other) {
         }
         final int xbits = value.bitLength();
         if ((xbits > BIGLEN_LIMIT) || (xbits * other > BIGLEN_LIMIT)) {
-            warn(context, "in a**b, b may be too big");
-            return pow(context, (double) other);
+            throw argumentError(context, "exponent is too large");
         } else {
             return newBignum(context.runtime, value.pow((int) other));
         }

core/src/main/java/org/jruby/RubyClass.java

@@ -1082,6 +1082,7 @@ private RubyClass initializeCommon(ThreadContext context, RubyClass superClazz,
     @JRubyMethod(name = "initialize_copy", visibility = PRIVATE)
     public IRubyObject initialize_copy(ThreadContext context, IRubyObject original) {
         checkNotInitialized(context);
+        if (original == context.runtime.getBasicObject()) throw typeError(context, "can't copy the root class");
         if (original instanceof MetaClass) throw typeError(context, "can't copy singleton class");
 
         super.initialize_copy(context, original);
@@ -2914,7 +2915,7 @@ public IRubyObject smartLoadNewUser(IRubyObject target, IRubyObject data) {
                     target.callMethod(context, "marshal_load", data);
                     return target;
                 } else {
-                    throw typeError(context, "class ", this, " needs to have method `marshal_load'");
+                    throw typeError(context, "class ", this, " needs to have method 'marshal_load'");
                 }
 
             } else if (!(cache = searchWithCache("marshal_load")).method.isUndefined()) {
@@ -2964,7 +2965,7 @@ public IRubyObject smartLoadOldUser(IRubyObject data) {
             if (method.call(context, this, cache.sourceModule, "respond_to?", asSymbol(context, "_load")).isTrue()) {
                 return callMethod(context, "_load", data);
             } else {
-                throw typeError(context, "class ", this, " needs to have method `_load'");
+                throw typeError(context, "class ", this, " needs to have method '_load'");
             }
         } else if (!(cache = singleton.searchWithCache("_load")).method.isUndefined()) {
             // real _load defined, cache and call it
@@ -2973,7 +2974,7 @@ public IRubyObject smartLoadOldUser(IRubyObject data) {
 
         } else {
             // provide an error, since it doesn't exist
-            throw typeError(context, "class ", this, " needs to have method `_load'");
+            throw typeError(context, "class ", this, " needs to have method '_load'");
         }
     }
 

core/src/main/java/org/jruby/RubyComplex.java

@@ -29,6 +29,7 @@
 import org.jcodings.specific.ASCIIEncoding;
 import org.jruby.anno.JRubyClass;
 import org.jruby.anno.JRubyMethod;
+import org.jruby.api.Convert;
 import org.jruby.ast.util.ArgsUtil;
 import org.jruby.exceptions.RaiseException;
 import org.jruby.runtime.Arity;
@@ -54,7 +55,9 @@
 
 import static org.jruby.api.Convert.asBoolean;
 import static org.jruby.api.Convert.asFixnum;
+import static org.jruby.api.Convert.asFloat;
 import static org.jruby.api.Create.newArray;
+import static org.jruby.api.Create.newRational;
 import static org.jruby.api.Define.defineClass;
 import static org.jruby.api.Error.*;
 import static org.jruby.api.Warn.warn;
@@ -494,16 +497,16 @@ private static IRubyObject convertCommon(ThreadContext context, IRubyObject recv
 
         if (a1 instanceof RubyComplex) {
             RubyComplex a1c = (RubyComplex) a1;
-            if (k_exact_p(a1c.image) && f_zero_p(context, a1c.image)) a1 = a1c.real;
+            if (k_exact_zero_p(context, a1c.image)) a1 = a1c.real;
         }
 
         if (a2 instanceof RubyComplex) {
             RubyComplex a2c = (RubyComplex) a2;
-            if (k_exact_p(a2c.image) && f_zero_p(context, a2c.image)) a2 = a2c.real;
+            if (k_exact_zero_p(context, a2c.image)) a2 = a2c.real;
         }
 
         if (a1 instanceof RubyComplex) {
-            if (singleArg || (k_exact_p(a2) && f_zero_p(context, a2))) return a1;
+            if (singleArg || (k_exact_zero_p(context, a2))) return a1;
         }
 
         if (singleArg) {
@@ -706,23 +709,30 @@ public IRubyObject fdiv(ThreadContext context, IRubyObject other) {
         return f_divide(context, this, other, (a, b) -> fdiv.call(context, a, a, b), fdiv);
     }
 
-    /** nucomp_expt
-     * 
+    /**
+     * MRI: nucomp_expt
      */
     @JRubyMethod(name = "**")
     public IRubyObject op_expt(ThreadContext context, IRubyObject other) {
-        if (k_exact_p(other) && f_zero_p(context, other)) {
-            return newComplexBang(context, getMetaClass(), asFixnum(context, 0));
+        if (other instanceof RubyNumeric && k_exact_zero_p(context, other)) {
+            return newComplexBang(context, getMetaClass(), asFixnum(context, 1));
         }
 
-        if (other instanceof RubyRational && f_one_p(context, f_denominator(context, other))) {
+        if (other instanceof RubyRational otherRational && f_one_p(context, otherRational.getDenominator())) {
             other = f_numerator(context, other); 
         }
 
-        if (other instanceof RubyComplex otherComplex && f_zero_p(context, otherComplex.image)) {
+        if (other instanceof RubyComplex otherComplex && k_exact_zero_p(context, otherComplex.image)) {
             other = otherComplex.real;
         }
 
+        if (other == RubyFixnum.one(context.runtime)) {
+            return newComplex(context, metaClass, real, image);
+        }
+
+        IRubyObject result = complexPowForSpecialAngle(context, other);
+        if (result != UNDEF) return result;
+
         if (other instanceof RubyComplex otherComplex) {
             IRubyObject otherReal = otherComplex.real;
             IRubyObject otherImage = otherComplex.image;
@@ -807,6 +817,82 @@ else if (f_zero_p(context, xr)) {
         return coerceBin(context, sites(context).op_exp, other);
     }
 
+    // MRI: complex_pow_for_special_angle
+    private IRubyObject complexPowForSpecialAngle(ThreadContext context, IRubyObject other) {
+        if (!(other instanceof RubyInteger integer)) {
+            return UNDEF;
+        }
+
+        IRubyObject x = UNDEF;
+        int dir;
+        if (f_zero_p(context, image)) {
+            x = real;
+            dir = 0;
+        }
+        else if (f_zero_p(context, real)) {
+            x = image;
+            dir = 2;
+        }
+        else if (Numeric.f_eqeq_p(context, real, image)) {
+            x = real;
+            dir = 1;
+        }
+        else if (Numeric.f_eqeq_p(context, real, Numeric.f_negate(context, image))) {
+            x = image;
+            dir = 3;
+        } else {
+            dir = 0;
+        }
+
+        if (x == UNDEF) return x;
+
+        if (f_negative_p(context, x)) {
+            x = f_negate(context, x);
+            dir += 4;
+        }
+
+        IRubyObject zx;
+        if (dir % 2 == 0) {
+            zx = num_pow(context, x, other);
+        }
+        else {
+            RubyFixnum two = RubyFixnum.two(context.runtime);
+            zx = num_pow(context,
+                    sites(context).op_times.call(context, two.op_mul(context, x), x),
+                    integer.div(context, two)
+            );
+            if (f_odd_p(context, other)) {
+                zx = sites(context).op_times.call(context, zx, x);
+            }
+        }
+        int dirs[][] = {
+            {1, 0}, {1, 1}, {0, 1}, {-1, 1}, {-1, 0}, {-1, -1}, {0, -1}, {1, -1}
+        };
+        int z_dir = fix2int(asFixnum(context, dir).modulo(context, 8));
+
+        IRubyObject zr = context.fals, zi = context.fals;
+        switch (dirs[z_dir][0]) {
+            case 0: zr = zero_for(context, zx); break;
+            case 1: zr = zx; break;
+            case -1: zr = f_negate(context, zx); break;
+        }
+        switch (dirs[z_dir][1]) {
+            case 0: zi = zero_for(context, zx); break;
+            case 1: zi = zx; break;
+            case -1: zi = f_negate(context, zx); break;
+        }
+        return newComplex(context, metaClass, zr, zi);
+    }
+
+    private static IRubyObject zero_for(ThreadContext context, IRubyObject x) {
+        if (x instanceof RubyFloat)
+            return asFloat(context, 0);
+        if (x instanceof RubyRational)
+            return newRational(context, 0, 1);
+
+        return asFixnum(context, 0);
+    }
+
     /** nucomp_equal_p
      * 
      */
@@ -1131,7 +1217,15 @@ public IRubyObject to_f(ThreadContext context) {
      */
     @JRubyMethod(name = "to_r")
     public IRubyObject to_r(ThreadContext context) {
-        checkValidRational(context, "Rational");
+        if (image instanceof RubyFloat imageFloat && imageFloat.isZero(context)) {
+            /* Do nothing here */
+        } else if (!k_exact_zero_p(context, image)) {
+            IRubyObject imag = Convert.checkToRational(context, image);
+            if (imag.isNil() || !k_exact_zero_p(context, imag)) {
+                throw rangeError(context, "can't convert " + this + " into Rational");
+            }
+        }
+
         return f_to_r(context, real);
     }
 
@@ -1145,7 +1239,7 @@ public IRubyObject rationalize(ThreadContext context, IRubyObject[] args) {
     }
 
     private void checkValidRational(ThreadContext context, String type) {
-        if (k_inexact_p(image) || !f_zero_p(context, image)) {
+        if (!k_exact_zero_p(context, image)) {
             throw rangeError(context, "can't convert " + f_to_s(context, this).convertToString() + " into " + type);
         }
     }

core/src/main/java/org/jruby/RubyDir.java

@@ -76,6 +76,7 @@
 import static org.jruby.api.Create.newString;
 import static org.jruby.api.Define.defineClass;
 import static org.jruby.api.Error.argumentError;
+import static org.jruby.api.Error.notImplementedError;
 import static org.jruby.api.Error.runtimeError;
 import static org.jruby.api.Warn.warn;
 import static org.jruby.util.RubyStringBuilder.str;
@@ -483,6 +484,11 @@ private static IRubyObject chdirCommon(ThreadContext context, Block block, RubyS
         return result;
     }
 
+    @JRubyMethod(name = "fchdir", meta = true, notImplemented = true)
+    public static IRubyObject fchdir(ThreadContext context, IRubyObject dirClass, IRubyObject ignored) {
+        throw notImplementedError(context, "Dir.fchdir");
+    }
+
     @JRubyMethod(name = "chdir")
     public IRubyObject chdir(ThreadContext context) {
         return chdir(context, this.getMetaClass(), path, Block.NULL_BLOCK);

core/src/main/java/org/jruby/RubyEncoding.java

@@ -37,6 +37,7 @@
 
 import org.jcodings.Encoding;
 import org.jcodings.EncodingDB.Entry;
+import org.jcodings.specific.ASCIIEncoding;
 import org.jcodings.specific.USASCIIEncoding;
 import org.jcodings.specific.UTF16BEEncoding;
 import org.jcodings.specific.UTF8Encoding;
@@ -72,6 +73,7 @@ public class RubyEncoding extends RubyObject implements Constantizable {
     public static final ByteList EXTERNAL = new ByteList(encodeISO("external"), false);
     public static final ByteList FILESYSTEM = new ByteList(encodeISO("filesystem"), false);
     public static final ByteList INTERNAL = new ByteList(encodeISO("internal"), false);
+    public static final ByteList BINARY_ASCII_NAME = new ByteList(encodeISO("BINARY (ASCII-8BIT)"), false);
 
     public static RubyClass createEncodingClass(ThreadContext context, RubyClass Object) {
         return defineClass(context, "Encoding", Object, NOT_ALLOCATABLE_ALLOCATOR).
@@ -574,12 +576,19 @@ public IRubyObject to_s(ThreadContext context) {
     public IRubyObject inspect(ThreadContext context) {
         ByteList bytes = new ByteList();
         bytes.append("#<Encoding:".getBytes());
-        bytes.append(name);
+        bytes.append(inspectName());
         if (isDummy) bytes.append(" (dummy)".getBytes());
         bytes.append('>');
         return RubyString.newUsAsciiStringNoCopy(context.runtime, bytes);
     }
 
+    private ByteList inspectName() {
+        if (encoding == ASCIIEncoding.INSTANCE) {
+            return BINARY_ASCII_NAME;
+        }
+        return name;
+    }
+
     @SuppressWarnings("unchecked")
     @JRubyMethod(name = "names")
     public IRubyObject names(ThreadContext context) {