So, I am running into a problem with extension function because of Jvm name clashes. In my particular case I need to offer two similar functions operation on either a non-nullable type X and on a nullable type X.

infix fun <T> String.blah(processor: (String)->T): T

infix fun <T> String?.blah(processor: (String)->T): T?

Normally, such problems can be fixed by adding a specific

@JvmName

annotation to at least one of the two methods - but in this case you get an error, stating "'@JvmName' annotation is not applicable to this declaration". This is quite a downer.. why is that and how can I make this compile? I thought an extension function is nothing special at all, in my case a function with two arguments... Any chance I might get this working? Thanks!

Trying to write a small compiler plugin following https://bnorm.medium.com/writing-your-second-kotlin-compiler-plugin-part-1-project-setup-7b05c7d93f6c How can I debug why the kotlin compiler plugin is not being activated? I can see that the gradle plugin part is being activated OK, and I can set a breakpoint in the debugger for it when running gradle in debug mode. But the kotlin compiler part (inheriting from CompilerPluginRegistrar) is not running, and not printing my test message as per this code:

@OptIn(ExperimentalCompilerApi::class)
@AutoService(CompilerPluginRegistrar::class)
class MyPlugin : CompilerPluginRegistrar() {
    override val supportsK2: Boolean
        get() = true

    override fun ExtensionStorage.registerExtensions(configuration: CompilerConfiguration) {

        val messageCollector = configuration.get(CLIConfigurationKeys.MESSAGE_COLLECTOR_KEY, MessageCollector.NONE)

        messageCollector.report(
            CompilerMessageSeverity.WARNING,
            "*** Hello from MyPlugin ***"
        )
    }
}

in the project which uses the plugin, I have defined

tasks.withType<KotlinCompile> {
    kotlin {
        jvmToolchain(19)
        kotlinOptions {
            verbose = true
            useK2 = false
        }
    }
}

and when running

./gradlew --debug

i can grep for KOTLIN in the logs and see some of the compiler output, where my plugin is mentioned:

2023-03-26T12:50:40.339+0200 [DEBUG] [org.gradle.api.Project] [KOTLIN] Subplugin my-plugin loaded
2023-03-26T12:50:40.339+0200 [DEBUG] [org.gradle.api.Project] [KOTLIN] Loading subplugin my-plugin
2023-03-26T12:50:40.339+0200 [DEBUG] [org.gradle.api.Project] [KOTLIN] Adding 'se.rrva:my-plugin:1.0.5' to 'kotlinCompilerPluginClasspathTest' configuration

This message was deleted.

We are trying in our project, to add additional semantic analysis to the compiler, that uses kotlins other semantic analysis like the inheritance graph, type inference or symbol resolution. We tried to add it as PartialAnalysisHandlerExtension, but couldn't find a way to get type inference and other resolve results. Is there a way to add semantic analysis after the analysis from the kotlin compiler, preferable in a way, that symbol resolutions are accessible via PsiReference to reuse code between a kotlinc and intellij-plugin?

alright friends I cant think of a better place to put this so im plopping it in here. I need to understand IEEE 754 and error with respect to writing values. For my problem there are no math operations to induce error, only attempts to represent a double value. the code

val firstDbl: Double = 0.1
val firstStr: String = "0.1"
val firstBigStr = BigDecimal("0.1")
val firstBigDbl = BigDecimal(0.1)

has some funny equality implications:

firstDbl == firstStr.toDouble() //true
firstBigStr == firstBigDbl //false
firstBigStr.toDouble() == firstBigDbl.toDouble() // false, 0.1 != 0.0...555

firstBigDb.toString() // 0.1000000000000000055511151231257827021181583404541015625

Can somebody help me understand where this error came from? Should i be calling a different BigDecimal constructor?

Hi guys, I have the following interface:

interface Bindable<in T> {
    fun bind(input: T)
    fun unbind()
}

And I’m trying to define two utility functions, one when T is nullable, one when it is not:

inline fun <B : Bindable<T>, T: Any> B.use(input: T, block: B.() -> Unit) {
    bind(input); try { block() } finally { unbind() }
}
inline fun <B : Bindable<T?>, T: Any> B.use(input: T? = null, block: B.() -> Unit) {
    bind(input); try { block() } finally { unbind() }
}

The only difference being that, in case of nullable

T

I can provide a default value to input. The problem is that the compiler complains about resolution ambiguity at use site in some cases, I think due to the

in

modifier. Is there any mechanism (annotation?) I can use to help it choose? For example, I’m calling

Bindable<Long?>.use(0L) { … }

