It would be better to work hard on good abstractions and throw all the codegen away.

I had asked this in another thread but it got a bit buried; we know that the compiler team is working on a new IR for Kotlin so we can write cross-platform compiler plugins. Is there anywhere that we can track that work? Either a bunch of Youtrack tickets, a branch or directory in the Github repo containing the latest work, etc.

Can I run the compiler directly from Kotlin in the same JVM?

details are in https://youtrack.jetbrains.com/issue/KT-9742

Does anyone know if

foo { bar(it) }

has a performance cost over

foo(bar)

allocating an extra lambda? If so is this something the Kotlin compiler already optimizes for?

If I sprinkle a few typos in module-info.java, the compiler (via gradle) happily compiles anyway. Meanwhile IntelliJ complains about both the typo and (when the typo is removed) the usual JPMS issues — split packages in dependencies, etc

Hi, I have a use case where I can optimize a type lookup with a fast

switch

based on ints. Does the kotlin compiler ever optimizes

when

to become a fast

switch

based on ints? If not what is the equivalent in Kotlin of https://www.scala-lang.org/api/current/scala/annotation/switch.html if any? thanks!

No, and I'm happy there's none. It could encourage people to write poor code with the excuse of build speed, that would make maintenance slower instead. kapt is slow though, because it's not incremental yet (unless you already use 1.3.30 with EAP and your kapt dependencies have incremental support), but kapt is mainly Java legacy that is replaced by things like SQLDelight, kotlinx.serialization, delegates, extension functions, coroutines, data classes and more great features that are actually faster than annotation processors to compile.

Hi. Working on a KEEP, is it possible to declare new line characters inside the

DefaultErrorMessages

and make them work in the inlined errors from the IDE inspections? Since looks like the errors print with new line chars on terminal if you build the project, but the inlined IDE error inspections don’t seem to show new line chars and show everything on a single line.

Hi! Still interested in finding out about compiler performance to feature information if anyone who actually works on the Kotlin team has any familiarity with it.

Hi, Junit5 team is encountering a weird issue where, in the face of 30+ overloads for a method, there seems to be a weird case where the Kotlin compiler generates a completely invalid call. We are looking at the bytecode and the compiler generates a call to the following method that doesn't exist:

org/junit/jupiter/api/Assertions.assertEquals:(ILjava/lang/Integer;)V

https://github.com/junit-team/junit5/issues/1859

Hello, I encountered an unexpected behaviour it this code snippet:

interface Command<T>
    
class TestUnitCommand : Command<Unit>

class TestIntCommand : Command<Int>
    
class TestStringCommand : Command<String>
    
class Result<T>
    
inline fun <reified T : Command<R>, reified R : Any> execute(crossinline block: suspend (T) -> R) {}

fun main() {
    execute<TestUnitCommand, Unit> { Result<Unit>() }        // OK
    execute<TestIntCommand, Int> { Result<Int>() }           // Error
    execute<TestStringCommand, String> { Result<String>() }  // Error
}

Why does it not error when

Command

generic parameter is

Unit

? Does it implicitly not return anything?

Hi, I am trying to compile some Kotlin code under Java 11 which is using an internal JDK api (eg. com.sun). I am therefore required to inform the compiler (Java) that I need to use this internal API by specifying:

--add-exports java.base/sun.security.x509=UNNAMED-MODULE

. How does one coax the Kotlin compiler to process/pass this directive?

Hi all 👋 I ran into something very weird when trying to check the compiled code for a simple coroutine example. Following 9 lines of Kotlin code result in 12, 402 lines of Java code according to IntellIJ’s decompiler.

import kotlin.coroutines.Continuation
import kotlin.coroutines.EmptyCoroutineContext
import kotlin.coroutines.startCoroutine

val f: suspend () -> String = suspend { "Hello World!" }

fun main() {
  f.startCoroutine(Continuation(EmptyCoroutineContext, ::println))
}

Hello! I’ve been poking through the compiler source code and have a couple questions. 1) It looks like you are lexing via JFlex instead of Antlr. Is this correct? Any reasons for one over the other? 2) Is the parser implemented by hand? I’ve seen some parsing examples where you can generate a simple parser from grammar rules. Did this not give you enough control?

Hey, all. 👋 I’m writing a Kotlin compiler plugin and I’m trying to get the fully qualified name of a

KtCallExpression

. Anyone know how?

Or better, yet. Is it possible to attach the debugger to my plugin?

println

is an inline-function which calls

