A modern programming language that makes developers happier.

kotlinlang

Testing upgrading my project to Kotlin 1.9.0, and I'm getting a compile error with Gradle code that was working in 1.8.20. (Will drop details in a :thread: )

Is this the right channel to ping? Just want to double check if it's user error before filing a bug. But if this is real, I can't imagine I'd be the only one hitting it...

Problematic line is here:
<https://github.com/varabyte/kobweb/blob/0f0c6a48d68efadeda4236263a075329c5583446/gradle-plugins/core/src/main/kotlin/com/varabyte/kobweb/gradle/core/KobwebCorePlugin.kt#L53|https://github.com/varabyte/kobweb/blob/0f0c6a48d68efadeda4236263a075329c5583446/g[…]main/kotlin/com/varabyte/kobweb/gradle/core/KobwebCorePlugin.kt>
```project.buildTargets.withType&lt;KotlinJsIrTarget&gt;.configureEach {
  val jsTarget = JsTarget(this)
  ...
}```
The "this" going into the callback should be `KotlinJsIrTarget` but with Kotlin 1.9.0 I'm getting this error:
```e: file:///home/d9n/Code/scratch/kobweb/gradle-plugins/core/src/main/kotlin/com/varabyte/kobweb/gradle/core/KobwebCorePlugin.kt:54:37 Type mismatch: inferred type is KobwebCorePlugin but KotlinJsIrTarget was expected```
so it thinks "this" is coming from the parent scope.

The Gradle API here is Java:
```void configureEach(Action&lt;? super T&gt; action);

@HasImplicitReceiver
public interface Action&lt;T&gt; {
    /**
     * Performs this action against the given object.
     *
     * @param t The object to perform the action on.
     */
    void execute(T t);
}```


I wonder if `HasImplicitReceiver` is doing something funky that is confusing the Kotlin 1.9.0 compiler? Because I'm having trouble imagining how to create such a functional interface manually.

```fun interface Action&lt;T&gt; {
  fun T.execute()
}```
maybe?

If anyone wants to repro, here's the steps I have currently

• In a tmp dir somewhere...
• `git clone <https://github.com/varabyte/kobweb> &amp;&amp; cd kobweb`
• Edit `gradle/libs.versions.toml`
    ◦ `compose = 1.4.1` --&gt; `compose = 1.4.3`
    ◦ `kotlin = 1.8.20` --&gt; `kotlin = 1.9.0`
• `./gradlew :gradle-plugins:core:build`

Of course, if anyone has a project with a Gradle plugin that uses configureEach, then I guess they should update the compiler to Kotlin 1.9.0 and see if it's working there?

_Gradle_ code should use the embedded Kotlin version that ships with Gradle; no Gradle version currently supports 1.9.0.  Note this is separate from using `kotlin("jvm")` which configures Kotlin for your _application_ code.

The list of embedded Kotlin versions is <https://docs.gradle.org/current/userguide/compatibility.html#kotlin|here>.

You are the only one hitting this (well, likely a small group) due to tweaking Gradle internals that aren’t designed to be changed.

A quick review of your repo shows several challenges, primarily mixing `kotlin-dsl` and `kotlin("jvm")`:
```plugins {
	// this brings in embedded kotlin + java-gradle-plugin and a few other settings
    `kotlin-dsl`

    // never mix this with `kotlin-dsl` - either a module is building Gradle code (`kotlin-dsl`) or application code (kotlin("jvm)"))
    alias(libs.plugins.kotlin.jvm)
    id("com.varabyte.kobweb.internal.publish")

    // both of these are redundant, included via `kotlin-dsl`
    `java-library`
    `java-gradle-plugin`

    
    alias(libs.plugins.kotlinx.serialization)
}```

You can, of course, upgrade the application code (not the plugins) to Kotlin 1.9.0 separately from the embedded Kotlin version with Gradle.

fyi, this topic is better suited for <#C19FD9681|gradle>