Anyone know what docs to read to get started with understanding how kotlin compilation works? I heard that it was a bit complicated and wanted to get a feel for what was going on to see if there's anything I can do about speeding it up over the next few months.

Hi! Is there any way of generating top level function (like SyntheticResolveExtension) from a Compiler plugin, I want to generate an entry point for an exeutable?

Odd compiler bug: https://pl.kotl.in/0dXZp5RHu try running that

Question for the team working on the compiler, specifically the new IR backend. Rewriting a compiler backend seems like a huge undertaking, and requires accounting for tons of edge cases in real-world code. Is the team using any real-world codebases to validate? I work on an open source codebase that uses a lot of generics, and I’m finding quite a few bugs with the IR backend. I am happy to keep testing out dev versions and reporting bugs as they come out, but I’m wondering if there would be any interest from anyone on the team to build the project themselves to iterate more quickly? If so, I can provide a branch that builds without IR but fails with IR turned on as a starting point, as well as whatever other support would be helpful.

Is there any non-descriptor way to go between expect/actuals for compile plugins?

Hi all! I do not how the kotlin compiler works so this might be a stupid question. I am curious about how kotlin works older JVMs. My question is Kotlin able to leverage the latest developments in Java like

records

may be helpful in implementing

data

classes.

I'm running into an issue when I try to generate (via IR) a suspend lambda. It fails validation because of duplicated nodes. It seems like during lowering, the body of the lambda is copied into the continuation class's

invokeSuspend

, but the original isn't deleted. Gists of the ir dump before lowering and after lowering (when the error happens). Note in the after lowering the original lambda's body on line 192, and the body in the continuation on line 210.

Different problem now: everything compiles fine on JVM, but when I try to use it on JS, I get

java.lang.IllegalStateException: Not found Idx for public kotlin.collections/mapOf|5848051883920634516[0]

from the IrLinker. I'm referencing and using

mapOf(vararg Pair<>)

which works fine on JVM. The

compileKotlinJs

task works fine, it's the

compileProductionExecutableKotlinJs

task that fails. It's happening on other methods to. Seems to be just top level functions. Is this a known bug? Poking around in debug in

KotlinIrLinker.IrDeserializerForFile

, while the referenced function (in this case,

to

) isn't in

reversedSignitureIndex

, it is in

fileLocalDeserializationState.reachableTopLevels

, so it is obviously being found somehow.

Questions about the KMM internals should I post here, #kmm, #kotlin-native, #kotlin-multiplatform, or #multiplatform? Basically I need to implement

desktopMain

to another OS

I'm having an interesting compiler issue when upgrading to Kotlin 1.4.0. One of the gradle plugins we use embeds the kotlin compiler to use it for some analyzation, but this turns into an error when upgrading the project. The error we get when building is here: https://hasteb.in/otohideq.sql. Which seems like some sort of stdlib versioning error, but I'm not sure how that could be, as the gradle plugin and its dependents all use the correct version of kotlin (1.4.10). I have looked this error up, but all of the reported issues are using spring boot, has this been encountered elsewhere? The Gradle Plugin responsible for running the embedded compiler is here: https://github.com/FalseHonesty/preprocessor/blob/kotlin-1.4/build.gradle.kts.

Another possible JS related bug: I'm trying to extract the value of a top level constant property (i.e.

const val prop = "..."

). I'm using

context.referenceProperties(name).single().owner.backingField!!.initalizer!!.expression as IrConst<String>

and it works fine on JVM, however on JS

backingField.expression

is

IrErrorExpressionImpl: Expression body is not deserialized yet

. I'll make an issue if this is indeed a bug, but wanted to check its not due to me miss-using something (should I just make an issue in the future?).

I wonder why

addGetter

extension was left on the

IrProperty

https://github.com/JetBrains/kotlin/blob/master/compiler/ir/backend.common/src/org/jetbrains/kotlin/ir/builders/declarations/declarationBuilders.kt#L107 while

addSetter

was removed in https://github.com/JetBrains/kotlin/commit/d1dc938a5d7331ba43fcbb8ce53c3e17ef76a22a#diff-2726c3747ace0a1c93ad82365cf3ff18L114 ? What's the new way to create setters on a generated property since

1.4.255

?

Hello! I've declared function

inline fun<reified T> test() {throw AssertionError("Implementing by compiler plugin")}

In IR generator I want to replace all calls to this function by some expression (using T type literal). For calls with direct literals (for example

test<Int>()

) it works as expected. But when calling from templated function with template parameter it appears to substitute just type parameter. For example

inline fun<reified T> test2(){test<T>()}

Is it possible in IR generation phase to transform all actual inlined types?

