DateTimeComponents.Format.parse() should parse timeZoneId() using the Temporal grammar instead of checking if the time zone exists in the time zone database

core/common/src/format/DateTimeComponents.kt

@@ -9,9 +9,12 @@ import kotlinx.datetime.*
 import kotlinx.datetime.DayOfWeek
 import kotlinx.datetime.internal.*
 import kotlinx.datetime.internal.format.*
+import kotlinx.datetime.internal.format.formatter.FormatterStructure
+import kotlinx.datetime.internal.format.formatter.StringFormatterStructure
 import kotlinx.datetime.internal.format.parser.Copyable
+import kotlinx.datetime.internal.format.parser.NamedTimeZoneParserOperation
 import kotlinx.datetime.internal.format.parser.ParserStructure
-import kotlinx.datetime.internal.format.parser.TimeZoneParserOperation
+import kotlinx.datetime.internal.format.parser.OffsetTimeZoneParserOperation
 import kotlinx.datetime.internal.safeMultiply
 import kotlin.reflect.*
 
@@ -565,27 +568,31 @@ internal class DateTimeComponentsContents internal constructor(
 
 internal val timeZoneField = GenericFieldSpec(PropertyAccessor(DateTimeComponentsContents::timeZoneId))
 
-internal class TimeZoneIdDirective(private val knownZones: Set<String>) :
-    StringFieldFormatDirective<DateTimeComponentsContents>(timeZoneField, knownZones) {
+internal class TimeZoneIdDirective() : FieldFormatDirective<DateTimeComponentsContents> {
+    override val field: FieldSpec<DateTimeComponentsContents, *>
+        get() = timeZoneField
 
     override val builderRepresentation: String
-        get() =
-            "${DateTimeFormatBuilder.WithDateTimeComponents::timeZoneId.name}()"
+        get() = "${DateTimeFormatBuilder.WithDateTimeComponents::timeZoneId.name}()"
+
+    override fun formatter(): FormatterStructure<DateTimeComponentsContents> {
+        return StringFormatterStructure { field.accessor.getterNotNull(it).toString() }
+    }
 
     override fun parser(): ParserStructure<DateTimeComponentsContents> =
         ParserStructure(
             emptyList(),
             listOf(
-                super.parser(),
                 ParserStructure(
-                    listOf(TimeZoneParserOperation(timeZoneField.accessor)),
+                    listOf(OffsetTimeZoneParserOperation(timeZoneField.accessor)),
                     emptyList()
-                )
+                ),
+                ParserStructure(
+                    listOf(NamedTimeZoneParserOperation(timeZoneField.accessor)),
+                    emptyList()
+                ),
             )
         )
-
-    override fun equals(other: Any?): Boolean = other is TimeZoneIdDirective && other.knownZones == knownZones
-    override fun hashCode(): Int = knownZones.hashCode()
 }
 
 internal class DateTimeComponentsFormat(override val actualFormat: CachedFormatStructure<DateTimeComponentsContents>) :
@@ -609,7 +616,7 @@ internal class DateTimeComponentsFormat(override val actualFormat: CachedFormatS
         }
 
         override fun timeZoneId() =
-            actualBuilder.add(BasicFormatStructure(TimeZoneIdDirective(TimeZone.availableZoneIds)))
+            actualBuilder.add(BasicFormatStructure(TimeZoneIdDirective()))
 
         @Suppress("NO_ELSE_IN_WHEN")
         override fun dateTimeComponents(format: DateTimeFormat<DateTimeComponents>) = when (format) {

core/common/src/internal/format/FieldFormatDirective.kt

@@ -147,27 +147,6 @@ internal abstract class NamedEnumIntFieldFormatDirective<in Target, Type>(
         )
 }
 
-internal abstract class StringFieldFormatDirective<in Target>(
-    final override val field: FieldSpec<Target, String>,
-    private val acceptedStrings: Set<String>,
-) : FieldFormatDirective<Target> {
-
-    init {
-        require(acceptedStrings.isNotEmpty()) {
-            "The set of accepted strings is empty"
-        }
-    }
-
-    override fun formatter(): FormatterStructure<Target> =
-        StringFormatterStructure(field.accessor::getterNotNull)
-
-    override fun parser(): ParserStructure<Target> =
-        ParserStructure(
-            listOf(StringSetParserOperation(acceptedStrings, field.accessor, field.name)),
-            emptyList()
-        )
-}
-
 internal abstract class SignedIntFieldFormatDirective<in Target>(
     final override val field: FieldSpec<Target, Int>,
     private val minDigits: Int?,

core/common/src/internal/format/parser/ParserOperation.kt

@@ -6,6 +6,7 @@
 package kotlinx.datetime.internal.format.parser
 
 import kotlinx.datetime.internal.isAsciiDigit
+import kotlinx.datetime.internal.isAsciiLetter
 
 internal interface ParserOperation<in Output> {
     fun consume(storage: Output, input: CharSequence, startIndex: Int): ParseResult
@@ -139,12 +140,12 @@ internal class UnconditionalModification<Output>(
     }
 }
 
-internal class TimeZoneParserOperation<Output>(
+internal abstract class TimeZoneParserOperation<Output>(
     private val setter: AssignableField<Output, String>
 ) : ParserOperation<Output> {
 
     override fun consume(storage: Output, input: CharSequence, startIndex: Int): ParseResult {
-        val lastMatch = validateTimezone(input, startIndex)
+        val lastMatch = validateTimeZone(input, startIndex)
         return if (lastMatch > startIndex) {
             setter.setWithoutReassigning(storage, input.substring(startIndex, lastMatch), startIndex, lastMatch)
             ParseResult.Ok(lastMatch)
@@ -153,101 +154,149 @@ internal class TimeZoneParserOperation<Output>(
         }
     }
 
-    companion object {
-        private enum class State {
-            START,
-            AFTER_PREFIX,
-            AFTER_SIGN,
-            AFTER_HOUR,
-            AFTER_MINUTE,
-            AFTER_COLON_MINUTE,
-            END,
-            INVALID
-        }
+    protected abstract fun validateTimeZone(input: CharSequence, startIndex: Int): Int
+}
 
-        private fun validateTimezone(input: CharSequence, startIndex: Int): Int {
-            var index = startIndex
-            var lastValidIndex = startIndex
-
-            fun validatePrefix(validValues: List<String>): Boolean =
-                validValues.firstOrNull { input.startsWith(it) }?.let {
-                    index += it.length
-                    lastValidIndex = index
-                    true
-                } ?: false
-
-            fun validateTimeComponent(length: Int): Boolean {
-                if ((index..<(index + length)).all { input.getOrNull(it)?.isAsciiDigit() ?: false }) {
-                    index += length
-                    lastValidIndex = index
-                    return true
-                }
-                return false
+internal class OffsetTimeZoneParserOperation<Output>(
+    setter: AssignableField<Output, String>
+) : TimeZoneParserOperation<Output>(setter) {
+    private enum class State {
+        START,
+        AFTER_PREFIX,
+        AFTER_SIGN,
+        AFTER_HOUR,
+        AFTER_MINUTE,
+        AFTER_COLON_MINUTE,
+        END,
+        INVALID
+    }
+
+    override fun validateTimeZone(input: CharSequence, startIndex: Int): Int {
+        var index = startIndex
+        var lastValidIndex = startIndex
+
+        fun validatePrefix(validValues: List<String>): Boolean =
+            validValues.firstOrNull { input.startsWith(it) }?.let {
+                index += it.length
+                lastValidIndex = index
+                true
+            } ?: false
+
+        fun validateTimeComponent(length: Int): Boolean {
+            if ((index..<(index + length)).all { input.getOrNull(it)?.isAsciiDigit() ?: false }) {
+                index += length
+                lastValidIndex = index
+                return true
             }
+            return false
+        }
 
-            var state = State.START
-            while (index < input.length) {
-                state = when (state) {
-                    State.START -> when {
-                        input[index] == 'Z' || input[index] == 'z' -> {
-                            index++
-                            State.END
-                        }
-
-                        input[index] in listOf('+', '-') -> {
-                            index++
-                            State.AFTER_SIGN
-                        }
-
-                        validatePrefix(listOf("UTC", "GMT", "UT")) -> State.AFTER_PREFIX
-                        else -> State.INVALID
+        var state = State.START
+        while (index < input.length) {
+            state = when (state) {
+                State.START -> when {
+                    input[index] == 'Z' || input[index] == 'z' -> {
+                        index++
+                        State.END
                     }
 
-                    State.AFTER_PREFIX -> when {
-                        input[index] in listOf('+', '-') -> {
-                            index++
-                            State.AFTER_SIGN
-                        }
-
-                        else -> State.INVALID
+                    input[index] in listOf('+', '-') -> {
+                        index++
+                        State.AFTER_SIGN
                     }
 
-                    State.AFTER_SIGN -> when {
-                        validateTimeComponent(2) -> State.AFTER_HOUR
-                        validateTimeComponent(1) -> State.END
-                        else -> State.INVALID
+                    validatePrefix(listOf("UTC", "GMT", "UT")) -> State.AFTER_PREFIX
+                    else -> State.INVALID
+                }
+
+                State.AFTER_PREFIX -> when {
+                    input[index] in listOf('+', '-') -> {
+                        index++
+                        State.AFTER_SIGN
                     }
 
-                    State.AFTER_HOUR -> when {
-                        input[index] == ':' -> {
-                            index++
-                            if (validateTimeComponent(2)) State.AFTER_COLON_MINUTE else State.INVALID
-                        }
+                    else -> State.INVALID
+                }
 
-                        validateTimeComponent(2) -> State.AFTER_MINUTE
-                        else -> State.INVALID
-                    }
+                State.AFTER_SIGN -> when {
+                    validateTimeComponent(2) -> State.AFTER_HOUR
+                    validateTimeComponent(1) -> State.END
+                    else -> State.INVALID
+                }
 
-                    State.AFTER_MINUTE -> when {
-                        validateTimeComponent(2) -> State.END
-                        else -> State.INVALID
+                State.AFTER_HOUR -> when {
+                    input[index] == ':' -> {
+                        index++
+                        if (validateTimeComponent(2)) State.AFTER_COLON_MINUTE else State.INVALID
                     }
 
-                    State.AFTER_COLON_MINUTE -> when {
-                        input[index] == ':' -> {
-                            index++
-                            if (validateTimeComponent(2)) State.END else State.INVALID
-                        }
+                    validateTimeComponent(2) -> State.AFTER_MINUTE
+                    else -> State.INVALID
+                }
+
+                State.AFTER_MINUTE -> when {
+                    validateTimeComponent(2) -> State.END
+                    else -> State.INVALID
+                }
 
-                        else -> State.INVALID
+                State.AFTER_COLON_MINUTE -> when {
+                    input[index] == ':' -> {
+                        index++
+                        if (validateTimeComponent(2)) State.END else State.INVALID
                     }
 
-                    State.END, State.INVALID -> break
+                    else -> State.INVALID
                 }
+
+                State.END, State.INVALID -> break
             }
+        }
+
+        return if (state == State.END) index else lastValidIndex
+    }
+}
+
+internal class NamedTimeZoneParserOperation<Output>(
+    setter: AssignableField<Output, String>
+) : TimeZoneParserOperation<Output>(setter) {
+    private enum class State {
+        START,
+        IN_PART,
+        AFTER_SLASH
+    }
+
+    override fun validateTimeZone(input: CharSequence, startIndex: Int): Int {
+        fun Char.isTimeZoneInitial() = isAsciiLetter() || this == '.' || this == '_'
+        fun Char.isTimeZoneChar() = isTimeZoneInitial() || isAsciiDigit() || this == '-' || this == '+'
+
+        var index = startIndex
+        var state = State.START
+
+        while (index < input.length) {
+            val currentChar = input[index]
+            state = when (state) {
+                State.START -> when {
+                    currentChar.isTimeZoneInitial() -> State.IN_PART
+                    else -> break
+                }
+
+                State.IN_PART -> when {
+                    currentChar.isTimeZoneChar() -> State.IN_PART
+                    currentChar == '/' -> State.AFTER_SLASH
+                    else -> break
+                }
 
-            return if (state == State.END) index else lastValidIndex
+                State.AFTER_SLASH -> when {
+                    currentChar.isTimeZoneInitial() -> State.IN_PART
+                    else -> break
+                }
+            }
+            index++
         }
+
+        if (state == State.AFTER_SLASH) index--
+
+        return index
     }
 }
 

core/common/src/internal/util.kt

@@ -7,6 +7,8 @@ package kotlinx.datetime.internal
 
 internal fun Char.isAsciiDigit(): Boolean = this in '0'..'9'
 
+internal fun Char.isAsciiLetter(): Boolean = this in 'A'..'Z' || this in 'a'..'z'
+
 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 */