Hey, I am getting some straight errors during JS IR compiling, but how do you get the causing file?

java.lang.IllegalStateException: IrSimpleFunctionSymbolImpl is already bound: FUN LOCAL_FUNCTION_FOR_LAMBDA name:<anonymous> visibility:local modality:FINAL <> () returnType:<Uninitialized>
	at org.jetbrains.kotlin.ir.symbols.impl.IrBindableSymbolBase.bind(IrPrivateSymbolBase.kt:64)

Hi, I use

IrGenerationExtension

to modify the IR for the current module. But is there a way to modify the IR coming from other modules? I know that seems odd. But the use case is in the context of JS. When a 'binary' is created, kotlin-IR-JS generates a js file that contains all the depended on modules also, and I want to adjust the JS that is generated for a depended on module - i.e. via the IR. thanks

for annotations you can use https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/-optional-expectation/

Hi, is there any way how to debug compile issues? I am trying to run

./gradlew :app:compileDebugUnitTestKotlin --debug

and it always stuck with following message

2021-08-27T16:31:11.764+0100 [DEBUG] [org.gradle.cache.internal.DefaultFileLockManager] Waiting to acquire shared lock on daemon addresses registry.
2021-08-27T16:31:11.764+0100 [DEBUG] [org.gradle.cache.internal.DefaultFileLockManager] Lock acquired on daemon addresses registry.
2021-08-27T16:31:11.764+0100 [DEBUG] [org.gradle.cache.internal.DefaultFileLockManager] Releasing lock on daemon addresses registry.
2021-08-27T16:31:11.764+0100 [DEBUG] [org.gradle.cache.internal.DefaultFileLockManager] Waiting to acquire shared lock on daemon addresses registry.
2021-08-27T16:31:11.764+0100 [DEBUG] [org.gradle.cache.internal.DefaultFileLockManager] Lock acquired on daemon addresses registry.
2021-08-27T16:31:11.764+0100 [DEBUG] [org.gradle.cache.internal.DefaultFileLockManager] Releasing lock on daemon addresses registry.

I already identified test file which causing this issue but I don’t know what could be wrong and it is stuck forever. AGP 4.2.0 Kotlin 1.5.0 Gradle wrapper 6.8.3 Java 11 macOS 11.5.2, Ubuntu 16.04

org.gradle.jvmargs=-Xmx4608M -XX:MaxPermSize=1024m -XX:+HeapDumpOnOutOfMemoryError -Dfile.encoding=UTF-8
org.gradle.parallel=true
org.gradle.caching=true
android.enableD8=true
android.useAndroidX=true
android.enableJetifier=true
kapt.use.worker.api=true
kapt.incremental.apt=true
kapt.include.compile.classpath=false
android.databinding.incremental=true
android.forceJacocoOutOfProcess=true

Hi!, I’m looking for publicly available snapshots and dev releases of the Kotlin compiler to depend on for some testing. Does the Kotlin compiler get published as snapshot, dev or nightly in some repo beside what’s available in maven central? Thanks!

Hi, I'm trying to build a compiler plugin, and am working my way throught the AST, I have a

KtNamedFunction

. Is there a way to check if the type it represents, is a subclass of some another type? Or is that simply too soon to say at that point?

Hello, I want to implement compiler plugin, that creates something like macro from annotated function. Something that would take something like:

fun styled(block : RuleSet, @CallerPackage packageName)

and introduce synthetic macro-like function:

fun styled(block : RuleSet) = styled(block, callerPackage())

and wherever

styled(block)

is used, plugin would replace calls with

styled(block, "actual.callers.package.name")

. Are there any good examples I could use? Maybe somewhere in compose?

Stupid question, I can attach a debuger into a compiler plugin, but how do I print something to console?

println

doesn't seem to work, and I have

verbose

flag in compile options as well (building via gradle)

How can I deep copy a IR tree? It has to be a really deep copy, no references between trees shall be left. I've tried this:

val symRemapper = DeepCopySymbolRemapper()
val moduleCopy = DeepCopyIrTreeWithSymbols(symRemapper, DeepCopyTypeRemapper(symRemapper)).visitModuleFragment(module)

But it gives me

java.lang.IllegalArgumentException: Non-remapped symbol FILE fqName:kotlin.ranges

Hi. I created a kotlin compiler plugin which adds kotlinx.serialization.Serializable annotation to specific classes automatically. However even if I see in the built decompiled class file the added annotation, the whole serializer code for that class of the kotlinx-serialization plugin is not generated. So is my plugin executed after the kotlinx-serialization plugin? How can this be fixed? I've implemented it as ClassBuilderInterceptorExtension with DelegatingClassBuilder if it's important

Not sure if this is the right channel for this, but is there any way to force using parameter names when calling a function?

Hello everyone! We developed a plugin for the Kotlin compiler that leverages the flows of the standard reflection approach and can find classes, objects or functions by some conditions in compile-time. The current latest version is ready and stable! Two ways of using the plugin are supported: by limited DSL (searching of classes and objects by supertypes and annotations; and searching of functions by signature and annotations) and by extended DSL (searching of classes and objects by custom condition and supertype; and searching of functions by custom condition and signature). Since we use IR generation, the plugin can be used by all platforms (JVM, Nativa and JavaScript). Although currently, we can analyze only kt files. Additionally, the plugin uses a code generation approach in limited DSL to support compile-time reflection in libraries. It means, if you have a library that uses Reflekt and you call something from this library in your project, all Reflekt calls will be in the compile-time. Currently we support 1.5.30, 1.5.21, 1.5.20, 1.5.10, 1.5.0 Kotlin versions. Unfortunately, we do not support incremental compilation yet, but in the next release, we will be! We will be happy if the plugin would be helpful for you! If you are interested in this project and have some ideas for improving the plugin, please don’t hesitate to contact me!