. I don’t care which one is chosen in this case, source code is the same.

what does

low level

mean in analysis package? e.g.

low-level-api-fir

and what is the meaning of

Cone

in

ConeKotlinType

class

anyone know what to do about this error?? kotlin version: 1.8.20 error message: java.lang.IllegalArgumentException: typeParameters = [org.jetbrains.kotlin.ir.declarations.impl.IrTypeParameterImpl@6325d378] size != typeArguments = [org.jetbrains.kotlin.ir.types.impl.IrSimpleTypeImpl@23f77bf4, org.jetbrains.kotlin.ir.types.impl.IrSimpleTypeImpl@a4070e5a] size at org.jetbrains.kotlin.ir.overrides.IrOverridingUtilKt.buildFakeOverrideMember(IrOverridingUtil.kt:79) at org.jetbrains.kotlin.ir.overrides.FakeOverrideBuilderStrategy.fakeOverrideMember(IrOverridingUtil.kt:25) at org.jetbrains.kotlin.ir.overrides.IrOverridingUtil.buildFakeOverridesForClass(IrOverridingUtil.kt:155) at org.jetbrains.kotlin.backend.common.overrides.FakeOverrideBuilder$buildFakeOverrideChainsForClass$2$1.invoke(FakeOverrides.kt:133) at org.jetbrains.kotlin.backend.common.overrides.FakeOverrideBuilder$buildFakeOverrideChainsForClass$2$1.invoke(FakeOverrides.kt:132) at org.jetbrains.kotlin.backend.common.serialization.signature.PublicIdSignatureComputer.inFile(IdSignatureSerializer.kt:45) at org.jetbrains.kotlin.backend.common.serialization.signature.IdSignatureSerializer.inFile(IdSignatureSerializer.kt:229) at org.jetbrains.kotlin.backend.common.serialization.DeclarationTable.inFile(DeclarationTable.kt:62) at org.jetbrains.kotlin.backend.common.overrides.FakeOverrideBuilder.buildFakeOverrideChainsForClass(FakeOverrides.kt:132) at org.jetbrains.kotlin.backend.common.overrides.FakeOverrideBuilder.provideFakeOverrides(FakeOverrides.kt:198) at org.jetbrains.kotlin.backend.common.overrides.FakeOverrideBuilder.provideFakeOverrides(FakeOverrides.kt:208) at org.jetbrains.kotlin.backend.common.serialization.KotlinIrLinker.postProcess(KotlinIrLinker.kt:219) at org.jetbrains.kotlin.ir.backend.js.ic.LoadedJsIr.loadUnboundSymbols(JsIrLinkerLoader.kt:71) at org.jetbrains.kotlin.ir.backend.js.ic.JsIrLinkerLoader.loadIr(JsIrLinkerLoader.kt:201) at org.jetbrains.kotlin.ir.backend.js.ic.JsIrLinkerLoader.loadIr$default(JsIrLinkerLoader.kt:151) at org.jetbrains.kotlin.ir.backend.js.ic.CacheUpdater.loadIrForDirtyFilesAndInitCompiler(CacheUpdater.kt:636) at org.jetbrains.kotlin.ir.backend.js.ic.CacheUpdater.loadIrAndMakeIrFragmentGenerators(CacheUpdater.kt:694) at org.jetbrains.kotlin.ir.backend.js.ic.CacheUpdater.actualizeCaches(CacheUpdater.kt:718) at org.jetbrains.kotlin.cli.js.K2JsIrCompiler.prepareIcCaches(K2JsIrCompiler.kt:704) at org.jetbrains.kotlin.cli.js.K2JsIrCompiler.doExecute(K2JsIrCompiler.kt:275) at org.jetbrains.kotlin.cli.js.K2JSCompiler.doExecute(K2JSCompiler.java:180) at org.jetbrains.kotlin.cli.js.K2JSCompiler.doExecute(K2JSCompiler.java:72) at org.jetbrains.kotlin.cli.common.CLICompiler.execImpl(CLICompiler.kt:100) at org.jetbrains.kotlin.cli.common.CLICompiler.execImpl(CLICompiler.kt:46) at org.jetbrains.kotlin.cli.common.CLITool.exec(CLITool.kt:101) at org.jetbrains.kotlin.daemon.CompileServiceImpl.compile(CompileServiceImpl.kt:1486) at java.base/jdk.internal.reflect.DirectMethodHandleAccessor.invoke(DirectMethodHandleAccessor.java:104) at java.base/java.lang.reflect.Method.invoke(Method.java:577) at java.rmi/sun.rmi.server.UnicastServerRef.dispatch(UnicastServerRef.java:360) at java.rmi/sun.rmi.transport.Transport$1.run(Transport.java:200) at java.rmi/sun.rmi.transport.Transport$1.run(Transport.java:197) at java.base/java.security.AccessController.doPrivileged(AccessController.java:712) at java.rmi/sun.rmi.transport.Transport.serviceCall(Transport.java:196) at java.rmi/sun.rmi.transport.tcp.TCPTransport.handleMessages(TCPTransport.java:598) at java.rmi/sun.rmi.transport.tcp.TCPTransport$ConnectionHandler.run0(TCPTransport.java:844) at java.rmi/sun.rmi.transport.tcp.TCPTransport$ConnectionHandler.lambda$run$0(TCPTransport.java:721) at java.base/java.security.AccessController.doPrivileged(AccessController.java:399) at java.rmi/sun.rmi.transport.tcp.TCPTransport$ConnectionHandler.run(TCPTransport.java:720) at java.base/java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1136) at java.base/java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:635) at java.base/java.lang.Thread.run(Thread.java:833)

