Programming languages often allow defining symbols implicitly. Imagine a default constructor in Java or Kotlin. You write class Foo {}, and that's it: there's a class, and there is a default constructor for that class.

Or, another example: a kotlin lambda can have a receiver:

fun foo(p: String) {
  p.apply { // <- we've got `this` parameter implictly declared here
    println(this.length) // `this` is used here explicitly
    println(length)      // `this` is used implicitly
  }
}

And here lies the problem: currently, there is no convenient way to interact with such declarations. Interactions include calling "find usages", showing implicit usages in the editor, etc.

During this internship, I suggest that you dive into APIs that IntelliJ Platform provides and enhance them to allow interaction with implicit declarations. Of course, you will be the first client for this API, and you will add support for "find usages" of Kotlin receivers, context parameters, etc.

The task combines two disciplines at once: static code analysis and ui/ux.

So it would be nice if you are interested at least in one of them, or better both.

The technology stack is going to be the following:

Java, Kotlin, multithreading, coroutines, IntelliJ platform, Swing.

You are not expected to know all these things right away, but be prepared to learn them on the go.