KT-81043 String.toBigDecimalOrNull should handle all supported strings

BigDecimal has its own format, different from the one
supported for String.toFloat and String.toDouble.
As a result, String.toBigDecimalOrNull was rejecting some valid inputs.

This replaces the validation shared between toFloat and toDouble,
with a one specific to String.toBigDecimalOrNull.

^KT-81043 Fixed

Merge-request: KT-MR-23651
Merged-by: Filipp Zhinkin <[email protected]>

Author: fzhinkin

libraries/stdlib/jvm/src/kotlin/text/StringNumberConversionsJVM.kt

@@ -250,7 +250,7 @@ public inline fun String.toBigDecimal(mathContext: java.math.MathContext): java.
  */
 @SinceKotlin("1.2")
 public fun String.toBigDecimalOrNull(): java.math.BigDecimal? =
-    screenFloatValue(this) { it.toBigDecimal() }
+    screenBigDecimalValue(this) { it.toBigDecimal() }
 
 /**
  * Parses the string as a [java.math.BigDecimal] number and returns the result
@@ -261,7 +261,7 @@ public fun String.toBigDecimalOrNull(): java.math.BigDecimal? =
  */
 @SinceKotlin("1.2")
 public fun String.toBigDecimalOrNull(mathContext: java.math.MathContext): java.math.BigDecimal? =
-    screenFloatValue(this) { it.toBigDecimal(mathContext) }
+    screenBigDecimalValue(this) { it.toBigDecimal(mathContext) }
 
 private inline fun <T> screenFloatValue(str: String, parse: (String) -> T): T? {
     return try {
@@ -274,6 +274,18 @@ private inline fun <T> screenFloatValue(str: String, parse: (String) -> T): T? {
     }
 }
 
+private inline fun <T> screenBigDecimalValue(str: String, parse: (String) -> T): T? {
+    return try {
+        if (isValidBigDecimal(str)) {
+            parse(str)
+        } else {
+            null
+        }
+    } catch (_: NumberFormatException) {
+        null
+    }
+}
+
 private fun isValidFloat(s: String): Boolean {
     // A float can have one of two representations:
     //
@@ -396,6 +408,51 @@ private fun isValidFloat(s: String): Boolean {
     return false
 }
 
+private fun isValidBigDecimal(s: String): Boolean {
+    if (s.isEmpty()) return false
+    // BigDecimal could be constructed from a string with a following format:
+    // BigDecimal := Sign? Significand Exponent?
+    // Sign := '-' | '+'
+    // Significand := IntegerPart '.' FractionalPart?
+    //              | '.' FractionalPart
+    //              | IntegerPart
+    // IntegerPart := Digits
+    // FractionalPart := Digits
+    // Exponent := ExponentIndicator SignedInteger
+    // ExponentIndicator := 'e' | 'E'
+    // SignedInteger := Sign? Digits
+    // Digits := Digit+
+    // Digits := Char, such as isDigit returns true
+
+    // consume optional sign
+    val start = if (s[0] == '-' || s[0] == '+') 1 else 0
+    // consume significand's integer part
+    var index = s.skipWhile(start) { it.isDigit() }
+    // if we ran out of characters, did we consume any digits?
+    if (index == s.length) return index - start > 0
+    // we found a dot, let's parse a fractional part
+    if (s[index] == '.') {
+        index++
+        // fraction could be empty, but only if an integer part contained any digits
+        if (index == s.length) return index - start > 1
+        // fraction could contain only digits
+        index = s.skipWhile(index) { it.isDigit() }
+    }
+    // nothing left, we're good
+    if (index == s.length) return true
+    // only exponent is expected here
+    if (s[index] != 'e' && s[index] != 'E') return false
+    index++ // consume exponent indicator
+    if (index == s.length) return false
+    // consume an optional sign
+    if (s[index] == '+' || s[index] == '-') index++
+    // there should be something after sign
+    if (index == s.length) return false
+    // and it could only contain digits
+    index = s.skipWhile(index) { it.isDigit() }
+    return index == s.length
+}
+
 /**
  * Given a [start] and [endInclusive] index in a string, returns what possible float
  * named constant could be in that string. For instance, if there are 3 characters

libraries/stdlib/jvm/test/text/StringNumberConversionJVMTest.kt

@@ -1,11 +1,10 @@
 /*
- * Copyright 2010-2018 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Copyright 2010-2025 JetBrains s.r.o. and Kotlin Programming Language contributors.
  * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
  */
 
 package test.text
 
-import test.*
 import kotlin.test.*
 
 class StringNumberConversionJVMTest {
@@ -77,17 +76,43 @@ class StringNumberConversionJVMTest {
             assertProduces("-77", bd("-77"))
             assertProduces("-77.0", bd("-77.0"))
             assertProduces("77.", bd("77"))
+            assertProduces(".77", bd("0.77"))
             assertProduces("123456789012345678901234567890.123456789", bd("123456789012345678901234567890.123456789"))
             assertProduces("-1.77", bd("-1.77"))
             assertProduces("+.77", bd("0.77"))
             assertProduces("7.7e1", bd("77"))
+            assertProduces("7.7E1", bd("77"))
+            assertProduces("7.e1", bd("7E+1"))
+            assertProduces("-7E+1", bd("-7E+1"))
+            assertProduces(".7E1", bd("7"))
             assertProduces("+770e-1", bd("77.0"))
+            assertProduces("৪೦໑.۵၅", bd("401.55"))
+            assertProduces("-.1e-1", bd("-0.01"))
+            assertProduces("-.1e+1", bd("-1"))
+            assertProduces("+1", bd("1"))
+            assertProduces("-1", bd("-1"))
 
             assertFailsOrNull("7..7")
             assertFailsOrNull("\t-77 \n")
             assertFailsOrNull("007 not a number")
             assertFailsOrNull("")
             assertFailsOrNull("   ")
+            assertFailsOrNull(" 3.14")
+            assertFailsOrNull("3.14 ")
+            assertFailsOrNull("0x77p1")
+            assertFailsOrNull("++123")
+            assertFailsOrNull("--123")
+            assertFailsOrNull("+-123")
+            assertFailsOrNull(".")
+            assertFailsOrNull("-.e-")
+            assertFailsOrNull("-.e-1")
+            assertFailsOrNull("-.1e+1e")
+            assertFailsOrNull("e")
+            assertFailsOrNull("e1")
+            assertFailsOrNull("e+1")
+            assertFailsOrNull("\u058A1") // ֊1
+            assertFailsOrNull("\u207A1") // ⁺1
+            assertFailsOrNull("123.A10")
         }
 
         var mc = java.math.MathContext(3, java.math.RoundingMode.UP)
@@ -101,4 +126,4 @@ class StringNumberConversionJVMTest {
         }
     }
 
-}
+}

