Is there any ETA on the K2 compiler? I can’t believe that I have a brand new MacBook Pro and my entire OS still becomes partially unresponsive while Kotlin is compiling something or while the IDE is doing whatever 😅

I now work on plugin and I have to work with KtClass(and similar classes). I really don't like it. Is there any way to convert KtClass to PsiClass (like in intellij plugins)?

Sad development of events in case of the issue of incorrect line numbering in stack traces: [KT-8628] Line numbers are incorrect in exception stack trace . JDK folks resolved the JDK issue (which was first rebranded as an enhancement request) as wontfix, which doesn't give hopes to fix the issue that Kotlin users face. Any idea what to go from here? I'd personally challenge the fact that it's not a bug in JDK. I don't have proper expertise within the JDK/JVM internals so cannot push the discussion forward. Once it's proven to be a bug, there's a chance to get it back on track.

Is/will there (be) a way to build Kotlin applications programatically? The use-case is an application which holds a representation of a user-defined set of models, and using the Kotlin compiler to do first line validations (field collisions, inheritance, etc) and typescript interface generation.

Is there any way to enable more logs when the IR validation fails?

java.lang.IllegalStateException: Validation failed in file main.kt

is almost impossible to debug without any hints. And the stack trace is not very helpful.

What is the name of the syntactical feature where you can scope a

Unit

to be a sort of anonymous extension function on a given class? I noticed it in the Compose code (I think) but I haven't been able to find it in the docs. Example:

fun render(node: Node, action: Node.() -> Unit) {
    node.action()
}

I want to modularize a codebase further to improve build times. A fun idea I had was to make module boundaries such that most historical commits only touch one module. What is a good way to algorithmically create such a grouping of files into modules?

Hello everyone, I have a question about compiler plugin, can I delay

SyntheticResolveExtension

execution? I need to synthesize a new property, and then the type of this property depends on the initializer expression of another property, so I must use

BindingContext.getType

to parse the actual type of another property’s initializer, but unfortunately

SyntheticResolveExtension

is executed a bit too early, at this time the value returned by the

BindingContext.getType

is

null

. Or is there another way for me to infer the type of another expression during synthesis?

Another question is how to get all the declared descriptors in the

ClassDescriptor

? I found this usage: https://github.com/JetBrains/kotlin/blob/1.6.0/plugins/kotlin-serialization/kotlin[…]otlinx/serialization/compiler/resolve/SerializableProperties.kt, but I can’t use it, an error will be thrown when I try to use the same code:

e: java.lang.AssertionError: Recursion detected on input: actualType under LockBasedStorageManager@30057fbe (TopDownAnalyzer for JVM)
	at org.jetbrains.kotlin.resolve.lazy.descriptors.AbstractLazyMemberScope.getContributedVariables(AbstractLazyMemberScope.kt:139)
	at org.jetbrains.kotlin.resolve.lazy.descriptors.LazyClassMemberScope.getContributedVariables(LazyClassMemberScope.kt:395)
	at org.jetbrains.kotlin.resolve.lazy.descriptors.AbstractLazyMemberScope.computeDescriptorsFromDeclaredElements(AbstractLazyMemberScope.kt:234)
	at org.jetbrains.kotlin.resolve.lazy.descriptors.LazyClassMemberScope.doDescriptors(LazyClassMemberScope.kt:68)
	at org.jetbrains.kotlin.resolve.lazy.descriptors.LazyClassMemberScope.access$doDescriptors(LazyClassMemberScope.kt:52)
	at org.jetbrains.kotlin.resolve.lazy.descriptors.LazyClassMemberScope$allDescriptors$1.invoke(LazyClassMemberScope.kt:64)

I wonder if the frontend of compiler plugin has extension that implicitly modify visibility of declarations. I want to make the constructors of all classes marked with an annotation

private

. Is that possible now?

