kotlin 1.9.0 (#63)

* kotlin 1.9.0

* fix github action

* use workers for clang compilations

* enable config cache

* more properties in tasks

* remove unused property, where were we using it???

* spotless

* set commonTest dependency for android test targets

* build cache api, fix some obselete warnings

* disable jetifier

* disable config cache for dist

* remove combined repo since we can build everything on mac

.github/actions/commonSetup/action.yml

@@ -11,12 +11,12 @@ inputs:
 runs:
   using: "composite"
   steps:
-    - name: Setup Java environment based on setup-java
-      uses: actions/setup-java@v1
+    - name: Set up JDK 17
+      uses: actions/setup-java@v2
       with:
         java-version: '17'
+        distribution: 'zulu'
         java-package: jdk
-        architecture: x64
     - name: Cache konan
       uses: actions/cache@v3
       with:

.github/workflows/main.yml

@@ -54,7 +54,7 @@ jobs:
         run: ./gradlew --stop
       - name: build dist
         id: gradle-build-dist
-        run: ./gradlew buildOnServer packageDebugAndroidTest --stacktrace --scan
+        run: ./gradlew buildOnServer packageDebugAndroidTest --stacktrace --scan --no-configuration-cache
         env:
           GRADLE_CACHE_KEY: ${{ secrets.GCP_ACCOUNT }}
           GRADLE_CACHE_PUSH: true
@@ -85,49 +85,15 @@ jobs:
         with:
           name: ${{ matrix.os }}-dist
           path: build/dist
+      - name: Upload Build Reports
+        if: always()
+        uses: actions/upload-artifact@v2
+        with:
+          name: ${{ matrix.os }}-build-reports
+          path: build/reports
       - name: Upload apks
         if: runner.os == 'Linux'
         uses: actions/upload-artifact@v2
         with:
           name: test apks of ${{ runner.os }}
           path: ./**/*.apk
-  buildFinalArtifacts:
-    needs: build
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v2
-      - name: Setup machine
-        uses: ./.github/actions/commonSetup
-        with:
-          gradleCacheKey: ${{ secrets.GCP_ACCOUNT }}
-          gradleCachePush: true
-      # ubuntu-latest, macos-latest, windows-latest -> should match the strategies of build
-      - name: Download linux dist
-        uses: actions/download-artifact@v2
-        with:
-          name: ubuntu-latest-dist
-          path: artifacts/linux
-      - name: Download mac dist
-        uses: actions/download-artifact@v2
-        with:
-          name: macos-latest-dist
-          path: artifacts/mac 
-      - name: Download windows dist
-        uses: actions/download-artifact@v2
-        with:
-          name: windows-latest-dist
-          path: artifacts/windows
-      - name: test and publish
-        id: gradle-test-and-dist
-        run: DIST_OUTPUTS=artifacts ./gradlew jvmTest createCombinedRepo  --info --stacktrace --scan
-        env:
-          GRADLE_CACHE_KEY: ${{ secrets.GCP_ACCOUNT }}
-          GRADLE_CACHE_PUSH: true
-      - name: Build Dist And Test Scan
-        shell: bash
-        run: echo "::notice title=Build and Dist Scan::${{ steps.gradle-test-and-dist.outputs.build-scan-url }}"
-      - name: Upload Repo
-        uses: actions/upload-artifact@v2
-        with:
-          name: combined-repo
-          path: build/dist/combinedRepo

buildPlugin/src/main/kotlin/com/birbit/ksqlite/build/CreateDefFileWithLibraryPathTask.kt

@@ -16,35 +16,41 @@
 package com.birbit.ksqlite.build
 
 import org.gradle.api.DefaultTask
+import org.gradle.api.file.DirectoryProperty
+import org.gradle.api.file.RegularFileProperty
 import org.gradle.api.tasks.CacheableTask
 import org.gradle.api.tasks.InputFile
+import org.gradle.api.tasks.Internal
 import org.gradle.api.tasks.OutputFile
 import org.gradle.api.tasks.PathSensitive
 import org.gradle.api.tasks.PathSensitivity
 import org.gradle.api.tasks.TaskAction
-import java.io.File
 
 @CacheableTask
 abstract class CreateDefFileWithLibraryPathTask : DefaultTask() {
     @get:InputFile
     @get:PathSensitive(PathSensitivity.RELATIVE)
-    abstract var original: File
+    abstract val original: RegularFileProperty
 
     @get:InputFile
     @get:PathSensitive(PathSensitivity.RELATIVE)
-    abstract var soFilePath: File
+    abstract val soFile: RegularFileProperty
 
     @get:OutputFile
-    val target = project.objects.fileProperty()
+    abstract val target: RegularFileProperty
+
+    @get:Internal
+    abstract val projectDir: DirectoryProperty
 
     @TaskAction
     fun doIt() {
         println("will copy from $original to $target")
         val target = target.asFile.get()
         target.parentFile.mkdirs()
         // use relative path to the owning project so it can be cached.
-        val soLocalPath = soFilePath.parentFile.relativeTo(project.projectDir)
-        val content = original.readText(Charsets.UTF_8) + System.lineSeparator() + "libraryPaths = \"$soLocalPath\"" +
+        val soLocalPath = soFile.asFile.get().parentFile.relativeTo(projectDir.get().asFile)
+        val content = original.asFile.get()
+            .readText(Charsets.UTF_8) + System.lineSeparator() + "libraryPaths = \"$soLocalPath\"" +
             System.lineSeparator()
         println("new content: $content")
         target.writeText(content, Charsets.UTF_8)

buildPlugin/src/main/kotlin/com/birbit/ksqlite/build/KSqliteBuildExtension.kt

@@ -59,7 +59,7 @@ open class KSqliteBuildExtension
     }
 
     fun includeSqlite(config: SqliteCompilationConfig) {
-        SqliteCompilation.setup(project, execOperations, config)
+        SqliteCompilation.setup(project, config)
     }
 
     fun buildOnServer() {

buildPlugin/src/main/kotlin/com/birbit/ksqlite/build/KSqliteBuildPlugin.kt

@@ -23,6 +23,7 @@ import org.gradle.api.specs.AndSpec
 import org.gradle.kotlin.dsl.create
 import org.gradle.kotlin.dsl.withType
 import org.jetbrains.kotlin.gradle.tasks.CInteropProcess
+import org.jetbrains.kotlin.gradle.tasks.KotlinNativeCompile
 
 class KSqliteBuildPlugin : Plugin<Project> {
     override fun apply(target: Project) {
@@ -34,6 +35,9 @@ class KSqliteBuildPlugin : Plugin<Project> {
         target.tasks.withType<org.jetbrains.kotlin.gradle.tasks.KotlinCompile>().configureEach {
             it.kotlinOptions.jvmTarget = "1.8"
         }
+        target.tasks.withType<KotlinNativeCompile>().configureEach {
+            it.compilerOptions.freeCompilerArgs.add("-opt-in=kotlinx.cinterop.ExperimentalForeignApi")
+        }
     }
 
     private fun Project.disableCinteropUpToDateChecks() {

buildPlugin/src/main/kotlin/com/birbit/ksqlite/build/internal/AndroidSetup.kt

@@ -21,7 +21,6 @@ import com.android.build.api.variant.LibraryAndroidComponentsExtension
 import org.gradle.api.Project
 import org.gradle.api.tasks.Copy
 import org.gradle.api.tasks.Exec
-import org.gradle.kotlin.dsl.get
 import org.gradle.nativeplatform.platform.internal.DefaultNativePlatform
 import java.io.File
 
@@ -47,7 +46,7 @@ internal object AndroidSetup {
         }
         androidLibrary.sourceSets {
             getByName("androidTest").java
-                .srcDir(project.file("src/androidTest/kotlin"))
+                .srcDir(project.file("src/androidInstrumented/kotlin"))
         }
         androidLibrary.ndkVersion = "23.1.7779620"
         val debugSigningConfig = androidLibrary.signingConfigs.getByName("debug")
@@ -73,13 +72,13 @@ internal object AndroidSetup {
             ?: return
 
         val rootProject = project.rootProject
-        val buildDir = rootProject.buildDir.resolve("android-cmd-line-tools")
-        val toolsZip = buildDir.resolve("tools.zip")
+        val buildDir = rootProject.layout.buildDirectory.dir("android-cmd-line-tools")
+        val toolsZip = buildDir.map { it.file("tools.zip") }
         val downloadTask = rootProject.tasks.register("downloadAndroidCmdLineTools", DownloadTask::class.java) {
-            it.downloadUrl = buildCommandLineToolsUrl()
-            it.downloadTargetFile = toolsZip
+            it.downloadUrl.set(buildCommandLineToolsUrl())
+            it.downloadTargetFile.set(toolsZip)
         }
-        val cmdLineToolsFolder = buildDir.resolve("tools")
+        val cmdLineToolsFolder = buildDir.map { it.dir("tools") }
         val unzipCommandLineToolsTask = rootProject.tasks.register("unzipCommandLineTools", Copy::class.java) {
             it.from(project.zipTree(toolsZip))
             it.into(cmdLineToolsFolder)
@@ -98,7 +97,7 @@ internal object AndroidSetup {
                     Runtime.getRuntime().exec("sudo chown \$USER:\$USER $sdkPath -R")
                 }
             }
-            it.executable(cmdLineToolsFolder.resolve("tools/bin/sdkmanager$ext"))
+            it.executable(cmdLineToolsFolder.map { it.file("tools/bin/sdkmanager$ext") })
             it.args("--install", "ndk;${androidLibraryExt.ndkVersion}", "--verbose")
             it.args("--sdk_root=$sdkPath")
             // pass y to accept licenses

buildPlugin/src/main/kotlin/com/birbit/ksqlite/build/internal/BuildOnServer.kt

@@ -31,7 +31,6 @@ object BuildOnServer {
             distDir = rootProject.buildDir.resolve("dist")
             rootProject.tasks.register(TASK_NAME)
             configureCopyNativeLibraries(rootProject)
-            Publishing.createCombinedRepoTaskIfPossible(rootProject)
         }
         return rootProject.tasks.named(TASK_NAME)
     }

buildPlugin/src/main/kotlin/com/birbit/ksqlite/build/internal/DownloadTask.kt

@@ -16,27 +16,29 @@
 package com.birbit.ksqlite.build.internal
 
 import org.gradle.api.DefaultTask
+import org.gradle.api.file.RegularFileProperty
+import org.gradle.api.provider.Property
 import org.gradle.api.tasks.CacheableTask
 import org.gradle.api.tasks.Input
 import org.gradle.api.tasks.OutputFile
 import org.gradle.api.tasks.TaskAction
-import java.io.File
 import java.io.FileOutputStream
 import java.net.URL
 
 @CacheableTask
 abstract class DownloadTask : DefaultTask() {
-    @Input
-    lateinit var downloadUrl: String
+    @get:Input
+    abstract val downloadUrl: Property<String>
 
-    @OutputFile
-    lateinit var downloadTargetFile: File
+    @get:OutputFile
+    abstract val downloadTargetFile: RegularFileProperty
 
     @TaskAction
     fun doIt() {
+        val downloadTargetFile = downloadTargetFile.asFile.get()
         downloadTargetFile.delete()
         downloadTargetFile.parentFile.mkdirs()
-        URL(downloadUrl).openStream().use { inputStream ->
+        URL(downloadUrl.get()).openStream().use { inputStream ->
             FileOutputStream(downloadTargetFile).use { outputStream ->
                 inputStream.copyTo(outputStream)
             }

buildPlugin/src/main/kotlin/com/birbit/ksqlite/build/internal/KonanBuildService.kt

@@ -0,0 +1,65 @@
+/*
+ * Copyright 2023 Google, LLC.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.birbit.ksqlite.build.internal
+
+import org.gradle.api.Project
+import org.gradle.api.provider.Property
+import org.gradle.api.provider.Provider
+import org.gradle.api.services.BuildService
+import org.gradle.api.services.BuildServiceParameters
+import org.gradle.process.ExecOperations
+import org.jetbrains.kotlin.konan.target.KonanTarget
+import java.io.File
+import javax.inject.Inject
+
+internal abstract class KonanBuildService
+@Inject constructor(
+    private val execOperations: ExecOperations
+) :
+    BuildService<KonanBuildService.Params> {
+    interface Params : BuildServiceParameters {
+        val compilerPath: Property<File>
+    }
+
+    fun obtainWrapper(
+        konanTarget: KonanTarget
+    ) = KonanUtil.KonanCompilerWrapper(
+        execOperations = execOperations,
+        konanTarget = konanTarget
+    ).also {
+        KonanUtil.KonanCompilerWrapper.ensureSupportForTarget(
+            parameters.compilerPath.get(),
+            execOperations,
+            konanTarget
+        )
+    }
+    companion object {
+        const val KEY = "konanBuildService"
+        fun register(
+            project: Project
+        ): Provider<KonanBuildService> {
+            val compilerPath = KonanUtil.KonanCompilerWrapper.obtainNativeCompiler(
+                project
+            )
+            return project.gradle.sharedServices.registerIfAbsent(
+                KEY,
+                KonanBuildService::class.java
+            ) {
+                it.parameters.compilerPath.set(compilerPath)
+            }
+        }
+    }
+}

buildPlugin/src/main/kotlin/com/birbit/ksqlite/build/internal/KonanTargetExt.kt

@@ -15,13 +15,8 @@
  */
 package com.birbit.ksqlite.build.internal
 
-import org.gradle.nativeplatform.platform.internal.DefaultNativePlatform
-import org.jetbrains.kotlin.konan.target.Family
 import org.jetbrains.kotlin.konan.target.HostManager
 import org.jetbrains.kotlin.konan.target.KonanTarget
 
 // check if the target can be built on this machine
-internal fun KonanTarget.isBuiltOnThisMachine() = HostManager().isEnabled(this) &&
-    DefaultNativePlatform.getCurrentOperatingSystem().let { os ->
-        !os.isWindows || this@isBuiltOnThisMachine.family == Family.MINGW
-    }
+internal fun KonanTarget.isBuiltOnThisMachine() = HostManager().isEnabled(this)