Can I pass arguments to

kotlinc

directly from command line?

Hello, I have a dozen+ kotlin micro services across different git repos. Each service has its own

gradle.build.kts

file and the duplication is driving us crazy! To start I'd like to extract common dependencies + versions and so we are looking at gradle's version catalogues. But now that we've gone down this route, there are lots of other common blocks in our

gradle.build.kts

that we'd like to capture centrally as well for example the plugins block or settings like

tasks.withType<KotlinCompile>.kotlinOptions { freeCompilerArgs = freeCompilerArgs + "-Xopt-in=kotlin.RequiresOptIn" }

. So what does best practice look like here? 🙏

is it normal that a

kotlin-bom:1.5.10

relies on

stdlib:1.4.21

?

[INFO]    +- org.jetbrains.kotlin:kotlin-bom:pom:1.5.10:compile
[INFO]    +- org.jetbrains.kotlin:kotlin-stdlib-jdk8:jar:1.5.10:compile
[INFO]    |  +- org.jetbrains.kotlin:kotlin-stdlib:jar:1.4.21:compile
[INFO]    |  |  \- org.jetbrains:annotations:jar:13.0:compile
[INFO]    |  \- org.jetbrains.kotlin:kotlin-stdlib-jdk7:jar:1.5.10:compile

hello! this is kind of a kotlin MPP and gradle question wrapped into one burrito. So we recently moved all of our apps into a monorepo from separate github repos. we converted everything into a gradle mutli-module project so we could share dependencies more easily. the problem: before, the MPP app front-end (javascript) was easily debuggable because we could set breakpoints in the kotlinjs files directly in the inspector or in intellij ultimate. however, since moving things into a monorepo and sharing dependencies the path info seems to have broken and now the webpack server can’t find any of the kotlinjs files. it appears that the files are located but they all give webpack a 404 error. the path info in the old non monorepo setup looks very different from the new path info, which makes sense because as a result of sharing code and using a multimodule gradle project the build directory is now one level up. i’m curious if anyone has run into this issue and fixed it or if anyone has advice on what to try

If you are wondering why your dependency downloads are failing now: https://discuss.gradle.org/t/getting-plugins-from-jcenter-no-longer-works/40998

Any ideas how I can get rid of these build warnings? I got them since Kotlin 1.5.20. Somehow reflect is stuck at 1.4.10

w: Runtime JAR files in the classpath should have the same version. These files were found in the classpath:
    .gradle/caches/transforms-3/59efbb5d2fb40235871696f9259a7d8d/transformed/jetified-kotlin-stdlib-jdk8-1.5.30.jar (version 1.5)
    .gradle/caches/transforms-3/e66f57a2a74abdb19022465647f40d82/transformed/jetified-kotlin-stdlib-jdk7-1.5.30.jar (version 1.5)
    .gradle/caches/transforms-3/2d4b2907d0729a36c30c280633903ab8/transformed/jetified-kotlin-reflect-1.4.10.jar (version 1.4)
    .gradle/caches/transforms-3/ef7b524e21c54733be325fc195aa1b28/transformed/jetified-kotlin-stdlib-1.5.30.jar (version 1.5)
    .gradle/caches/transforms-3/fa4d08380a08dd9897606270ef087751/transformed/jetified-kotlin-stdlib-common-1.5.30.jar (version 1.5)

i’ve just upgraded to gradle 7 (using

./gradlew wrapper --gradle-version 7.0.2

) and my kotlin gradle scripts show many errors saying something similar to

Cannot access 'kotlin.collections.Collection' which is a supertype of 'org.gradle.api.artifacts.dsl.RepositoryHandler'. Check your module classpath for missing or conflicting dependencies

i don’t see any reason this should happen based on the gradle 7 docs. any ideas?

Hello, I'm encountering this issue " Task :app:connectedDebugAndroidTest FAILED", when running test cases via Gradle command. This is when i'm trying to generate the coverage report from Jacoco using command "createDebugCoverageReport"

Hey so I was writing a multiplatform library, but it seems to be that case that all the code can just be in common. What's the best way to setup builds for various platforms without having source sets for each platform? Or should I just not worry about it and remove the directories. (bout to eat lunch apologies in advance for delayed responses)

when making an extension for a custom gradle plugin, which is more idiomatic for kotlin-dsl and is it just a design thing or does it matter for some other reason

//using just String
myPlugin {
    foo = "bar"
}

//using Property
myPlugin {
    foo.set("bar")
}

Haven’t had any responses to this in #android, hoping someone can shed some light on why android gradle 7 is causing this issue

Ppl, do you know if I can import a

.gradle.kts

file inside a

.gradle

file?

i’ve got a

kotlin-conventions

plugin (precompiled script plugin), that users can put on their app, and it will configure kotlin (apply various plugins, imports kotlin bom, configure detekt etc.) the version of the kotlin bom applied is configurable via an extension class, but i’ve run into an issue with kapt. the version of the kotlin plugins (e.g. kapt) applied seems to be fixed, by whatever is added to the plugin build’s classpath. Is there any way to make this configurable? It looks like using kotlin 1.5.31 at runtime, with kapt plugin version 1.4.31 was causing some very strange and unexpected failures. and i’m not sure how to solve this for a generic plugin. i guess the generic question is: is there any way to apply a plugin to a project, where the version of the plugin comes from an extension object, and is not statically defined.

