Improve number normalization in NumberNode

This change now makes the BigDecimal get created eagerly, and accounts
for NaN and Infinity. The previous implementation would have failed
in these cases. The node validation visitor now uses the computed
BigDecimal rather than create a one-off each time. It also doesn't
recreate the already available BigDecimcal of the range trait.

Author: mtdowling

smithy-model/src/main/java/software/amazon/smithy/model/node/NumberNode.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2019 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
  *
  * Licensed under the Apache License, Version 2.0 (the "License").
  * You may not use this file except in compliance with the License.
@@ -16,7 +16,6 @@
 package software.amazon.smithy.model.node;
 
 import java.math.BigDecimal;
-import java.math.BigInteger;
 import java.util.Objects;
 import java.util.Optional;
 import java.util.function.Supplier;
@@ -31,17 +30,48 @@
  */
 public final class NumberNode extends Node {
 
-    private final Number value;
+    private final BigDecimal value;
+    private final Number originalValue;
     private final String stringCache;
-    private volatile BigDecimal equality;
+    private boolean isNaN;
+    private boolean isPositiveInfinity;
+    private boolean isNegativeInfinity;
 
     public NumberNode(Number value, SourceLocation sourceLocation) {
         super(sourceLocation);
-        this.value = Objects.requireNonNull(value);
+        originalValue = value;
         stringCache = value.toString();
+        this.value = toBigDecimal(originalValue);
+    }
 
+    private BigDecimal toBigDecimal(Number value) {
         if (value instanceof BigDecimal) {
-            equality = (BigDecimal) value;
+            return (BigDecimal) value;
+        } else if (value instanceof Integer) {
+            return BigDecimal.valueOf(value.intValue());
+        } else if (value instanceof Short) {
+            return BigDecimal.valueOf(value.shortValue());
+        } else if (value instanceof Byte) {
+            return BigDecimal.valueOf(value.byteValue());
+        } else if (value instanceof Long) {
+            return BigDecimal.valueOf(value.longValue());
+        } else if (value instanceof Float || value instanceof Double) {
+            double d = value.doubleValue();
+            if (Double.isNaN(d)) {
+                isNaN = true;
+                return null;
+            } else if (Double.isInfinite(d)) {
+                if (stringCache.startsWith("-")) {
+                    isNegativeInfinity = true;
+                } else {
+                    isPositiveInfinity = true;
+                }
+                return null;
+            } else {
+                return BigDecimal.valueOf(d);
+            }
+        } else {
+            return new BigDecimal(stringCache);
         }
     }
 
@@ -51,7 +81,18 @@ public NumberNode(Number value, SourceLocation sourceLocation) {
      * @return Returns a number.
      */
     public Number getValue() {
-        return value;
+        return originalValue;
+    }
+
+    /**
+     * Gets the number value as a BigDecimal if possible.
+     *
+     * <p>NaN and infinite numbers will return an empty Optional.
+     *
+     * @return Returns the BigDecimal value of the wrapped number.
+     */
+    public Optional<BigDecimal> asBigDecimal() {
+        return Optional.ofNullable(value);
     }
 
     /**
@@ -69,10 +110,30 @@ public boolean isNaturalNumber() {
      * @return Returns true if the node contains a floating point number.
      */
     public boolean isFloatingPointNumber() {
-        return value instanceof Float
-                || value instanceof Double
-                || value instanceof BigDecimal
-                || stringCache.contains(".");
+        return toString().contains(".")
+               || isInfinite()
+               || isNaN()
+               || value == null
+               || value.scale() > 0
+               || value.stripTrailingZeros().scale() > 0;
+    }
+
+    /**
+     * Returns true if the number is a floating point NaN.
+     *
+     * @return Return true if NaN.
+     */
+    public boolean isNaN() {
+        return isNaN;
+    }
+
+    /**
+     * Returns true if the number is infinite.
+     *
+     * @return Return true if infinite.
+     */
+    public boolean isInfinite() {
+        return isPositiveInfinity || isNegativeInfinity;
     }
 
     @Override
@@ -117,18 +178,15 @@ public Optional<NumberNode> asNumberNode() {
      * @return Returns true if set to zero.
      */
     public boolean isZero() {
-        // Do a cheap test based on the serialized value of the number first.
-        // This test covers byte, short, integer, and long.
-        if (toString().equals("0") || toString().equals("0.0")) {
+        if (isNegativeInfinity || isPositiveInfinity || isNaN) {
+            return false;
+        } else if (toString().equals("0") || toString().equals("0.0")) {
             return true;
-        } else if (value instanceof BigDecimal) {
-            return value.equals(BigDecimal.ZERO);
-        } else if (value instanceof BigInteger) {
-            return value.equals(BigInteger.ZERO);
-        } else if (value instanceof Float) {
-            return value.floatValue() == 0f;
+        } else if (value == null) {
+            // This case should never happen.
+            return false;
         } else {
-            return value.doubleValue() == 0d;
+            return value.compareTo(BigDecimal.ZERO) == 0;
         }
     }
 
@@ -139,42 +197,12 @@ public boolean equals(Object other) {
         } else if (other == this) {
             return true;
         } else {
-            NumberNode otherNode = (NumberNode) other;
-
-            // This only works if both values are the same type.
-            if (value.equals(otherNode.value)) {
-                return true;
-            }
-
-            // Attempt a cheap check based on the string cache.
-            if (stringCache.equals(otherNode.stringCache)) {
-                return true;
-            }
-
-            // Convert both to BigDecimal and compare equality.
-            return getEquality().equals(otherNode.getEquality());
-        }
-    }
-
-    private BigDecimal getEquality() {
-        BigDecimal e = equality;
-
-        if (e == null) {
-            if (value instanceof Integer) {
-                e = BigDecimal.valueOf(value.intValue());
-            } else if (value instanceof Short) {
-                e = BigDecimal.valueOf(value.shortValue());
-            } else if (value instanceof Byte) {
-                e = BigDecimal.valueOf(value.byteValue());
-            } else if (value instanceof Long) {
-                e = BigDecimal.valueOf(value.longValue());
-            } else {
-                e = new BigDecimal(stringCache);
-            }
-            equality = e;
+            NumberNode o = (NumberNode) other;
+            return isNaN == o.isNaN
+                   && isPositiveInfinity == o.isPositiveInfinity
+                   && isNegativeInfinity == o.isNegativeInfinity
+                   && Objects.equals(value, o.value);
         }
-
-        return e;
     }
 
     @Override

smithy-model/src/test/java/software/amazon/smithy/model/node/NumberNodeTest.java

@@ -199,6 +199,11 @@ public float floatValue() {
             public double doubleValue() {
                 return 0;
             }
+
+            @Override
+            public String toString() {
+                return "0.000";
+            }
         }, true);
         cases.put(new Number() {
             @Override