Im having issues with getting stderr (or any output really) from a compiler plugin being printed on a gradle setup. This is still on the pre-K2 API. The plugin is being invoked and the codepaths that the print statements are on are being executed, so Im a bit lost as to whats going on. Any leads? Im trying to log exceptions in the plugin, but I cant get them to be logged. Not catching the exceptions works fine, but it fails the build which we really dont want to do

Hi everyone - is there a way to selectively treat a particular compiler warning as an error? I'm aware of

kotlinOptions.allWarningsAsErrors = true

but wondering if there's a way to pick individual warnings to regard as errors.

Hello, what is the difference between IrBlock vs IrBlockBody vs IrExpressionBody vs IrReturnableBlock vs IrComposite? They all seem very similar. Some of them are rarely used. Also, how does this relate to https://youtrack.jetbrains.com/issue/KT-53992/Deprecate-IrExpressionBody?

where is the youtube link to KotlinConf'23 – BERLAGEZAAL Day 2? I want to see the contents of the K2 compiler section.

Why does

b()

produces more complex bytecode than

a()

, instead of just adding a private field to the anonymous class?

fun interface Counter {
    fun getAndIncrement(): Int
}

fun a(): Counter = object : Counter {
    var number = 42
    override fun getAndIncrement(): Int {
        return number++
    }
}

fun b(): Counter {
    var number = 42
    return Counter { number++ }
}

Maybe somebody here has a clue for me in this weird error when using the Kotlin script compiler? When updating from 1.8.10 to 1.8.20 I ran into this issue.... Thanks!

(Resolved) Creating a generic extension is behaving weirdly. I have a boolean list and its allowing me to add a integer, no compilation issue (line 15). What am I missing here? Kotlin playground link: https://pl.kotl.in/eSKHXxqzq

What's the best way to analyze compiler performance on a per-file basis? I have couple of modules that take relatively long to compile, and I'm wondering if it's maybe some specific files that cause the issues. I'm almost certain I saw an answer to this already but couldn't find it. I tried using various flags like

-Xreport-perf

(with and without

kotlin.compiler.execution.strategy=in-process

) but I see no output anywhere, and I couldn't find any documentation outlining what flags exists and how they should work. I also tried

kotlin.build.report.output=file

but I don't think it provides the information I want (and it doesn't work anyway, always produces an empty file)

There's been lots of chat about FIR in the context of plugins and the within the compiler, but are there any examples of setting up FIR in a standalone project to interpret parsed Kotlin? I'm currently doing this with PSI and it's a huge pain because I don't actually care about the precise syntax tree but just want to parse a semantic tree (similar to what runtime reflection would provide).

No sure where to ask about this, but here seems the most fitting... Is there a compiler plugin which allows to inline html/xml so we could write something similar like jsx/tsx?

Getting the following exception on a kotlin 1.8 project using a compiler plugin compiled with kotlin 1.5.30. Not sure why this would happen, the interface definition is identical in both versions

> Task :app:compileKotlin FAILED
e: java.lang.NoClassDefFoundError: org/jetbrains/kotlin/resolve/jvm/extensions/AnalysisHandlerExtension$DefaultImpls
        at com.sourcegraph.semanticdb_kotlinc.Analyzer.doAnalysis(Analyzer.kt:24)
        at org.jetbrains.kotlin.cli.jvm.compiler.TopDownAnalyzerFacadeForJVM.analyzeFilesWithJavaIntegration(TopDownAnalyzerFacadeForJVM.kt:123)
        at org.jetbrains.kotlin.cli.jvm.compiler.TopDownAnalyzerFacadeForJVM.analyzeFilesWithJavaIntegration$default(TopDownAnalyzerFacadeForJVM.kt:99)