I'm learning custom gradle plugins and I'm struggling with plugin extensions. I'm currently working through the gradle guide on making the plugin configurable but i'm getting the following error when running

./gradlew tasks

locally:

* What went wrong:
Failed to apply plugin class 'Build_gradle$FooPlugin'.
> Could not create plugin of type 'FooPlugin'.
   > The constructor for type Build_gradle.FooPlugin should be annotated with @Inject.

Hi! Newbie here. I have a ktor project and want to inject external .war files to my build and deploy them together with my app with exposed endpoints for each. I have no idea how to achieve this - any pointers would be much appreciated.

serialization plugin is not applied in a composite build. Intellij 2021 and kotlin 1.5.30

I feel like this is a super simple question. I have a Kotlin JVM project making a jar. It's a gradle plugin. There are some local jar's that aren't published to anywhere, so I'm using the shadow plugin to pull them in (https://imperceptiblethoughts.com/shadow/). That's all working, but the build makes the regular jar, and also an '-all' jar from the shadow plugin. I've been trying to configure

maven-publish

and/or

com.vanniktech.maven.publish

to simply replace the regular jar with the '-all' one and publish that. So far, publishing still seems to consider the main jar the primary artifact. The docs don't really get at what I'm trying to go (https://imperceptiblethoughts.com/shadow/publishing/#publishing-with-maven-publish-plugin). So far at best I'm able to get both jars published with the shadow jar mentioned in the module (not the pom), but using it as a dependency pulls in the regular jar and fails because of ClassNotFound type exceptions (for obvious reasons). I'm hoping somebody has a simple answer or example. Seems like it should be easy, but I still haven't found an example that works (with gradle 7+, anyway). Switching focus till late tomorrow but will try to extract a simple example and post. Thanks in advance!

Hi, is there a difference between those options? I see both in examples

kotlin {
    sourceSets {
        val commonMain by getting { /* ... */ }
    }
}

and

kotlin {
    sourceSets {
        commonMain { /* ... */ }
    }
}

Hello, i haven’t gotten any help on my problem and i’ve posted a few times. I don’t want to spam the channel, so i’m not sure what to do. anyone have any recommendations?

my project has the following plugins applied:

kotlin("jvm") version "1.5.31" 
    id("org.jetbrains.kotlin.plugin.spring") version "1.5.31" 
    id("org.jetbrains.kotlin.plugin.noarg") version "1.5.31"
    id("org.jetbrains.kotlin.plugin.lombok") version "1.5.31"
    id("io.freefair.lombok") version "5.3.0"
    id("org.jetbrains.dokka") version "1.5.30"

but for some reason it looks like gradle is selecting

1.5.10

for the

kotlin-stdlib-*

dependencies:

❯ gr dependencyInsight --dependency "org.jetbrains.kotlin:kotlin-stdlib-jdk8" --configuration kotlinCompilerPluginClasspathMain
executing gradlew instead of gradle
Type-safe dependency accessors is an incubating feature.
Type-safe project accessors is an incubating feature.

> Task :dependencyInsight
org.jetbrains.kotlin:kotlin-stdlib-jdk8:1.5.10 (selected by rule)
   variant "runtime" [
      org.gradle.status          = release (not requested)
      org.gradle.usage           = java-runtime (not requested)
      org.gradle.libraryelements = jar (not requested)
      org.gradle.category        = library (not requested)
   ]

org.jetbrains.kotlin:kotlin-stdlib-jdk8:1.5.20 -> 1.5.10
\--- org.jetbrains.kotlinx:kotlinx-coroutines-core-jvm:1.5.1
     \--- org.jetbrains.kotlinx:kotlinx-coroutines-core:1.5.1
          +--- org.jetbrains.kotlin:kotlin-scripting-compiler-impl-embeddable:1.5.31 (requested org.jetbrains.kotlinx:kotlinx-coroutines-core:1.5.0)
          |    \--- org.jetbrains.kotlin:kotlin-scripting-compiler-embeddable:1.5.31
          |         \--- kotlinCompilerPluginClasspathMain
          \--- org.jetbrains.kotlin:kotlin-scripting-common:1.5.10 (requested org.jetbrains.kotlinx:kotlinx-coroutines-core:1.3.8)
               +--- org.jetbrains.kotlin:kotlin-scripting-compiler-impl-embeddable:1.5.31 (requested org.jetbrains.kotlin:kotlin-scripting-common:1.5.31) (*)
               \--- org.jetbrains.kotlin:kotlin-scripting-jvm:1.5.10
                    \--- org.jetbrains.kotlin:kotlin-scripting-compiler-impl-embeddable:1.5.31 (requested org.jetbrains.kotlin:kotlin-scripting-jvm:1.5.31) (*)

(*) - dependencies omitted (listed previously)

perhaps i just don’t understand how to read the dependencyInsights, but it’s unclear to me why it would choose that version

Anyone knows why

plugins { kotlin("jvm") }

does not apply configurations like

api

in subproject?

I have integration and system test source sets and I’ve marked the related folders in IntelliJ as test sources root. Whenever I do a Gradle sync, it changes back to sources root. How can I define in Gradle that the root folder is test sources root? Here’s how I define the sourceSet and test task for integration tests:

// custom task type to be able to create custom environment variables here
abstract class IntegrationTest : Test()

val integrationTest: SourceSet by sourceSets.creating {
    compileClasspath += sourceSets.main.get().output
    runtimeClasspath += sourceSets.main.get().output
}

configurations[integrationTest.implementationConfigurationName].extendsFrom(configurations.testImplementation.get())
configurations[integrationTest.runtimeOnlyConfigurationName].extendsFrom(configurations.runtimeOnly.get())

val integrationTestTask = tasks.register<IntegrationTest>("integrationTest") {
    description = "Runs integration tests."
    group = "verification"
    testClassesDirs = sourceSets["integrationTest"].output.classesDirs
    classpath = sourceSets["integrationTest"].runtimeClasspath
}

tasks.withType<IntegrationTest> {
    val envName = "local"

    environment(
        mapOf(
            "KEY" to "myTestValue"
        )
    )
}

Is

plugins {
    id 'org.jetbrains.kotlin:android' version "$kotlin_version"
}

alternative syntax for:

apply plugin: 'kotlin-android'

? Apologies for the noob question.

When applying the above plugin I’m getting the error:

A problem occurred configuring root project ''.

> 'kotlin-android' plugin requires one of the Android Gradle plugins.

Please apply one of the following plugins to ':' project:

- com.android.application

- com.android.library

- com.android.dynamic-feature

- com.android.asset-pack

- com.android.asset-pack-bundle

- com.android.lint

- com.android.test

- com.android.instantapp

- com.android.feature

What am I missing?

Not sure which channel is the appropriate one, but I’m experimenting with detekt + kotlinter and I’m trying to achieve the following: • when I hit

cmd+option+L

(I’m using a mac) to reformat kotlin code, I want this to match with the format kotlinter uses • when I run a gradle build, kotlinter should format not only the changed code, but everything • I want kotlinter result to be applied before detekt is executed (so for example if I have a long line, kotlinter fixes it, so detekt doesn’t fail on that) From all things (idea, detekt, kotlinter) I’m using the latest versions: • IDEA 2021.2.2 Ultimate (212.5284.40) • detekt: 1.18.1 • kotlinter: 3.6.0 I always run into some problems: • idea autoformat doesn’t match kotlinter format • kotlinter only formats changed lines not the entire file Relevant gradle parts:

plugins {
    base

    kotlin("jvm")
    id("java")
    id("idea")
    id("com.google.cloud.tools.jib")
    id("org.jmailen.kotlinter")
    id("org.jetbrains.dokka")
    id("io.gitlab.arturbosch.detekt")

    `version-catalog`

    application
}

detekt {
    toolVersion = findProperty("detektVersion") as String
    config = files("config/detekt/detekt.yml")
    buildUponDefaultConfig = true
    autoCorrect = true
    debug = true
}

tasks.detekt {
    dependsOn("formatKotlinMain")
}

// right now it's a single project, but might be a multiproject later
allprojects {
    apply(plugin = "idea")
    apply(plugin = "org.jmailen.kotlinter")
    apply(plugin = "io.gitlab.arturbosch.detekt")
}

kotlinter {
    ignoreFailures = false
    indentSize = 4
    reporters = arrayOf("checkstyle", "plain")
    experimentalRules = false
}

Hey all - I'm hoping someone can help here - still working on my gradle... probably around bluebelt level here... So what's I'm needing to do, GROOVY - I have an enterprise application which must stay on Kotlin 1.2.71 for the build.... but I'm trying to add Dokka to the project which I haven't gotten to work on anything less that Kotlin 1.4.. Does anyone know if there is a way in gradle to build on kotlin plugin/std-lib 1.2 but have JUST Dokka tasks go on 1.4??? Thanks in advance! :)

Is there any way to stop detekt and IDEA from complaining about unused variables when I use delegates to declare top-level tasks?

Anyone tried gradle composite builds with Kotlin projects? I am getting:

Caused by: org.gradle.api.UnknownDomainObjectException: Included build 'my-library' not found in build 'my-project'.

I recently tried adding the following dependencies:

implementation "com.google.android.libraries.maps:maps:3.1.0-beta"
    implementation "com.google.maps.android:maps-v3-ktx:3.0.1"

But I'm receiving the following error:

2 files found with path 'build-data.properties'.
Adding a packagingOptions block may help, please refer to
<https://google.github.io/android-gradle-dsl/current/com.android.build.gradle.internal.dsl.PackagingOptions.html>
for more information

The link provided sends me to a website that doesn't exist, so how should I go about modifying packagingOptions?