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

.changes/next-release/feature-6289218d427df9d332b7104ad0012f630797168f.json

@@ -0,0 +1,7 @@
+{
+  "type": "feature",
+  "description": "Fix issues handling high-precision numbers",
+  "pull_requests": [
+    "[#3004](https://github.com/smithy-lang/smithy/pull/3004)"
+  ]
+}

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

@@ -10,6 +10,7 @@
 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> {
 
@@ -468,12 +469,7 @@ private Token parseNumber() {
         String lexeme = sliceFrom(start);
 
         try {
-            Number number;
-            if (lexeme.contains(".") || lexeme.toLowerCase().contains("e")) {
-                number = Double.parseDouble(lexeme);
-            } else {
-                number = Long.parseLong(lexeme);
-            }
+            Number number = NumberUtils.parseNumber(lexeme);
             LiteralExpression node = new LiteralExpression(number, currentLine, currentColumn);
             return new Token(TokenType.NUMBER, node, currentLine, currentColumn);
         } catch (NumberFormatException e) {

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

@@ -10,8 +10,10 @@
 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.math.BigDecimal;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collections;
@@ -542,6 +544,49 @@ 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(BigDecimal.class)));
+        assertThat(value.toString(), equalTo("9007199254740993.0"));
+    }
+
+    @Test
+    public void parsesOverflowPositiveDoubleAsBigDecimal() {
+        // 1e309 overflows Double to +Infinity, but is a valid BigDecimal.
+        List<Token> tokens = tokenize("1e309");
+
+        assertThat(tokens.get(0).type, equalTo(TokenType.NUMBER));
+        Number value = tokens.get(0).value.expectNumberValue();
+        assertThat(value, is(instanceOf(BigDecimal.class)));
+        assertThat(value, equalTo(new BigDecimal("1e309")));
+    }
+
+    @Test
+    public void parsesOverflowNegativeDoubleAsBigDecimal() {
+        // -1e309 overflows Double to -Infinity, but is a valid BigDecimal.
+        List<Token> tokens = tokenize("-1e309");
+
+        assertThat(tokens.get(0).type, equalTo(TokenType.NUMBER));
+        Number value = tokens.get(0).value.expectNumberValue();
+        assertThat(value, is(instanceOf(BigDecimal.class)));
+        assertThat(value, equalTo(new BigDecimal("-1e309")));
+    }
+
     @Test
     public void detectsTopLevelInvalidSyntax() {
         Assertions.assertThrows(JmespathException.class, () -> Lexer.tokenize("~"));

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

@@ -4,10 +4,9 @@
  */
 package software.amazon.smithy.model.loader;
 
-import java.math.BigDecimal;
-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 {
@@ -318,22 +317,7 @@ private IdlToken parseComment() {
 
     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)) {
-                    currentTokenNumber = value;
-                } else {
-                    currentTokenNumber = new BigDecimal(lexeme);
-                }
-            } else {
-                try {
-                    currentTokenNumber = Long.parseLong(lexeme);
-                } catch (NumberFormatException e) {
-                    currentTokenNumber = new BigInteger(lexeme);
-                }
-            }
-
+            currentTokenNumber = NumberUtils.parseNumber(ParserUtils.parseNumber(parser));
             currentTokenEnd = parser.position();
             return currentTokenType = IdlToken.NUMBER;
         } catch (RuntimeException e) {

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

@@ -6,8 +6,6 @@
 
 import java.io.StringWriter;
 import java.io.Writer;
-import java.math.BigDecimal;
-import java.math.BigInteger;
 import software.amazon.smithy.model.SourceLocation;
 import software.amazon.smithy.model.node.ArrayNode;
 import software.amazon.smithy.model.node.BooleanNode;
@@ -16,6 +14,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
@@ -69,21 +68,7 @@ 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)) {
-                value = new NumberNode(doubleValue, location);
-            } else {
-                value = new NumberNode(new BigDecimal(string), location);
-            }
-        } else {
-            try {
-                value = new NumberNode(Long.parseLong(string), location);
-            } catch (NumberFormatException e) {
-                value = new NumberNode(new BigInteger(string), location);
-            }
-
-        }
+        value = new NumberNode(NumberUtils.parseNumber(string), location);
     }
 
     @Override

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,49 @@ 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 parsesOverflowPositiveDoubleAsBigDecimal() {
+        // 1e309 overflows Double to +Infinity, but is a valid BigDecimal.
+        IdlTokenizer tokenizer = IdlTokenizer.create("1e309");
+
+        assertThat(tokenizer.next(), is(IdlToken.NUMBER));
+        Number value = tokenizer.getCurrentTokenNumberValue();
+        assertThat(value, instanceOf(java.math.BigDecimal.class));
+        assertThat(value, equalTo(new java.math.BigDecimal("1e309")));
+    }
+
+    @Test
+    public void parsesOverflowNegativeDoubleAsBigDecimal() {
+        // -1e309 overflows Double to -Infinity, but is a valid BigDecimal.
+        IdlTokenizer tokenizer = IdlTokenizer.create("-1e309");
+
+        assertThat(tokenizer.next(), is(IdlToken.NUMBER));
+        Number value = tokenizer.getCurrentTokenNumberValue();
+        assertThat(value, instanceOf(java.math.BigDecimal.class));
+        assertThat(value, equalTo(new java.math.BigDecimal("-1e309")));
+    }
+
     @Test
     public void throwsWhenAccessingStringValue() {
         IdlTokenizer tokenizer = IdlTokenizer.create("10");

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

@@ -6,9 +6,11 @@
 
 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;
 
+import java.math.BigDecimal;
 import java.util.Map;
 import org.junit.jupiter.api.Assertions;
 import org.junit.jupiter.api.Test;
@@ -69,11 +71,49 @@ 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(BigDecimal.class)));
+        assertThat(numberNode.getValue().toString(), equalTo("9007199254740993.0"));
+        assertThat(numberNode.getSourceLocation().getLine(), is(1));
+        assertThat(numberNode.getSourceLocation().getColumn(), is(1));
+    }
+
+    @Test
+    public void parsesOverflowPositiveDoubleAsBigDecimal() {
+        // 1e309 overflows Double to +Infinity, but is a valid BigDecimal.
+        Node result = Node.parse("1e309");
+
+        NumberNode numberNode = result.expectNumberNode();
+        assertThat(numberNode.getValue(), is(instanceOf(BigDecimal.class)));
+        assertThat(numberNode.getValue(), equalTo(new BigDecimal("1e309")));
+        assertThat(numberNode.getSourceLocation().getLine(), is(1));
+        assertThat(numberNode.getSourceLocation().getColumn(), is(1));
+    }
+
+    @Test
+    public void parsesOverflowNegativeDoubleAsBigDecimal() {
+        // -1e309 overflows Double to -Infinity, but is a valid BigDecimal.
+        Node result = Node.parse("-1e309");
+
+        NumberNode numberNode = result.expectNumberNode();
+        assertThat(numberNode.getValue(), is(instanceOf(BigDecimal.class)));
+        assertThat(numberNode.getValue(), equalTo(new BigDecimal("-1e309")));
+        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,80 @@
+/*
+ * 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;
+import java.math.BigInteger;
+
+/**
+ * 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;
+    }
+
+    /**
+     * Parses a decimal (floating-point or scientific notation) string into the
+     * most precise Number type that preserves the value.
+     *
+     * <p>Returns a {@link Double} when the value can be represented without
+     * precision loss. Returns a {@link BigDecimal} when the value exceeds
+     * double range (would become infinity) or loses precision in IEEE-754.
+     *
+     * @param lexeme A numeric string containing "." or "e"/"E".
+     * @return A Double or BigDecimal representing the parsed value.
+     */
+    public static Number parseDecimalNumber(String lexeme) {
+        Double doubleValue = Double.valueOf(lexeme);
+        if (doubleValue.isNaN()) {
+            return doubleValue;
+        }
+        if (lexeme.contains("I")) {
+            return doubleValue;
+        }
+        if (doubleValue.isInfinite()) {
+            // Doubles parse values outside their range as infinity.
+            // Literal infinity is handled by the `I` test, so parse the real value.
+            return new BigDecimal(lexeme);
+        }
+        BigDecimal bigDecimalValue = new BigDecimal(lexeme);
+        if (isDoublePrecisionCompatible(bigDecimalValue, doubleValue)) {
+            return doubleValue;
+        }
+        return bigDecimalValue;
+    }
+
+    /**
+     * Parses a numeric string into the most appropriate Number type.
+     *
+     * <p>Strings containing ".", "e", or "E" are treated as decimal numbers
+     * and parsed via {@link #parseDecimalNumber}. All other strings are
+     * parsed as integers, trying {@link Long} first and falling back to
+     * {@link BigInteger} for values that overflow long.
+     *
+     * @param lexeme A numeric string.
+     * @return A Long, BigInteger, Double, or BigDecimal representing the value.
+     */
+    public static Number parseNumber(String lexeme) {
+        if (lexeme.contains("e") || lexeme.contains("E") || lexeme.contains(".")) {
+            return parseDecimalNumber(lexeme);
+        }
+        try {
+            return Long.parseLong(lexeme);
+        } catch (NumberFormatException e) {
+            return new BigInteger(lexeme);
+        }
+    }
+}