The Kotlin counterpart of C#'s Expression<Func<...>>. A compiler plugin (K2, IR) turns a lambda literal into code that builds an expression tree — at compile time. There is no reflection and no bytecode parsing at runtime. Kotlin Multiplatform: JVM, JS, Wasm, Native.

// C#: Expression<Func<int, int, int>> add = (a, b) => a + b * 2;
val add: Expr<(Int, Int) -> Int> = expr { a, b -> a + b * 2 }

add.parameters      // [a: kotlin.Int, b: kotlin.Int]
add.body            // BinaryExpression(PLUS, a, BinaryExpression(TIMES, b, 2))
add.toString()      // { a: Int, b: Int -> a + (b * 2) }
add(1, 3)           // 7 — compile() returns the original lambda, which is already compiled statically

For an example consumer of the trees — a LINQ-style SQL provider — see sample/README.md.

Apply the Gradle plugin next to a Kotlin plugin (multiplatform, jvm or android):

// settings.gradle.kts
pluginManagement {
    repositories {
        mavenCentral()
        gradlePluginPortal()
    }
}

// build.gradle.kts
plugins {
    kotlin("multiplatform") version "2.4.20"
    id("ru.ttraum.kexpression") version "0.1.0"
}

The plugin attaches kexpression-compiler-plugin to every Kotlin compilation and adds kexpression-runtime of the same version to commonMain (or implementation for single-platform projects). To declare the runtime yourself:

kexpression {
    addRuntimeDependency = false
}

expr { } — explicit quoting, like assigning a lambda to an Expression<...> in C#:

val isAdult = expr { u: User -> u.age >= 18 && u.role == Role.USER }

@Quoted — for your own APIs: a lambda passed to an annotated parameter stays a regular function, but carries its tree with it.

class Query<T> {
    fun where(@Quoted predicate: (T) -> Boolean): Query<T> {
        val tree: LambdaExpression = predicate.toExpression()
        // ... process the tree
    }
}

users.where { it.age >= minAge }   // callers write a plain lambda

The argument must be a lambda literal. Passing a variable to expr() is a compile error; passing one to a @Quoted parameter is a warning.

Every node is a data class extending Expression and carries its static type (type):

Traversal and rewriting: children, walk(), rewrite { } — the counterpart of C#'s ExpressionVisitor.

As in C#, the lambda body must be an expression. Local vals are allowed and inlined at their uses, while var, loops and assignments cause the compile error [kexpression] Cannot convert lambda to expression tree.

The largest subtrees that don't depend on the lambda's parameters (filter.minAge + 1, repo.activeIds()) become EvaluableExpression(original, evaluate): the structure plus an evaluator generated by the compiler. The evaluator runs the subtree's original code without reflection, on any platform.

val e = expr { u: User -> u.age > filter.minAge + 1 }
val node = (e.body as BinaryExpression).right as EvaluableExpression
node.original    // filter.minAge + 1 — the structure
node.evaluate()  // 19 — the value, read at the time of the call

The consumer of the tree decides what to evaluate on the client and what to process as structure, via EvaluationPolicy (EvaluationPolicy.Always and EvaluationPolicy.Never are provided).

• What doesn't become an evaluator: constants and captured variables (they are already values), nested lambdas, and calls to @Translatable functions.
• Side effects: an evaluator runs the original code every time it's called. Keep that in mind if the code has side effects.

A meta-annotation for function annotations. Such a call is never evaluated on the client, and the annotation itself ends up in CallExpression.annotations. The call's arguments are processed as usual.

@Translatable
annotation class DbFunction(val name: String)

@DbFunction("upper")
fun dbUpper(s: String): String = throw UnsupportedOperationException("db only")

val e = expr { u: User -> u.name == dbUpper(prefix + "x") }
val call = (e.body as BinaryExpression).right as CallExpression
call.annotation<DbFunction>()?.name                         // "upper"
(call.arguments.single() as EvaluableExpression).evaluate()  // "abx"

The plugin works on IR, which is the same for every backend. The Gradle plugin attaches it to all compilations (JVM, JS, Wasm, Native) — see Installation.

Platform specifics:

• JS: a class can't implement a function type, so a @Quoted lambda isn't wrapped — the tree is stored in a property of the JS function itself. On the other platforms it's a wrapper, and the number of parameters is limited to four.
• Literal printing relies on the node's static type, not on the value: on JS, Int, Float and Double are the same number.

./gradlew :kexpression-tests:jvmTest :kexpression-tests:jsNodeTest :kexpression-tests:wasmJsNodeTest

./gradlew :kexpression-tests:macosArm64Test   # requires a full Xcode install

The Linux test binary (linkDebugTestLinuxArm64) can be built on macOS and run in a Linux container.

The plugin is built for the Kotlin version pinned in gradle/libs.versions.toml. Any other release can be tried with -PkotlinVersion — it replaces Kotlin in the whole build, the Gradle plugin included:

./gradlew -PkotlinVersion=2.5.0-Beta2 :kexpression-tests:jvmTest :sample:test

This rebuilds the compiler plugin too, so it answers "would a plugin release for that Kotlin work" (source compatibility). Whether the plugin built with the pinned Kotlin — the one users get — runs on another compiler is a separate question (binary compatibility): the compiler's API can change in ways that still compile but break an already built plugin. -PcompilerPluginJar uses a prebuilt plugin instead of the kexpression-compiler-plugin module:

./gradlew :kexpression-compiler-plugin:jar

./gradlew -PkotlinVersion=2.5.0-Beta2 -PcompilerPluginJar=kexpression-compiler-plugin/build/libs/kexpression-compiler-plugin-0.1.0.jar :kexpression-tests:jvmTest :sample:test

CI (kotlin-compat.yml) runs both checks on the latest patch of the pinned minor release, the latest stable release and the latest Beta/RC if it is newer, plus the regular tests on the pinned version — on every push and every Monday. Only the pinned version has to pass; the others are a compatibility report. A green binary run for a version means the published plugin can be used with it. Extra versions can be passed when the workflow is started by hand.

kexpression-runtime (all KMP targets), kexpression-compiler-plugin and kexpression-gradle-plugin (with its plugin marker) are published with vanniktech/gradle-maven-publish-plugin. Versions live in gradle/libs.versions.toml, Maven coordinates in gradle.properties (buildInfo.*).

./gradlew publishToMavenLocal

./gradlew publishAndReleaseToMavenCentral

Maven Central credentials and the signing key are read from ~/.gradle/gradle.properties and are never stored in this repository. Publications are signed only when a signing key is configured.

• Capture by value. Captured variables are recorded when the tree is created. A regular lambda sees later changes to a var; the tree doesn't.
• Expressions only. Trees have no statements: no assignments, loops or var.
• Argument names. They aren't kept for function calls; they are kept for constructor calls.
• Kotlin versions. Version 0.1.0 is built with Kotlin 2.4.20 and checked to work with 2.4.0–2.4.21 and 2.5.0-Beta2. Kotlin 2.3 and older are not supported: the plugin fails to load there. The compiler's IR API is unstable, so a new Kotlin release can break the plugin — the compatibility workflow checks new releases weekly (see Other Kotlin versions).