Hi Kotlin maintainers 👋. I think I've found another "Exception during IR lowering" bug. This is in 1.18.20. I haven't checked K2 yet. Detailed here: https://youtrack.jetbrains.com/issue/KT-58476/Context-receiver-inside-suspended-lambda-c[…]er-suspended-function-causes-Exception-during-IR-lowering Minimized code sample here: https://github.com/deusaquilus/ContextBugTest The code-sample might look a bit contrived because I had to heavily reduce it down from what it was before. Originally the code comes from an error I got while trying to build an SQL DSL.

Hi! I’ve reached a working proof-of-concept for a Kotlin compiler plugin that brings Svelte-like reactivity to Kotlin. You can check it out here: GitHub - spxbhuhb/rui: Kotlin Reactive UI inspired by Svelte. Your ideas, comments, opinion would be very welcome!

Hi, today we spent some time finding a bug with an NPE on a non-nullable type. We simplified the scenario down to a small toy example to showcase the problem: https://play.kotlinlang.org/#eyJ2ZXJzaW9uIjoiMS44LjIxIiwicGxhdGZvcm0iOiJqYXZhIiwiYXJncy[…]xufVxuXG5mdW4gbWFpbigpIHtcbiAgICBwcmludGxuKEZvbygpKVxufSJ9

// This code compiles, but leads to an NPE on a non-nullable type
class Foo {
    val output = doSomething()
    val input = "This value is not set yet"
    fun doSomething(): String = input.uppercase()
}

The order of the class properties matters, as

input

is still

null

, when

doSomething()

is called. This is trivial to see in this example, but tricky in more complex scenarios. Is this expected behavior? Couldn't the compiler notice the nullability issue?

I try to write unit tests for my complier plugin using kotlin-compile-testing. The tests that are supposed to generate a compilation error are successful. The result of the compilation is COMPILATION_ERROR, this is good. However, IDEA recognises the error and reports it (see the screenshot attached). I use

pluginContext.createDiagnosticReporter(_PLUGIN_ID_)

to create a diagnostics reporter and send the errors through that reporter. Is there a smarter way to do this? It is an inconvenience only but I don't like that the build seems like an error even when it is successful.

I've 2 small questions: Why is the expected version 1.6 when I have 1.8 everywhere in my code ? Why can I still compile using

gradle build

but intellij says it can't build the project:

/home/merlijn/.gradle/caches/modules-2/files-2.1/com.google.devtools.ksp/symbol-processing-gradle-plugin/1.8.21-1.0.11/84f788fcf1cbc31bb6491f29df3343c8b5fcc7c1/symbol-processing-gradle-plugin-1.8.21-1.0.11.jar!/META-INF/gradle-plugin.kotlin_module: Module was compiled with an incompatible version of Kotlin. The binary version of its metadata is 1.8.0, expected version is 1.6.0.

This happened when I wanted to update from 1.6 compiler to 1.8 along with kotlin 1.7.20 libs to 1.8.20

How do I add the JDK classpath to a compiler configuration? I was calling

configureJdkClasspathRoots()

but it no-ops when the JDK is Java 9+, presumably due to the switch to modules and the disappearance of

rt.jar

. It seems like there's helpers for adding module roots given I know the path. Is it just my responsibility to do the JDK lookup, check for modular, and then conditionally do one or the other?

Hi! I've been playing with the compiler backend for a while and, in short, I managed to make it 2.3x faster 🚀 (so far), while also somewhat simplifying the code 🌟 ! More in 🧵 .

Not sure if this is the best channel to ask, but does anyone know some compiler plugin which can turn a class with suspend (or non-suspend) functions and also a whole module or individual functions into non-suspend (or suspend) versions, so one doesn’t have to copy-paste lots of code and keep the two versions in sync by hand? The function coloring problem keeps hitting us every now and then and

inline

can’t always be used to work around it.

was it ever seriously considered to implement the Kotlin compiler in something like Rust? omitting the aspect of performance, I suppose Kotlin compiler’s API is not just the CLI (which would allow implementing it in whatever one wants), but it also exposes some libraries right? Any thoughts on this?

In IR compiler/plugin code, it’s possible to generate a call to a function via

irCall

, like how data classes have generated calls to their properties’ hashCode functions. Is it possible to generate a call to an arbitrary function that you don’t have a direct reference to, like a

kotlin-stdlib-common

function?