I am puzzeled by the fact that the following snippet compiles:

val x : (()->Unit)? = null


fun main() {
    if (x != null) {
        x.invoke()
    }
}

while with this one the compiler complains about the reference having a nullable type:

val x : (()->Unit)? = null


fun main() {
    if (x != null) {
        x()
    }
}

Compiler and Android Studio even agree on complaining about the second snippet. Am I missing something?

Hi! I've been poking around

IrGenerationExtension

, and am trying to add a function to annotated classes that just prints "Hello World". I got stuck figuring out how to find the

println

descriptor or symbol to build the function call through

IrCallImpl

. Does anyone know where I could find an example, or another way I could go about this? Thanks!

is anyone familiar with the :generators:test-generator module in the kotlin compiler repo? I'm trying to generate tests and I'm assuming 'testClasses' task is the task responsible for generating the tests.

What are the compile times people are experiencing? I'm new to the Kotlin compiler development and it takes about 40 seconds to compile (context: debugging plugin tests). Is this normal?

Hi, i want to detect annotated expressions. Does someone know which class i could use for that?

How stable is the IR api? Is it safe to start using to develop a compiler plugin?

Where can I find the Kotlin Native compiler artifacts on Maven? Or does that not exist? I'm working on an alternative build tool and have had little luck going through the repository to find any public embedded compiler like there is for JS and JVM. I could always run them through the command line, but I'd prefer to keep the fully-typed interface from the source if there's one available.

As I work on testing the Arrow codebase with Arrow Meta and IR enabled on I’m finding many unsupported and missing cases in IR translation even in the JVM target. Is there a public list or way to track what is missing?. We could help contributing the missing pieces to the compiler if that helps us in any way getting there faster.

Is anyone familiar with the automated test setup in the compiler? I added some tests to verify IR pass code transformation is correct, and although my test passes it fails because its being included in another test suite where it cannot find my test data. I want to exclude my test from this suite, but I'm having a hard time locating where this inclusion is specified. The stack trace is unhelpful and the error message searches yields no result. The problem test suite is android-tests

I’ve got an issue filed regarding generating

.class

files directly via Kapt, but I’m wondering actually if this is a bug in the compiler itself by virtue of not putting

.class

source roots on the compile classpath (so other code can link against it). I’ve been looking at how gradle handles this, and while it supports generating class files directly via annotation processing, its annotation processing machinery doesn’t actually appear to do anything special to ensure the class file is on the compile classpath. It just hands it over to the compiler. Issue for ref: https://youtrack.jetbrains.com/issue/KT-33847 I’m wondering if this should be reassigned as a kotlinc bug basically.

I am trying to find the cause of this bug in Moshi: https://github.com/square/moshi/issues/615 (more out of interest than need). The issue is that Moshi and Retrofit have different notions of what the generic type actually is. The underlying cause is that

Foo<Nothing?>

