A modern programming language that makes developers happier.

kotlinlang

Hi folks! I'm trying to find the correct PSI classes to use in order to get a `KtNamedFunction` from a `KtCallExpression`, or something similar. Is that possible at all, maybe with a Resolver or something? I followed the instructions in the documentation about `getReferences()`, but I get a null value for a very simple example like this one:
```fun add(x: Int, y: Int): Int {
    return x + y
}

fun main(args : Array&lt;String&gt;) {
    println(add(1 + 2, 3))   // &lt;- How do I get from the PSI node of add to the PSI node of add's declaration
}```

Yeahhh I ran into that same issue. `getReferences()` only works in the context of an IDE plugin, and it has no value when dealing with the Kotlin Frontend. You can see an example of how to do it <https://github.com/kyay10/kotlin-lambda-return-inliner/blob/master/kotlin-plugin/src/main/kotlin/com/github/kyay10/kotlinlambdareturninliner/LambdaReturnInlinerAnalysisHandler.kt#L89|over at my repo> (the code might not make too much sense though) but the quick TL;DR is that you need an `AnalysisHandlerExtension` and then in its `analysisCompleted` function use the `bindingTrace.bindingContext` to call `KtCallElement.getResolvedCall(BindingContext)` and that'll simply get you a `ResolvedCall` object that has a `resultingDescriptor` property that then simply has all the info and data about the function that  the call element is referring to.

(Also if you do check the repo make sure to check out and possibly vote for <https://youtrack.jetbrains.com/issue/KT-44530|KT-44530> because the whole repo is a POC of that issue. The TL;DR of that issue is that the Kotlin compiler currently can't, but should, be able to inline some lambda returning functions. if that issue does get implemented, that can result in things as crazy as actual zero-overhead structs being possible idiomatically)

Shoot at me with any other frontend or IR questions if needed :)
My knowledge isn't as extensive as the Arrow Meta team for example, but I still know my war around some things and the memory of knowing absolutely nothing about how compiler plugins work is still fresh in my mind

That's super nice of you <@U019AG342E5>, I'll give it a try and definitely take you up on the offer

Oh, and the example file you wrote, that's not bytecode dependent, right?

That is, the call resolution works on source code info alone

Not at all byte-code related. It just deals with the result of the compiler front end analysing the code yes

However technically it is "bytecode dependent" in that for example if you reference a Java function then of course it'll be referring to that. Oh and also careful because AnalysisHandlers are currently Kotlin JVM only. The plan is that with the new Frontend IR there will be some unified API that has better semantics than AnalysisHandlers to deal with code analysis but of course currently the FIR is not ready for extensions like at all