[GR-15764] Fix creating BigDecimal instances from non-finite Float values.

PullRequest: truffleruby/834

Author: nirvdrum

CHANGELOG.md

@@ -3,6 +3,7 @@
 Bug fixes:
 
 * Fixed `BigDecimal#dup` so it now just returns the receiver, per Ruby 2.5+ semantics (#1680).
+* Fixed creating `BigDecimal` instances from non-finite `Float` values (#1685).
 * Implemented `rb_eval_string_protect`.
 * Fixed `rb_get_kwargs` to correctly handle optional and rest arguments.
 

spec/ruby/library/bigdecimal/BigDecimal_spec.rb

@@ -100,6 +100,34 @@
     neg_inf.should < 0
   end
 
+  describe "accepts NaN and [+-]Infinity as Float values" do
+    it "works without an explicit precision" do
+      BigDecimal(Float::NAN).nan?.should == true
+
+      pos_inf = BigDecimal(Float::INFINITY)
+      pos_inf.finite?.should == false
+      pos_inf.should > 0
+      pos_inf.should == BigDecimal("+Infinity")
+
+      neg_inf = BigDecimal(-Float::INFINITY)
+      neg_inf.finite?.should == false
+      neg_inf.should < 0
+    end
+
+    it "works with an explicit precision" do
+      BigDecimal(Float::NAN, Float::DIG).nan?.should == true
+
+      pos_inf = BigDecimal(Float::INFINITY, Float::DIG)
+      pos_inf.finite?.should == false
+      pos_inf.should > 0
+      pos_inf.should == BigDecimal("+Infinity")
+
+      neg_inf = BigDecimal(-Float::INFINITY, Float::DIG)
+      neg_inf.finite?.should == false
+      neg_inf.should < 0
+    end
+  end
+
   it "allows for [eEdD] as exponent separator" do
     reference = BigDecimal("12345.67E89")
 

src/main/java/org/truffleruby/stdlib/bigdecimal/CreateBigDecimalNode.java

@@ -15,6 +15,7 @@
 import com.oracle.truffle.api.dsl.NodeChild;
 import com.oracle.truffle.api.dsl.Specialization;
 import com.oracle.truffle.api.object.DynamicObject;
+import com.oracle.truffle.api.profiles.BranchProfile;
 import com.oracle.truffle.api.profiles.ConditionProfile;
 import org.truffleruby.Layouts;
 import org.truffleruby.core.cast.BooleanCastNode;
@@ -68,16 +69,33 @@ public DynamicObject create(long value, int digits,
     }
 
     @Specialization
-    public DynamicObject create(double value, NotProvided digits) {
-        throw new RaiseException(getContext(), coreExceptions().argumentErrorCantOmitPrecision(this));
+    public DynamicObject create(double value, NotProvided digits,
+            @Cached("createBinaryProfile()") ConditionProfile finiteValueProfile,
+            @Cached("create()") BranchProfile nanProfile,
+            @Cached("create()") BranchProfile positiveInfinityProfile,
+            @Cached("create()") BranchProfile negativeInfinityProfile) {
+        if (finiteValueProfile.profile(Double.isFinite(value))) {
+            throw new RaiseException(getContext(), coreExceptions().argumentErrorCantOmitPrecision(this));
+        } else {
+            return createNonFiniteBigDecimal(value, nanProfile, positiveInfinityProfile, negativeInfinityProfile);
+        }
     }
 
     @Specialization
     public DynamicObject create(double value, int digits,
-            @Cached("create()") BigDecimalCastNode bigDecimalCastNode) {
-        final RoundingMode roundMode = getRoundMode();
-        final BigDecimal bigDecimal = (BigDecimal) bigDecimalCastNode.execute(value, roundMode);
-        return createNormalBigDecimal(round(bigDecimal, new MathContext(digits, roundMode)));
+            @Cached("create()") BigDecimalCastNode bigDecimalCastNode,
+            @Cached("createBinaryProfile()") ConditionProfile finiteValueProfile,
+            @Cached("create()") BranchProfile nanProfile,
+            @Cached("create()") BranchProfile positiveInfinityProfile,
+            @Cached("create()") BranchProfile negativeInfinityProfile) {
+        if (finiteValueProfile.profile(Double.isFinite(value))) {
+            final RoundingMode roundMode = getRoundMode();
+            final BigDecimal bigDecimal = (BigDecimal) bigDecimalCastNode.execute(value, roundMode);
+
+            return createNormalBigDecimal(round(bigDecimal, new MathContext(digits, roundMode)));
+        } else {
+            return createNonFiniteBigDecimal(value, nanProfile, positiveInfinityProfile, negativeInfinityProfile);
+        }
     }
 
     @Specialization(guards = "type == NEGATIVE_INFINITY || type == POSITIVE_INFINITY")
@@ -249,4 +267,20 @@ private Object getValueFromString(String string, int digits) {
         }
     }
 
+    private DynamicObject createNonFiniteBigDecimal(double value, BranchProfile nanProfile,
+            BranchProfile positiveInfinityProfile, BranchProfile negativeInfinityProfile) {
+        if (Double.isNaN(value)) {
+            nanProfile.enter();
+            return createSpecialBigDecimal(BigDecimalType.NAN);
+        } else {
+            if (value == Double.POSITIVE_INFINITY) {
+                positiveInfinityProfile.enter();
+                return createSpecialBigDecimal(BigDecimalType.POSITIVE_INFINITY);
+            } else {
+                negativeInfinityProfile.enter();
+                return createSpecialBigDecimal(BigDecimalType.NEGATIVE_INFINITY);
+            }
+        }
+    }
+
 }