hi. When I got a compiler exception (not just an error message), is this the right channel to report it?

I have just tried to update an example multiplatform project to 1.2.0-alpha01-dev741 and Kotlin 1.7.10 (1.7.0 is the same) from dev-731 and Kotlin 1.6.21 and get the following error message when I build for iOS

java.lang.IllegalStateException: IrBasedSimpleFunctionDescriptor: FUN name:DataTooltipArea visibility:public modality:FINAL <> (dataString:kotlin.String, modifier:androidx.compose.ui.Modifier, content:kotlin.Function2<androidx.compose.runtime.Composer, kotlin.Int, kotlin.Unit>) returnType:kotlin.Unit [expect]

The project builds and runs perfectly on JVM and even on Web (Canvas). Can anybody tell me what this error message actually means?

Is there a way to do incremental parsing/compilation of `KtFile`s in a standalone application that only uses the Kotlin compiler APIs and

intellij-core

, i.e. outside of an IDE context? Creating `LightVirtualFile`s and passing them to

PsiManager.findFile

yields an initial parse, but is there a way to e.g. update a certain text range in the virtual file and also trigger an update to the PSI? My attempts to modify the virtual file e.g. by

setBinaryContent

or

setContent

either caused the PSI file to not get updated at all or throw an exception that it's out-of-sync with the virtual file

Hey everyone. We are using the embedded compiler and just upgraded from 1.6.21 to 1.7.0. All of a sudden, we can't resolve certain types using the binding context, many (all?) of which seem to be coming from the Java standard library (e.g.

java.util.Properties

,

javax.crypto.Cipher

). I've been debugging a little already and found that the new version behaves differently during resolution of imports and 1.7.0 doesn't seem to successfully resolve these types anymore. I haven't been able to pinpoint the exact place where this is caused yet. Can anyone tell me if there is something to watch out for in 1.7.0? Am I missing something?

Why is the Java statement

public static final long  SIGN_BIT_MASK  = 0x8000000000000000L;

a perfectly legal statement and its Kotlin counterpart

const val SIGN_BIT_MASK: Long = 0x8000000000000000L

results in an error? (Value out of range.) Such inconsistencies make it very difficult to port any Math libraries from Java to Kotlin.

Hi! I'm working on an IR plugin and I'm not sure how to report errors. The easiest way would be to collect the errors during the IR visits/transformations. Is this possible or do I have to use a DeclarationChecker instead? The first thing I would like to report is declaration of variables at some points of the code. I see the point in declaration checkers, only I have to write things twice if I have to work both with Kt and Ir structures.

Stupid question - I’m trying to write a hello world compiler plugin and apparently it is not being invoked. How would you go to debug this situation? I can see that the provider lambda returned by

KotlinCompilerPluginSupportPlugin.applyToCompilation

is invoked, so kotlin is preparing the args to be passed to the plugin. There I have a command line processor and an IrGenerationExtension. I’m adding all kinds of logs - println(), error(“Hello world”), send stuff to createDiagnosticReporter(). But I get nothing, compilation succeeds. Not sure what to do, maybe there is some compiler flag that can give me more information?

Why am I getting this warning when the library is built with 1.7.10 and I'm also using 1.7.10?

Getting an error related to extending a method with context receivers but only in a different project with a jar dependency on the one I'm overriding, is this a known bug?

Huh? The project I use was built with java 11 target and the current project uses java 17 target

Take the following code snippet:

abstract class Base {
    open fun foo() = "Base"
}
class A: Base()
class B: Base() {
    override fun foo() = "B"
}

fun main(vararg args: String) {
    val foo: Base = B()
    if (foo is B) println(foo.foo())
}

The call to

foo.foo()

in the main method results in

B

to be printed, as expected. However, when I try to resolve

foo.foo()

using the compiler, it resolves it to the implementation in

Base

. This can be observed as well when pasting the code into IntelliJ and

Ctrl + clicking

on

foo.foo()

call. If I change the line to

println((foo as B).foo())

the static resolution works as expected and resolves to the implementation in

B

. I don't know how exactly smart casts work internally, however, shouldn't the compiler resolve to

B#foo

in both cases?

Hello! I've updated Kotlin compiler to 1.7.0 version and want to use underscore operator for template parameters type infer in such code:

abstract class SomeClass<T> {
    abstract fun execute(): T
}

class SomeImplementation : SomeClass<String>() {
    override fun execute(): String = "Test"
}

open class Test<S: SomeClass<T>, T>