(and

Foo<Nothing>

) compile to a raw type. While that is fine for the runtime it means losing generic information where it would be normally available (such as in method signatures). I have found this (https://github.com/JetBrains/kotlin/commit/9acf3e40de2d22318f9d3eda15e5da47117edbc4#diff-efccdee550f101125771902fc631175a) commit that implemented the Nothing -> raw type conversion. I could not find an explanation. Does someone know the reason behind this decision? How could I recover the Nothing generic argument? Is this the only case that compiles to a raw type?

is there any nice blog posts on how to create a kotlin compiler plugin ?

Can we write a custom syntax for Kotlin with a compiler plugin? Like union type:

type newType = typeA | typeB

?

Is there possibility to enrich JS

prototype

via compiler plugin?

// Kotlin
class A: B

// compiled JS
A.prototype = Object.create(B)

// compiled JS + enrich
A.prototype = Object.create(enrichMethod(B))

Can it be realized using

JsSyntheticTranslateExtension

?

Is there some util functions I can use to know the expected type at some position in a KtFile ? for instance let's say I have a method

doSomething(s: String)

we know that when calling this function the expected value inside the

()

should be a string. Is there anything in

kotlin-compiler

that already does all of this kind of logic and returns a

KotlinType

?

I’m experience an odd behavior when repackaging compiler plugins with the gradle shadow plugin. If I depend in the shadowed version of the compiler plugin once the compiler loads my plugin I always get:

e: java.lang.IllegalStateException: The provided plugin arrow.meta.MetaPlugin is not compatible with this version of compiler

My current config for the shadow plugin looks like:

shadowJar {
    configurations = [project.configurations.compile]
    relocate 'org.jetbrains.kotlin.com.intellij', 'com.intellij'
    dependencies {
        exclude(dependency {
            it.moduleGroup.startsWith('org.jetbrains') || it.moduleGroup.startsWith('org.intellij')
        })
    }
    //relocate 'org.jetbrains.kotlin.load', 'kotlin.reflect.jvm.internal.impl.load'
}

Same behavior regardless if I include the embedded Kotlin deps or not. Whenever I shadow a compiler plugin I get that error. does anyone know if there is a special setting or something I am missing?. The only difference between the jars I’ve noticed is that due to the package relocation the shadowed version may have different size .class files. Any help is much appreciated. Thanks.

Dummy question about Kotlin to JVM compiler: 1. Was it implemented from scratch in Java? 2. Was it implemented using some standard Java lexer/parser framework? 3. Was it implemented using LLVM, compiled to LLVM IR and later compiled to JVM bytecode?

The Kotlin compilation process works in several stages: - First the compiler is called with the kapt plugin which generates Java stub files from the Kotlin files and then calls apt with that. AFAIK the kapt plugin "shortwires" the rest of the compilation, so that no actual compilation of Kotlin sources takes place in this stage - Then the Kotlin compiler is called regularly to compile the Kotlin sources - Finally the Java compiler is called to compile all Java sources, with the compiled Kotlin class-files from the previous step on the classpath. My question is: Do third-party compiler plugins get passed to both the first 2 stages or just in the 2nd stage? Does the kapt plugin prevent the execution of further compiler plugins as well, like it shortwires the regular compilation?

I'm just starting writing compiler plugins and just want to ask if there is a way to log in the extensions , or debug the compiler (that would be perfect )

hello ! just want to know if given a functionDescriptor can we know if this is a topLevel function or a Function inside a class ?

Hey , i'm writing a kotlin compiler plugin that will generate code that use some android classes how can i generate code that use the android classes like View.java ?

After updating to the latest version of UAST, it seems that it hides any functions that take/return

reified

types. For example:

package test.pkg
inline fun <reified T> Context.systemService1() = getSystemService(T::class.java)
inline fun Context.systemService2() = getSystemService(String::class.java)

For this

PsiClassItem

call to

methods

only returns 1 method (the one without

reified

). Removing

reified

brings it back, going back to older version of UAST also brings it back. I was wondering if this sounds familiar to anyone?

Hi everyone, I'm new to the kotlin compiler (but not new to kotlin or compilers), are there any resources you would recommend other than the source for getting started with compiler/compiler plugin development? Thanks!

Hey, has anyone had any experience with a compiler plugin that works for both JVM and native? I've got a JVM plugin working but having some trouble getting plugins to work for native. I've been compiling against

kotlin-compiler-embeddable

(which has been working great for JVM) but it seems to have a bunch of dependencies remapped under

org.jetbrains.kotlin

. The problem is

konanc

, even when run from gradle just like I'm doing for JVM, doesn't seem to have those packages remapped so my plugin doesn't load since it's referencing the wrong classes. Is it possible to write a plugin that works for both JVM/native at the moment?

Hi everyone , i'm making a compiler plugin so i got 3 module : the gradle plugin module , the kotlin compiler module and a runtime module that hold my annotation , so i want the module to be used only in android applications so to do so the runtime module must be only accessed from android modules how can i achieve that . after inspecting the android extensions plugins i've noticed that they hide the runtime module inside the 'kotlin-android' plugin is there a way to do so ?

Is someone familiar with ASM Transformations?

What does Fir stand for in Kotlin compiler?

I'm seeing override by an inline function is only a warning that can be suppressed. What happens under the hood when I do it? Tries to resolve to inline when the type is the impl of the interface?

Hi all! I am writing a Kotlin plugin code, and at some point I would like to get all candidates descriptors of a (incomplete) function call. The code below works for calls that have only one possible candidate, but not for calls with multiple candidates/overloads :

val context: BindingContext = ...
val callExpression: KtCallExpression = ...
val call = callExpression.getCall(context)
val resolvedDescriptor = call?.getResolvedCall(context)?.candidateDescriptor

if (resolvedDescriptor == null) {
  // TODO: Find a list of candidate descriptors.
}

For example, the following code:

fun hello(s: String) { ... }
fun helloWithOverload(s: String) { ... }
fun helloWithOverload(i: Int) { ... }

fun main() {
  hello("foo") // will be correctly resolved
  hello() // will be correctly resolved as there is only one possible call
  helloWithOverload("foo") // will be correctly resolved as the call is complete
  helloWithOverload() // won't be resolved as the call is incomplete and there are multiple candidates
}

My question: what methods can I use to find those candidates ? Thanks a lot 🙂