Kotlin

The registry row this page is generated from

Read at render time from the same family row the register reads, so nothing in this block can disagree with it.

Extensions

.kt, .kts

Registry names

kotlin

Recorded symbols

classes · interfaces · methods · constructors

Relationship types this analyzer constructs

11 of 14 constructed, read from this analyzer's source and re-derived by the languages gate. Each row below is one of the engine's types, in the engine's own order.

11 constructed, 3 not constructed. All 3 absent types are recorded as ruled absent: the written reason and the corpus measurement behind each are in this family's completeness record. The register explains what each label means.

What this analyzer does not resolve

• An expression-body function has no inferable return type: fun f() = 42 reports none rather than guessing Int from the literal.
• An extension function is recorded against the receiver type it extends as a use carrying an is-extension marker, never as extends — labelling it inheritance would fabricate hierarchy that is not in the code.
• A generated data-class member is published at reduced confidence and with no line number, because it is derived from the class rather than written in it, and a line would point at the wrong place.

Every line above was written against Kotlin’s own analyzer module and is named against a construct in it, so it can be checked against the source. Nothing here is inherited from a template, or from another language’s page.

Where you meet it in a repository

Recognised by extension — .kt, .kts. Everything below is about where those files actually sit in a working repository.

• A Kotlin service is usually an interface plus its implementation in the same file, so the contract and its only implementer sit together.
• Jetpack Compose builds a UI out of nested function calls, and the annotation sits on the enclosing function rather than on a type.
• Extension functions live at file scope in a file that may not import the type they extend, so the receiver type is often the only thing connecting them.

Questions this index answers

Phrased as retrievals, because that is what an index can honestly do: it holds the symbols and the edges between them, and hands them back with the evidence attached.

1. Which classes implement this interface?
2. Which of these members did the data class generate?
3. Which extension function is declared for this receiver type?
4. Where is this coroutine launched from?

What the analyzer sees in code like this

data class Column(val type: String)   // bb records: class Column · generated component1

interface Repo { fun findAll(): List<Column> }

class ColumnController(private val repo: Repo) {
    // bb records: method list, marked as suspending
    suspend fun list(): List<Column> = repo.findAll()
}

Symbols are stored with the file they came from and the bytes they span, so a hit points at a line rather than at a guess. The annotations in the sample are commentary for the reader, not strings the index would store.

Languages that turn up in the same repository

Application & systems — the count beside each name is how many relationship types that family’s analyzer constructs.

• TypeScript14 types
• JavaScript12 types
• Python11 types
• Rust14 types
• Go12 types
• Java10 types
• C++11 types
• C9 types
• C#11 types
• Swift11 types
• Dart13 types
• Zig8 types
• Objective-C11 types
• Visual Basic11 types
• VBA9 types