Not sure where to ask this, but I think this is the best place. Basically, I'm using

@JvmName

annotations on a lot of my properties in interfaces. Now, this isn't an issue for the most part, except for the very frustrating and ridiculous inapplicable JVM name error that has to be suppressed in every class, but that's not the point of this. When I implement this interface, I would expect that those

@JvmName

named functions would be overridden in the Java code, however this is not the case. What I actually find is that the compiler will generate the property as normal, and then generate normal getters and setters, and make the overridden function a synthetic bridge method that delegates to the getter. Now, here's an example:

interface Vehicle {

    @get:JvmName("wheels")
    val wheels: Int
}

data class Car(override val wheels: Int) : Vehicle

And the generated code for this ends up looking something like this:

public interface Vehicle {

    @JvmName(
        name = "wheels"
    )
    int wheels();
}

public final class Car {

    private final int wheels;

    public Car(int wheels) {
        this.wheels = wheels;
    }

    public int getWheels() {
        return wheels;
    }

    // $FF: synthetic method
    // $FF: bridge method
    public int wheels() {
        return getWheels();
    }
}

I am unsure if this is intended behaviour or not, but to me it seems counter-intuitive.

any idea when kotlin will allow for jdk 17 as target?

is it correct that kotlin metadata does not contain information about other annotations? do I need to fall back to the java

TypeElement

for this information? if this is correct are there any libraries that wrap both in a kotlin idiomatic library?

message has been deleted

Rahul, I just commented on that bug. I think there's no reason it can't be used for everything, without any backwards compatibility breaks.

FYI it appears that setting

kotlinOptions.modulePath

in an android project breaks incremental compilation. I've reproduced it and filed a bug here https://youtrack.jetbrains.com/issue/KT-49066

Can anyone tell me what does

Non-incremental compilation will be performed: NO_BUILD_HISTORY

mean in kotlin build report? Occasionally build will take a long time (obviously non-incremental) and looking at the build report will produce above message. I have not cleaned the build folder or did anything similar (just normal run command while developing). How would I go about debugging what causes build history to get wiped?

Is there any plans on adding interface delegation to value classes, fully compiled away?

@JvmInline value class Foo(val b: Iface): Iface by b; fun bar(b: Iface) { ... }; val foo = Foo(..); bar(foo) // no boxing

?

Hi, is there a branch or fork of the Kotlin compiler where the https://github.com/Kotlin/KEEP/issues/259 prototype is happening? I would like to take a look at it to see how we could model some new features we have in the works for Arrow. Thanks!

Anyone know why you can’t have bounds on type alias parameters? I was trying to do this:

typealias Fact<T : Any> = Pair<FactName, T>

in order to ensure that you can’t put null in it, but no dice.

I am getting:

java.lang.IllegalStateException: Not found Idx for public house.boardgames.model.cursor/CursorQuery|null[0]

Obviously a bug in compiler, but as project is not open source I am trying to figure out the issue and create mve. So far unsuccessful, If you have any hint what may be causing it, I would be grateful. Details in the thread. Affected version: 1.5.30, 1.5.31 Works in: 1.5.21 (Unable to test 1.6.00-M1)

Anyone know if it would be possible to create a compiler plugin that could automatically apply

JvmName

annotations to getters, or better yet, just rename the getters itself?

btw. Why is kotlin comiler distributed as single jar with dependencies (note - there is also dummy sources artifact distributed to maven, without any actual sources)

I'd like to delegate to some automation some additional code in order to dispose efficiently some resources which do not escape the scope of a function, that is they are local to the function. Annotation processor seems to be able to only generate new source code.. would a compiler plugin be able to modify existing source code instead?

Hi 👋 I’ve enabled

kotlinOptions {
   allWarningsAsErrors = true    
}

in my gradle android project and it works as expected but unfortunately one library is generating code through kapt which has warnings and then my project does not compile. Is there a way to disable checks for specific warnings or to not check the generated code?

how do we spoof a primitive int into a

val foo:(Int)->Int

in kotlin-jvm to squash boxing?

i ran into this type-inference problem, which i’m not sure how to think about. an example:

class Container<T>(
    val func: (T) -> Unit,
    val aT: T
)

sealed class Foo {
    object Bar : Foo()
    object Baz : Foo()
}

fun main() {
    val c = Container(
        { f: Foo -> print("Got $f")},
        Foo.Bar
    )

    c.func(Foo.Baz) // doesn't compile, because c is Container<Foo.Bar>, not Container<Foo>

    val c2 = Container(
        { f: Foo -> print("Got $f")},
        Foo.Bar as Foo
    )

    c2.func(Foo.Baz) // compiles
}

so, the compiler infers

c

to be of type

Container<Foo.Bar>

, where I expected to get a

Container<Foo>

. It seems to me that there are two possible choices - either use

Foo

for type parameter

T

, or use the fact that since

f

accepts a

Foo

, it can also accept all `Foo.Bar`s. But what I wanted was in fact the former (the real use case is complicated by me trying to implement a typesafe heterogenous map of sorts, so I didn’t even get a compilation error, just a runtime ClassCastException). It seems to me like the current behaviour might be surprising - is there a reason for it, is it somehow more correct?