Rework the Windows timezone implementation (#390)

Now, cinterop is not used in timezone implementations,
improving compatibility between versions of the library.

As part of the rewrite, the allocation strategy on startup
was improved, which should lower memory usage during
initialization.

Additionally, the implementation is now thoroughly tested.

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)