Rework the Windows timezone implementation

core/build.gradle.kts

@@ -6,6 +6,7 @@ import java.io.ByteArrayOutputStream
 import java.io.PrintWriter
 import org.jetbrains.dokka.gradle.AbstractDokkaLeafTask
 import org.jetbrains.kotlin.gradle.ExperimentalKotlinGradlePluginApi
+import org.jetbrains.kotlin.konan.target.Family
 
 plugins {
     kotlin("multiplatform")
@@ -29,9 +30,6 @@ val serializationVersion: String by project
 
 java {
     toolchain { languageVersion.set(JavaLanguageVersion.of(mainJavaToolchainVersion)) }
-    with(javaToolchains.launcherFor(toolchain).get().metadata) {
-        logger.info("Using JDK $languageVersion toolchain installed in $installationPath")
-    }
 }
 
 kotlin {
@@ -150,25 +148,13 @@ kotlin {
         compilations["test"].kotlinOptions {
             freeCompilerArgs += listOf("-trw")
         }
-        when {
-            konanTarget.family == org.jetbrains.kotlin.konan.target.Family.MINGW -> {
-                compilations["main"].cinterops {
-                    create("declarations") {
-                        defFile("$projectDir/windows/cinterop/definitions.def")
-                        headers("$projectDir/windows/cinterop/definitions.h")
-                    }
+        if (konanTarget.family == Family.MINGW) {
+            compilations["test"].cinterops {
+                create("modern_api") {
+                    defFile("$projectDir/windows/test_cinterop/modern_api.def")
+                    headers("$projectDir/windows/test_cinterop/modern_api.h")
                 }
             }
-
-            konanTarget.family == org.jetbrains.kotlin.konan.target.Family.LINUX ||
-                konanTarget.family == org.jetbrains.kotlin.konan.target.Family.ANDROID ||
-                konanTarget.family.isAppleFamily ->
-            {
-                // do nothing special
-            }
-            else -> {
-                throw IllegalArgumentException("Unknown native target ${this@withType}")
-            }
         }
     }
     sourceSets {

core/native/src/internal/MonthDayTime.kt

@@ -129,14 +129,17 @@ internal class MonthDayTime(
      * Converts this [MonthDayTime] to an [Instant] in the given [year],
      * using the knowledge of the offset that's in effect at the resulting datetime.
      */
-    fun toInstant(year: Int, effectiveOffset: UtcOffset): Instant {
-        val localDateTime = time.resolve(date.toLocalDate(year))
-        return when (this.offset) {
-            is OffsetResolver.WallClockOffset -> localDateTime.toInstant(effectiveOffset)
-            is OffsetResolver.FixedOffset -> localDateTime.toInstant(this.offset.offset)
-        }
+    fun toInstant(year: Int, effectiveOffset: UtcOffset): Instant = when (this.offset) {
+        is OffsetResolver.WallClockOffset -> toLocalDateTime(year).toInstant(effectiveOffset)
+        is OffsetResolver.FixedOffset -> toLocalDateTime(year).toInstant(this.offset.offset)
     }
 
+    /**
+     * Converts this [MonthDayTime] to a [LocalDateTime] in the given [year],
+     * ignoring the UTC offset.
+     */
+    fun toLocalDateTime(year: Int): LocalDateTime = time.resolve(date.toLocalDate(year))
+
     /**
      * Describes how the offset in which the local datetime is expressed is defined.
      */
@@ -160,7 +163,6 @@ internal class MonthDayTime(
      * The local time of day at which the transition occurs.
      */
     class TransitionLocaltime(val seconds: Int) {
-        constructor(time: LocalTime) : this(time.toSecondOfDay())
 
         constructor(hour: Int, minute: Int, second: Int) : this(hour * 3600 + minute * 60 + second)
 

core/native/src/internal/TimeZoneRules.kt

@@ -128,12 +128,12 @@ internal class RecurringZoneRules(
         val offsetBefore: UtcOffset,
         val offsetAfter: UtcOffset,
     ) {
-        override fun toString(): String = "transitioning to $offsetAfter on $transitionDateTime"
+        override fun toString(): String = "transitioning from $offsetBefore to $offsetAfter on $transitionDateTime"
     }
 
     // see `tzparse` in https://data.iana.org/time-zones/tzdb/localtime.c: looks like there's no guarantees about
     // a way to pre-sort the transitions, so we have to do it for each query separately.
-    private fun rulesForYear(year: Int): List<Rule<Instant>> {
+    fun rulesForYear(year: Int): List<Rule<Instant>> {
         return rules.map { rule ->
             val transitionInstant = rule.transitionDateTime.toInstant(year, rule.offsetBefore)
             Rule(transitionInstant, rule.offsetBefore, rule.offsetAfter)