Merge pull request #1 from touchlab/kpg/non_shadow

Kpg/non shadow

Author: kpgalligan

build.gradle.kts

@@ -19,17 +19,16 @@ buildscript {
 }
 
 plugins {
-    kotlin("multiplatform") apply false
-    id("com.android.library") version "4.1.2" apply false
     id("com.github.gmazzo.buildconfig") version "2.1.0" apply false
 }
 
 val GROUP: String by project
-val VERSION_NAME: String by project
+val KOTLIN_VERSION: String by project
+val VERSION_EXTENSION: String by project
 
 allprojects {
     group = GROUP
-    version = VERSION_NAME
+    version = "${KOTLIN_VERSION}.${VERSION_EXTENSION}"
 }
 
 allprojects {

gradle.properties

@@ -14,8 +14,8 @@ android.useAndroidX=true
 org.gradle.jvmargs=-Xmx2g
 
 GROUP=co.touchlab
-VERSION_NAME=0.1.0
 KOTLIN_VERSION=1.5.31
+VERSION_EXTENSION=1
 
 POM_NAME=CKlib
 POM_DESCRIPTION=C/C++ Bitcode Into Klib

plugin/build.gradle.kts

@@ -1,71 +1,17 @@
-import com.android.build.gradle.internal.tasks.factory.dependsOn
-import com.github.jengelman.gradle.plugins.shadow.tasks.ConfigureShadowRelocation
-import com.github.jengelman.gradle.plugins.shadow.tasks.ShadowJar
-
 plugins {
   id("java-gradle-plugin")
   kotlin("jvm")
   id("com.github.gmazzo.buildconfig")
   id("com.vanniktech.maven.publish")
-  id("com.github.johnrengelman.shadow").version("7.0.0")
 }
 
+val KOTLIN_VERSION: String by project
 
 dependencies {
-  shadow(gradleApi())
-  implementation(fileTree("lib") { include("*.jar") })
-  implementation(fileTree("${System.getProperty("user.home")}/.konan/kotlin-native-prebuilt-macos-x86_64-1.5.30/konan/lib") { include("*.jar") })
-}
-
-val shadowJarTask = tasks.shadowJar
-
-// Add shadow jar to the Gradle module metadata api and runtime configurations
-configurations {
-  artifacts {
-    runtimeElements(shadowJarTask)
-    apiElements(shadowJarTask)
-  }
+  implementation(gradleApi())
+  implementation("org.jetbrains.kotlin:kotlin-gradle-plugin:$KOTLIN_VERSION")
 }
 
-tasks.whenTaskAdded {
-  if (name == "publishPluginJar" || name == "generateMetadataFileForPluginMavenPublication") {
-    dependsOn(tasks.named("shadowJar"))
-  }
-}
-
-// Disabling default jar task as it is overridden by shadowJar
-tasks.named("jar").configure {
-  enabled = false
-}
-
-// Need to move publishing configuration into afterEvaluate {}
-// to override changes done by "com.gradle.plugin-publish" plugin in afterEvaluate {} block
-// See PublishPlugin class for details
-afterEvaluate {
-  publishing {
-    publications {
-      withType<MavenPublication> {
-        // Special workaround to publish shadow jar instead of normal one. Name to override peeked here:
-        // https://github.com/gradle/gradle/blob/master/subprojects/plugin-development/src/main/java/org/gradle/plugin/devel/plugins/MavenPluginPublishPlugin.java#L73
-        if (name == "pluginMaven") {
-          setArtifacts(
-            listOf(
-              shadowJarTask.get()
-            )
-          )
-        }
-      }
-    }
-  }
-}
-
-/*tasks.create("relocateShadowJar", ConfigureShadowRelocation::class.java) {
-  target = tasks.shadowJar.get()
-  prefix = "cklib" // Default value is "shadow"
-}
-
-tasks.shadowJar.dependsOn(tasks.findByName("relocateShadowJar")!!)*/
-
 buildConfig {
   packageName("co.touchlab.cklib.gradle")
   buildConfigField("String", "KOTLIN_PLUGIN_ID", "\"${rootProject.extra["kotlin_plugin_id"]}\"")

plugin/src/main/kotlin/GradleValues.kt

@@ -0,0 +1,13 @@
+/*
+ * Copyright (c) 2021 Touchlab
+ * 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.
+ */
+
+object GradleValues {
+    val KOTLIN_VERSION = "1.5.31"
+}

plugin/src/main/kotlin/co/touchlab/cklib/gradle/CKlibGradleExtension.kt

@@ -10,20 +10,20 @@
 
 package co.touchlab.cklib.gradle
 
+import co.touchlab.cklib.gradle.reflection.PlatformManager
 import org.gradle.api.Project
 import org.jetbrains.kotlin.konan.target.Distribution
-import org.jetbrains.kotlin.konan.target.PlatformManager
 import javax.inject.Inject
 
 open class CKlibGradleExtension @Inject constructor(val project: Project){
-    var konanHome: String = "${System.getProperty("user.home")}/.konan/kotlin-native-prebuilt-macos-x86_64-1.5.30"
+    var konanHome: String = "${System.getProperty("user.home")}/.konan/kotlin-native-prebuilt-macos-x86_64-${GradleValues.KOTLIN_VERSION}"
     var llvmHome: String = "${System.getProperty("user.home")}/.konan/dependencies/clang-llvm-apple-8.0.0-darwin-macos"
 }
 
 internal val Project.platformManager: PlatformManager
     get() {
         val cklibExtension = extensions.getByType(CKlibGradleExtension::class.java)
-        return PlatformManager(Distribution(cklibExtension.konanHome))
+        return PlatformManager(Distribution(cklibExtension.konanHome), cklibExtension.konanHome)
     }
 
 internal val Project.llvmHome: String

plugin/src/main/kotlin/co/touchlab/cklib/gradle/CompileToBitcode.kt

@@ -10,6 +10,7 @@
 
 package co.touchlab.cklib.gradle
 
+import co.touchlab.cklib.gradle.CompileToBitcodePlugin.Companion.PLUGIN_NAME
 import org.gradle.api.DefaultTask
 import org.gradle.api.file.FileCollection
 import org.gradle.api.tasks.*
@@ -18,13 +19,12 @@ import javax.inject.Inject
 
 open class CompileToBitcode @Inject constructor(
     srcRoot: File,
-    @Input val folderName: String,
-    @Input val target: String,
-    @Input val outputGroup: String
+    @Input val compileName: String,
+    @Input val target: String
 ) : DefaultTask() {
 
     enum class Language {
-        C, CPP
+        C, CPP, OBJC
     }
 
     // Compiler args are part of compilerFlags so we don't register them as an input.
@@ -34,13 +34,19 @@ open class CompileToBitcode @Inject constructor(
     val linkerArgs = mutableListOf<String>()
     @Input
     var excludeFiles: List<String> = listOf(
+        "**/*Test.c",
+        "**/*TestSupport.c",
+        "**/*Test.m",
+        "**/*TestSupport.m",
         "**/*Test.cpp",
         "**/*TestSupport.cpp",
         "**/*Test.mm",
         "**/*TestSupport.mm"
     )
     @Input
     var includeFiles: List<String> = listOf(
+        "**/*.c",
+        "**/*.m",
         "**/*.cpp",
         "**/*.mm"
     )
@@ -55,42 +61,30 @@ open class CompileToBitcode @Inject constructor(
     @Input
     var language = Language.CPP
 
-    @Input @Optional
-    var sanitizer: org.jetbrains.kotlin.konan.target.SanitizerKind? = null
-
-    private val targetDir: File
+    @get:Internal
+    internal val targetDir: File
         get() {
-            val sanitizerSuffix = when (sanitizer) {
-                null -> ""
-                org.jetbrains.kotlin.konan.target.SanitizerKind.ADDRESS -> "-asan"
-                org.jetbrains.kotlin.konan.target.SanitizerKind.THREAD -> "-tsan"
-            }
-            return project.buildDir.resolve("bitcode/$outputGroup/$target$sanitizerSuffix")
+            return project.buildDir.resolve("$PLUGIN_NAME/$compileName/$target")
         }
 
     @get:OutputDirectory
     val objDir
-        get() = File(targetDir, folderName)
+        get() = File(targetDir, compileName)
 
     private val org.jetbrains.kotlin.konan.target.KonanTarget.isMINGW
         get() = this.family == org.jetbrains.kotlin.konan.target.Family.MINGW
 
     @get:Internal
     val executable
         get() = when (language) {
-            Language.C -> "clang"
+            Language.C, Language.OBJC -> "clang"
             Language.CPP -> "clang++"
         }
 
     @get:Input
     val compilerFlags: List<String>
         get() {
             val commonFlags = listOf("-c", "-emit-llvm") + headersDirs.map { "-I$it" }
-            val sanitizerFlags = when (sanitizer) {
-                null -> listOf()
-                org.jetbrains.kotlin.konan.target.SanitizerKind.ADDRESS -> listOf("-fsanitize=address")
-                org.jetbrains.kotlin.konan.target.SanitizerKind.THREAD -> listOf("-fsanitize=thread")
-            }
             val languageFlags = when (language) {
                 Language.C ->
                     // Used flags provided by original build of allocator C code.
@@ -100,8 +94,11 @@ open class CompileToBitcode @Inject constructor(
                         "-Wall", "-Wextra",
                         "-Wno-unused-parameter"  // False positives with polymorphic functions.
                     )
+                Language.OBJC ->
+                    // Used flags provided by original build of allocator C code.
+                    listOf("-fobjc-arc", "-fmodules", "-mmacosx-version-min=10.6","-std=gnu11", "-O3", "-Wall", "-Wextra", "-Werror")
             }
-            return commonFlags + sanitizerFlags + languageFlags + compilerArgs
+            return commonFlags + languageFlags + compilerArgs
         }
 
     @get:SkipWhenEmpty
@@ -147,7 +144,7 @@ open class CompileToBitcode @Inject constructor(
             return dirs.flatMap { dir ->
                 project.fileTree(dir) {
                     val includePatterns = when (language) {
-                        Language.C -> arrayOf("**/.h")
+                        Language.C, Language.OBJC -> arrayOf("**/.h")
                         Language.CPP -> arrayOf("**/*.h", "**/*.hpp")
                     }
                     it.include(*includePatterns)
@@ -157,7 +154,7 @@ open class CompileToBitcode @Inject constructor(
 
     @get:OutputFile
     val outFile: File
-        get() = File(targetDir, "${folderName}.bc")
+        get() = File(targetDir, "${compileName}.bc")
 
     @TaskAction
     fun compile() {

plugin/src/main/kotlin/co/touchlab/cklib/gradle/CompileToBitcodeExtension.kt

@@ -11,52 +11,52 @@
 package co.touchlab.cklib.gradle
 
 import org.gradle.api.Project
+import org.jetbrains.kotlin.gradle.dsl.KotlinMultiplatformExtension
+import org.jetbrains.kotlin.gradle.plugin.mpp.KotlinNativeTarget
 import javax.inject.Inject
 
 open class CompileToBitcodeExtension @Inject constructor(val project: Project) {
-/*
-    private val targetList = listOf(
-        "linux_x64",
-        "macos_x64",
-        "ios_arm64",
-        "ios_arm32",
-        "ios_simulator_arm64",
-        "ios_x64",
-        "watchos_arm32",
-        "watchos_arm64",
-        "watchos_x86",
-        "watchos_x64",
-        "watchos_simulator_arm64",
-        "tvos_arm64",
-        "tvos_x64",
-        "tvos_simulator_arm64",
-        "macos_arm64"
-    )*/
 
     fun create(
         name: String,
-        targets: List<String>,
         srcDir: java.io.File = project.file("src/$name"),
-        outputGroup: String = "main",
+        compilations: List<String> = listOf("main"),
         configurationBlock: CompileToBitcode.() -> Unit = {}
     ) {
+        val kmpExt = project.kmpExt
+
         val allBitcode = project.tasks.register("all${name.snakeCaseToCamelCase().capitalize()}") {
             it.group = GROUP_NAME
             it.description = "Compiles '$name' to bitcode for all targets"
         }.get()
-        val allTaskProviders = targets.map { targetName ->
-            val taskName = "${targetName}${name.snakeCaseToCamelCase().capitalize()}"
-            project.logger.warn("taskName $taskName")
+
+        val allTaskProviders = kmpExt.kotlinNativeTargets.map { knTarget ->
+            val taskName = "${knTarget.name}${name.snakeCaseToCamelCase().capitalize()}"
+
             val taskProvider = project.tasks.register(
                 taskName,
                 CompileToBitcode::class.java,
-                srcDir, name, targetName, outputGroup
+                srcDir, name, knTarget.konanTarget.name
             )
-            taskProvider.configure {
-                it.group = GROUP_NAME
-                it.description = "Compiles '$name' to bitcode for $targetName"
-                it.configurationBlock()
+
+            //tasks.getByName("compileKotlin${targetName.capitalize()}").dependsOn("${it.second}Quickjs")
+            project.tasks.getByPath("compileKotlin${knTarget.name.capitalize()}")
+                .dependsOn(taskName)
+
+            taskProvider.configure { compileToBitcodeTask ->
+                compileToBitcodeTask.group = GROUP_NAME
+                compileToBitcodeTask.description = "Compiles '$name' to bitcode for ${knTarget.name}"
+
+                compilations.forEach { compilation ->
+                    val knCompilation = knTarget.compilations.getByName(compilation)
+
+                    knCompilation.kotlinOptions.freeCompilerArgs +=
+                        listOf("-native-library", compileToBitcodeTask.outFile.absolutePath)
+                }
+
+                compileToBitcodeTask.configurationBlock()
             }
+
             taskProvider
         }
         allBitcode.dependsOn(allTaskProviders)
@@ -66,6 +66,12 @@ open class CompileToBitcodeExtension @Inject constructor(val project: Project) {
         private fun String.snakeCaseToCamelCase() =
             split('_').joinToString(separator = "") { it.capitalize() }
 
-        const val GROUP_NAME = "bitcode"
+        const val GROUP_NAME = CompileToBitcodePlugin.PLUGIN_NAME
     }
-}
+}
+
+private val KotlinMultiplatformExtension.kotlinNativeTargets: Collection<KotlinNativeTarget>
+    get() = targets.withType(KotlinNativeTarget::class.java)
+
+private val Project.kmpExt: KotlinMultiplatformExtension
+    get() = extensions.getByType(KotlinMultiplatformExtension::class.java)

plugin/src/main/kotlin/co/touchlab/cklib/gradle/CompileToBitcodePlugin.kt

@@ -18,19 +18,22 @@ class CompileToBitcodePlugin : Plugin<Project> {
         extensions.create(EXTENSION_NAME, CompileToBitcodeExtension::class.java, target)
         extensions.create(CKLIB_EXTENSION_NAME, CKlibGradleExtension::class.java, target)
 
-        afterEvaluate {
+//        target.pluginManager.apply(org.jetbrains.kotlin.gradle.plugin.mpp.KotlinMultiplatformPlugin::class.java)
+
+        Unit
+        /*afterEvaluate {
             // TODO: Support providers (https://docs.gradle.org/current/userguide/lazy_configuration.html)
             //       in database tasks and create them along with corresponding compile tasks (not in afterEvaluate).
             org.jetbrains.kotlin.createCompilationDatabasesFromCompileToBitcodeTasks(
                 project,
                 COMPILATION_DATABASE_TASK_NAME
             )
-        }
+        }*/
     }
 
     companion object {
-        const val EXTENSION_NAME = "bitcode"
-        const val CKLIB_EXTENSION_NAME = "cklib"
-        const val COMPILATION_DATABASE_TASK_NAME = "CompilationDatabase"
+        const val EXTENSION_NAME = "cklib"
+        const val CKLIB_EXTENSION_NAME = "cklibPaths"
+        const val PLUGIN_NAME = "cklib"
     }
 }