System.out.println

internally. That's how Kotlin function inlining look like.

So here is what I have found out from reading the sources in the past two days: Generally speaking it is not possible to simply create a synthetic class outside the bounds of existing class, at least there is no officially endorsed way of doing so. However there are several ways to do it, if you really need to. The first way is to obtain the

CompilerConfiguration

using the

CompilerConfigurationExtension

in order to get hold of the output directory. You can then write your own files using the

BinaryClassWriter

. This way is pretty safe and should be stable across future releases. The second method would be to use either the

AnalysisHandlerExtension

or the

CollectAdditionalSourcesExtension

to access and modify the list of source files. The list of sources is leaking and can simply be casted into a

MutableList

. While this can be pretty useful, it is not recommendable, because this will probably be fixed in the future.

Would it make sense to have equals rely on type checks instead of using the default JVM implementation that uses the instance id? Maybe the compiler could add these default implementations:

sealed class Location: Serializable {
    object Unknown : Location() {
        override fun equals(other: Any?) = other is Unknown
        override fun hashCode() = toString().hashCode()
        override fun toString(): String = "Location.Unknown"
    }
    data class Known(val lat: Float, val lon: Float) : Location()
}

https://stackoverflow.com/a/56485743/458365

Where is

TypeResolutionInterceptorExtension

in the compiler?. I see Jetpack Compose uses that and can’t find that on github.

I have a compiler plugin where I’m subscribing to the

org.jetbrains.kotlin.backend.common.extensions.IrGenerationExtension

. It does not seem like it’s calling me back so I’m guessing is not using the IR format. Is there a compiler flag or some kind of way to turn IR generation on?. Thanks!

Hey guys, I'm writing a compiler plugin for fun and I'm generating additional functions in a class. Is there any way to include (in bytecode) generated things in for example the ide (intellij) completion? I mean without writing a custom intellij plugin? I want the ide to use the build for class compilation and the compilation output for Code completion somehow O:-)

What is the best way to obtain an

IrType

for a known type given it’s fully qualified name and type arguments? I need to refer to a known type that is not in the

IrBuiltins

constants.

with 1.3.31 i'm seeing enum `when`'s generating a bunch of if/else's instead of a tableswitch

is the

Kotlin Bytecode Viewer

actually decompiling binaries or just making a best effort based on the sources presented? I have a compiler plugin injecting stuff in the bytecode that I don’t see in the bytecode viewer. What do people use to debug emitted bytecode when working with compiler plugins? thanks!

In a compiler plugin in the

SyntheticResolverExtension

I’m overriding

generateSyntheticClasses(PackageFragmentDescriptor, ...)

and

addSyntheticSupertypes

. I’m attempting to add a super type to a class that I generate myself in that pass. For example:

package x
interface Foo<A>
class Bar

I want to expand to:

package x
interface Foo<A>
class GeneratedClass
class Bar : Foo<GeneratedClass>

The issue I’m having is that

addSyntheticSupertypes

happens before

GeneratedClass

has a valid

ClasDescriptor

so when I add the supertype I get:

Bar : Foo<[ERROR : Unsubstituted type for <ERROR CLASS>]>

e: java.lang.IllegalStateException: Backend Internal error: Exception during code generation
Cause: Error type encountered: [ERROR : Unsubstituted type for <ERROR CLASS>] (ErrorType).

How can I generate a valid descriptor in that phase for

GeneratedClass

or how can I add a supertype to a class given the class the type refers to may not have been generated yet? Is this the wrong phase to do this kind of work?

What is the state of compiler plugins in Kotlin? I believe the native compiler allows for code generation via IR. What about the JVM and js compilers? Are they compatible with IR yet?

I have implemented my own extensions for

PackageFragmentProviderExtension

and now I’m verifying that all the code is generated properly and I can even import classes and they compile fine from the command line. For example this compiles:

import sample.GeneratedClass

And also this:

Class.forName("sample.GeneratedClass")

I’m still seeing these issues: 1. This compiles fine only in the command line. IDEA still shows redlines for all the types it can’t find. Does IDEA use automatically the

PackageFramentDescriptor

and

SyntheticResolver

info or am I missing additional setup to get this to work on IDEA? 2. It only compiles fine with

import sample.GeneratedClass

if its in the same module. If I add the compilation result with codegen as dependency in a different module it does not compile but shows instead:

sample/test.kt: (3, 21): Unresolved reference: GeneratedClass

Any help is appreciated, thanks!