jruby · Jul 18, 2017 · Jul 18, 2017 · Jul 18, 2017 · Jul 18, 2017 · Jul 19, 2017
diff --git a/core/pom.rb b/core/pom.rb
@@ -54,7 +54,7 @@
 
   jar 'org.jruby.joni:joni:2.1.12-SNAPSHOT'
   jar 'org.jruby.extras:bytelist:1.0.15'
-  jar 'org.jruby.jcodings:jcodings:1.0.18'
+  jar 'org.jruby.jcodings:jcodings:1.0.20'
   jar 'org.jruby:dirgra:0.3'
 
   jar 'com.headius:invokebinder:1.8-SNAPSHOT'

diff --git a/core/pom.xml b/core/pom.xml
@@ -183,7 +183,7 @@ DO NOT MODIFIY - GENERATED CODE
     <dependency>
       <groupId>org.jruby.jcodings</groupId>
       <artifactId>jcodings</artifactId>
-      <version>1.0.18</version>
+      <version>1.0.20</version>
     </dependency>
     <dependency>
       <groupId>org.jruby</groupId>

diff --git a/core/src/main/java/org/jruby/Ruby.java b/core/src/main/java/org/jruby/Ruby.java
@@ -700,25 +700,25 @@ public IRubyObject runWithGetsLoop(RootNode scriptNode, boolean printing, boolea
     private RootNode addGetsLoop(RootNode oldRoot, boolean printing, boolean processLineEndings, boolean split) {
         ISourcePosition pos = oldRoot.getPosition();
         BlockNode newBody = new BlockNode(pos);
-        newBody.add(new GlobalAsgnNode(pos, "$/", new StrNode(pos, ((RubyString) globalVariables.get("$/")).getByteList())));
+        newBody.add(new GlobalAsgnNode(pos, newSymbol("$/"), new StrNode(pos, ((RubyString) globalVariables.get("$/")).getByteList())));
 
-        if (processLineEndings) newBody.add(new GlobalAsgnNode(pos, "$\\", new GlobalVarNode(pos, "$/")));
+        if (processLineEndings) newBody.add(new GlobalAsgnNode(pos, newSymbol("$\\"), new GlobalVarNode(pos, newSymbol("$/"))));
 
-        GlobalVarNode dollarUnderscore = new GlobalVarNode(pos, "$_");
+        GlobalVarNode dollarUnderscore = new GlobalVarNode(pos, newSymbol("$_"));
 
         BlockNode whileBody = new BlockNode(pos);
         newBody.add(new WhileNode(pos, new VCallNode(pos, "gets"), whileBody));
 
-        if (processLineEndings) whileBody.add(new CallNode(pos, dollarUnderscore, "chop!", null, null));
-        if (split) whileBody.add(new GlobalAsgnNode(pos, "$F", new CallNode(pos, dollarUnderscore, "split", null, null)));
+        if (processLineEndings) whileBody.add(new CallNode(pos, dollarUnderscore, newSymbol("chop!"), null, null, false));
+        if (split) whileBody.add(new GlobalAsgnNode(pos, newSymbol("$F"), new CallNode(pos, dollarUnderscore, newSymbol("split"), null, null, false)));
 
         if (oldRoot.getBodyNode() instanceof BlockNode) {   // common case n stmts
             whileBody.addAll(((BlockNode) oldRoot.getBodyNode()));
         } else {                                            // single expr script
             whileBody.add(oldRoot.getBodyNode());
         }
 
-        if (printing) whileBody.add(new FCallNode(pos, "puts", new ArrayNode(pos, dollarUnderscore), null));
+        if (printing) whileBody.add(new FCallNode(pos, newSymbol("puts"), new ArrayNode(pos, dollarUnderscore), null));
 
         return new RootNode(pos, oldRoot.getScope(), newBody, oldRoot.getFile());
     }

diff --git a/core/src/main/java/org/jruby/RubyArray.java b/core/src/main/java/org/jruby/RubyArray.java
@@ -4645,8 +4645,11 @@ public RubyString pack(ThreadContext context, IRubyObject obj, IRubyObject maybe
         RubyString str;
 
         try {
-            IRubyObject buffer = opts.convertToHash().fastARef(runtime.newSymbol("buffer"));
-            if (buffer != null) {
+            IRubyObject buffer = ArgsUtil.extractKeywordArg(context, "buffer", opts);
+            if (!buffer.isNil() && !(buffer instanceof RubyString)) {
+                throw runtime.newTypeError("buffer must be String, not " + buffer.getType().getName());
+            }
+            if (buffer.isNil()) {
                 str = buffer.convertToString();
             } else {
                 str = RubyString.newString(runtime, "");

diff --git a/core/src/main/java/org/jruby/RubyBignum.java b/core/src/main/java/org/jruby/RubyBignum.java
@@ -89,6 +89,11 @@ public static RubyBignum newBignum(Ruby runtime, long value) {
         return newBignum(runtime, BigInteger.valueOf(value));
     }
 
+    /**
+     * Return a Bignum for the given value, or raise FloatDomainError if it is out of range.
+     *
+     * Note this method may return Bignum that are in Fixnum range.
+     */
     public static RubyBignum newBignum(Ruby runtime, double value) {
         try {
             return newBignum(runtime, new BigDecimal(value).toBigInteger());
@@ -97,6 +102,19 @@ public static RubyBignum newBignum(Ruby runtime, double value) {
         }
     }
 
+    /**
+     * Return a Bignum or Fixnum (Integer) for the given value, or raise FloatDomainError if it is out of range.
+     *
+     * MRI: rb_dbl2big
+     */
+    public static RubyInteger newBignorm(Ruby runtime, double value) {
+        try {
+            return bignorm(runtime, new BigDecimal(value).toBigInteger());
+        } catch (NumberFormatException nfe) {
+            throw runtime.newFloatDomainError(Double.toString(value));
+        }
+    }
+
     public static RubyBignum newBignum(Ruby runtime, BigInteger value) {
         return new RubyBignum(runtime, value);
     }
@@ -547,7 +565,7 @@ public IRubyObject op_div(ThreadContext context, IRubyObject other) {
      *
      */
     @Override
-    public IRubyObject op_idiv(ThreadContext context, IRubyObject other) {
+    public IRubyObject idiv(ThreadContext context, IRubyObject other) {
         return op_divide(context, other, false);
     }
 
@@ -683,17 +701,32 @@ public IRubyObject op_pow(ThreadContext context, IRubyObject other) {
         Ruby runtime = context.runtime;
         if (other == RubyFixnum.zero(runtime)) return RubyFixnum.one(runtime);
         final double d;
-        if (other instanceof RubyFixnum) {
-            return op_pow(context, ((RubyFixnum) other).getLongValue());
-        } else if (other instanceof RubyBignum) {
-            d = ((RubyBignum) other).getDoubleValue();
-            context.runtime.getWarnings().warn(ID.MAY_BE_TOO_BIG, "in a**b, b may be too big");
-        } else if (other instanceof RubyFloat) {
+        if (other instanceof RubyFloat) {
             d = ((RubyFloat) other).getDoubleValue();
             if (compareTo(RubyFixnum.zero(runtime)) == -1 && d != Math.round(d)) {
                 RubyComplex complex = RubyComplex.newComplexRaw(context.runtime, this);
                 return sites(context).op_exp.call(context, complex, complex, other);
             }
+        } else if (other instanceof RubyBignum) {
+            d = ((RubyBignum) other).getDoubleValue();
+            context.runtime.getWarnings().warn(ID.MAY_BE_TOO_BIG, "in a**b, b may be too big");
+        } else if (other instanceof RubyFixnum) {
+            long yy = other.convertToInteger().getLongValue();
+            if (yy < 0)
+                return RubyRational.newRationalRaw(runtime, this).op_expt(context, other);
+            else {
+                int xbits = value.bitLength();
+                int BIGLEN_LIMIT = 32*1024*1024;
+
+                if ((xbits > BIGLEN_LIMIT) ||
+                        (xbits * yy > BIGLEN_LIMIT)) {
+                    runtime.getWarnings().warn("in a**b, b may be too big");
+                    d = (double)yy;
+                }
+                else {
+                    return newBignum(runtime, value.pow((int)yy));
+                }
+            }
         } else {
             return coerceBin(context, sites(context).op_exp, other);
         }
@@ -704,18 +737,6 @@ public IRubyObject op_pow(ThreadContext context, IRubyObject other) {
         return RubyNumeric.dbl2ival(runtime, pow);
     }
 
-    public final IRubyObject op_pow(final ThreadContext context, final long other) {
-        if (other >= 0) {
-            if (other <= Integer.MAX_VALUE) { // only have BigInteger#pow(int)
-                return bignorm(context.runtime, value.pow((int) other)); // num2int is also implemented
-            }
-            warnIfPowExponentTooBig(context, other);
-            return RubyFloat.newFloat(context.runtime, Math.pow(big2dbl(this), (double) other));
-        }
-        // (other < 0)
-        return RubyRational.newRationalRaw(context.runtime, this).op_expt(context, other);
-    }
-
     private void warnIfPowExponentTooBig(final ThreadContext context, final long other) {
         // MRI issuses warning here on (RBIGNUM(x)->len * SIZEOF_BDIGITS * yy > 1024*1024)
         if ( ((value.bitLength() + 7) / 8) * 4 * Math.abs((double) other) > 1024 * 1024 ) {
@@ -1087,6 +1108,25 @@ public IRubyObject isPositive(ThreadContext context) {
         return sites(context).basic_op_gt.call(context, this, this, RubyFixnum.zero(runtime));
     }
 
+    @Override
+    protected boolean int_round_zero_p(ThreadContext context, int ndigits) {
+        long bytes = value.bitLength() / 8 + 1;
+        return (-0.415241 * ndigits - 0.125 > bytes);
+    }
+
+    @Deprecated
+    public final IRubyObject op_pow(final ThreadContext context, final long other) {
+        if (other >= 0) {
+            if (other <= Integer.MAX_VALUE) { // only have BigInteger#pow(int)
+                return bignorm(context.runtime, value.pow((int) other)); // num2int is also implemented
+            }
+            warnIfPowExponentTooBig(context, other);
+            return RubyFloat.newFloat(context.runtime, Math.pow(big2dbl(this), (double) other));
+        }
+        // (other < 0)
+        return RubyRational.newRationalRaw(context.runtime, this).op_expt(context, other);
+    }
+
     private static JavaSites.BignumSites sites(ThreadContext context) {
         return context.sites.Bignum;
     }

diff --git a/core/src/main/java/org/jruby/RubyFixnum.java b/core/src/main/java/org/jruby/RubyFixnum.java
@@ -642,7 +642,7 @@ public IRubyObject op_mul(ThreadContext context, long otherValue) {
      * also note that RubyFloat doesn't override Numeric.div
      */
     @Override
-    public IRubyObject op_idiv(ThreadContext context, IRubyObject other) {
+    public IRubyObject idiv(ThreadContext context, IRubyObject other) {
         checkZeroDivisionError(context, other);
 
         return idiv(context, other, sites(context).div);
@@ -1336,6 +1336,12 @@ public IRubyObject isPositive(ThreadContext context) {
         return sites(context).basic_op_gt.call(context, this, this, RubyFixnum.zero(runtime));
     }
 
+    @Override
+    protected boolean int_round_zero_p(ThreadContext context, int ndigits) {
+        long bytes = 8; // sizeof(long)
+        return (-0.415241 * ndigits - 0.125 > bytes);
+    }
+
     private static JavaSites.FixnumSites sites(ThreadContext context) {
         return context.sites.Fixnum;
     }

diff --git a/core/src/main/java/org/jruby/RubyFloat.java b/core/src/main/java/org/jruby/RubyFloat.java
@@ -748,32 +748,37 @@ public IRubyObject rationalize(ThreadContext context, IRubyObject[] args) {
 
         final Ruby runtime = context.runtime;
         RubyFixnum one = RubyFixnum.one(runtime);
-        RubyFixnum two = RubyFixnum.two(runtime);
 
         IRubyObject eps, a, b;
         if (args.length != 0) {
             eps = f_abs(context, args[0]);
             a = f_sub(context, this, eps);
             b = f_add(context, this, eps);
         } else {
+            IRubyObject flt;
+            IRubyObject p, q;
             long[] exp = new long[1];
+
+            // float_decode_internal
             double f = frexp(value, exp);
             f = ldexp(f, DBL_MANT_DIG);
             long n = exp[0] - DBL_MANT_DIG;
 
+            RubyInteger rf = RubyBignum.newBignorm(runtime, f);
+            RubyFixnum rn = RubyFixnum.newFixnum(runtime, n);
+
+            if (rf.zero_p(context).isTrue() || fix2int(rn) >= 0) {
+                return RubyRational.newRationalRaw(runtime, rf.op_lshift(context, rn));
+            }
 
-            IRubyObject rf = RubyNumeric.dbl2ival(runtime, f);
-            IRubyObject rn = RubyFixnum.newFixnum(runtime, n);
+            RubyInteger two_times_f, den;
 
-            if (f_zero_p(context, rf) || !(f_negative_p(context, rn) || f_zero_p(context, rn)))
-                return RubyRational.newRationalRaw(runtime, f_lshift(context,rf,rn));
+            RubyFixnum two = RubyFixnum.two(runtime);
+            two_times_f = (RubyInteger) two.op_mul(context, rf);
+            den = (RubyInteger) RubyFixnum.one(runtime).op_lshift(context, RubyFixnum.one(runtime).op_minus(context, n));
 
-            a = RubyRational.newRationalRaw(runtime,
-                    f_sub(context,f_mul(context, two, rf),one),
-                    f_lshift(context, one, f_sub(context,one,rn)));
-            b = RubyRational.newRationalRaw(runtime,
-                    f_add(context,f_mul(context, two, rf),one),
-                    f_lshift(context, one, f_sub(context,one,rn)));
+            a = RubyRational.newRationalRaw(runtime, two_times_f.op_minus(context, RubyFixnum.one(runtime)), den);
+            b = RubyRational.newRationalRaw(runtime, two_times_f.op_plus(context, RubyFixnum.one(runtime)), den);
         }
 
         if (sites(context).op_equal.call(context, a, a, b).isTrue()) return f_to_r(context, this);
@@ -949,17 +954,10 @@ private IRubyObject roundShared(ThreadContext context, RoundingMode roundingMode
             return this;
         }
 
-        if (Double.isInfinite(value)) {
+        if (Double.isNaN(value)) {
             if (ndigits <= 0) throw context.runtime.newFloatDomainError("NaN");
             return this;
         }
-        double binexp;
-        // Missing binexp values for NaN and (-|+)Infinity.  frexp man page just says unspecified.
-        if (value == 0) {
-            binexp = 0;
-        } else {
-            binexp = Math.ceil(Math.log(value)/Math.log(2));
-        }
 
         if (ndigits < 0) {
             return ((RubyInteger) truncate(context)).round(context, ndigits);
@@ -1026,7 +1024,10 @@ private static double roundHalfDown(double x, double s) {
     }
 
     private static double roundHalfUp(double xs) {
-        return Math.floor((Math.floor((xs + 0.5) * 2.0)) / 2.0);
+        if (xs < 0.0) {
+            return Math.round(xs * -1.0) * -1.0;
+        }
+        return Math.round(xs);
     }
 
     private static double roundHalfEven(double x, double s) {