Hello everyone! 👋 I have a situation where I need to compile a fairly large Kotlin application (that I don't want to rewrite into Java!) so it can run on target version Java 1.5. I'm reading in the docs here https://kotlinlang.org/docs/compiler-reference.html#jvm-target-version that the lowest supported version (which is deprecated) is 1.6. Is it completely impossible to achieve bytecode that can run on a VM that's version 1.5? Otherwise, any ideas on how to progress without re-writing the whole thing in Java 1.5? 😬 Thank you! 🙏

I get

* What went wrong:
Execution failed for task ':generateMavenPluginDescriptor'.
> org.apache.maven.plugin.descriptor.InvalidPluginDescriptorException: No mojo definitions were found for plugin: com.bnorm.template:kotlin-ir-plugin-template.

is it possible to somehow convert project to maven?

maybe I need to add some more jars as dependencies? my plugin has this

dependencies {
    compileOnly("org.jetbrains.kotlin:kotlin-compiler-embeddable")

    kapt("com.google.auto.service:auto-service:1.0")
    compileOnly("com.google.auto.service:auto-service-annotations:1.0")

    testImplementation("org.junit.jupiter:junit-jupiter-engine:5.8.2")
    testImplementation(kotlin("test-junit"))
    testImplementation("org.jetbrains.kotlin:kotlin-compiler-embeddable")
    testImplementation("com.github.tschuchortdev:kotlin-compile-testing:1.4.4")

    testImplementation("org.junit.jupiter:junit-jupiter-params:5.8.1")

if I write a class like

class Foo { private val bar = "bar" }

, is compiler smart enough to convert bar to static field (companion object)?

Is it possible to download the IDE plugin for the version

build-1.7.0-dev-1671

without having to build it myself?

Is there a way to change the nullability annotation the Kotlin compiler emits into class files?

I would like to reflect over nullability at runtime, but, without using Kotlin reflection (which is very slow and anyway, reduces java interop). Unfortunately the compiler produces org.jetbrains.annotation.Nullable which isn't retained at runtime.

Is there an API I can use to determine what properties/functions are unused in a given set of classes in my project (without using the IDE)?

How can I make a JVM static function without using a companion object? GraalVM native image is being really funky with it and errors out.

I know the reason due to which I'm able to write this without any issues. But should I be able to do that with strict type checking?

It used to be that Java interfaces with default implementations were called instead of a delegate -- I thought this was fixed in 1.4? I'm on a project using 1.5.31 and am still seeing that behavior, while my jvm target is 11. Why would that be?

Are there documented limits about what the compiler can accept? I have a 357k lines file containing a class with a ton of nested classes and any code referencing it fails to compile with

Unresolved Reference

. I'm not really expecting this use case to work but curious when to giveup and throw a better error message than

Unresolved Reference

Hello! 👋 (cross posting this from #ksp) Is this a good place to discuss Kotlin Compiler Plugin’s? I’m trying to write a plugin that will add Gson’s

@SerializedName

annotation and Moshi’s

@Json

annotation to all the properties of a data class. Everything seems to be working in my transformer (

IrElementTransformerVoidWithContext

) , but the resulting class doesn’t seem to have the annotations when I try to run a unit test (which loads the class from a temp working directory). If anyone has any documentation or resources that could help, I would be most grateful. Thanks!

[thread] Kotlin IR Documentation (Stack Code & Tuples)

Are there any regressions in 1.6.20-RC? Trying to use 1.6.20-RC fails to build my existing 1.6.10 code with the following error

java.lang.AssertionError: SyntheticAccessorLowering should not attempt to modify other files!

https://pastes.dev/IumlkSq7Qg

Is there a listing of all the frontend and backend compiler extensions somewhere?

Is @JvmName supposed to allow characters from this list to work within identifiers when with back ticks? Kotlin/JVM (any declaration publicity) ~ ( [\r\n] | '`' | '.' | ';' | ':' | '\' | '/' | '[' | ']' | '<' | '>' ) https://kotlinlang.org/docs/reference/grammar.html#Identifier

Hello 👋 Was just wondering - are there any plans with the new compiler to generate some default value metadata so it could be accessed through a reflection? Guessing no as that is pretty fringe use case.

Hello lovely people - I have one small question - does anybody knows if the order of plugins is arbitrary or does the compiler sticks to the order in which the plugins are registrated?