libraries/stdlib/src/kotlin/text/Strings.kt

@@ -1640,3 +1640,20 @@ public fun String.toBooleanStrictOrNull(): Boolean? = when (this) {
     "false" -> false
     else -> null
 }
+
+/**
+ * Scans the string (skips its characters) starting from [startIndex] until [predicate] return `false`,
+ * and returns the index of the first character rejected by the predicate, or the length of [this] string,
+ * whichever is reached first.
+ *
+ * This function is intended for internal use only and does not validate [startIndex] index value.
+ *
+ * @param startIndex the index to start scanning from
+ * @param predicate a test applied to each character of the scanned string prefix
+ * @return the index of a first character not conforming to the [predicate], or the length of this string, if all characters conform it.
+ */
+internal inline fun String.skipWhile(startIndex: Int, predicate: (Char) -> Boolean): Int {
+    var i = startIndex
+    while (i < length && predicate(this[i])) i++
+    return i
+}

libraries/stdlib/src/kotlin/time/Duration.kt

@@ -1436,19 +1436,6 @@ private inline fun handleError(throwException: Boolean, message: String = ""): D
  */
 private inline fun Duration.onInvalid(block: () -> Duration?): Duration? = if (this == Duration.INVALID) block() else this
 
-/**
- * Skips characters in this string starting from the given index while they match the predicate.
- *
- * @param startIndex the index to start skipping from
- * @param predicate condition to test each character
- * @return the index of the first character that doesn't match the predicate, or string length
- */
-private inline fun String.skipWhile(startIndex: Int, predicate: (Char) -> Boolean): Int {
-    var i = startIndex
-    while (i < length && predicate(this[i])) i++
-    return i
-}
-
 /**
  * Parses a duration unit from its default format short name at the given position.
  *