Hey there, I'm working on a compiler plugin which generates new files in the AnalysisHandlerExtension. Everything works fine until I turn on incremental compilation. The problem is that the compiler has no idea about the relation between the generated files and their "originating files". The first compilation works fine. Then when a originating file changes, the compiler only compiles the originating file (Here I create a new generated file). But the compiler starts another compilation round and now compiles both the originating file and the generated file. And this is the problem. The compiler should not trigger another round only to recompile the two files from the previous round. I tried to cache the relations between the files and delete the generated ones, when ever a originating one changes, but this does not work, because the dirty generated files are already in the environment of the compiler. I also tried to manually remove the files via reflection but the compiler can't handle that. Another thing I tried is to just generate the file again, but this causes other issues, because the compiler analysis the old version of the file which may have errors in it. Is there a workaround for my issue?

Has anyone experienced this? I couldn’t find anything. And the message is not great to know what I’ve done wrong 😅 Using 1.4.10

so, im doing a bit of premature optimization: im writing some kotlin wrappers for guice methods used by a large java codebase. I'm looking to streamline the

getInstance

flow. Im looking at something like this:

inline fun <reified T> Injector.getInstance(): T {
    val targetType = T::class.java
    if(targetType.typeParameters.isEmpty()){
        return getInstance(T::class.java)
    }
    else {
        val targetTypeSpecifically = Key.get(object: TypeLiteral<T>(){})
        return getInstance(targetTypeSpecifically)
    }
}

I'm wondering what the compiler does with dead-code-elimination of the type that gets created for

targetTypeSpecifically

. For the case where the type isnt generic (we take the true branch) Will that create a new

Class

entry at runtime or wont it? Whats the best way for me to test that?

Is it possible to turn some Kotlin compiler warnings into errors via a compiler plugin, or compiler plugins don't have access to that? Goal being for example turning unused variables into errors etc.

Hi, I was wondering if this is a known issue already or I should file one. I expect the program below to not compile because the expression A.B.c can’t be resolved until A is initialised assuming the inner object is path dependent. If the object is not and it’s fully static then

s

should not have compiled or become accessible.

Is it still the case that the bytecode viewer in IDEA doesn’t properly reflect the final Java class output? Simple things like

(0..10).forEach { … }

cause an

IntRange

and an iterator to be allocated. If I recall correctly calls like that are supposed to be optimized.

I have a question regarding the

public

modifier in Kotlin. Since everything is already public by default, is there a use case where you actually need to "force" put that modifier? Basically, at the moment I cannot think of such case, when you need a

public

modifier in front of something.

Is KSP ready right now to be used with multiplatform?

Do

const val

affect/hinder incremental compilation in ways plan

val

don't, granted their value don't change, but something else changed in the host class (e.g. a new constant or property)?

Hi everyone! I would like to track which external dependent classes were used during compilation of some Kotlin files. Output could be similar to jdeps java tool. Is this reasonable to try to achieve this with a Kotlin Compiler Plugin? If so, what would be the best approach? Would we use a class visitor for the compiled classes and extract all used/dependent external classes- or is there a better approach? Thanks in advance!

Hi, how is it possible that I get this warning during compilation with 1.4.20-M2?

w: Flag is not supported by this version of the compiler: -XInlineClasses

hmm. Is there a name for a kind've backwards operation for destructure, a kind of implied structuring? eg

sealed class Configuration {
    data class Customer(val name: String, val age: Int): Configuration()
    data class User(val email: String): Configuration()
}

class Whatever {
  fun doStuff(config: Configuration): Int {
    //...
  }
}

and I would like kotlin to do something automagical with

w.doStuff("bob", 42) // --calls Customer.<init>, doStuff()
w.doStuff("<mailto:jane_doe@email.com|jane_doe@email.com>") // calls User.<init>, doStuff()

I feel like I use sealed-classes as a way to expand a functions capability a lot. Right now (at least 3x in recent memory), I'll add exension functions to call the constructor and the method for you. eg

fun Whatever.doStuff(name: String, age: Int) = doStuff(Customer(name, age))

but this is kinda tedious, and i feel like the compiler could do it for me.

I’m seeing some weird bytecode generated by the new IR backend with kotlin 1.4.20-RC: Some default method overloads (named like

foo$default

) were generated as

synthetic

and non-final methods without the IR backend, but are now generated as final and non-synthetic (+final, -synthetic). Does anyone know if this is intentional?

I see... Still. Is there a case where

emptyList<Value>

would behave differently than

emptyList<Node>

?

The fact that list elements implements the 2 same interfaces seems to force

List<Any>

there. I guess because it could because

List<Named>

is as good of a solution than

List<Node>

? But in the context of

List<Node>

, I feel like this could be disambiguated_?_

KotlinFrontEndExceptino: Front-end Internal error: Failed to analyze declaration ApplicationSecurity