class Test1 : Test<SomeImplementation, _>() //  compiler complains about  Unresolved reference: _

Will Kotlin IR include the Java source files?

Is there any way to disable mangling for functions that consume inline classes? Spring Data cant deal with this.

If anyone is looking for an example of a plugin that does some extensive code generation https://github.com/facebookresearch/optimizer-plugins is now open source.

Hello, since Kotlin 1.7.10, I consistently get this error when building a Wear OS (Android) app:

Could not perform incremental compilation: Could not connect to Kotlin compile daemon

Could not connect to kotlin daemon. Using fallback strategy.

What could cause this?

Is there a way to make annotation

@NotBlank

appear within the type declaration on the field but not in the constructor parameter?

In an IR plugin using

dump

, I see that the compiler generates fake overrides for everything defined in the superclass. Is this necessary for the backend? I mean it is not a trouble to generate them but it makes the generated IR quite big. What do these fake overrides actually do?

Is there any compile-time-evaluated way to check if a reified type is a specific class?

T::class == Desired::class

doesn't seem to be evaluated at compile time. I can also do

valueOfTypeDesired is T && !(valueOfSupertypeOfDesired is T)

but again this isn't evaluated at compile time. I'm interested not only because of performance but for a value-class optimization use case (can give more details if interested).

We’ve got a multiplatform compiler plugin in Zipline. When I upgraded from Kotlin 1.6.21 to 1.7.10 I was surprised to learn that we must use the embeddable plugin everywhere including Kotlin/Native. In particular our

ComponentRegistrar

now uses

<http://org.jetbrains.kotlin.com|org.jetbrains.kotlin.com>.intellij.mock.MockProject

on all platforms. (We had been using

com.intellij.mock.MockProject

for Kotlin/Native). Is this expected? It’s awesome

This fails with a JNI error at runtime

context(Unit, Boolean)
fun bothContexts() {
  // Refers to String.toInt() for some reason
  toInt()
}

Looks pretty bad to me. Has this been reported already? It doesn't reproduce in FIR btw.

When I have a function that expects a value of type

(A) -> B

, it’d be cool to be able to just pass

::foo

instead of

A::foo

. Is there a name for what I want? Even better, is there an existing ticket/proposal for it? Example:

data class A(val name: String)
fun <B> A.getProp(prop: (A) -> B) = prop(this)
fun A.getName() = getProp(::name) // I want this
fun A.getName2() = getProp(A::name) // But I have to do this instead

Hello! What is the syntax to call super for overriden function that has additional receiver?

open class Test {
  open fun SomeClass.test(){}
}

class Test2 : Test() {
  override fun SomeClass.test() {
    super.test() // is compilation error
  }
}

I’m writing a plugin to generate

@CName

functions and have them exported in the final K/N binary. But looking at the file with

nm

, I can see that the generated symbol is not exported. Is it even possible to achieve this? Maybe the export pipeline runs before

IrGeneration

and so my symbol is useless? Or I’m doing something wrong. I’m generating my function and then calling

irFile.declarations.add(function)

, something I’m a bit unsure of.

How do you reference another function (or wrap it in a lambda) in IR? I have a

fun hello(who: String) = "Hello, $who!"

as a

IrSimpleFunction

. I need to pass this to a fun

process(function: (String) -> String)

, but I’m confused as to how to pass my function as a value argument to another. To be clear, in source code I’d do process(::hello) or process { hello(it) }.

Hey! I have never written a compiler plugin and I was wondering if I it's possible to write one that adds an annotation like this

@MustUse
class Foo

and every function that returns a Foo will issue a warning at call site the returned value is not used in some way

I am getting an empty list when I call

function.contextReceivers

where

function

is

KtNamedFunction

with Kotlin 1.7.10. Is there any way to get the list of context receivers?

Does anyone know what this means?

IllegalStateException: No file for io.company.product.sample/functionName|8889119292615326163[0] in module

<io.company.product:sample>

I’m trying to change value params and return type of a top level function. I’m using

irFile.transformChildrenVoid

and then

function.deepCopySavingMetadata

and then doing my changes. Compilation works, but I get the error above when linking the native binary.

Today (well, yesterday actually) I realized that every lambda and function reference is compiled (for the JVM) into a separate class, and this slows down app startup.

I've got two sealed classes

CurrentState

and

DesiredState

. When doing

val x = when (CurrentState to DesiredState) { ... }

, the exhaustiveness checker doesn't seem to like the non-existence of an

else

, even if I covered all branches. Any way to help it out a bit?