Fix issues handling high-precision numbers

The Double.isFinite method was incorrectly used to detect if a value would
fit in a double. The method handles this properly, but it's not actually what
we want - we want to know if the value will be accurately represented by a
double.

To resolve this, a NumberUtils class is added with a method that validates
precision compatibility. Tests are added for this and all call sites to
ensure the behavior remains consistent.

Author: kstich

smithy-jmespath/build.gradle.kts

@@ -10,3 +10,7 @@ description = "A standalone JMESPath parser"
 
 extra["displayName"] = "Smithy :: JMESPath"
 extra["moduleName"] = "software.amazon.smithy.jmespath"
+
+dependencies {
+    api(project(":smithy-utils"))
+}

smithy-jmespath/src/main/java/software/amazon/smithy/jmespath/Lexer.java

@@ -4,12 +4,14 @@
  */
 package software.amazon.smithy.jmespath;
 
+import java.math.BigDecimal;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Objects;
 import java.util.function.Predicate;
 import software.amazon.smithy.jmespath.ast.LiteralExpression;
 import software.amazon.smithy.jmespath.evaluation.JmespathRuntime;
+import software.amazon.smithy.utils.NumberUtils;
 
 final class Lexer<T> {
 
@@ -470,7 +472,17 @@ private Token parseNumber() {
         try {
             Number number;
             if (lexeme.contains(".") || lexeme.toLowerCase().contains("e")) {
-                number = Double.parseDouble(lexeme);
+                Double doubleValue = Double.parseDouble(lexeme);
+                if (doubleValue.isInfinite() || doubleValue.isNaN()) {
+                    number = doubleValue;
+                } else {
+                    BigDecimal bigDecimalValue = new BigDecimal(lexeme);
+                    if (NumberUtils.isDoublePrecisionCompatible(bigDecimalValue, doubleValue)) {
+                        number = doubleValue;
+                    } else {
+                        number = bigDecimalValue;
+                    }
+                }
             } else {
                 number = Long.parseLong(lexeme);
             }
@@ -481,6 +493,8 @@ private Token parseNumber() {
         }
     }
 
+
+
     private String createInvalidNumberString(int startPosition, String message) {
         String lexeme = sliceFrom(startPosition);
         return String.format("Invalid number '%s': %s", lexeme, message);

smithy-jmespath/src/test/java/software/amazon/smithy/jmespath/LexerTest.java

@@ -10,6 +10,7 @@
 import static org.hamcrest.Matchers.empty;
 import static org.hamcrest.Matchers.equalTo;
 import static org.hamcrest.Matchers.hasSize;
+import static org.hamcrest.Matchers.instanceOf;
 import static org.hamcrest.Matchers.is;
 
 import java.util.ArrayList;
@@ -542,6 +543,27 @@ public void parsesComplexNumbers() {
         assertThat(tokens.get(2).column, equalTo(25));
     }
 
+    @Test
+    public void parsesDoublePrecisionCompatibleNumber() {
+        List<Token> tokens = tokenize("1.5");
+
+        assertThat(tokens.get(0).type, equalTo(TokenType.NUMBER));
+        Number value = tokens.get(0).value.expectNumberValue();
+        assertThat(value, is(instanceOf(Double.class)));
+        assertThat(value.doubleValue(), equalTo(1.5));
+    }
+
+    @Test
+    public void parsesDoublePrecisionIncompatibleNumberAsBigDecimal() {
+        // 2^53 + 1 with a decimal triggers the float path but loses precision as a double.
+        List<Token> tokens = tokenize("9007199254740993.0");
+
+        assertThat(tokens.get(0).type, equalTo(TokenType.NUMBER));
+        Number value = tokens.get(0).value.expectNumberValue();
+        assertThat(value, is(instanceOf(java.math.BigDecimal.class)));
+        assertThat(value.toString(), equalTo("9007199254740993.0"));
+    }
+
     @Test
     public void detectsTopLevelInvalidSyntax() {
         Assertions.assertThrows(JmespathException.class, () -> Lexer.tokenize("~"));

smithy-model/src/main/java/software/amazon/smithy/model/loader/DefaultTokenizer.java

@@ -8,6 +8,7 @@
 import java.math.BigInteger;
 import java.util.NoSuchElementException;
 import software.amazon.smithy.model.SourceLocation;
+import software.amazon.smithy.utils.NumberUtils;
 import software.amazon.smithy.utils.SimpleParser;
 
 class DefaultTokenizer implements IdlTokenizer {
@@ -320,11 +321,16 @@ private IdlToken parseNumber() {
         try {
             String lexeme = ParserUtils.parseNumber(parser);
             if (lexeme.contains("e") || lexeme.contains("E") || lexeme.contains(".")) {
-                double value = Double.parseDouble(lexeme);
-                if (Double.isFinite(value)) {
+                Double value = Double.valueOf(lexeme);
+                if (value.isInfinite() || value.isNaN()) {
                     currentTokenNumber = value;
                 } else {
-                    currentTokenNumber = new BigDecimal(lexeme);
+                    BigDecimal bigDecimalValue = new BigDecimal(lexeme);
+                    if (NumberUtils.isDoublePrecisionCompatible(bigDecimalValue, value)) {
+                        currentTokenNumber = value;
+                    } else {
+                        currentTokenNumber = bigDecimalValue;
+                    }
                 }
             } else {
                 try {
@@ -348,6 +354,8 @@ private IdlToken parseNumber() {
         }
     }
 
+
+
     private IdlToken parseIdentifier() {
         try {
             ParserUtils.consumeIdentifier(parser);

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

@@ -34,6 +34,13 @@ public NumberNode(Number value, SourceLocation sourceLocation) {
         this.value = toBigDecimal(originalValue);
     }
 
+    public NumberNode(Number value, BigDecimal bigDecimalValue, SourceLocation sourceLocation) {
+        super(sourceLocation);
+        originalValue = value;
+        stringCache = value.toString();
+        this.value = bigDecimalValue;
+    }
+
     private BigDecimal toBigDecimal(Number value) {
         if (value instanceof BigDecimal) {
             return (BigDecimal) value;

smithy-model/src/main/java/software/amazon/smithy/model/node/internal/NodeHandler.java

@@ -16,6 +16,7 @@
 import software.amazon.smithy.model.node.NumberNode;
 import software.amazon.smithy.model.node.ObjectNode;
 import software.amazon.smithy.model.node.StringNode;
+import software.amazon.smithy.utils.NumberUtils;
 import software.amazon.smithy.utils.SmithyInternalApi;
 
 @SmithyInternalApi
@@ -70,19 +71,23 @@ void endString(String string, SourceLocation location) {
     @Override
     void endNumber(String string, SourceLocation location) {
         if (string.contains("e") || string.contains("E") || string.contains(".")) {
-            double doubleValue = Double.parseDouble(string);
-            if (Double.isFinite(doubleValue)) {
+            Double doubleValue = Double.valueOf(string);
+            if (doubleValue.isInfinite() || doubleValue.isNaN()) {
                 value = new NumberNode(doubleValue, location);
             } else {
-                value = new NumberNode(new BigDecimal(string), location);
+                BigDecimal bigDecimalValue = new BigDecimal(string);
+                if (NumberUtils.isDoublePrecisionCompatible(bigDecimalValue, doubleValue)) {
+                    value = new NumberNode(doubleValue, bigDecimalValue, location);
+                } else {
+                    value = new NumberNode(bigDecimalValue, bigDecimalValue, location);
+                }
             }
         } else {
             try {
                 value = new NumberNode(Long.parseLong(string), location);
             } catch (NumberFormatException e) {
                 value = new NumberNode(new BigInteger(string), location);
             }
-
         }
     }
 

smithy-model/src/test/java/software/amazon/smithy/model/loader/TokenizerTest.java

@@ -6,6 +6,7 @@
 
 import static org.hamcrest.MatcherAssert.assertThat;
 import static org.hamcrest.Matchers.equalTo;
+import static org.hamcrest.Matchers.instanceOf;
 import static org.hamcrest.Matchers.is;
 
 import java.util.NoSuchElementException;
@@ -199,6 +200,27 @@ public void storesCurrentTokenNumber() {
         assertThat(tokenizer.getCurrentTokenNumberValue(), equalTo(10L));
     }
 
+    @Test
+    public void parsesDoublePrecisionCompatibleFloat() {
+        IdlTokenizer tokenizer = IdlTokenizer.create("1.5");
+
+        assertThat(tokenizer.next(), is(IdlToken.NUMBER));
+        Number value = tokenizer.getCurrentTokenNumberValue();
+        assertThat(value, instanceOf(Double.class));
+        assertThat(value.doubleValue(), equalTo(1.5));
+    }
+
+    @Test
+    public void parsesDoublePrecisionIncompatibleFloatAsBigDecimal() {
+        // 2^53 + 1 with a decimal triggers the float path but loses precision as a double.
+        IdlTokenizer tokenizer = IdlTokenizer.create("9007199254740993.0");
+
+        assertThat(tokenizer.next(), is(IdlToken.NUMBER));
+        Number value = tokenizer.getCurrentTokenNumberValue();
+        assertThat(value, instanceOf(java.math.BigDecimal.class));
+        assertThat(value.toString(), equalTo("9007199254740993.0"));
+    }
+
     @Test
     public void throwsWhenAccessingStringValue() {
         IdlTokenizer tokenizer = IdlTokenizer.create("10");

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

@@ -6,6 +6,7 @@
 
 import static org.hamcrest.MatcherAssert.assertThat;
 import static org.hamcrest.Matchers.equalTo;
+import static org.hamcrest.Matchers.instanceOf;
 import static org.hamcrest.Matchers.is;
 import static org.hamcrest.Matchers.startsWith;
 
@@ -69,11 +70,25 @@ public void parsesFloatNode() {
         Node result = Node.parse("1.5");
 
         assertThat(result.isNumberNode(), is(true));
+        assertThat(result.expectNumberNode().getValue(), is(instanceOf(Double.class)));
         assertThat(result.expectNumberNode().getValue(), equalTo(1.5));
         assertThat(result.getSourceLocation().getLine(), is(1));
         assertThat(result.getSourceLocation().getColumn(), is(1));
     }
 
+    @Test
+    public void parsesDoublePrecisionIncompatibleNumberAsBigDecimal() {
+        // 2^53 + 1 with a decimal triggers the float path but loses precision as a double.
+        Node result = Node.parse("9007199254740993.0");
+        assertThat(result.isNumberNode(), is(true));
+
+        NumberNode numberNode = result.expectNumberNode();
+        assertThat(numberNode.getValue(), is(instanceOf(java.math.BigDecimal.class)));
+        assertThat(numberNode.getValue().toString(), equalTo("9007199254740993.0"));
+        assertThat(numberNode.getSourceLocation().getLine(), is(1));
+        assertThat(numberNode.getSourceLocation().getColumn(), is(1));
+    }
+
     @Test
     public void parsesEmptyArray() {
         Node result = Node.parse("[]");

smithy-utils/src/main/java/software/amazon/smithy/utils/NumberUtils.java

@@ -0,0 +1,26 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+package software.amazon.smithy.utils;
+
+import java.math.BigDecimal;
+
+/**
+ * Functions that make working with numbers easier.
+ */
+public final class NumberUtils {
+    private NumberUtils() {}
+
+    /**
+     * Checks whether the bigDecimalValue is represented in the doubleValue without
+     * a loss of precision due to IEEE-754 floating-point representation.
+     * 
+     * @param bigDecimalValue The value as a BigDecimal.
+     * @param doubleValue The value as a double.
+     * @return true if the bigDecimalValue is precisely represented by the doubleValue.
+     */
+    public static boolean isDoublePrecisionCompatible(BigDecimal bigDecimalValue, Double doubleValue) {
+        return bigDecimalValue.compareTo(BigDecimal.valueOf(doubleValue)) == 0;
+    }
+}

smithy-utils/src/test/java/software/amazon/smithy/utils/NumberUtilsTest.java

@@ -0,0 +1,95 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+package software.amazon.smithy.utils;
+
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.is;
+
+import java.math.BigDecimal;
+import java.util.stream.Stream;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
+
+public class NumberUtilsTest {
+
+    @ParameterizedTest
+    @MethodSource("compatibleValues")
+    public void detectsDoublePrecisionCompatibleValues(BigDecimal bd, Double d) {
+        assertThat(NumberUtils.isDoublePrecisionCompatible(bd, d), is(true));
+    }
+
+    static Stream<Arguments> compatibleValues() {
+        return Stream.of(
+                // Zero
+                Arguments.of(new BigDecimal("0"), 0.0),
+                // Negative zero is mathematically equal to zero
+                Arguments.of(new BigDecimal("0"), -0.0),
+                // Small positive integer
+                Arguments.of(new BigDecimal("1"), 1.0),
+                // Trailing zeros in BigDecimal scale don't affect compareTo
+                Arguments.of(new BigDecimal("1.00"), 1.0),
+                // Negative integer
+                Arguments.of(new BigDecimal("-42"), -42.0),
+                // Simple decimal that doubles represent exactly
+                Arguments.of(new BigDecimal("0.5"), 0.5),
+                // Power-of-two fraction
+                Arguments.of(new BigDecimal("0.25"), 0.25),
+                // Another power-of-two fraction
+                Arguments.of(new BigDecimal("0.125"), 0.125),
+                // Larger exact integer within double range
+                Arguments.of(new BigDecimal("1048576"), 1048576.0),
+                // Max safe integer for doubles (2^53)
+                Arguments.of(new BigDecimal("9007199254740992"), 9007199254740992.0),
+                // Negative max safe integer
+                Arguments.of(new BigDecimal("-9007199254740992"), -9007199254740992.0),
+                // Small negative decimal
+                Arguments.of(new BigDecimal("-0.5"), -0.5),
+                // Double.MAX_VALUE round-trips through Double.toString
+                Arguments.of(new BigDecimal(String.valueOf(Double.MAX_VALUE)), Double.MAX_VALUE),
+                // Double.MIN_VALUE round-trips through Double.toString
+                Arguments.of(new BigDecimal(String.valueOf(Double.MIN_VALUE)), Double.MIN_VALUE),
+                // 0.1 round-trips: BigDecimal.valueOf(0.1) equals BigDecimal("0.1")
+                Arguments.of(new BigDecimal("0.1"), 0.1),
+                // 0.2 round-trips cleanly
+                Arguments.of(new BigDecimal("0.2"), 0.2),
+                // 0.3 round-trips cleanly
+                Arguments.of(new BigDecimal("0.3"), 0.3),
+                // Negative decimal round-trips cleanly
+                Arguments.of(new BigDecimal("-0.1"), -0.1)
+        );
+    }
+
+    @ParameterizedTest
+    @MethodSource("incompatibleValues")
+    public void detectsDoublePrecisionIncompatibleValues(BigDecimal bd, Double d) {
+        assertThat(NumberUtils.isDoublePrecisionCompatible(bd, d), is(false));
+    }
+
+    static Stream<Arguments> incompatibleValues() {
+        return Stream.of(
+                // Integer beyond 2^53 loses precision
+                Arguments.of(new BigDecimal("9007199254740993"), 9007199254740993.0),
+                // Large integer that rounds in double
+                Arguments.of(new BigDecimal("9007199254740995"), 9007199254740995.0),
+                // High-precision decimal beyond what double can distinguish
+                Arguments.of(new BigDecimal("1.0000000000000001"), 1.0000000000000001),
+                // Precision loss in negative large integer
+                Arguments.of(new BigDecimal("-9007199254740993"), -9007199254740993.0),
+                // Decimal with many significant digits
+                Arguments.of(new BigDecimal("123456789.123456789"), 123456789.123456789),
+                // Small value with precision beyond double's capability
+                Arguments.of(new BigDecimal("0.10000000000000001"), 0.10000000000000001),
+                // Precision beyond what Double.toString preserves
+                Arguments.of(new BigDecimal("3.141592653589793238"), 3.141592653589793238),
+                // Very small difference from an integer, not representable at stated precision
+                Arguments.of(new BigDecimal("2.00000000000000005"), 2.00000000000000005),
+                // Large number with fractional precision loss
+                Arguments.of(new BigDecimal("1e308").add(new BigDecimal("1")), 1e308),
+                // Negative high-precision decimal beyond double's digits
+                Arguments.of(new BigDecimal("-0.123456789012345678"), -0.123456789012345678)
+        );
+    }
+}