Fix some parsing bugs in default parsers (#447)

Fixes #443

Author: dkhalanskyjb

core/common/src/DateTimePeriod.kt

@@ -260,6 +260,7 @@ public sealed class DateTimePeriod {
             var minutes = 0
             var seconds = 0
             var nanoseconds = 0
+            var someComponentParsed = false
             while (true) {
                 if (i >= text.length) {
                     if (state == START)
@@ -270,6 +271,8 @@ public sealed class DateTimePeriod {
                         in Int.MIN_VALUE..Int.MAX_VALUE -> n.toInt()
                         else -> parseException("The total number of days under 'D' and 'W' designators should fit into an Int", 0)
                     }
+                    if (!someComponentParsed)
+                        parseException("At least one component is required, but none were found", 0)
                     return DateTimePeriod(years, months, daysTotal, hours, minutes, seconds, nanoseconds.toLong())
                 }
                 if (state == START) {
@@ -316,6 +319,7 @@ public sealed class DateTimePeriod {
                     }
                     i += 1
                 }
+                someComponentParsed = true
                 number *= localSign
                 if (i == text.length)
                     parseException("Expected a designator after the numerical value", i)

core/common/src/internal/util.kt

@@ -8,3 +8,33 @@ package kotlinx.datetime.internal
 internal fun Char.isAsciiDigit(): Boolean = this in '0'..'9'
 
 internal fun Char.asciiDigitToInt(): Int = this - '0'
+
+/** Working around the JSR-310 behavior of failing to parse long year numbers even when they start with leading zeros */
+private fun removeLeadingZerosFromLongYearForm(input: String, minStringLengthAfterYear: Int): String {
+    // the smallest string where the issue can occur is "+00000002024", its length is 12
+    val failingYearStringLength = 12
+    // happy path: the input is too short or the first character is not a sign, so the year is not in the long form
+    if (input.length < failingYearStringLength + minStringLengthAfterYear || input[0] !in "+-") return input
+    // the year is in the long form, so we need to remove the leading zeros
+    // find the `-` that separates the year from the month
+    val yearEnd = input.indexOf('-', 1)
+    // if (yearEnd == -1) return input // implied by the next condition
+    // if the year is too short, no need to remove the leading zeros, and if the string is malformed, just leave it
+    if (yearEnd < failingYearStringLength) return input
+    // how many leading zeroes are there?
+    var leadingZeros = 0
+    while (input[1 + leadingZeros] == '0') leadingZeros++ // no overflow, we know `-` is there
+    // even if we removed all leading zeros, the year would still be too long
+    if (yearEnd - leadingZeros >= failingYearStringLength) return input
+    // we remove just enough leading zeros to make the year the right length
+    // We need the resulting length to be `failYearStringLength - 1`, the current length is `yearEnd`.
+    // The difference is `yearEnd - failingYearStringLength + 1` characters to remove.
+    // Both the start index and the end index are shifted by 1 because of the sign.
+    return input.removeRange(startIndex = 1, endIndex = yearEnd - failingYearStringLength + 2)
+}
+
+internal fun removeLeadingZerosFromLongYearFormLocalDate(input: String) =
+    removeLeadingZerosFromLongYearForm(input.toString(), 6) // 6 = "-01-02".length
+
+internal fun removeLeadingZerosFromLongYearFormLocalDateTime(input: String) =
+    removeLeadingZerosFromLongYearForm(input.toString(), 12) // 12 = "-01-02T23:59".length

core/common/test/DateTimePeriodTest.kt

@@ -110,10 +110,14 @@ class DateTimePeriodTest {
         assertEquals(DateTimePeriod(nanoseconds = -999_999_999), DateTimePeriod.parse("-PT0.999999999S"))
         assertEquals(DateTimePeriod(days = 1, nanoseconds = -999_999_999), DateTimePeriod.parse("P1DT-0.999999999S"))
         assertPeriodComponents(DateTimePeriod.parse("P1DT-0.999999999S"), days = 1, nanoseconds = -999_999_999)
+        assertEquals(DatePeriod(days = 1), DateTimePeriod.parse("P000000000000000000000000000001D"))
+
+        assertFailsWith<IllegalArgumentException> { DateTimePeriod.parse("P") }
 
         // overflow of `Int.MAX_VALUE` months
         assertFailsWith<IllegalArgumentException> { DateTimePeriod.parse("P2000000000Y") }
         assertFailsWith<IllegalArgumentException> { DateTimePeriod.parse("P1Y2147483640M") }
+        assertFailsWith<IllegalArgumentException> { DateTimePeriod.parse("PT+-2H") }
 
         // too large a number in a field
         assertFailsWith<DateTimeFormatException> { DateTimePeriod.parse("P3000000000Y") }

core/common/test/LocalDateTest.kt

@@ -62,6 +62,10 @@ class LocalDateTest {
         checkParsedComponents("-10000-01-01", -10000, 1, 1)
         checkParsedComponents("+123456-01-01", 123456, 1, 1)
         checkParsedComponents("-123456-01-01", -123456, 1, 1)
+        for (i in 1..30) {
+            checkComponents(LocalDate.parse("+${"0".repeat(i)}2024-01-01"), 2024, 1, 1)
+            checkComponents(LocalDate.parse("-${"0".repeat(i)}2024-01-01"), -2024, 1, 1)
+        }
     }
 
     @Test

core/common/test/LocalDateTimeTest.kt

@@ -28,6 +28,11 @@ class LocalDateTimeTest {
         assertFailsWith<DateTimeFormatException> { LocalDateTime.parse("x") }
         assertFailsWith<DateTimeFormatException> { "+1000000000-03-26T04:00:00".toLocalDateTime() }
 
+        for (i in 1..30) {
+            checkComponents(LocalDateTime.parse("+${"0".repeat(i)}2024-01-01T23:59"), 2024, 1, 1, 23, 59)
+            checkComponents(LocalDateTime.parse("-${"0".repeat(i)}2024-01-01T23:59:03"), -2024, 1, 1, 23, 59, 3)
+        }
+
         /* Based on the ThreeTenBp project.
          * Copyright (c) 2007-present, Stephen Colebourne & Michael Nascimento Santos
          */

core/commonJs/src/LocalDate.kt

@@ -6,6 +6,7 @@
 package kotlinx.datetime
 
 import kotlinx.datetime.format.*
+import kotlinx.datetime.internal.removeLeadingZerosFromLongYearFormLocalDate
 import kotlinx.datetime.serializers.LocalDateIso8601Serializer
 import kotlinx.serialization.Serializable
 import kotlinx.datetime.internal.JSJoda.LocalDate as jtLocalDate
@@ -20,7 +21,8 @@ public actual class LocalDate internal constructor(internal val value: jtLocalDa
             format: DateTimeFormat<LocalDate>
         ): LocalDate = if (format === Formats.ISO) {
             try {
-                jsTry { jtLocalDate.parse(input.toString()) }.let(::LocalDate)
+                val sanitizedInput = removeLeadingZerosFromLongYearFormLocalDate(input.toString())
+                jsTry { jtLocalDate.parse(sanitizedInput.toString()) }.let(::LocalDate)
             } catch (e: Throwable) {
                 if (e.isJodaDateTimeParseException()) throw DateTimeFormatException(e)
                 throw e

core/commonJs/src/LocalDateTime.kt

@@ -7,6 +7,7 @@ package kotlinx.datetime
 import kotlinx.datetime.format.*
 import kotlinx.datetime.format.ISO_DATETIME
 import kotlinx.datetime.format.LocalDateTimeFormat
+import kotlinx.datetime.internal.removeLeadingZerosFromLongYearFormLocalDateTime
 import kotlinx.datetime.serializers.LocalDateTimeIso8601Serializer
 import kotlinx.serialization.Serializable
 import kotlinx.datetime.internal.JSJoda.LocalDateTime as jtLocalDateTime
@@ -57,7 +58,8 @@ public actual class LocalDateTime internal constructor(internal val value: jtLoc
         public actual fun parse(input: CharSequence, format: DateTimeFormat<LocalDateTime>): LocalDateTime =
             if (format === Formats.ISO) {
                 try {
-                    jsTry { jtLocalDateTime.parse(input.toString()) }.let(::LocalDateTime)
+                    val sanitizedInput = removeLeadingZerosFromLongYearFormLocalDateTime(input.toString())
+                    jsTry { jtLocalDateTime.parse(sanitizedInput.toString()) }.let(::LocalDateTime)
                 } catch (e: Throwable) {
                     if (e.isJodaDateTimeParseException()) throw DateTimeFormatException(e)
                     throw e

core/jvm/src/LocalDate.kt

@@ -22,7 +22,8 @@ public actual class LocalDate internal constructor(internal val value: jtLocalDa
         public actual fun parse(input: CharSequence, format: DateTimeFormat<LocalDate>): LocalDate =
             if (format === Formats.ISO) {
                 try {
-                    jtLocalDate.parse(input).let(::LocalDate)
+                    val sanitizedInput = removeLeadingZerosFromLongYearFormLocalDate(input.toString())
+                    jtLocalDate.parse(sanitizedInput).let(::LocalDate)
                 } catch (e: DateTimeParseException) {
                     throw DateTimeFormatException(e)
                 }

core/jvm/src/LocalDateTime.kt

@@ -6,6 +6,7 @@
 package kotlinx.datetime
 
 import kotlinx.datetime.format.*
+import kotlinx.datetime.internal.removeLeadingZerosFromLongYearFormLocalDateTime
 import kotlinx.datetime.serializers.LocalDateTimeIso8601Serializer
 import kotlinx.serialization.Serializable
 import java.time.DateTimeException
@@ -60,7 +61,8 @@ public actual class LocalDateTime internal constructor(internal val value: jtLoc
         public actual fun parse(input: CharSequence, format: DateTimeFormat<LocalDateTime>): LocalDateTime =
             if (format === Formats.ISO) {
                 try {
-                    jtLocalDateTime.parse(input).let(::LocalDateTime)
+                    val sanitizedInput = removeLeadingZerosFromLongYearFormLocalDateTime(input.toString())
+                    jtLocalDateTime.parse(sanitizedInput).let(::LocalDateTime)
                 } catch (e: DateTimeParseException) {
                     throw DateTimeFormatException(e)
                 }
@@ -84,4 +86,3 @@ public actual class LocalDateTime internal constructor(internal val value: jtLoc
     }
 
 }
-