Struct KtFun 

pub struct KtFun {
    pub name: String,
    pub vis: KtVis,
    pub modifiers: Vec<String>,
    pub annotations: Vec<String>,
    pub kdoc: Option<String>,
    pub generics: Vec<String>,
    pub receiver: Option<KtType>,
    pub params: Vec<KtParam>,
    pub ret: Option<KtType>,
    pub body: KtBody,
}

A function declaration (top-level or member).

Fields

name: String

vis: KtVis

modifiers: Vec<String>

Modifier keywords in render order, e.g. external, inline, override, abstract, operator.

annotations: Vec<String>

kdoc: Option<String>

generics: Vec<String>

Generic type-variable names: ["R"] → fun <R> ….

receiver: Option<KtType>

Extension receiver: Some(Foo) → fun Foo.name(…). See KtFunSig::receiver.

params: Vec<KtParam>

ret: Option<KtType>

body: KtBody

Implementations

impl KtFun

pub fn new(name: impl Into<String>) -> Self

Examples found in repository

examples/invalid.rs (line 67)

fn broken_files() -> Vec<KtFile> {
    vec![
        broken_declarations(),
        // A package path that is not a dotted sequence of legal identifiers.
        KtFile::new("io..example.object").decl(KtFun::new("stillChecked").body(KtCode::new())),
    ]
}

fn broken_declarations() -> KtFile {
    KtFile::new("io.example.broken")
        // Two classes of the same name: a redeclaration in the type namespace.
        .decl(KtClass::class_("Session"))
        .decl(KtClass::class_("Session"))
        // An interface and a type alias are both classifier declarations, so they collide.
        .decl(
            KtClass::interface_("Describable")
                .member(KtFun::new("describe").returns(KtType::string())),
        )
        .decl(KtDecl::TypeAlias {
            vis: KtVis::Public,
            name: "Describable".to_string(),
            target: KtType::string(),
        })
        // Same name AND same parameter types: not an overload.
        .decl(
            KtFun::new("send")
                .param(KtParam::new("value", KtType::int()))
                .returns(KtType::boolean())
                .body(KtCode::new()),
        )
        .decl(
            KtFun::new("send")
                .param(KtParam::new("other", KtType::int()))
                .returns(KtType::long())
                .body(KtCode::new()),
        )
        // Extensions are keyed on their receiver, so these two collide while
        // the same pair on different receivers would not.
        .decl(
            KtFun::new("asRaw")
                .receiver(KtType::cls("io.example.Codec"))
                .body(KtCode::new()),
        )
        .decl(
            KtFun::new("asRaw")
                .receiver(KtType::cls("io.example.Codec"))
                .body(KtCode::new()),
        )
        // ...as here: same name, different receiver, no diagnostic.
        .decl(
            KtFun::new("asRaw")
                .receiver(KtType::cls("io.example.Other"))
                .body(KtCode::new()),
        )
        // Names that are not legal Kotlin identifiers.
        .decl(
            KtClass::class_("My-Class")
                .ctor_param(KtCtorParam::new("2fast", KtType::int()))
                .member(
                    KtFun::new("object")
                        .param(KtParam::new("in", KtType::int()))
                        .body(KtCode::new()),
                ),
        )
        // `val x` with no type, no value and no accessors.
        .decl(KtProperty::val("bare"))
        // A function with no body, at top level, where that cannot mean
        // "abstract".
        .decl(KtFun::new("nobody"))
        // An abstract class member missing the `abstract` keyword.
        .decl(
            KtClass::class_with(KtClassModifier::Abstract, "Base")
                .member(KtFun::new("unimplemented")),
        )
        // An enum whose entries do not call the constructor it declares.
        .decl(
            KtClass::enum_("Priority")
                .ctor_param(KtCtorParam::new("code", KtType::int()).val())
                .entry(KtEnumEntry::with_args("HIGH", "1"))
                .entry(KtEnumEntry::new("LOW")),
        )
        // A constructor property and a member property of one name: both live
        // in the value namespace.
        .decl(
            KtClass::class_("Holder")
                .ctor_param(KtCtorParam::new("id", KtType::long()).val())
                .member(KtProperty::val("id").initializer("0")),
        )
        // A named companion object colliding with a nested class.
        .decl(
            KtClass::class_("Outer")
                .member(KtClass::class_("Factory"))
                .companion(KtCompanion::named("Factory")),
        )
        // Two raw blocks claiming one identity with different bodies.
        .decl(KtDecl::Raw {
            name: "__loader".to_string(),
            code: KtCode::new().line("internal val __loader = 1"),
        })
        .decl(KtDecl::Raw {
            name: "__loader".to_string(),
            code: KtCode::new().line("internal val __loader = 2"),
        })
        // Two different classes referenced from raw text under one short name:
        // the text already says `Codec`, so it cannot mean both.
        .import("io.example.a.Codec")
        .import("io.example.b.Codec")
}

/// The same model, adopted the way a generator that already produces output
/// would: every check a warning, so nothing is blocked while the backlog is
/// worked through.
fn merge_files_warning() -> (Vec<KtFile>, Vec<kotlin_codegen::Diagnostic>) {
    kotlin_codegen::merge_files_with(broken_files(), &ValidationPolicy::warn_all())
        .expect("warnings never stop generation")
}

/// Shapes that are not merely *detected* — they cannot be constructed. The
/// builder rejects them, so no invalid value ever reaches the renderer.
fn refused_shapes() -> Vec<(&'static str, String)> {
    vec![
        (
            "object Foo(x: Int)  — an object has no primary constructor",
            refused(|| {
                KtClass::object_("Foo").ctor_param(KtCtorParam::new("x", KtType::int()));
            }),
        ),
        (
            "data class Foo(x: Int)  — a data class parameter must be a property",
            refused(|| {
                KtClass::data("Foo", KtCtorParam::new("x", KtType::int()));
            }),
        ),
        (
            "value class Foo(var x: Long)  — a value class wraps one read-only property",
            refused(|| {
                KtClass::value("Foo", KtCtorParam::new("x", KtType::long()).var());
            }),
        ),
        (
            "class A : B(x), C(y)  — Kotlin constructs at most one superclass",
            refused(|| {
                KtClass::class_("A")
                    .extends(KtType::cls("B"), Some("x"))
                    .extends(KtType::cls("C"), Some("y"));
            }),
        ),
        (
            "external fun f() { … }  — `external` is a body kind, not a modifier",
            refused(|| {
                KtFun::new("f").modifier("external");
            }),
        ),
        (
            "enum entry on a non-enum class",
            refused(|| {
                KtClass::class_("C").entry(KtEnumEntry::new("A"));
            }),
        ),
        (
            "companion object with an empty name",
            refused(|| {
                KtCompanion::named("");
            }),
        ),
    ]
}

examples/showcase.rs (line 80)

fn types_fragment() -> KtFile {
    // `enum class` with a primary constructor its entries call, plus a named
    // companion object holding a factory.
    let priority = KtClass::enum_("Priority")
        .vis(KtVis::Public)
        .kdoc("Delivery priority.\n\nMirrors the native `z_priority_t`.")
        .ctor_param(
            KtCtorParam::new("code", KtType::int())
                .val()
                .vis(KtVis::Public),
        )
        .entry(KtEnumEntry::with_args("REAL_TIME", "1"))
        .entry(KtEnumEntry::with_args("INTERACTIVE", "4"))
        .entry(KtEnumEntry::with_args("DATA", "5"))
        .companion(
            KtCompanion::named("Codes")
                .vis(KtVis::Public)
                .kdoc("Lookup helpers keyed by the native code.")
                .member(
                    KtFun::new("fromInt")
                        .vis(KtVis::Public)
                        .annotation("JvmStatic")
                        .param(KtParam::new("value", KtType::int()))
                        .returns(KtType::cls("Priority"))
                        .body(
                            KtCode::new()
                                .blk("return when (value) {", |c| {
                                    c.line("1 -> REAL_TIME")
                                        .line("4 -> INTERACTIVE")
                                        .line("5 -> DATA")
                                        .line("else -> throw IllegalArgumentException(\"bad priority: $value\")")
                                }),
                        ),
                ),
        );

    // `@JvmInline value class` — exactly one read-only property.
    let zid = KtClass::value(
        "ZenohId",
        KtCtorParam::new("bytes", KtType::byte_array())
            .val()
            .vis(KtVis::Public),
    )
    .vis(KtVis::Public)
    .kdoc("A 16-byte peer identifier, carried by value.");

    // `data class` — every constructor parameter is a property.
    let sample = KtClass::data(
        "Sample",
        KtCtorParam::new("keyExpr", KtType::string())
            .val()
            .vis(KtVis::Public),
    )
    .vis(KtVis::Public)
    .ctor_param(
        KtCtorParam::new("payload", KtType::byte_array())
            .val()
            .vis(KtVis::Public),
    )
    .ctor_param(
        KtCtorParam::new("priority", KtType::cls("Priority"))
            .val()
            .vis(KtVis::Public)
            .default("Priority.DATA"),
    )
    .ctor_param(
        KtCtorParam::new("attachment", KtType::byte_array().nullable())
            .var()
            .vis(KtVis::Public)
            .annotation("JvmField")
            .default("null"),
    );

    // A `sealed interface` whose alternatives nest inside it: a `data class`
    // with a payload and a `data object` without one.
    let reply = KtClass::sealed_interface("Reply")
        .vis(KtVis::Public)
        .kdoc("Either a sample or the end of the stream.")
        .member(
            KtClass::data(
                "Value",
                KtCtorParam::new("sample", KtType::cls("Sample"))
                    .val()
                    .vis(KtVis::Public),
            )
            .vis(KtVis::Public)
            .implements(KtType::cls("Reply")),
        )
        .member(
            KtClass::data_object("Done")
                .vis(KtVis::Public)
                .implements(KtType::cls("Reply")),
        );

    KtFile::new("io.example.api")
        .decl(priority)
        .decl(zid)
        .decl(sample)
        .decl(reply)
}

/// The handle surface: an abstract base, a concrete subclass, an interface,
/// a `fun interface`, and a type alias.
fn session_fragment() -> KtFile {
    // `abstract class` with an `abstract` member (bodiless, and it says so),
    // a `@Volatile` property, and an interface it implements.
    let base = KtClass::class_with(KtClassModifier::Abstract, "NativeHandle")
        .vis(KtVis::Public)
        .kdoc("Owns a raw pointer into Rust and frees it exactly once.")
        .ctor_param(KtCtorParam::new("initialPtr", KtType::long()))
        .implements(KtType::cls("AutoCloseable"))
        .member(
            KtProperty::var("ptr")
                .ty(KtType::long())
                .vis(KtVis::Internal)
                .annotation("Volatile")
                .kdoc("Zero once closed.")
                .initializer("initialPtr"),
        )
        .member(
            KtProperty::val("isClosed")
                .ty(KtType::boolean())
                .vis(KtVis::Public)
                .accessors(KtCode::new().line("get() = ptr == 0L")),
        )
        .member(
            KtFun::new("freePtr")
                .vis(KtVis::Public)
                .modifier("abstract")
                .kdoc("Release the native allocation. Called once, under the lock.")
                .param(KtParam::new("ptr", KtType::long())),
        );

    // `open class` extending the abstract base and constructing it.
    let session = KtClass::class_with(KtClassModifier::Open, "Session")
        .vis(KtVis::Public)
        .annotation("Suppress(\"unused\")")
        .ctor_param(KtCtorParam::new("initialPtr", KtType::long()))
        .extends(KtType::cls("NativeHandle"), Some("initialPtr"))
        .implements(KtType::cls("io.example.api.Describable"))
        .member(
            KtFun::new("freePtr")
                .vis(KtVis::Public)
                .modifier("override")
                .param(KtParam::new("ptr", KtType::long()))
                .body(KtCode::new().line("JNINative.sessionFree(ptr)")),
        )
        .member(
            KtFun::new("describe")
                .vis(KtVis::Public)
                .modifier("override")
                .returns(KtType::string())
                .expr_body(KtCode::new().line("\"Session(0x${ptr.toString(16)})\"")),
        )
        // A generic method whose body uses every `KtCode` block form.
        .member(
            KtFun::new("get")
                .vis(KtVis::Public)
                .generic("R")
                .kdoc("Run a query, folding each reply into an accumulator.")
                .param(KtParam::new("selector", KtType::string()))
                .param(KtParam::new(
                    "onReply",
                    KtType::lambda(
                        [("reply".to_string(), KtType::cls("io.example.api.Reply"))],
                        KtType::var_r(),
                    ),
                ))
                .param(KtParam::new("timeoutMs", KtType::long()).default("10_000L"))
                .returns(KtType::generic("List", [KtType::var_r()]))
                .body(
                    KtCode::new()
                        .line("val acc = ArrayList<R>()")
                        .line("val guard = Guard.acquire(this)")
                        .import("io.example.internal.Guard")
                        .try_finally(
                            "",
                            KtCode::new().blk("JNINative.sessionGet(ptr, selector, timeoutMs) { raw ->", |c| {
                                c.line("acc.add(onReply(raw))")
                            }),
                            KtCode::new().line("guard.release()"),
                        )
                        .line("")
                        // A long call that the renderer breaks by width at its
                        // real nesting level.
                        .wline("reportQueryOutcome(selector, timeoutMs, acc.size, acc.isNotEmpty(), \"query finished\", System.nanoTime())")
                        .line("return acc"),
                ),
        )
        // The interface's member extension, implemented.
        .member(
            KtFun::new("label")
                .vis(KtVis::Public)
                .modifier("override")
                .receiver(KtType::cls("Sample"))
                .returns(KtType::string())
                .expr_body(KtCode::new().line("\"${keyExpr}@${describe()}\"")),
        )
        // A member extension of the class itself.
        .member(
            KtFun::new("toSample")
                .vis(KtVis::Public)
                .receiver(KtType::byte_array())
                .returns(KtType::cls("Sample"))
                .expr_body(KtCode::new().line("Sample(describe(), this)")),
        )
        // A nested class — its own scope, so its members may reuse names.
        .member(
            KtClass::class_("Config")
                .vis(KtVis::Public)
                .member(KtProperty::val("describe").initializer("\"config\"")),
        )
        .companion(
            KtCompanion::new()
                .vis(KtVis::Public)
                .member(
                    KtFun::new("open")
                        .vis(KtVis::Public)
                        .annotation("JvmStatic")
                        .param(KtParam::new("config", KtType::string()).default("\"{}\""))
                        .returns(KtType::cls("Session"))
                        .expr_body(KtCode::new().line("Session(JNINative.sessionOpen(config))")),
                ),
        );

    // A plain `interface`: bodiless members are abstract by position, and a
    // `KtFunSig` is exactly that.
    let describable = KtClass::interface_("Describable")
        .vis(KtVis::Public)
        .member(KtFunSig::new("describe").returns(KtType::string()))
        // A member extension: abstract here, supplied by the implementor.
        // `KtFunSig` carries a receiver too, so a signature does not quietly
        // become a plain member.
        .member(
            KtFunSig::new("label")
                .receiver(KtType::cls("Sample"))
                .returns(KtType::string()),
        );

    // A `fun interface` (SAM) — its single method cannot carry a body.
    let handler = KtFunInterface::new(
        "ReplyHandler",
        KtFunSig::new("onReply")
            .param(KtParam::new("reply", KtType::cls("Reply")))
            .returns(KtType::var_r()),
    )
    .vis(KtVis::Public)
    .type_param("out R")
    .kdoc("Invoked from the native thread for each reply.");

    // Top-level extension functions. The receiver is a type, not part of the
    // name, so it resolves through the import set and the name stays a plain
    // identifier the validator can check as one.
    let summary = KtFun::new("summary")
        .vis(KtVis::Public)
        .receiver(KtType::cls("Sample"))
        .returns(KtType::string())
        .expr_body(KtCode::new().line("\"$keyExpr (${payload.size} bytes)\""));

    // Generics render before the receiver, which renders before the name.
    let map_replies = KtFun::new("mapValues")
        .vis(KtVis::Public)
        .generic("R")
        .receiver(KtType::generic("List", [KtType::cls("Reply")]))
        .param(KtParam::new(
            "transform",
            KtType::lambda(
                [("sample".to_string(), KtType::cls("Sample"))],
                KtType::var_r(),
            ),
        ))
        .returns(KtType::generic("List", [KtType::var_r()]))
        .expr_body(
            KtCode::new().line("filterIsInstance<Reply.Value>().map { transform(it.sample) }"),
        );

    // An extension on a *function type*. The receiver needs parentheses here
    // or the `.` would bind to the return type instead.
    let as_raw = KtFun::new("asRaw")
        .vis(KtVis::Internal)
        .receiver(KtType::lambda(
            [("sample".to_string(), KtType::cls("Sample"))],
            KtType::unit(),
        ))
        .returns(KtType::cls("io.example.api.internal.RawSink"))
        // The proxy adapts a typed callback to the raw one the natives call,
        // so it has to narrow `Reply` to the `Sample` the receiver takes.
        .expr_body(
            KtCode::new().line("RawSink { raw -> if (raw is Reply.Value) this(raw.sample) }"),
        );

    KtFile::new("io.example.api")
        // FQNs named only from raw body text, which the model cannot see.
        .imports(["io.example.api.internal.JNINative".to_string()])
        .decl(base)
        .decl(describable)
        .decl(handler)
        .decl(session)
        .decl(summary)
        .decl(map_replies)
        .decl(as_raw)
        .decl(KtDecl::TypeAlias {
            vis: KtVis::Public,
            name: "SampleList".to_string(),
            target: KtType::generic("List", [KtType::cls("Sample")]),
        })
}

/// The `external` surface — an object of natives, in its own subpackage.
fn natives_fragment() -> KtFile {
    let natives = KtClass::object_("JNINative")
        .vis(KtVis::Internal)
        .kdoc("One-to-one with the exported Rust symbols.")
        .member(
            KtFun::new("sessionOpen")
                .vis(KtVis::Internal)
                .param(KtParam::new("config", KtType::string()))
                .returns(KtType::long())
                .external(),
        )
        .member(
            KtFun::new("sessionFree")
                .vis(KtVis::Internal)
                .param(KtParam::new("ptr", KtType::long()))
                .external(),
        )
        .member(
            KtFun::new("sessionGet")
                .vis(KtVis::Internal)
                .param(KtParam::new("ptr", KtType::long()))
                .param(KtParam::new("selector", KtType::string()))
                .param(KtParam::new("timeoutMs", KtType::long()))
                .param(KtParam::new(
                    "sink",
                    KtType::lambda(
                        [("reply".to_string(), KtType::cls("io.example.api.Reply"))],
                        KtType::unit(),
                    ),
                ))
                .external(),
        );

    // A pre-rendered block, for text the model does not describe. Its name is
    // a merge identity, never emitted.
    let loader = KtDecl::Raw {
        name: "__loadNative".to_string(),
        code: KtCode::raw_reindent(
            "internal val __loaded: Boolean = run {\n\
             System.loadLibrary(\"example_jni\")\n\
             true\n\
             }",
        ),
    };

    let raw_sink = KtFunInterface::new(
        "RawSink",
        KtFunSig::new("accept").param(KtParam::new("reply", KtType::cls("io.example.api.Reply"))),
    )
    .vis(KtVis::Internal);

    KtFile::new("io.example.api.internal")
        .decl(raw_sink)
        .decl(natives)
        .decl(loader)
        // An FQN referenced only from raw text the model cannot see.
        .import("io.example.api.Reply")
}

/// A file in the default (root) package, exercising a banner override and
/// top-level declarations of every value kind.
fn root_fragment() -> KtFile {
    KtFile::new("")
        .banner("// Hand-tuned banner for the root package.")
        .decl(
            KtProperty::val("LIBRARY_VERSION")
                .ty(KtType::string())
                .vis(KtVis::Public)
                .kdoc("Version this binding was generated against.")
                .initializer("\"1.9.0\""),
        )
        // A keyword modifier rendered between visibility and `val`.
        .decl(
            KtProperty::val("PROTOCOL")
                .ty(KtType::string())
                .vis(KtVis::Public)
                .modifier("const")
                .initializer("\"tcp\""),
        )
        // A delegated property: `by <expr>` rather than `= <expr>`.
        .decl(
            KtProperty::val("defaultTimeout")
                .vis(KtVis::Internal)
                .ty(KtType::cls("java.time.Duration"))
                .delegate("lazy { Duration.ofSeconds(10) }"),
        )
        .decl(
            KtFun::new("describeAll")
                .vis(KtVis::Public)
                // Generic parameter lists are free-form text, so a bound is
                // written as given — it is not shortened against the imports.
                .generic("T : io.example.api.Describable")
                .param(KtParam::new(
                    "items",
                    KtType::generic("List", [KtType::var_("T")]),
                ))
                .returns(KtType::string())
                .expr_body(KtCode::new().line("items.joinToString { it.describe() }")),
        )
}

pub fn vis(self, v: KtVis) -> Self

Examples found in repository

examples/showcase.rs (line 81)

fn types_fragment() -> KtFile {
    // `enum class` with a primary constructor its entries call, plus a named
    // companion object holding a factory.
    let priority = KtClass::enum_("Priority")
        .vis(KtVis::Public)
        .kdoc("Delivery priority.\n\nMirrors the native `z_priority_t`.")
        .ctor_param(
            KtCtorParam::new("code", KtType::int())
                .val()
                .vis(KtVis::Public),
        )
        .entry(KtEnumEntry::with_args("REAL_TIME", "1"))
        .entry(KtEnumEntry::with_args("INTERACTIVE", "4"))
        .entry(KtEnumEntry::with_args("DATA", "5"))
        .companion(
            KtCompanion::named("Codes")
                .vis(KtVis::Public)
                .kdoc("Lookup helpers keyed by the native code.")
                .member(
                    KtFun::new("fromInt")
                        .vis(KtVis::Public)
                        .annotation("JvmStatic")
                        .param(KtParam::new("value", KtType::int()))
                        .returns(KtType::cls("Priority"))
                        .body(
                            KtCode::new()
                                .blk("return when (value) {", |c| {
                                    c.line("1 -> REAL_TIME")
                                        .line("4 -> INTERACTIVE")
                                        .line("5 -> DATA")
                                        .line("else -> throw IllegalArgumentException(\"bad priority: $value\")")
                                }),
                        ),
                ),
        );

    // `@JvmInline value class` — exactly one read-only property.
    let zid = KtClass::value(
        "ZenohId",
        KtCtorParam::new("bytes", KtType::byte_array())
            .val()
            .vis(KtVis::Public),
    )
    .vis(KtVis::Public)
    .kdoc("A 16-byte peer identifier, carried by value.");

    // `data class` — every constructor parameter is a property.
    let sample = KtClass::data(
        "Sample",
        KtCtorParam::new("keyExpr", KtType::string())
            .val()
            .vis(KtVis::Public),
    )
    .vis(KtVis::Public)
    .ctor_param(
        KtCtorParam::new("payload", KtType::byte_array())
            .val()
            .vis(KtVis::Public),
    )
    .ctor_param(
        KtCtorParam::new("priority", KtType::cls("Priority"))
            .val()
            .vis(KtVis::Public)
            .default("Priority.DATA"),
    )
    .ctor_param(
        KtCtorParam::new("attachment", KtType::byte_array().nullable())
            .var()
            .vis(KtVis::Public)
            .annotation("JvmField")
            .default("null"),
    );

    // A `sealed interface` whose alternatives nest inside it: a `data class`
    // with a payload and a `data object` without one.
    let reply = KtClass::sealed_interface("Reply")
        .vis(KtVis::Public)
        .kdoc("Either a sample or the end of the stream.")
        .member(
            KtClass::data(
                "Value",
                KtCtorParam::new("sample", KtType::cls("Sample"))
                    .val()
                    .vis(KtVis::Public),
            )
            .vis(KtVis::Public)
            .implements(KtType::cls("Reply")),
        )
        .member(
            KtClass::data_object("Done")
                .vis(KtVis::Public)
                .implements(KtType::cls("Reply")),
        );

    KtFile::new("io.example.api")
        .decl(priority)
        .decl(zid)
        .decl(sample)
        .decl(reply)
}

/// The handle surface: an abstract base, a concrete subclass, an interface,
/// a `fun interface`, and a type alias.
fn session_fragment() -> KtFile {
    // `abstract class` with an `abstract` member (bodiless, and it says so),
    // a `@Volatile` property, and an interface it implements.
    let base = KtClass::class_with(KtClassModifier::Abstract, "NativeHandle")
        .vis(KtVis::Public)
        .kdoc("Owns a raw pointer into Rust and frees it exactly once.")
        .ctor_param(KtCtorParam::new("initialPtr", KtType::long()))
        .implements(KtType::cls("AutoCloseable"))
        .member(
            KtProperty::var("ptr")
                .ty(KtType::long())
                .vis(KtVis::Internal)
                .annotation("Volatile")
                .kdoc("Zero once closed.")
                .initializer("initialPtr"),
        )
        .member(
            KtProperty::val("isClosed")
                .ty(KtType::boolean())
                .vis(KtVis::Public)
                .accessors(KtCode::new().line("get() = ptr == 0L")),
        )
        .member(
            KtFun::new("freePtr")
                .vis(KtVis::Public)
                .modifier("abstract")
                .kdoc("Release the native allocation. Called once, under the lock.")
                .param(KtParam::new("ptr", KtType::long())),
        );

    // `open class` extending the abstract base and constructing it.
    let session = KtClass::class_with(KtClassModifier::Open, "Session")
        .vis(KtVis::Public)
        .annotation("Suppress(\"unused\")")
        .ctor_param(KtCtorParam::new("initialPtr", KtType::long()))
        .extends(KtType::cls("NativeHandle"), Some("initialPtr"))
        .implements(KtType::cls("io.example.api.Describable"))
        .member(
            KtFun::new("freePtr")
                .vis(KtVis::Public)
                .modifier("override")
                .param(KtParam::new("ptr", KtType::long()))
                .body(KtCode::new().line("JNINative.sessionFree(ptr)")),
        )
        .member(
            KtFun::new("describe")
                .vis(KtVis::Public)
                .modifier("override")
                .returns(KtType::string())
                .expr_body(KtCode::new().line("\"Session(0x${ptr.toString(16)})\"")),
        )
        // A generic method whose body uses every `KtCode` block form.
        .member(
            KtFun::new("get")
                .vis(KtVis::Public)
                .generic("R")
                .kdoc("Run a query, folding each reply into an accumulator.")
                .param(KtParam::new("selector", KtType::string()))
                .param(KtParam::new(
                    "onReply",
                    KtType::lambda(
                        [("reply".to_string(), KtType::cls("io.example.api.Reply"))],
                        KtType::var_r(),
                    ),
                ))
                .param(KtParam::new("timeoutMs", KtType::long()).default("10_000L"))
                .returns(KtType::generic("List", [KtType::var_r()]))
                .body(
                    KtCode::new()
                        .line("val acc = ArrayList<R>()")
                        .line("val guard = Guard.acquire(this)")
                        .import("io.example.internal.Guard")
                        .try_finally(
                            "",
                            KtCode::new().blk("JNINative.sessionGet(ptr, selector, timeoutMs) { raw ->", |c| {
                                c.line("acc.add(onReply(raw))")
                            }),
                            KtCode::new().line("guard.release()"),
                        )
                        .line("")
                        // A long call that the renderer breaks by width at its
                        // real nesting level.
                        .wline("reportQueryOutcome(selector, timeoutMs, acc.size, acc.isNotEmpty(), \"query finished\", System.nanoTime())")
                        .line("return acc"),
                ),
        )
        // The interface's member extension, implemented.
        .member(
            KtFun::new("label")
                .vis(KtVis::Public)
                .modifier("override")
                .receiver(KtType::cls("Sample"))
                .returns(KtType::string())
                .expr_body(KtCode::new().line("\"${keyExpr}@${describe()}\"")),
        )
        // A member extension of the class itself.
        .member(
            KtFun::new("toSample")
                .vis(KtVis::Public)
                .receiver(KtType::byte_array())
                .returns(KtType::cls("Sample"))
                .expr_body(KtCode::new().line("Sample(describe(), this)")),
        )
        // A nested class — its own scope, so its members may reuse names.
        .member(
            KtClass::class_("Config")
                .vis(KtVis::Public)
                .member(KtProperty::val("describe").initializer("\"config\"")),
        )
        .companion(
            KtCompanion::new()
                .vis(KtVis::Public)
                .member(
                    KtFun::new("open")
                        .vis(KtVis::Public)
                        .annotation("JvmStatic")
                        .param(KtParam::new("config", KtType::string()).default("\"{}\""))
                        .returns(KtType::cls("Session"))
                        .expr_body(KtCode::new().line("Session(JNINative.sessionOpen(config))")),
                ),
        );

    // A plain `interface`: bodiless members are abstract by position, and a
    // `KtFunSig` is exactly that.
    let describable = KtClass::interface_("Describable")
        .vis(KtVis::Public)
        .member(KtFunSig::new("describe").returns(KtType::string()))
        // A member extension: abstract here, supplied by the implementor.
        // `KtFunSig` carries a receiver too, so a signature does not quietly
        // become a plain member.
        .member(
            KtFunSig::new("label")
                .receiver(KtType::cls("Sample"))
                .returns(KtType::string()),
        );

    // A `fun interface` (SAM) — its single method cannot carry a body.
    let handler = KtFunInterface::new(
        "ReplyHandler",
        KtFunSig::new("onReply")
            .param(KtParam::new("reply", KtType::cls("Reply")))
            .returns(KtType::var_r()),
    )
    .vis(KtVis::Public)
    .type_param("out R")
    .kdoc("Invoked from the native thread for each reply.");

    // Top-level extension functions. The receiver is a type, not part of the
    // name, so it resolves through the import set and the name stays a plain
    // identifier the validator can check as one.
    let summary = KtFun::new("summary")
        .vis(KtVis::Public)
        .receiver(KtType::cls("Sample"))
        .returns(KtType::string())
        .expr_body(KtCode::new().line("\"$keyExpr (${payload.size} bytes)\""));

    // Generics render before the receiver, which renders before the name.
    let map_replies = KtFun::new("mapValues")
        .vis(KtVis::Public)
        .generic("R")
        .receiver(KtType::generic("List", [KtType::cls("Reply")]))
        .param(KtParam::new(
            "transform",
            KtType::lambda(
                [("sample".to_string(), KtType::cls("Sample"))],
                KtType::var_r(),
            ),
        ))
        .returns(KtType::generic("List", [KtType::var_r()]))
        .expr_body(
            KtCode::new().line("filterIsInstance<Reply.Value>().map { transform(it.sample) }"),
        );

    // An extension on a *function type*. The receiver needs parentheses here
    // or the `.` would bind to the return type instead.
    let as_raw = KtFun::new("asRaw")
        .vis(KtVis::Internal)
        .receiver(KtType::lambda(
            [("sample".to_string(), KtType::cls("Sample"))],
            KtType::unit(),
        ))
        .returns(KtType::cls("io.example.api.internal.RawSink"))
        // The proxy adapts a typed callback to the raw one the natives call,
        // so it has to narrow `Reply` to the `Sample` the receiver takes.
        .expr_body(
            KtCode::new().line("RawSink { raw -> if (raw is Reply.Value) this(raw.sample) }"),
        );

    KtFile::new("io.example.api")
        // FQNs named only from raw body text, which the model cannot see.
        .imports(["io.example.api.internal.JNINative".to_string()])
        .decl(base)
        .decl(describable)
        .decl(handler)
        .decl(session)
        .decl(summary)
        .decl(map_replies)
        .decl(as_raw)
        .decl(KtDecl::TypeAlias {
            vis: KtVis::Public,
            name: "SampleList".to_string(),
            target: KtType::generic("List", [KtType::cls("Sample")]),
        })
}

/// The `external` surface — an object of natives, in its own subpackage.
fn natives_fragment() -> KtFile {
    let natives = KtClass::object_("JNINative")
        .vis(KtVis::Internal)
        .kdoc("One-to-one with the exported Rust symbols.")
        .member(
            KtFun::new("sessionOpen")
                .vis(KtVis::Internal)
                .param(KtParam::new("config", KtType::string()))
                .returns(KtType::long())
                .external(),
        )
        .member(
            KtFun::new("sessionFree")
                .vis(KtVis::Internal)
                .param(KtParam::new("ptr", KtType::long()))
                .external(),
        )
        .member(
            KtFun::new("sessionGet")
                .vis(KtVis::Internal)
                .param(KtParam::new("ptr", KtType::long()))
                .param(KtParam::new("selector", KtType::string()))
                .param(KtParam::new("timeoutMs", KtType::long()))
                .param(KtParam::new(
                    "sink",
                    KtType::lambda(
                        [("reply".to_string(), KtType::cls("io.example.api.Reply"))],
                        KtType::unit(),
                    ),
                ))
                .external(),
        );

    // A pre-rendered block, for text the model does not describe. Its name is
    // a merge identity, never emitted.
    let loader = KtDecl::Raw {
        name: "__loadNative".to_string(),
        code: KtCode::raw_reindent(
            "internal val __loaded: Boolean = run {\n\
             System.loadLibrary(\"example_jni\")\n\
             true\n\
             }",
        ),
    };

    let raw_sink = KtFunInterface::new(
        "RawSink",
        KtFunSig::new("accept").param(KtParam::new("reply", KtType::cls("io.example.api.Reply"))),
    )
    .vis(KtVis::Internal);

    KtFile::new("io.example.api.internal")
        .decl(raw_sink)
        .decl(natives)
        .decl(loader)
        // An FQN referenced only from raw text the model cannot see.
        .import("io.example.api.Reply")
}

/// A file in the default (root) package, exercising a banner override and
/// top-level declarations of every value kind.
fn root_fragment() -> KtFile {
    KtFile::new("")
        .banner("// Hand-tuned banner for the root package.")
        .decl(
            KtProperty::val("LIBRARY_VERSION")
                .ty(KtType::string())
                .vis(KtVis::Public)
                .kdoc("Version this binding was generated against.")
                .initializer("\"1.9.0\""),
        )
        // A keyword modifier rendered between visibility and `val`.
        .decl(
            KtProperty::val("PROTOCOL")
                .ty(KtType::string())
                .vis(KtVis::Public)
                .modifier("const")
                .initializer("\"tcp\""),
        )
        // A delegated property: `by <expr>` rather than `= <expr>`.
        .decl(
            KtProperty::val("defaultTimeout")
                .vis(KtVis::Internal)
                .ty(KtType::cls("java.time.Duration"))
                .delegate("lazy { Duration.ofSeconds(10) }"),
        )
        .decl(
            KtFun::new("describeAll")
                .vis(KtVis::Public)
                // Generic parameter lists are free-form text, so a bound is
                // written as given — it is not shortened against the imports.
                .generic("T : io.example.api.Describable")
                .param(KtParam::new(
                    "items",
                    KtType::generic("List", [KtType::var_("T")]),
                ))
                .returns(KtType::string())
                .expr_body(KtCode::new().line("items.joinToString { it.describe() }")),
        )
}

pub fn receiver(self, ty: KtType) -> Self

Make this an extension function on ty: fun <R> Foo<R>.name(…).

Examples found in repository

examples/invalid.rs (line 103)

fn broken_declarations() -> KtFile {
    KtFile::new("io.example.broken")
        // Two classes of the same name: a redeclaration in the type namespace.
        .decl(KtClass::class_("Session"))
        .decl(KtClass::class_("Session"))
        // An interface and a type alias are both classifier declarations, so they collide.
        .decl(
            KtClass::interface_("Describable")
                .member(KtFun::new("describe").returns(KtType::string())),
        )
        .decl(KtDecl::TypeAlias {
            vis: KtVis::Public,
            name: "Describable".to_string(),
            target: KtType::string(),
        })
        // Same name AND same parameter types: not an overload.
        .decl(
            KtFun::new("send")
                .param(KtParam::new("value", KtType::int()))
                .returns(KtType::boolean())
                .body(KtCode::new()),
        )
        .decl(
            KtFun::new("send")
                .param(KtParam::new("other", KtType::int()))
                .returns(KtType::long())
                .body(KtCode::new()),
        )
        // Extensions are keyed on their receiver, so these two collide while
        // the same pair on different receivers would not.
        .decl(
            KtFun::new("asRaw")
                .receiver(KtType::cls("io.example.Codec"))
                .body(KtCode::new()),
        )
        .decl(
            KtFun::new("asRaw")
                .receiver(KtType::cls("io.example.Codec"))
                .body(KtCode::new()),
        )
        // ...as here: same name, different receiver, no diagnostic.
        .decl(
            KtFun::new("asRaw")
                .receiver(KtType::cls("io.example.Other"))
                .body(KtCode::new()),
        )
        // Names that are not legal Kotlin identifiers.
        .decl(
            KtClass::class_("My-Class")
                .ctor_param(KtCtorParam::new("2fast", KtType::int()))
                .member(
                    KtFun::new("object")
                        .param(KtParam::new("in", KtType::int()))
                        .body(KtCode::new()),
                ),
        )
        // `val x` with no type, no value and no accessors.
        .decl(KtProperty::val("bare"))
        // A function with no body, at top level, where that cannot mean
        // "abstract".
        .decl(KtFun::new("nobody"))
        // An abstract class member missing the `abstract` keyword.
        .decl(
            KtClass::class_with(KtClassModifier::Abstract, "Base")
                .member(KtFun::new("unimplemented")),
        )
        // An enum whose entries do not call the constructor it declares.
        .decl(
            KtClass::enum_("Priority")
                .ctor_param(KtCtorParam::new("code", KtType::int()).val())
                .entry(KtEnumEntry::with_args("HIGH", "1"))
                .entry(KtEnumEntry::new("LOW")),
        )
        // A constructor property and a member property of one name: both live
        // in the value namespace.
        .decl(
            KtClass::class_("Holder")
                .ctor_param(KtCtorParam::new("id", KtType::long()).val())
                .member(KtProperty::val("id").initializer("0")),
        )
        // A named companion object colliding with a nested class.
        .decl(
            KtClass::class_("Outer")
                .member(KtClass::class_("Factory"))
                .companion(KtCompanion::named("Factory")),
        )
        // Two raw blocks claiming one identity with different bodies.
        .decl(KtDecl::Raw {
            name: "__loader".to_string(),
            code: KtCode::new().line("internal val __loader = 1"),
        })
        .decl(KtDecl::Raw {
            name: "__loader".to_string(),
            code: KtCode::new().line("internal val __loader = 2"),
        })
        // Two different classes referenced from raw text under one short name:
        // the text already says `Codec`, so it cannot mean both.
        .import("io.example.a.Codec")
        .import("io.example.b.Codec")
}

examples/showcase.rs (line 255)

fn session_fragment() -> KtFile {
    // `abstract class` with an `abstract` member (bodiless, and it says so),
    // a `@Volatile` property, and an interface it implements.
    let base = KtClass::class_with(KtClassModifier::Abstract, "NativeHandle")
        .vis(KtVis::Public)
        .kdoc("Owns a raw pointer into Rust and frees it exactly once.")
        .ctor_param(KtCtorParam::new("initialPtr", KtType::long()))
        .implements(KtType::cls("AutoCloseable"))
        .member(
            KtProperty::var("ptr")
                .ty(KtType::long())
                .vis(KtVis::Internal)
                .annotation("Volatile")
                .kdoc("Zero once closed.")
                .initializer("initialPtr"),
        )
        .member(
            KtProperty::val("isClosed")
                .ty(KtType::boolean())
                .vis(KtVis::Public)
                .accessors(KtCode::new().line("get() = ptr == 0L")),
        )
        .member(
            KtFun::new("freePtr")
                .vis(KtVis::Public)
                .modifier("abstract")
                .kdoc("Release the native allocation. Called once, under the lock.")
                .param(KtParam::new("ptr", KtType::long())),
        );

    // `open class` extending the abstract base and constructing it.
    let session = KtClass::class_with(KtClassModifier::Open, "Session")
        .vis(KtVis::Public)
        .annotation("Suppress(\"unused\")")
        .ctor_param(KtCtorParam::new("initialPtr", KtType::long()))
        .extends(KtType::cls("NativeHandle"), Some("initialPtr"))
        .implements(KtType::cls("io.example.api.Describable"))
        .member(
            KtFun::new("freePtr")
                .vis(KtVis::Public)
                .modifier("override")
                .param(KtParam::new("ptr", KtType::long()))
                .body(KtCode::new().line("JNINative.sessionFree(ptr)")),
        )
        .member(
            KtFun::new("describe")
                .vis(KtVis::Public)
                .modifier("override")
                .returns(KtType::string())
                .expr_body(KtCode::new().line("\"Session(0x${ptr.toString(16)})\"")),
        )
        // A generic method whose body uses every `KtCode` block form.
        .member(
            KtFun::new("get")
                .vis(KtVis::Public)
                .generic("R")
                .kdoc("Run a query, folding each reply into an accumulator.")
                .param(KtParam::new("selector", KtType::string()))
                .param(KtParam::new(
                    "onReply",
                    KtType::lambda(
                        [("reply".to_string(), KtType::cls("io.example.api.Reply"))],
                        KtType::var_r(),
                    ),
                ))
                .param(KtParam::new("timeoutMs", KtType::long()).default("10_000L"))
                .returns(KtType::generic("List", [KtType::var_r()]))
                .body(
                    KtCode::new()
                        .line("val acc = ArrayList<R>()")
                        .line("val guard = Guard.acquire(this)")
                        .import("io.example.internal.Guard")
                        .try_finally(
                            "",
                            KtCode::new().blk("JNINative.sessionGet(ptr, selector, timeoutMs) { raw ->", |c| {
                                c.line("acc.add(onReply(raw))")
                            }),
                            KtCode::new().line("guard.release()"),
                        )
                        .line("")
                        // A long call that the renderer breaks by width at its
                        // real nesting level.
                        .wline("reportQueryOutcome(selector, timeoutMs, acc.size, acc.isNotEmpty(), \"query finished\", System.nanoTime())")
                        .line("return acc"),
                ),
        )
        // The interface's member extension, implemented.
        .member(
            KtFun::new("label")
                .vis(KtVis::Public)
                .modifier("override")
                .receiver(KtType::cls("Sample"))
                .returns(KtType::string())
                .expr_body(KtCode::new().line("\"${keyExpr}@${describe()}\"")),
        )
        // A member extension of the class itself.
        .member(
            KtFun::new("toSample")
                .vis(KtVis::Public)
                .receiver(KtType::byte_array())
                .returns(KtType::cls("Sample"))
                .expr_body(KtCode::new().line("Sample(describe(), this)")),
        )
        // A nested class — its own scope, so its members may reuse names.
        .member(
            KtClass::class_("Config")
                .vis(KtVis::Public)
                .member(KtProperty::val("describe").initializer("\"config\"")),
        )
        .companion(
            KtCompanion::new()
                .vis(KtVis::Public)
                .member(
                    KtFun::new("open")
                        .vis(KtVis::Public)
                        .annotation("JvmStatic")
                        .param(KtParam::new("config", KtType::string()).default("\"{}\""))
                        .returns(KtType::cls("Session"))
                        .expr_body(KtCode::new().line("Session(JNINative.sessionOpen(config))")),
                ),
        );

    // A plain `interface`: bodiless members are abstract by position, and a
    // `KtFunSig` is exactly that.
    let describable = KtClass::interface_("Describable")
        .vis(KtVis::Public)
        .member(KtFunSig::new("describe").returns(KtType::string()))
        // A member extension: abstract here, supplied by the implementor.
        // `KtFunSig` carries a receiver too, so a signature does not quietly
        // become a plain member.
        .member(
            KtFunSig::new("label")
                .receiver(KtType::cls("Sample"))
                .returns(KtType::string()),
        );

    // A `fun interface` (SAM) — its single method cannot carry a body.
    let handler = KtFunInterface::new(
        "ReplyHandler",
        KtFunSig::new("onReply")
            .param(KtParam::new("reply", KtType::cls("Reply")))
            .returns(KtType::var_r()),
    )
    .vis(KtVis::Public)
    .type_param("out R")
    .kdoc("Invoked from the native thread for each reply.");

    // Top-level extension functions. The receiver is a type, not part of the
    // name, so it resolves through the import set and the name stays a plain
    // identifier the validator can check as one.
    let summary = KtFun::new("summary")
        .vis(KtVis::Public)
        .receiver(KtType::cls("Sample"))
        .returns(KtType::string())
        .expr_body(KtCode::new().line("\"$keyExpr (${payload.size} bytes)\""));

    // Generics render before the receiver, which renders before the name.
    let map_replies = KtFun::new("mapValues")
        .vis(KtVis::Public)
        .generic("R")
        .receiver(KtType::generic("List", [KtType::cls("Reply")]))
        .param(KtParam::new(
            "transform",
            KtType::lambda(
                [("sample".to_string(), KtType::cls("Sample"))],
                KtType::var_r(),
            ),
        ))
        .returns(KtType::generic("List", [KtType::var_r()]))
        .expr_body(
            KtCode::new().line("filterIsInstance<Reply.Value>().map { transform(it.sample) }"),
        );

    // An extension on a *function type*. The receiver needs parentheses here
    // or the `.` would bind to the return type instead.
    let as_raw = KtFun::new("asRaw")
        .vis(KtVis::Internal)
        .receiver(KtType::lambda(
            [("sample".to_string(), KtType::cls("Sample"))],
            KtType::unit(),
        ))
        .returns(KtType::cls("io.example.api.internal.RawSink"))
        // The proxy adapts a typed callback to the raw one the natives call,
        // so it has to narrow `Reply` to the `Sample` the receiver takes.
        .expr_body(
            KtCode::new().line("RawSink { raw -> if (raw is Reply.Value) this(raw.sample) }"),
        );

    KtFile::new("io.example.api")
        // FQNs named only from raw body text, which the model cannot see.
        .imports(["io.example.api.internal.JNINative".to_string()])
        .decl(base)
        .decl(describable)
        .decl(handler)
        .decl(session)
        .decl(summary)
        .decl(map_replies)
        .decl(as_raw)
        .decl(KtDecl::TypeAlias {
            vis: KtVis::Public,
            name: "SampleList".to_string(),
            target: KtType::generic("List", [KtType::cls("Sample")]),
        })
}

pub fn modifier(self, m: impl Into<String>) -> Self

Add a modifier keyword (override, inline, operator, …).

Panics

On "external" — it is a body kind, not a modifier, so that it cannot be combined with one. Use KtFun::external.

Examples found in repository

examples/invalid.rs (line 213)

fn refused_shapes() -> Vec<(&'static str, String)> {
    vec![
        (
            "object Foo(x: Int)  — an object has no primary constructor",
            refused(|| {
                KtClass::object_("Foo").ctor_param(KtCtorParam::new("x", KtType::int()));
            }),
        ),
        (
            "data class Foo(x: Int)  — a data class parameter must be a property",
            refused(|| {
                KtClass::data("Foo", KtCtorParam::new("x", KtType::int()));
            }),
        ),
        (
            "value class Foo(var x: Long)  — a value class wraps one read-only property",
            refused(|| {
                KtClass::value("Foo", KtCtorParam::new("x", KtType::long()).var());
            }),
        ),
        (
            "class A : B(x), C(y)  — Kotlin constructs at most one superclass",
            refused(|| {
                KtClass::class_("A")
                    .extends(KtType::cls("B"), Some("x"))
                    .extends(KtType::cls("C"), Some("y"));
            }),
        ),
        (
            "external fun f() { … }  — `external` is a body kind, not a modifier",
            refused(|| {
                KtFun::new("f").modifier("external");
            }),
        ),
        (
            "enum entry on a non-enum class",
            refused(|| {
                KtClass::class_("C").entry(KtEnumEntry::new("A"));
            }),
        ),
        (
            "companion object with an empty name",
            refused(|| {
                KtCompanion::named("");
            }),
        ),
    ]
}

examples/showcase.rs (line 189)

fn session_fragment() -> KtFile {
    // `abstract class` with an `abstract` member (bodiless, and it says so),
    // a `@Volatile` property, and an interface it implements.
    let base = KtClass::class_with(KtClassModifier::Abstract, "NativeHandle")
        .vis(KtVis::Public)
        .kdoc("Owns a raw pointer into Rust and frees it exactly once.")
        .ctor_param(KtCtorParam::new("initialPtr", KtType::long()))
        .implements(KtType::cls("AutoCloseable"))
        .member(
            KtProperty::var("ptr")
                .ty(KtType::long())
                .vis(KtVis::Internal)
                .annotation("Volatile")
                .kdoc("Zero once closed.")
                .initializer("initialPtr"),
        )
        .member(
            KtProperty::val("isClosed")
                .ty(KtType::boolean())
                .vis(KtVis::Public)
                .accessors(KtCode::new().line("get() = ptr == 0L")),
        )
        .member(
            KtFun::new("freePtr")
                .vis(KtVis::Public)
                .modifier("abstract")
                .kdoc("Release the native allocation. Called once, under the lock.")
                .param(KtParam::new("ptr", KtType::long())),
        );

    // `open class` extending the abstract base and constructing it.
    let session = KtClass::class_with(KtClassModifier::Open, "Session")
        .vis(KtVis::Public)
        .annotation("Suppress(\"unused\")")
        .ctor_param(KtCtorParam::new("initialPtr", KtType::long()))
        .extends(KtType::cls("NativeHandle"), Some("initialPtr"))
        .implements(KtType::cls("io.example.api.Describable"))
        .member(
            KtFun::new("freePtr")
                .vis(KtVis::Public)
                .modifier("override")
                .param(KtParam::new("ptr", KtType::long()))
                .body(KtCode::new().line("JNINative.sessionFree(ptr)")),
        )
        .member(
            KtFun::new("describe")
                .vis(KtVis::Public)
                .modifier("override")
                .returns(KtType::string())
                .expr_body(KtCode::new().line("\"Session(0x${ptr.toString(16)})\"")),
        )
        // A generic method whose body uses every `KtCode` block form.
        .member(
            KtFun::new("get")
                .vis(KtVis::Public)
                .generic("R")
                .kdoc("Run a query, folding each reply into an accumulator.")
                .param(KtParam::new("selector", KtType::string()))
                .param(KtParam::new(
                    "onReply",
                    KtType::lambda(
                        [("reply".to_string(), KtType::cls("io.example.api.Reply"))],
                        KtType::var_r(),
                    ),
                ))
                .param(KtParam::new("timeoutMs", KtType::long()).default("10_000L"))
                .returns(KtType::generic("List", [KtType::var_r()]))
                .body(
                    KtCode::new()
                        .line("val acc = ArrayList<R>()")
                        .line("val guard = Guard.acquire(this)")
                        .import("io.example.internal.Guard")
                        .try_finally(
                            "",
                            KtCode::new().blk("JNINative.sessionGet(ptr, selector, timeoutMs) { raw ->", |c| {
                                c.line("acc.add(onReply(raw))")
                            }),
                            KtCode::new().line("guard.release()"),
                        )
                        .line("")
                        // A long call that the renderer breaks by width at its
                        // real nesting level.
                        .wline("reportQueryOutcome(selector, timeoutMs, acc.size, acc.isNotEmpty(), \"query finished\", System.nanoTime())")
                        .line("return acc"),
                ),
        )
        // The interface's member extension, implemented.
        .member(
            KtFun::new("label")
                .vis(KtVis::Public)
                .modifier("override")
                .receiver(KtType::cls("Sample"))
                .returns(KtType::string())
                .expr_body(KtCode::new().line("\"${keyExpr}@${describe()}\"")),
        )
        // A member extension of the class itself.
        .member(
            KtFun::new("toSample")
                .vis(KtVis::Public)
                .receiver(KtType::byte_array())
                .returns(KtType::cls("Sample"))
                .expr_body(KtCode::new().line("Sample(describe(), this)")),
        )
        // A nested class — its own scope, so its members may reuse names.
        .member(
            KtClass::class_("Config")
                .vis(KtVis::Public)
                .member(KtProperty::val("describe").initializer("\"config\"")),
        )
        .companion(
            KtCompanion::new()
                .vis(KtVis::Public)
                .member(
                    KtFun::new("open")
                        .vis(KtVis::Public)
                        .annotation("JvmStatic")
                        .param(KtParam::new("config", KtType::string()).default("\"{}\""))
                        .returns(KtType::cls("Session"))
                        .expr_body(KtCode::new().line("Session(JNINative.sessionOpen(config))")),
                ),
        );

    // A plain `interface`: bodiless members are abstract by position, and a
    // `KtFunSig` is exactly that.
    let describable = KtClass::interface_("Describable")
        .vis(KtVis::Public)
        .member(KtFunSig::new("describe").returns(KtType::string()))
        // A member extension: abstract here, supplied by the implementor.
        // `KtFunSig` carries a receiver too, so a signature does not quietly
        // become a plain member.
        .member(
            KtFunSig::new("label")
                .receiver(KtType::cls("Sample"))
                .returns(KtType::string()),
        );

    // A `fun interface` (SAM) — its single method cannot carry a body.
    let handler = KtFunInterface::new(
        "ReplyHandler",
        KtFunSig::new("onReply")
            .param(KtParam::new("reply", KtType::cls("Reply")))
            .returns(KtType::var_r()),
    )
    .vis(KtVis::Public)
    .type_param("out R")
    .kdoc("Invoked from the native thread for each reply.");

    // Top-level extension functions. The receiver is a type, not part of the
    // name, so it resolves through the import set and the name stays a plain
    // identifier the validator can check as one.
    let summary = KtFun::new("summary")
        .vis(KtVis::Public)
        .receiver(KtType::cls("Sample"))
        .returns(KtType::string())
        .expr_body(KtCode::new().line("\"$keyExpr (${payload.size} bytes)\""));

    // Generics render before the receiver, which renders before the name.
    let map_replies = KtFun::new("mapValues")
        .vis(KtVis::Public)
        .generic("R")
        .receiver(KtType::generic("List", [KtType::cls("Reply")]))
        .param(KtParam::new(
            "transform",
            KtType::lambda(
                [("sample".to_string(), KtType::cls("Sample"))],
                KtType::var_r(),
            ),
        ))
        .returns(KtType::generic("List", [KtType::var_r()]))
        .expr_body(
            KtCode::new().line("filterIsInstance<Reply.Value>().map { transform(it.sample) }"),
        );

    // An extension on a *function type*. The receiver needs parentheses here
    // or the `.` would bind to the return type instead.
    let as_raw = KtFun::new("asRaw")
        .vis(KtVis::Internal)
        .receiver(KtType::lambda(
            [("sample".to_string(), KtType::cls("Sample"))],
            KtType::unit(),
        ))
        .returns(KtType::cls("io.example.api.internal.RawSink"))
        // The proxy adapts a typed callback to the raw one the natives call,
        // so it has to narrow `Reply` to the `Sample` the receiver takes.
        .expr_body(
            KtCode::new().line("RawSink { raw -> if (raw is Reply.Value) this(raw.sample) }"),
        );

    KtFile::new("io.example.api")
        // FQNs named only from raw body text, which the model cannot see.
        .imports(["io.example.api.internal.JNINative".to_string()])
        .decl(base)
        .decl(describable)
        .decl(handler)
        .decl(session)
        .decl(summary)
        .decl(map_replies)
        .decl(as_raw)
        .decl(KtDecl::TypeAlias {
            vis: KtVis::Public,
            name: "SampleList".to_string(),
            target: KtType::generic("List", [KtType::cls("Sample")]),
        })
}

pub fn annotation(self, a: impl Into<String>) -> Self

Examples found in repository

examples/showcase.rs (line 82)

fn types_fragment() -> KtFile {
    // `enum class` with a primary constructor its entries call, plus a named
    // companion object holding a factory.
    let priority = KtClass::enum_("Priority")
        .vis(KtVis::Public)
        .kdoc("Delivery priority.\n\nMirrors the native `z_priority_t`.")
        .ctor_param(
            KtCtorParam::new("code", KtType::int())
                .val()
                .vis(KtVis::Public),
        )
        .entry(KtEnumEntry::with_args("REAL_TIME", "1"))
        .entry(KtEnumEntry::with_args("INTERACTIVE", "4"))
        .entry(KtEnumEntry::with_args("DATA", "5"))
        .companion(
            KtCompanion::named("Codes")
                .vis(KtVis::Public)
                .kdoc("Lookup helpers keyed by the native code.")
                .member(
                    KtFun::new("fromInt")
                        .vis(KtVis::Public)
                        .annotation("JvmStatic")
                        .param(KtParam::new("value", KtType::int()))
                        .returns(KtType::cls("Priority"))
                        .body(
                            KtCode::new()
                                .blk("return when (value) {", |c| {
                                    c.line("1 -> REAL_TIME")
                                        .line("4 -> INTERACTIVE")
                                        .line("5 -> DATA")
                                        .line("else -> throw IllegalArgumentException(\"bad priority: $value\")")
                                }),
                        ),
                ),
        );

    // `@JvmInline value class` — exactly one read-only property.
    let zid = KtClass::value(
        "ZenohId",
        KtCtorParam::new("bytes", KtType::byte_array())
            .val()
            .vis(KtVis::Public),
    )
    .vis(KtVis::Public)
    .kdoc("A 16-byte peer identifier, carried by value.");

    // `data class` — every constructor parameter is a property.
    let sample = KtClass::data(
        "Sample",
        KtCtorParam::new("keyExpr", KtType::string())
            .val()
            .vis(KtVis::Public),
    )
    .vis(KtVis::Public)
    .ctor_param(
        KtCtorParam::new("payload", KtType::byte_array())
            .val()
            .vis(KtVis::Public),
    )
    .ctor_param(
        KtCtorParam::new("priority", KtType::cls("Priority"))
            .val()
            .vis(KtVis::Public)
            .default("Priority.DATA"),
    )
    .ctor_param(
        KtCtorParam::new("attachment", KtType::byte_array().nullable())
            .var()
            .vis(KtVis::Public)
            .annotation("JvmField")
            .default("null"),
    );

    // A `sealed interface` whose alternatives nest inside it: a `data class`
    // with a payload and a `data object` without one.
    let reply = KtClass::sealed_interface("Reply")
        .vis(KtVis::Public)
        .kdoc("Either a sample or the end of the stream.")
        .member(
            KtClass::data(
                "Value",
                KtCtorParam::new("sample", KtType::cls("Sample"))
                    .val()
                    .vis(KtVis::Public),
            )
            .vis(KtVis::Public)
            .implements(KtType::cls("Reply")),
        )
        .member(
            KtClass::data_object("Done")
                .vis(KtVis::Public)
                .implements(KtType::cls("Reply")),
        );

    KtFile::new("io.example.api")
        .decl(priority)
        .decl(zid)
        .decl(sample)
        .decl(reply)
}

/// The handle surface: an abstract base, a concrete subclass, an interface,
/// a `fun interface`, and a type alias.
fn session_fragment() -> KtFile {
    // `abstract class` with an `abstract` member (bodiless, and it says so),
    // a `@Volatile` property, and an interface it implements.
    let base = KtClass::class_with(KtClassModifier::Abstract, "NativeHandle")
        .vis(KtVis::Public)
        .kdoc("Owns a raw pointer into Rust and frees it exactly once.")
        .ctor_param(KtCtorParam::new("initialPtr", KtType::long()))
        .implements(KtType::cls("AutoCloseable"))
        .member(
            KtProperty::var("ptr")
                .ty(KtType::long())
                .vis(KtVis::Internal)
                .annotation("Volatile")
                .kdoc("Zero once closed.")
                .initializer("initialPtr"),
        )
        .member(
            KtProperty::val("isClosed")
                .ty(KtType::boolean())
                .vis(KtVis::Public)
                .accessors(KtCode::new().line("get() = ptr == 0L")),
        )
        .member(
            KtFun::new("freePtr")
                .vis(KtVis::Public)
                .modifier("abstract")
                .kdoc("Release the native allocation. Called once, under the lock.")
                .param(KtParam::new("ptr", KtType::long())),
        );

    // `open class` extending the abstract base and constructing it.
    let session = KtClass::class_with(KtClassModifier::Open, "Session")
        .vis(KtVis::Public)
        .annotation("Suppress(\"unused\")")
        .ctor_param(KtCtorParam::new("initialPtr", KtType::long()))
        .extends(KtType::cls("NativeHandle"), Some("initialPtr"))
        .implements(KtType::cls("io.example.api.Describable"))
        .member(
            KtFun::new("freePtr")
                .vis(KtVis::Public)
                .modifier("override")
                .param(KtParam::new("ptr", KtType::long()))
                .body(KtCode::new().line("JNINative.sessionFree(ptr)")),
        )
        .member(
            KtFun::new("describe")
                .vis(KtVis::Public)
                .modifier("override")
                .returns(KtType::string())
                .expr_body(KtCode::new().line("\"Session(0x${ptr.toString(16)})\"")),
        )
        // A generic method whose body uses every `KtCode` block form.
        .member(
            KtFun::new("get")
                .vis(KtVis::Public)
                .generic("R")
                .kdoc("Run a query, folding each reply into an accumulator.")
                .param(KtParam::new("selector", KtType::string()))
                .param(KtParam::new(
                    "onReply",
                    KtType::lambda(
                        [("reply".to_string(), KtType::cls("io.example.api.Reply"))],
                        KtType::var_r(),
                    ),
                ))
                .param(KtParam::new("timeoutMs", KtType::long()).default("10_000L"))
                .returns(KtType::generic("List", [KtType::var_r()]))
                .body(
                    KtCode::new()
                        .line("val acc = ArrayList<R>()")
                        .line("val guard = Guard.acquire(this)")
                        .import("io.example.internal.Guard")
                        .try_finally(
                            "",
                            KtCode::new().blk("JNINative.sessionGet(ptr, selector, timeoutMs) { raw ->", |c| {
                                c.line("acc.add(onReply(raw))")
                            }),
                            KtCode::new().line("guard.release()"),
                        )
                        .line("")
                        // A long call that the renderer breaks by width at its
                        // real nesting level.
                        .wline("reportQueryOutcome(selector, timeoutMs, acc.size, acc.isNotEmpty(), \"query finished\", System.nanoTime())")
                        .line("return acc"),
                ),
        )
        // The interface's member extension, implemented.
        .member(
            KtFun::new("label")
                .vis(KtVis::Public)
                .modifier("override")
                .receiver(KtType::cls("Sample"))
                .returns(KtType::string())
                .expr_body(KtCode::new().line("\"${keyExpr}@${describe()}\"")),
        )
        // A member extension of the class itself.
        .member(
            KtFun::new("toSample")
                .vis(KtVis::Public)
                .receiver(KtType::byte_array())
                .returns(KtType::cls("Sample"))
                .expr_body(KtCode::new().line("Sample(describe(), this)")),
        )
        // A nested class — its own scope, so its members may reuse names.
        .member(
            KtClass::class_("Config")
                .vis(KtVis::Public)
                .member(KtProperty::val("describe").initializer("\"config\"")),
        )
        .companion(
            KtCompanion::new()
                .vis(KtVis::Public)
                .member(
                    KtFun::new("open")
                        .vis(KtVis::Public)
                        .annotation("JvmStatic")
                        .param(KtParam::new("config", KtType::string()).default("\"{}\""))
                        .returns(KtType::cls("Session"))
                        .expr_body(KtCode::new().line("Session(JNINative.sessionOpen(config))")),
                ),
        );

    // A plain `interface`: bodiless members are abstract by position, and a
    // `KtFunSig` is exactly that.
    let describable = KtClass::interface_("Describable")
        .vis(KtVis::Public)
        .member(KtFunSig::new("describe").returns(KtType::string()))
        // A member extension: abstract here, supplied by the implementor.
        // `KtFunSig` carries a receiver too, so a signature does not quietly
        // become a plain member.
        .member(
            KtFunSig::new("label")
                .receiver(KtType::cls("Sample"))
                .returns(KtType::string()),
        );

    // A `fun interface` (SAM) — its single method cannot carry a body.
    let handler = KtFunInterface::new(
        "ReplyHandler",
        KtFunSig::new("onReply")
            .param(KtParam::new("reply", KtType::cls("Reply")))
            .returns(KtType::var_r()),
    )
    .vis(KtVis::Public)
    .type_param("out R")
    .kdoc("Invoked from the native thread for each reply.");

    // Top-level extension functions. The receiver is a type, not part of the
    // name, so it resolves through the import set and the name stays a plain
    // identifier the validator can check as one.
    let summary = KtFun::new("summary")
        .vis(KtVis::Public)
        .receiver(KtType::cls("Sample"))
        .returns(KtType::string())
        .expr_body(KtCode::new().line("\"$keyExpr (${payload.size} bytes)\""));

    // Generics render before the receiver, which renders before the name.
    let map_replies = KtFun::new("mapValues")
        .vis(KtVis::Public)
        .generic("R")
        .receiver(KtType::generic("List", [KtType::cls("Reply")]))
        .param(KtParam::new(
            "transform",
            KtType::lambda(
                [("sample".to_string(), KtType::cls("Sample"))],
                KtType::var_r(),
            ),
        ))
        .returns(KtType::generic("List", [KtType::var_r()]))
        .expr_body(
            KtCode::new().line("filterIsInstance<Reply.Value>().map { transform(it.sample) }"),
        );

    // An extension on a *function type*. The receiver needs parentheses here
    // or the `.` would bind to the return type instead.
    let as_raw = KtFun::new("asRaw")
        .vis(KtVis::Internal)
        .receiver(KtType::lambda(
            [("sample".to_string(), KtType::cls("Sample"))],
            KtType::unit(),
        ))
        .returns(KtType::cls("io.example.api.internal.RawSink"))
        // The proxy adapts a typed callback to the raw one the natives call,
        // so it has to narrow `Reply` to the `Sample` the receiver takes.
        .expr_body(
            KtCode::new().line("RawSink { raw -> if (raw is Reply.Value) this(raw.sample) }"),
        );

    KtFile::new("io.example.api")
        // FQNs named only from raw body text, which the model cannot see.
        .imports(["io.example.api.internal.JNINative".to_string()])
        .decl(base)
        .decl(describable)
        .decl(handler)
        .decl(session)
        .decl(summary)
        .decl(map_replies)
        .decl(as_raw)
        .decl(KtDecl::TypeAlias {
            vis: KtVis::Public,
            name: "SampleList".to_string(),
            target: KtType::generic("List", [KtType::cls("Sample")]),
        })
}

pub fn kdoc(self, d: impl Into<String>) -> Self

Examples found in repository

examples/showcase.rs (line 190)

fn session_fragment() -> KtFile {
    // `abstract class` with an `abstract` member (bodiless, and it says so),
    // a `@Volatile` property, and an interface it implements.
    let base = KtClass::class_with(KtClassModifier::Abstract, "NativeHandle")
        .vis(KtVis::Public)
        .kdoc("Owns a raw pointer into Rust and frees it exactly once.")
        .ctor_param(KtCtorParam::new("initialPtr", KtType::long()))
        .implements(KtType::cls("AutoCloseable"))
        .member(
            KtProperty::var("ptr")
                .ty(KtType::long())
                .vis(KtVis::Internal)
                .annotation("Volatile")
                .kdoc("Zero once closed.")
                .initializer("initialPtr"),
        )
        .member(
            KtProperty::val("isClosed")
                .ty(KtType::boolean())
                .vis(KtVis::Public)
                .accessors(KtCode::new().line("get() = ptr == 0L")),
        )
        .member(
            KtFun::new("freePtr")
                .vis(KtVis::Public)
                .modifier("abstract")
                .kdoc("Release the native allocation. Called once, under the lock.")
                .param(KtParam::new("ptr", KtType::long())),
        );

    // `open class` extending the abstract base and constructing it.
    let session = KtClass::class_with(KtClassModifier::Open, "Session")
        .vis(KtVis::Public)
        .annotation("Suppress(\"unused\")")
        .ctor_param(KtCtorParam::new("initialPtr", KtType::long()))
        .extends(KtType::cls("NativeHandle"), Some("initialPtr"))
        .implements(KtType::cls("io.example.api.Describable"))
        .member(
            KtFun::new("freePtr")
                .vis(KtVis::Public)
                .modifier("override")
                .param(KtParam::new("ptr", KtType::long()))
                .body(KtCode::new().line("JNINative.sessionFree(ptr)")),
        )
        .member(
            KtFun::new("describe")
                .vis(KtVis::Public)
                .modifier("override")
                .returns(KtType::string())
                .expr_body(KtCode::new().line("\"Session(0x${ptr.toString(16)})\"")),
        )
        // A generic method whose body uses every `KtCode` block form.
        .member(
            KtFun::new("get")
                .vis(KtVis::Public)
                .generic("R")
                .kdoc("Run a query, folding each reply into an accumulator.")
                .param(KtParam::new("selector", KtType::string()))
                .param(KtParam::new(
                    "onReply",
                    KtType::lambda(
                        [("reply".to_string(), KtType::cls("io.example.api.Reply"))],
                        KtType::var_r(),
                    ),
                ))
                .param(KtParam::new("timeoutMs", KtType::long()).default("10_000L"))
                .returns(KtType::generic("List", [KtType::var_r()]))
                .body(
                    KtCode::new()
                        .line("val acc = ArrayList<R>()")
                        .line("val guard = Guard.acquire(this)")
                        .import("io.example.internal.Guard")
                        .try_finally(
                            "",
                            KtCode::new().blk("JNINative.sessionGet(ptr, selector, timeoutMs) { raw ->", |c| {
                                c.line("acc.add(onReply(raw))")
                            }),
                            KtCode::new().line("guard.release()"),
                        )
                        .line("")
                        // A long call that the renderer breaks by width at its
                        // real nesting level.
                        .wline("reportQueryOutcome(selector, timeoutMs, acc.size, acc.isNotEmpty(), \"query finished\", System.nanoTime())")
                        .line("return acc"),
                ),
        )
        // The interface's member extension, implemented.
        .member(
            KtFun::new("label")
                .vis(KtVis::Public)
                .modifier("override")
                .receiver(KtType::cls("Sample"))
                .returns(KtType::string())
                .expr_body(KtCode::new().line("\"${keyExpr}@${describe()}\"")),
        )
        // A member extension of the class itself.
        .member(
            KtFun::new("toSample")
                .vis(KtVis::Public)
                .receiver(KtType::byte_array())
                .returns(KtType::cls("Sample"))
                .expr_body(KtCode::new().line("Sample(describe(), this)")),
        )
        // A nested class — its own scope, so its members may reuse names.
        .member(
            KtClass::class_("Config")
                .vis(KtVis::Public)
                .member(KtProperty::val("describe").initializer("\"config\"")),
        )
        .companion(
            KtCompanion::new()
                .vis(KtVis::Public)
                .member(
                    KtFun::new("open")
                        .vis(KtVis::Public)
                        .annotation("JvmStatic")
                        .param(KtParam::new("config", KtType::string()).default("\"{}\""))
                        .returns(KtType::cls("Session"))
                        .expr_body(KtCode::new().line("Session(JNINative.sessionOpen(config))")),
                ),
        );

    // A plain `interface`: bodiless members are abstract by position, and a
    // `KtFunSig` is exactly that.
    let describable = KtClass::interface_("Describable")
        .vis(KtVis::Public)
        .member(KtFunSig::new("describe").returns(KtType::string()))
        // A member extension: abstract here, supplied by the implementor.
        // `KtFunSig` carries a receiver too, so a signature does not quietly
        // become a plain member.
        .member(
            KtFunSig::new("label")
                .receiver(KtType::cls("Sample"))
                .returns(KtType::string()),
        );

    // A `fun interface` (SAM) — its single method cannot carry a body.
    let handler = KtFunInterface::new(
        "ReplyHandler",
        KtFunSig::new("onReply")
            .param(KtParam::new("reply", KtType::cls("Reply")))
            .returns(KtType::var_r()),
    )
    .vis(KtVis::Public)
    .type_param("out R")
    .kdoc("Invoked from the native thread for each reply.");

    // Top-level extension functions. The receiver is a type, not part of the
    // name, so it resolves through the import set and the name stays a plain
    // identifier the validator can check as one.
    let summary = KtFun::new("summary")
        .vis(KtVis::Public)
        .receiver(KtType::cls("Sample"))
        .returns(KtType::string())
        .expr_body(KtCode::new().line("\"$keyExpr (${payload.size} bytes)\""));

    // Generics render before the receiver, which renders before the name.
    let map_replies = KtFun::new("mapValues")
        .vis(KtVis::Public)
        .generic("R")
        .receiver(KtType::generic("List", [KtType::cls("Reply")]))
        .param(KtParam::new(
            "transform",
            KtType::lambda(
                [("sample".to_string(), KtType::cls("Sample"))],
                KtType::var_r(),
            ),
        ))
        .returns(KtType::generic("List", [KtType::var_r()]))
        .expr_body(
            KtCode::new().line("filterIsInstance<Reply.Value>().map { transform(it.sample) }"),
        );

    // An extension on a *function type*. The receiver needs parentheses here
    // or the `.` would bind to the return type instead.
    let as_raw = KtFun::new("asRaw")
        .vis(KtVis::Internal)
        .receiver(KtType::lambda(
            [("sample".to_string(), KtType::cls("Sample"))],
            KtType::unit(),
        ))
        .returns(KtType::cls("io.example.api.internal.RawSink"))
        // The proxy adapts a typed callback to the raw one the natives call,
        // so it has to narrow `Reply` to the `Sample` the receiver takes.
        .expr_body(
            KtCode::new().line("RawSink { raw -> if (raw is Reply.Value) this(raw.sample) }"),
        );

    KtFile::new("io.example.api")
        // FQNs named only from raw body text, which the model cannot see.
        .imports(["io.example.api.internal.JNINative".to_string()])
        .decl(base)
        .decl(describable)
        .decl(handler)
        .decl(session)
        .decl(summary)
        .decl(map_replies)
        .decl(as_raw)
        .decl(KtDecl::TypeAlias {
            vis: KtVis::Public,
            name: "SampleList".to_string(),
            target: KtType::generic("List", [KtType::cls("Sample")]),
        })
}

pub fn generic(self, g: impl Into<String>) -> Self

Examples found in repository

examples/showcase.rs (line 219)

fn session_fragment() -> KtFile {
    // `abstract class` with an `abstract` member (bodiless, and it says so),
    // a `@Volatile` property, and an interface it implements.
    let base = KtClass::class_with(KtClassModifier::Abstract, "NativeHandle")
        .vis(KtVis::Public)
        .kdoc("Owns a raw pointer into Rust and frees it exactly once.")
        .ctor_param(KtCtorParam::new("initialPtr", KtType::long()))
        .implements(KtType::cls("AutoCloseable"))
        .member(
            KtProperty::var("ptr")
                .ty(KtType::long())
                .vis(KtVis::Internal)
                .annotation("Volatile")
                .kdoc("Zero once closed.")
                .initializer("initialPtr"),
        )
        .member(
            KtProperty::val("isClosed")
                .ty(KtType::boolean())
                .vis(KtVis::Public)
                .accessors(KtCode::new().line("get() = ptr == 0L")),
        )
        .member(
            KtFun::new("freePtr")
                .vis(KtVis::Public)
                .modifier("abstract")
                .kdoc("Release the native allocation. Called once, under the lock.")
                .param(KtParam::new("ptr", KtType::long())),
        );

    // `open class` extending the abstract base and constructing it.
    let session = KtClass::class_with(KtClassModifier::Open, "Session")
        .vis(KtVis::Public)
        .annotation("Suppress(\"unused\")")
        .ctor_param(KtCtorParam::new("initialPtr", KtType::long()))
        .extends(KtType::cls("NativeHandle"), Some("initialPtr"))
        .implements(KtType::cls("io.example.api.Describable"))
        .member(
            KtFun::new("freePtr")
                .vis(KtVis::Public)
                .modifier("override")
                .param(KtParam::new("ptr", KtType::long()))
                .body(KtCode::new().line("JNINative.sessionFree(ptr)")),
        )
        .member(
            KtFun::new("describe")
                .vis(KtVis::Public)
                .modifier("override")
                .returns(KtType::string())
                .expr_body(KtCode::new().line("\"Session(0x${ptr.toString(16)})\"")),
        )
        // A generic method whose body uses every `KtCode` block form.
        .member(
            KtFun::new("get")
                .vis(KtVis::Public)
                .generic("R")
                .kdoc("Run a query, folding each reply into an accumulator.")
                .param(KtParam::new("selector", KtType::string()))
                .param(KtParam::new(
                    "onReply",
                    KtType::lambda(
                        [("reply".to_string(), KtType::cls("io.example.api.Reply"))],
                        KtType::var_r(),
                    ),
                ))
                .param(KtParam::new("timeoutMs", KtType::long()).default("10_000L"))
                .returns(KtType::generic("List", [KtType::var_r()]))
                .body(
                    KtCode::new()
                        .line("val acc = ArrayList<R>()")
                        .line("val guard = Guard.acquire(this)")
                        .import("io.example.internal.Guard")
                        .try_finally(
                            "",
                            KtCode::new().blk("JNINative.sessionGet(ptr, selector, timeoutMs) { raw ->", |c| {
                                c.line("acc.add(onReply(raw))")
                            }),
                            KtCode::new().line("guard.release()"),
                        )
                        .line("")
                        // A long call that the renderer breaks by width at its
                        // real nesting level.
                        .wline("reportQueryOutcome(selector, timeoutMs, acc.size, acc.isNotEmpty(), \"query finished\", System.nanoTime())")
                        .line("return acc"),
                ),
        )
        // The interface's member extension, implemented.
        .member(
            KtFun::new("label")
                .vis(KtVis::Public)
                .modifier("override")
                .receiver(KtType::cls("Sample"))
                .returns(KtType::string())
                .expr_body(KtCode::new().line("\"${keyExpr}@${describe()}\"")),
        )
        // A member extension of the class itself.
        .member(
            KtFun::new("toSample")
                .vis(KtVis::Public)
                .receiver(KtType::byte_array())
                .returns(KtType::cls("Sample"))
                .expr_body(KtCode::new().line("Sample(describe(), this)")),
        )
        // A nested class — its own scope, so its members may reuse names.
        .member(
            KtClass::class_("Config")
                .vis(KtVis::Public)
                .member(KtProperty::val("describe").initializer("\"config\"")),
        )
        .companion(
            KtCompanion::new()
                .vis(KtVis::Public)
                .member(
                    KtFun::new("open")
                        .vis(KtVis::Public)
                        .annotation("JvmStatic")
                        .param(KtParam::new("config", KtType::string()).default("\"{}\""))
                        .returns(KtType::cls("Session"))
                        .expr_body(KtCode::new().line("Session(JNINative.sessionOpen(config))")),
                ),
        );

    // A plain `interface`: bodiless members are abstract by position, and a
    // `KtFunSig` is exactly that.
    let describable = KtClass::interface_("Describable")
        .vis(KtVis::Public)
        .member(KtFunSig::new("describe").returns(KtType::string()))
        // A member extension: abstract here, supplied by the implementor.
        // `KtFunSig` carries a receiver too, so a signature does not quietly
        // become a plain member.
        .member(
            KtFunSig::new("label")
                .receiver(KtType::cls("Sample"))
                .returns(KtType::string()),
        );

    // A `fun interface` (SAM) — its single method cannot carry a body.
    let handler = KtFunInterface::new(
        "ReplyHandler",
        KtFunSig::new("onReply")
            .param(KtParam::new("reply", KtType::cls("Reply")))
            .returns(KtType::var_r()),
    )
    .vis(KtVis::Public)
    .type_param("out R")
    .kdoc("Invoked from the native thread for each reply.");

    // Top-level extension functions. The receiver is a type, not part of the
    // name, so it resolves through the import set and the name stays a plain
    // identifier the validator can check as one.
    let summary = KtFun::new("summary")
        .vis(KtVis::Public)
        .receiver(KtType::cls("Sample"))
        .returns(KtType::string())
        .expr_body(KtCode::new().line("\"$keyExpr (${payload.size} bytes)\""));

    // Generics render before the receiver, which renders before the name.
    let map_replies = KtFun::new("mapValues")
        .vis(KtVis::Public)
        .generic("R")
        .receiver(KtType::generic("List", [KtType::cls("Reply")]))
        .param(KtParam::new(
            "transform",
            KtType::lambda(
                [("sample".to_string(), KtType::cls("Sample"))],
                KtType::var_r(),
            ),
        ))
        .returns(KtType::generic("List", [KtType::var_r()]))
        .expr_body(
            KtCode::new().line("filterIsInstance<Reply.Value>().map { transform(it.sample) }"),
        );

    // An extension on a *function type*. The receiver needs parentheses here
    // or the `.` would bind to the return type instead.
    let as_raw = KtFun::new("asRaw")
        .vis(KtVis::Internal)
        .receiver(KtType::lambda(
            [("sample".to_string(), KtType::cls("Sample"))],
            KtType::unit(),
        ))
        .returns(KtType::cls("io.example.api.internal.RawSink"))
        // The proxy adapts a typed callback to the raw one the natives call,
        // so it has to narrow `Reply` to the `Sample` the receiver takes.
        .expr_body(
            KtCode::new().line("RawSink { raw -> if (raw is Reply.Value) this(raw.sample) }"),
        );

    KtFile::new("io.example.api")
        // FQNs named only from raw body text, which the model cannot see.
        .imports(["io.example.api.internal.JNINative".to_string()])
        .decl(base)
        .decl(describable)
        .decl(handler)
        .decl(session)
        .decl(summary)
        .decl(map_replies)
        .decl(as_raw)
        .decl(KtDecl::TypeAlias {
            vis: KtVis::Public,
            name: "SampleList".to_string(),
            target: KtType::generic("List", [KtType::cls("Sample")]),
        })
}

/// The `external` surface — an object of natives, in its own subpackage.
fn natives_fragment() -> KtFile {
    let natives = KtClass::object_("JNINative")
        .vis(KtVis::Internal)
        .kdoc("One-to-one with the exported Rust symbols.")
        .member(
            KtFun::new("sessionOpen")
                .vis(KtVis::Internal)
                .param(KtParam::new("config", KtType::string()))
                .returns(KtType::long())
                .external(),
        )
        .member(
            KtFun::new("sessionFree")
                .vis(KtVis::Internal)
                .param(KtParam::new("ptr", KtType::long()))
                .external(),
        )
        .member(
            KtFun::new("sessionGet")
                .vis(KtVis::Internal)
                .param(KtParam::new("ptr", KtType::long()))
                .param(KtParam::new("selector", KtType::string()))
                .param(KtParam::new("timeoutMs", KtType::long()))
                .param(KtParam::new(
                    "sink",
                    KtType::lambda(
                        [("reply".to_string(), KtType::cls("io.example.api.Reply"))],
                        KtType::unit(),
                    ),
                ))
                .external(),
        );

    // A pre-rendered block, for text the model does not describe. Its name is
    // a merge identity, never emitted.
    let loader = KtDecl::Raw {
        name: "__loadNative".to_string(),
        code: KtCode::raw_reindent(
            "internal val __loaded: Boolean = run {\n\
             System.loadLibrary(\"example_jni\")\n\
             true\n\
             }",
        ),
    };

    let raw_sink = KtFunInterface::new(
        "RawSink",
        KtFunSig::new("accept").param(KtParam::new("reply", KtType::cls("io.example.api.Reply"))),
    )
    .vis(KtVis::Internal);

    KtFile::new("io.example.api.internal")
        .decl(raw_sink)
        .decl(natives)
        .decl(loader)
        // An FQN referenced only from raw text the model cannot see.
        .import("io.example.api.Reply")
}

/// A file in the default (root) package, exercising a banner override and
/// top-level declarations of every value kind.
fn root_fragment() -> KtFile {
    KtFile::new("")
        .banner("// Hand-tuned banner for the root package.")
        .decl(
            KtProperty::val("LIBRARY_VERSION")
                .ty(KtType::string())
                .vis(KtVis::Public)
                .kdoc("Version this binding was generated against.")
                .initializer("\"1.9.0\""),
        )
        // A keyword modifier rendered between visibility and `val`.
        .decl(
            KtProperty::val("PROTOCOL")
                .ty(KtType::string())
                .vis(KtVis::Public)
                .modifier("const")
                .initializer("\"tcp\""),
        )
        // A delegated property: `by <expr>` rather than `= <expr>`.
        .decl(
            KtProperty::val("defaultTimeout")
                .vis(KtVis::Internal)
                .ty(KtType::cls("java.time.Duration"))
                .delegate("lazy { Duration.ofSeconds(10) }"),
        )
        .decl(
            KtFun::new("describeAll")
                .vis(KtVis::Public)
                // Generic parameter lists are free-form text, so a bound is
                // written as given — it is not shortened against the imports.
                .generic("T : io.example.api.Describable")
                .param(KtParam::new(
                    "items",
                    KtType::generic("List", [KtType::var_("T")]),
                ))
                .returns(KtType::string())
                .expr_body(KtCode::new().line("items.joinToString { it.describe() }")),
        )
}

pub fn param(self, p: KtParam) -> Self

Examples found in repository

examples/showcase.rs (line 83)

fn types_fragment() -> KtFile {
    // `enum class` with a primary constructor its entries call, plus a named
    // companion object holding a factory.
    let priority = KtClass::enum_("Priority")
        .vis(KtVis::Public)
        .kdoc("Delivery priority.\n\nMirrors the native `z_priority_t`.")
        .ctor_param(
            KtCtorParam::new("code", KtType::int())
                .val()
                .vis(KtVis::Public),
        )
        .entry(KtEnumEntry::with_args("REAL_TIME", "1"))
        .entry(KtEnumEntry::with_args("INTERACTIVE", "4"))
        .entry(KtEnumEntry::with_args("DATA", "5"))
        .companion(
            KtCompanion::named("Codes")
                .vis(KtVis::Public)
                .kdoc("Lookup helpers keyed by the native code.")
                .member(
                    KtFun::new("fromInt")
                        .vis(KtVis::Public)
                        .annotation("JvmStatic")
                        .param(KtParam::new("value", KtType::int()))
                        .returns(KtType::cls("Priority"))
                        .body(
                            KtCode::new()
                                .blk("return when (value) {", |c| {
                                    c.line("1 -> REAL_TIME")
                                        .line("4 -> INTERACTIVE")
                                        .line("5 -> DATA")
                                        .line("else -> throw IllegalArgumentException(\"bad priority: $value\")")
                                }),
                        ),
                ),
        );

    // `@JvmInline value class` — exactly one read-only property.
    let zid = KtClass::value(
        "ZenohId",
        KtCtorParam::new("bytes", KtType::byte_array())
            .val()
            .vis(KtVis::Public),
    )
    .vis(KtVis::Public)
    .kdoc("A 16-byte peer identifier, carried by value.");

    // `data class` — every constructor parameter is a property.
    let sample = KtClass::data(
        "Sample",
        KtCtorParam::new("keyExpr", KtType::string())
            .val()
            .vis(KtVis::Public),
    )
    .vis(KtVis::Public)
    .ctor_param(
        KtCtorParam::new("payload", KtType::byte_array())
            .val()
            .vis(KtVis::Public),
    )
    .ctor_param(
        KtCtorParam::new("priority", KtType::cls("Priority"))
            .val()
            .vis(KtVis::Public)
            .default("Priority.DATA"),
    )
    .ctor_param(
        KtCtorParam::new("attachment", KtType::byte_array().nullable())
            .var()
            .vis(KtVis::Public)
            .annotation("JvmField")
            .default("null"),
    );

    // A `sealed interface` whose alternatives nest inside it: a `data class`
    // with a payload and a `data object` without one.
    let reply = KtClass::sealed_interface("Reply")
        .vis(KtVis::Public)
        .kdoc("Either a sample or the end of the stream.")
        .member(
            KtClass::data(
                "Value",
                KtCtorParam::new("sample", KtType::cls("Sample"))
                    .val()
                    .vis(KtVis::Public),
            )
            .vis(KtVis::Public)
            .implements(KtType::cls("Reply")),
        )
        .member(
            KtClass::data_object("Done")
                .vis(KtVis::Public)
                .implements(KtType::cls("Reply")),
        );

    KtFile::new("io.example.api")
        .decl(priority)
        .decl(zid)
        .decl(sample)
        .decl(reply)
}

/// The handle surface: an abstract base, a concrete subclass, an interface,
/// a `fun interface`, and a type alias.
fn session_fragment() -> KtFile {
    // `abstract class` with an `abstract` member (bodiless, and it says so),
    // a `@Volatile` property, and an interface it implements.
    let base = KtClass::class_with(KtClassModifier::Abstract, "NativeHandle")
        .vis(KtVis::Public)
        .kdoc("Owns a raw pointer into Rust and frees it exactly once.")
        .ctor_param(KtCtorParam::new("initialPtr", KtType::long()))
        .implements(KtType::cls("AutoCloseable"))
        .member(
            KtProperty::var("ptr")
                .ty(KtType::long())
                .vis(KtVis::Internal)
                .annotation("Volatile")
                .kdoc("Zero once closed.")
                .initializer("initialPtr"),
        )
        .member(
            KtProperty::val("isClosed")
                .ty(KtType::boolean())
                .vis(KtVis::Public)
                .accessors(KtCode::new().line("get() = ptr == 0L")),
        )
        .member(
            KtFun::new("freePtr")
                .vis(KtVis::Public)
                .modifier("abstract")
                .kdoc("Release the native allocation. Called once, under the lock.")
                .param(KtParam::new("ptr", KtType::long())),
        );

    // `open class` extending the abstract base and constructing it.
    let session = KtClass::class_with(KtClassModifier::Open, "Session")
        .vis(KtVis::Public)
        .annotation("Suppress(\"unused\")")
        .ctor_param(KtCtorParam::new("initialPtr", KtType::long()))
        .extends(KtType::cls("NativeHandle"), Some("initialPtr"))
        .implements(KtType::cls("io.example.api.Describable"))
        .member(
            KtFun::new("freePtr")
                .vis(KtVis::Public)
                .modifier("override")
                .param(KtParam::new("ptr", KtType::long()))
                .body(KtCode::new().line("JNINative.sessionFree(ptr)")),
        )
        .member(
            KtFun::new("describe")
                .vis(KtVis::Public)
                .modifier("override")
                .returns(KtType::string())
                .expr_body(KtCode::new().line("\"Session(0x${ptr.toString(16)})\"")),
        )
        // A generic method whose body uses every `KtCode` block form.
        .member(
            KtFun::new("get")
                .vis(KtVis::Public)
                .generic("R")
                .kdoc("Run a query, folding each reply into an accumulator.")
                .param(KtParam::new("selector", KtType::string()))
                .param(KtParam::new(
                    "onReply",
                    KtType::lambda(
                        [("reply".to_string(), KtType::cls("io.example.api.Reply"))],
                        KtType::var_r(),
                    ),
                ))
                .param(KtParam::new("timeoutMs", KtType::long()).default("10_000L"))
                .returns(KtType::generic("List", [KtType::var_r()]))
                .body(
                    KtCode::new()
                        .line("val acc = ArrayList<R>()")
                        .line("val guard = Guard.acquire(this)")
                        .import("io.example.internal.Guard")
                        .try_finally(
                            "",
                            KtCode::new().blk("JNINative.sessionGet(ptr, selector, timeoutMs) { raw ->", |c| {
                                c.line("acc.add(onReply(raw))")
                            }),
                            KtCode::new().line("guard.release()"),
                        )
                        .line("")
                        // A long call that the renderer breaks by width at its
                        // real nesting level.
                        .wline("reportQueryOutcome(selector, timeoutMs, acc.size, acc.isNotEmpty(), \"query finished\", System.nanoTime())")
                        .line("return acc"),
                ),
        )
        // The interface's member extension, implemented.
        .member(
            KtFun::new("label")
                .vis(KtVis::Public)
                .modifier("override")
                .receiver(KtType::cls("Sample"))
                .returns(KtType::string())
                .expr_body(KtCode::new().line("\"${keyExpr}@${describe()}\"")),
        )
        // A member extension of the class itself.
        .member(
            KtFun::new("toSample")
                .vis(KtVis::Public)
                .receiver(KtType::byte_array())
                .returns(KtType::cls("Sample"))
                .expr_body(KtCode::new().line("Sample(describe(), this)")),
        )
        // A nested class — its own scope, so its members may reuse names.
        .member(
            KtClass::class_("Config")
                .vis(KtVis::Public)
                .member(KtProperty::val("describe").initializer("\"config\"")),
        )
        .companion(
            KtCompanion::new()
                .vis(KtVis::Public)
                .member(
                    KtFun::new("open")
                        .vis(KtVis::Public)
                        .annotation("JvmStatic")
                        .param(KtParam::new("config", KtType::string()).default("\"{}\""))
                        .returns(KtType::cls("Session"))
                        .expr_body(KtCode::new().line("Session(JNINative.sessionOpen(config))")),
                ),
        );

    // A plain `interface`: bodiless members are abstract by position, and a
    // `KtFunSig` is exactly that.
    let describable = KtClass::interface_("Describable")
        .vis(KtVis::Public)
        .member(KtFunSig::new("describe").returns(KtType::string()))
        // A member extension: abstract here, supplied by the implementor.
        // `KtFunSig` carries a receiver too, so a signature does not quietly
        // become a plain member.
        .member(
            KtFunSig::new("label")
                .receiver(KtType::cls("Sample"))
                .returns(KtType::string()),
        );

    // A `fun interface` (SAM) — its single method cannot carry a body.
    let handler = KtFunInterface::new(
        "ReplyHandler",
        KtFunSig::new("onReply")
            .param(KtParam::new("reply", KtType::cls("Reply")))
            .returns(KtType::var_r()),
    )
    .vis(KtVis::Public)
    .type_param("out R")
    .kdoc("Invoked from the native thread for each reply.");

    // Top-level extension functions. The receiver is a type, not part of the
    // name, so it resolves through the import set and the name stays a plain
    // identifier the validator can check as one.
    let summary = KtFun::new("summary")
        .vis(KtVis::Public)
        .receiver(KtType::cls("Sample"))
        .returns(KtType::string())
        .expr_body(KtCode::new().line("\"$keyExpr (${payload.size} bytes)\""));

    // Generics render before the receiver, which renders before the name.
    let map_replies = KtFun::new("mapValues")
        .vis(KtVis::Public)
        .generic("R")
        .receiver(KtType::generic("List", [KtType::cls("Reply")]))
        .param(KtParam::new(
            "transform",
            KtType::lambda(
                [("sample".to_string(), KtType::cls("Sample"))],
                KtType::var_r(),
            ),
        ))
        .returns(KtType::generic("List", [KtType::var_r()]))
        .expr_body(
            KtCode::new().line("filterIsInstance<Reply.Value>().map { transform(it.sample) }"),
        );

    // An extension on a *function type*. The receiver needs parentheses here
    // or the `.` would bind to the return type instead.
    let as_raw = KtFun::new("asRaw")
        .vis(KtVis::Internal)
        .receiver(KtType::lambda(
            [("sample".to_string(), KtType::cls("Sample"))],
            KtType::unit(),
        ))
        .returns(KtType::cls("io.example.api.internal.RawSink"))
        // The proxy adapts a typed callback to the raw one the natives call,
        // so it has to narrow `Reply` to the `Sample` the receiver takes.
        .expr_body(
            KtCode::new().line("RawSink { raw -> if (raw is Reply.Value) this(raw.sample) }"),
        );

    KtFile::new("io.example.api")
        // FQNs named only from raw body text, which the model cannot see.
        .imports(["io.example.api.internal.JNINative".to_string()])
        .decl(base)
        .decl(describable)
        .decl(handler)
        .decl(session)
        .decl(summary)
        .decl(map_replies)
        .decl(as_raw)
        .decl(KtDecl::TypeAlias {
            vis: KtVis::Public,
            name: "SampleList".to_string(),
            target: KtType::generic("List", [KtType::cls("Sample")]),
        })
}

/// The `external` surface — an object of natives, in its own subpackage.
fn natives_fragment() -> KtFile {
    let natives = KtClass::object_("JNINative")
        .vis(KtVis::Internal)
        .kdoc("One-to-one with the exported Rust symbols.")
        .member(
            KtFun::new("sessionOpen")
                .vis(KtVis::Internal)
                .param(KtParam::new("config", KtType::string()))
                .returns(KtType::long())
                .external(),
        )
        .member(
            KtFun::new("sessionFree")
                .vis(KtVis::Internal)
                .param(KtParam::new("ptr", KtType::long()))
                .external(),
        )
        .member(
            KtFun::new("sessionGet")
                .vis(KtVis::Internal)
                .param(KtParam::new("ptr", KtType::long()))
                .param(KtParam::new("selector", KtType::string()))
                .param(KtParam::new("timeoutMs", KtType::long()))
                .param(KtParam::new(
                    "sink",
                    KtType::lambda(
                        [("reply".to_string(), KtType::cls("io.example.api.Reply"))],
                        KtType::unit(),
                    ),
                ))
                .external(),
        );

    // A pre-rendered block, for text the model does not describe. Its name is
    // a merge identity, never emitted.
    let loader = KtDecl::Raw {
        name: "__loadNative".to_string(),
        code: KtCode::raw_reindent(
            "internal val __loaded: Boolean = run {\n\
             System.loadLibrary(\"example_jni\")\n\
             true\n\
             }",
        ),
    };

    let raw_sink = KtFunInterface::new(
        "RawSink",
        KtFunSig::new("accept").param(KtParam::new("reply", KtType::cls("io.example.api.Reply"))),
    )
    .vis(KtVis::Internal);

    KtFile::new("io.example.api.internal")
        .decl(raw_sink)
        .decl(natives)
        .decl(loader)
        // An FQN referenced only from raw text the model cannot see.
        .import("io.example.api.Reply")
}

/// A file in the default (root) package, exercising a banner override and
/// top-level declarations of every value kind.
fn root_fragment() -> KtFile {
    KtFile::new("")
        .banner("// Hand-tuned banner for the root package.")
        .decl(
            KtProperty::val("LIBRARY_VERSION")
                .ty(KtType::string())
                .vis(KtVis::Public)
                .kdoc("Version this binding was generated against.")
                .initializer("\"1.9.0\""),
        )
        // A keyword modifier rendered between visibility and `val`.
        .decl(
            KtProperty::val("PROTOCOL")
                .ty(KtType::string())
                .vis(KtVis::Public)
                .modifier("const")
                .initializer("\"tcp\""),
        )
        // A delegated property: `by <expr>` rather than `= <expr>`.
        .decl(
            KtProperty::val("defaultTimeout")
                .vis(KtVis::Internal)
                .ty(KtType::cls("java.time.Duration"))
                .delegate("lazy { Duration.ofSeconds(10) }"),
        )
        .decl(
            KtFun::new("describeAll")
                .vis(KtVis::Public)
                // Generic parameter lists are free-form text, so a bound is
                // written as given — it is not shortened against the imports.
                .generic("T : io.example.api.Describable")
                .param(KtParam::new(
                    "items",
                    KtType::generic("List", [KtType::var_("T")]),
                ))
                .returns(KtType::string())
                .expr_body(KtCode::new().line("items.joinToString { it.describe() }")),
        )
}

examples/invalid.rs (line 89)

fn broken_declarations() -> KtFile {
    KtFile::new("io.example.broken")
        // Two classes of the same name: a redeclaration in the type namespace.
        .decl(KtClass::class_("Session"))
        .decl(KtClass::class_("Session"))
        // An interface and a type alias are both classifier declarations, so they collide.
        .decl(
            KtClass::interface_("Describable")
                .member(KtFun::new("describe").returns(KtType::string())),
        )
        .decl(KtDecl::TypeAlias {
            vis: KtVis::Public,
            name: "Describable".to_string(),
            target: KtType::string(),
        })
        // Same name AND same parameter types: not an overload.
        .decl(
            KtFun::new("send")
                .param(KtParam::new("value", KtType::int()))
                .returns(KtType::boolean())
                .body(KtCode::new()),
        )
        .decl(
            KtFun::new("send")
                .param(KtParam::new("other", KtType::int()))
                .returns(KtType::long())
                .body(KtCode::new()),
        )
        // Extensions are keyed on their receiver, so these two collide while
        // the same pair on different receivers would not.
        .decl(
            KtFun::new("asRaw")
                .receiver(KtType::cls("io.example.Codec"))
                .body(KtCode::new()),
        )
        .decl(
            KtFun::new("asRaw")
                .receiver(KtType::cls("io.example.Codec"))
                .body(KtCode::new()),
        )
        // ...as here: same name, different receiver, no diagnostic.
        .decl(
            KtFun::new("asRaw")
                .receiver(KtType::cls("io.example.Other"))
                .body(KtCode::new()),
        )
        // Names that are not legal Kotlin identifiers.
        .decl(
            KtClass::class_("My-Class")
                .ctor_param(KtCtorParam::new("2fast", KtType::int()))
                .member(
                    KtFun::new("object")
                        .param(KtParam::new("in", KtType::int()))
                        .body(KtCode::new()),
                ),
        )
        // `val x` with no type, no value and no accessors.
        .decl(KtProperty::val("bare"))
        // A function with no body, at top level, where that cannot mean
        // "abstract".
        .decl(KtFun::new("nobody"))
        // An abstract class member missing the `abstract` keyword.
        .decl(
            KtClass::class_with(KtClassModifier::Abstract, "Base")
                .member(KtFun::new("unimplemented")),
        )
        // An enum whose entries do not call the constructor it declares.
        .decl(
            KtClass::enum_("Priority")
                .ctor_param(KtCtorParam::new("code", KtType::int()).val())
                .entry(KtEnumEntry::with_args("HIGH", "1"))
                .entry(KtEnumEntry::new("LOW")),
        )
        // A constructor property and a member property of one name: both live
        // in the value namespace.
        .decl(
            KtClass::class_("Holder")
                .ctor_param(KtCtorParam::new("id", KtType::long()).val())
                .member(KtProperty::val("id").initializer("0")),
        )
        // A named companion object colliding with a nested class.
        .decl(
            KtClass::class_("Outer")
                .member(KtClass::class_("Factory"))
                .companion(KtCompanion::named("Factory")),
        )
        // Two raw blocks claiming one identity with different bodies.
        .decl(KtDecl::Raw {
            name: "__loader".to_string(),
            code: KtCode::new().line("internal val __loader = 1"),
        })
        .decl(KtDecl::Raw {
            name: "__loader".to_string(),
            code: KtCode::new().line("internal val __loader = 2"),
        })
        // Two different classes referenced from raw text under one short name:
        // the text already says `Codec`, so it cannot mean both.
        .import("io.example.a.Codec")
        .import("io.example.b.Codec")
}

pub fn returns(self, ty: KtType) -> Self

Examples found in repository

examples/showcase.rs (line 84)

fn types_fragment() -> KtFile {
    // `enum class` with a primary constructor its entries call, plus a named
    // companion object holding a factory.
    let priority = KtClass::enum_("Priority")
        .vis(KtVis::Public)
        .kdoc("Delivery priority.\n\nMirrors the native `z_priority_t`.")
        .ctor_param(
            KtCtorParam::new("code", KtType::int())
                .val()
                .vis(KtVis::Public),
        )
        .entry(KtEnumEntry::with_args("REAL_TIME", "1"))
        .entry(KtEnumEntry::with_args("INTERACTIVE", "4"))
        .entry(KtEnumEntry::with_args("DATA", "5"))
        .companion(
            KtCompanion::named("Codes")
                .vis(KtVis::Public)
                .kdoc("Lookup helpers keyed by the native code.")
                .member(
                    KtFun::new("fromInt")
                        .vis(KtVis::Public)
                        .annotation("JvmStatic")
                        .param(KtParam::new("value", KtType::int()))
                        .returns(KtType::cls("Priority"))
                        .body(
                            KtCode::new()
                                .blk("return when (value) {", |c| {
                                    c.line("1 -> REAL_TIME")
                                        .line("4 -> INTERACTIVE")
                                        .line("5 -> DATA")
                                        .line("else -> throw IllegalArgumentException(\"bad priority: $value\")")
                                }),
                        ),
                ),
        );

    // `@JvmInline value class` — exactly one read-only property.
    let zid = KtClass::value(
        "ZenohId",
        KtCtorParam::new("bytes", KtType::byte_array())
            .val()
            .vis(KtVis::Public),
    )
    .vis(KtVis::Public)
    .kdoc("A 16-byte peer identifier, carried by value.");

    // `data class` — every constructor parameter is a property.
    let sample = KtClass::data(
        "Sample",
        KtCtorParam::new("keyExpr", KtType::string())
            .val()
            .vis(KtVis::Public),
    )
    .vis(KtVis::Public)
    .ctor_param(
        KtCtorParam::new("payload", KtType::byte_array())
            .val()
            .vis(KtVis::Public),
    )
    .ctor_param(
        KtCtorParam::new("priority", KtType::cls("Priority"))
            .val()
            .vis(KtVis::Public)
            .default("Priority.DATA"),
    )
    .ctor_param(
        KtCtorParam::new("attachment", KtType::byte_array().nullable())
            .var()
            .vis(KtVis::Public)
            .annotation("JvmField")
            .default("null"),
    );

    // A `sealed interface` whose alternatives nest inside it: a `data class`
    // with a payload and a `data object` without one.
    let reply = KtClass::sealed_interface("Reply")
        .vis(KtVis::Public)
        .kdoc("Either a sample or the end of the stream.")
        .member(
            KtClass::data(
                "Value",
                KtCtorParam::new("sample", KtType::cls("Sample"))
                    .val()
                    .vis(KtVis::Public),
            )
            .vis(KtVis::Public)
            .implements(KtType::cls("Reply")),
        )
        .member(
            KtClass::data_object("Done")
                .vis(KtVis::Public)
                .implements(KtType::cls("Reply")),
        );

    KtFile::new("io.example.api")
        .decl(priority)
        .decl(zid)
        .decl(sample)
        .decl(reply)
}

/// The handle surface: an abstract base, a concrete subclass, an interface,
/// a `fun interface`, and a type alias.
fn session_fragment() -> KtFile {
    // `abstract class` with an `abstract` member (bodiless, and it says so),
    // a `@Volatile` property, and an interface it implements.
    let base = KtClass::class_with(KtClassModifier::Abstract, "NativeHandle")
        .vis(KtVis::Public)
        .kdoc("Owns a raw pointer into Rust and frees it exactly once.")
        .ctor_param(KtCtorParam::new("initialPtr", KtType::long()))
        .implements(KtType::cls("AutoCloseable"))
        .member(
            KtProperty::var("ptr")
                .ty(KtType::long())
                .vis(KtVis::Internal)
                .annotation("Volatile")
                .kdoc("Zero once closed.")
                .initializer("initialPtr"),
        )
        .member(
            KtProperty::val("isClosed")
                .ty(KtType::boolean())
                .vis(KtVis::Public)
                .accessors(KtCode::new().line("get() = ptr == 0L")),
        )
        .member(
            KtFun::new("freePtr")
                .vis(KtVis::Public)
                .modifier("abstract")
                .kdoc("Release the native allocation. Called once, under the lock.")
                .param(KtParam::new("ptr", KtType::long())),
        );

    // `open class` extending the abstract base and constructing it.
    let session = KtClass::class_with(KtClassModifier::Open, "Session")
        .vis(KtVis::Public)
        .annotation("Suppress(\"unused\")")
        .ctor_param(KtCtorParam::new("initialPtr", KtType::long()))
        .extends(KtType::cls("NativeHandle"), Some("initialPtr"))
        .implements(KtType::cls("io.example.api.Describable"))
        .member(
            KtFun::new("freePtr")
                .vis(KtVis::Public)
                .modifier("override")
                .param(KtParam::new("ptr", KtType::long()))
                .body(KtCode::new().line("JNINative.sessionFree(ptr)")),
        )
        .member(
            KtFun::new("describe")
                .vis(KtVis::Public)
                .modifier("override")
                .returns(KtType::string())
                .expr_body(KtCode::new().line("\"Session(0x${ptr.toString(16)})\"")),
        )
        // A generic method whose body uses every `KtCode` block form.
        .member(
            KtFun::new("get")
                .vis(KtVis::Public)
                .generic("R")
                .kdoc("Run a query, folding each reply into an accumulator.")
                .param(KtParam::new("selector", KtType::string()))
                .param(KtParam::new(
                    "onReply",
                    KtType::lambda(
                        [("reply".to_string(), KtType::cls("io.example.api.Reply"))],
                        KtType::var_r(),
                    ),
                ))
                .param(KtParam::new("timeoutMs", KtType::long()).default("10_000L"))
                .returns(KtType::generic("List", [KtType::var_r()]))
                .body(
                    KtCode::new()
                        .line("val acc = ArrayList<R>()")
                        .line("val guard = Guard.acquire(this)")
                        .import("io.example.internal.Guard")
                        .try_finally(
                            "",
                            KtCode::new().blk("JNINative.sessionGet(ptr, selector, timeoutMs) { raw ->", |c| {
                                c.line("acc.add(onReply(raw))")
                            }),
                            KtCode::new().line("guard.release()"),
                        )
                        .line("")
                        // A long call that the renderer breaks by width at its
                        // real nesting level.
                        .wline("reportQueryOutcome(selector, timeoutMs, acc.size, acc.isNotEmpty(), \"query finished\", System.nanoTime())")
                        .line("return acc"),
                ),
        )
        // The interface's member extension, implemented.
        .member(
            KtFun::new("label")
                .vis(KtVis::Public)
                .modifier("override")
                .receiver(KtType::cls("Sample"))
                .returns(KtType::string())
                .expr_body(KtCode::new().line("\"${keyExpr}@${describe()}\"")),
        )
        // A member extension of the class itself.
        .member(
            KtFun::new("toSample")
                .vis(KtVis::Public)
                .receiver(KtType::byte_array())
                .returns(KtType::cls("Sample"))
                .expr_body(KtCode::new().line("Sample(describe(), this)")),
        )
        // A nested class — its own scope, so its members may reuse names.
        .member(
            KtClass::class_("Config")
                .vis(KtVis::Public)
                .member(KtProperty::val("describe").initializer("\"config\"")),
        )
        .companion(
            KtCompanion::new()
                .vis(KtVis::Public)
                .member(
                    KtFun::new("open")
                        .vis(KtVis::Public)
                        .annotation("JvmStatic")
                        .param(KtParam::new("config", KtType::string()).default("\"{}\""))
                        .returns(KtType::cls("Session"))
                        .expr_body(KtCode::new().line("Session(JNINative.sessionOpen(config))")),
                ),
        );

    // A plain `interface`: bodiless members are abstract by position, and a
    // `KtFunSig` is exactly that.
    let describable = KtClass::interface_("Describable")
        .vis(KtVis::Public)
        .member(KtFunSig::new("describe").returns(KtType::string()))
        // A member extension: abstract here, supplied by the implementor.
        // `KtFunSig` carries a receiver too, so a signature does not quietly
        // become a plain member.
        .member(
            KtFunSig::new("label")
                .receiver(KtType::cls("Sample"))
                .returns(KtType::string()),
        );

    // A `fun interface` (SAM) — its single method cannot carry a body.
    let handler = KtFunInterface::new(
        "ReplyHandler",
        KtFunSig::new("onReply")
            .param(KtParam::new("reply", KtType::cls("Reply")))
            .returns(KtType::var_r()),
    )
    .vis(KtVis::Public)
    .type_param("out R")
    .kdoc("Invoked from the native thread for each reply.");

    // Top-level extension functions. The receiver is a type, not part of the
    // name, so it resolves through the import set and the name stays a plain
    // identifier the validator can check as one.
    let summary = KtFun::new("summary")
        .vis(KtVis::Public)
        .receiver(KtType::cls("Sample"))
        .returns(KtType::string())
        .expr_body(KtCode::new().line("\"$keyExpr (${payload.size} bytes)\""));

    // Generics render before the receiver, which renders before the name.
    let map_replies = KtFun::new("mapValues")
        .vis(KtVis::Public)
        .generic("R")
        .receiver(KtType::generic("List", [KtType::cls("Reply")]))
        .param(KtParam::new(
            "transform",
            KtType::lambda(
                [("sample".to_string(), KtType::cls("Sample"))],
                KtType::var_r(),
            ),
        ))
        .returns(KtType::generic("List", [KtType::var_r()]))
        .expr_body(
            KtCode::new().line("filterIsInstance<Reply.Value>().map { transform(it.sample) }"),
        );

    // An extension on a *function type*. The receiver needs parentheses here
    // or the `.` would bind to the return type instead.
    let as_raw = KtFun::new("asRaw")
        .vis(KtVis::Internal)
        .receiver(KtType::lambda(
            [("sample".to_string(), KtType::cls("Sample"))],
            KtType::unit(),
        ))
        .returns(KtType::cls("io.example.api.internal.RawSink"))
        // The proxy adapts a typed callback to the raw one the natives call,
        // so it has to narrow `Reply` to the `Sample` the receiver takes.
        .expr_body(
            KtCode::new().line("RawSink { raw -> if (raw is Reply.Value) this(raw.sample) }"),
        );

    KtFile::new("io.example.api")
        // FQNs named only from raw body text, which the model cannot see.
        .imports(["io.example.api.internal.JNINative".to_string()])
        .decl(base)
        .decl(describable)
        .decl(handler)
        .decl(session)
        .decl(summary)
        .decl(map_replies)
        .decl(as_raw)
        .decl(KtDecl::TypeAlias {
            vis: KtVis::Public,
            name: "SampleList".to_string(),
            target: KtType::generic("List", [KtType::cls("Sample")]),
        })
}

/// The `external` surface — an object of natives, in its own subpackage.
fn natives_fragment() -> KtFile {
    let natives = KtClass::object_("JNINative")
        .vis(KtVis::Internal)
        .kdoc("One-to-one with the exported Rust symbols.")
        .member(
            KtFun::new("sessionOpen")
                .vis(KtVis::Internal)
                .param(KtParam::new("config", KtType::string()))
                .returns(KtType::long())
                .external(),
        )
        .member(
            KtFun::new("sessionFree")
                .vis(KtVis::Internal)
                .param(KtParam::new("ptr", KtType::long()))
                .external(),
        )
        .member(
            KtFun::new("sessionGet")
                .vis(KtVis::Internal)
                .param(KtParam::new("ptr", KtType::long()))
                .param(KtParam::new("selector", KtType::string()))
                .param(KtParam::new("timeoutMs", KtType::long()))
                .param(KtParam::new(
                    "sink",
                    KtType::lambda(
                        [("reply".to_string(), KtType::cls("io.example.api.Reply"))],
                        KtType::unit(),
                    ),
                ))
                .external(),
        );

    // A pre-rendered block, for text the model does not describe. Its name is
    // a merge identity, never emitted.
    let loader = KtDecl::Raw {
        name: "__loadNative".to_string(),
        code: KtCode::raw_reindent(
            "internal val __loaded: Boolean = run {\n\
             System.loadLibrary(\"example_jni\")\n\
             true\n\
             }",
        ),
    };

    let raw_sink = KtFunInterface::new(
        "RawSink",
        KtFunSig::new("accept").param(KtParam::new("reply", KtType::cls("io.example.api.Reply"))),
    )
    .vis(KtVis::Internal);

    KtFile::new("io.example.api.internal")
        .decl(raw_sink)
        .decl(natives)
        .decl(loader)
        // An FQN referenced only from raw text the model cannot see.
        .import("io.example.api.Reply")
}

/// A file in the default (root) package, exercising a banner override and
/// top-level declarations of every value kind.
fn root_fragment() -> KtFile {
    KtFile::new("")
        .banner("// Hand-tuned banner for the root package.")
        .decl(
            KtProperty::val("LIBRARY_VERSION")
                .ty(KtType::string())
                .vis(KtVis::Public)
                .kdoc("Version this binding was generated against.")
                .initializer("\"1.9.0\""),
        )
        // A keyword modifier rendered between visibility and `val`.
        .decl(
            KtProperty::val("PROTOCOL")
                .ty(KtType::string())
                .vis(KtVis::Public)
                .modifier("const")
                .initializer("\"tcp\""),
        )
        // A delegated property: `by <expr>` rather than `= <expr>`.
        .decl(
            KtProperty::val("defaultTimeout")
                .vis(KtVis::Internal)
                .ty(KtType::cls("java.time.Duration"))
                .delegate("lazy { Duration.ofSeconds(10) }"),
        )
        .decl(
            KtFun::new("describeAll")
                .vis(KtVis::Public)
                // Generic parameter lists are free-form text, so a bound is
                // written as given — it is not shortened against the imports.
                .generic("T : io.example.api.Describable")
                .param(KtParam::new(
                    "items",
                    KtType::generic("List", [KtType::var_("T")]),
                ))
                .returns(KtType::string())
                .expr_body(KtCode::new().line("items.joinToString { it.describe() }")),
        )
}

examples/invalid.rs (line 79)

fn broken_declarations() -> KtFile {
    KtFile::new("io.example.broken")
        // Two classes of the same name: a redeclaration in the type namespace.
        .decl(KtClass::class_("Session"))
        .decl(KtClass::class_("Session"))
        // An interface and a type alias are both classifier declarations, so they collide.
        .decl(
            KtClass::interface_("Describable")
                .member(KtFun::new("describe").returns(KtType::string())),
        )
        .decl(KtDecl::TypeAlias {
            vis: KtVis::Public,
            name: "Describable".to_string(),
            target: KtType::string(),
        })
        // Same name AND same parameter types: not an overload.
        .decl(
            KtFun::new("send")
                .param(KtParam::new("value", KtType::int()))
                .returns(KtType::boolean())
                .body(KtCode::new()),
        )
        .decl(
            KtFun::new("send")
                .param(KtParam::new("other", KtType::int()))
                .returns(KtType::long())
                .body(KtCode::new()),
        )
        // Extensions are keyed on their receiver, so these two collide while
        // the same pair on different receivers would not.
        .decl(
            KtFun::new("asRaw")
                .receiver(KtType::cls("io.example.Codec"))
                .body(KtCode::new()),
        )
        .decl(
            KtFun::new("asRaw")
                .receiver(KtType::cls("io.example.Codec"))
                .body(KtCode::new()),
        )
        // ...as here: same name, different receiver, no diagnostic.
        .decl(
            KtFun::new("asRaw")
                .receiver(KtType::cls("io.example.Other"))
                .body(KtCode::new()),
        )
        // Names that are not legal Kotlin identifiers.
        .decl(
            KtClass::class_("My-Class")
                .ctor_param(KtCtorParam::new("2fast", KtType::int()))
                .member(
                    KtFun::new("object")
                        .param(KtParam::new("in", KtType::int()))
                        .body(KtCode::new()),
                ),
        )
        // `val x` with no type, no value and no accessors.
        .decl(KtProperty::val("bare"))
        // A function with no body, at top level, where that cannot mean
        // "abstract".
        .decl(KtFun::new("nobody"))
        // An abstract class member missing the `abstract` keyword.
        .decl(
            KtClass::class_with(KtClassModifier::Abstract, "Base")
                .member(KtFun::new("unimplemented")),
        )
        // An enum whose entries do not call the constructor it declares.
        .decl(
            KtClass::enum_("Priority")
                .ctor_param(KtCtorParam::new("code", KtType::int()).val())
                .entry(KtEnumEntry::with_args("HIGH", "1"))
                .entry(KtEnumEntry::new("LOW")),
        )
        // A constructor property and a member property of one name: both live
        // in the value namespace.
        .decl(
            KtClass::class_("Holder")
                .ctor_param(KtCtorParam::new("id", KtType::long()).val())
                .member(KtProperty::val("id").initializer("0")),
        )
        // A named companion object colliding with a nested class.
        .decl(
            KtClass::class_("Outer")
                .member(KtClass::class_("Factory"))
                .companion(KtCompanion::named("Factory")),
        )
        // Two raw blocks claiming one identity with different bodies.
        .decl(KtDecl::Raw {
            name: "__loader".to_string(),
            code: KtCode::new().line("internal val __loader = 1"),
        })
        .decl(KtDecl::Raw {
            name: "__loader".to_string(),
            code: KtCode::new().line("internal val __loader = 2"),
        })
        // Two different classes referenced from raw text under one short name:
        // the text already says `Codec`, so it cannot mean both.
        .import("io.example.a.Codec")
        .import("io.example.b.Codec")
}

pub fn body(self, c: KtCode) -> Self

Examples found in repository

examples/invalid.rs (line 67)

fn broken_files() -> Vec<KtFile> {
    vec![
        broken_declarations(),
        // A package path that is not a dotted sequence of legal identifiers.
        KtFile::new("io..example.object").decl(KtFun::new("stillChecked").body(KtCode::new())),
    ]
}

fn broken_declarations() -> KtFile {
    KtFile::new("io.example.broken")
        // Two classes of the same name: a redeclaration in the type namespace.
        .decl(KtClass::class_("Session"))
        .decl(KtClass::class_("Session"))
        // An interface and a type alias are both classifier declarations, so they collide.
        .decl(
            KtClass::interface_("Describable")
                .member(KtFun::new("describe").returns(KtType::string())),
        )
        .decl(KtDecl::TypeAlias {
            vis: KtVis::Public,
            name: "Describable".to_string(),
            target: KtType::string(),
        })
        // Same name AND same parameter types: not an overload.
        .decl(
            KtFun::new("send")
                .param(KtParam::new("value", KtType::int()))
                .returns(KtType::boolean())
                .body(KtCode::new()),
        )
        .decl(
            KtFun::new("send")
                .param(KtParam::new("other", KtType::int()))
                .returns(KtType::long())
                .body(KtCode::new()),
        )
        // Extensions are keyed on their receiver, so these two collide while
        // the same pair on different receivers would not.
        .decl(
            KtFun::new("asRaw")
                .receiver(KtType::cls("io.example.Codec"))
                .body(KtCode::new()),
        )
        .decl(
            KtFun::new("asRaw")
                .receiver(KtType::cls("io.example.Codec"))
                .body(KtCode::new()),
        )
        // ...as here: same name, different receiver, no diagnostic.
        .decl(
            KtFun::new("asRaw")
                .receiver(KtType::cls("io.example.Other"))
                .body(KtCode::new()),
        )
        // Names that are not legal Kotlin identifiers.
        .decl(
            KtClass::class_("My-Class")
                .ctor_param(KtCtorParam::new("2fast", KtType::int()))
                .member(
                    KtFun::new("object")
                        .param(KtParam::new("in", KtType::int()))
                        .body(KtCode::new()),
                ),
        )
        // `val x` with no type, no value and no accessors.
        .decl(KtProperty::val("bare"))
        // A function with no body, at top level, where that cannot mean
        // "abstract".
        .decl(KtFun::new("nobody"))
        // An abstract class member missing the `abstract` keyword.
        .decl(
            KtClass::class_with(KtClassModifier::Abstract, "Base")
                .member(KtFun::new("unimplemented")),
        )
        // An enum whose entries do not call the constructor it declares.
        .decl(
            KtClass::enum_("Priority")
                .ctor_param(KtCtorParam::new("code", KtType::int()).val())
                .entry(KtEnumEntry::with_args("HIGH", "1"))
                .entry(KtEnumEntry::new("LOW")),
        )
        // A constructor property and a member property of one name: both live
        // in the value namespace.
        .decl(
            KtClass::class_("Holder")
                .ctor_param(KtCtorParam::new("id", KtType::long()).val())
                .member(KtProperty::val("id").initializer("0")),
        )
        // A named companion object colliding with a nested class.
        .decl(
            KtClass::class_("Outer")
                .member(KtClass::class_("Factory"))
                .companion(KtCompanion::named("Factory")),
        )
        // Two raw blocks claiming one identity with different bodies.
        .decl(KtDecl::Raw {
            name: "__loader".to_string(),
            code: KtCode::new().line("internal val __loader = 1"),
        })
        .decl(KtDecl::Raw {
            name: "__loader".to_string(),
            code: KtCode::new().line("internal val __loader = 2"),
        })
        // Two different classes referenced from raw text under one short name:
        // the text already says `Codec`, so it cannot mean both.
        .import("io.example.a.Codec")
        .import("io.example.b.Codec")
}

examples/showcase.rs (lines 85-93)

fn types_fragment() -> KtFile {
    // `enum class` with a primary constructor its entries call, plus a named
    // companion object holding a factory.
    let priority = KtClass::enum_("Priority")
        .vis(KtVis::Public)
        .kdoc("Delivery priority.\n\nMirrors the native `z_priority_t`.")
        .ctor_param(
            KtCtorParam::new("code", KtType::int())
                .val()
                .vis(KtVis::Public),
        )
        .entry(KtEnumEntry::with_args("REAL_TIME", "1"))
        .entry(KtEnumEntry::with_args("INTERACTIVE", "4"))
        .entry(KtEnumEntry::with_args("DATA", "5"))
        .companion(
            KtCompanion::named("Codes")
                .vis(KtVis::Public)
                .kdoc("Lookup helpers keyed by the native code.")
                .member(
                    KtFun::new("fromInt")
                        .vis(KtVis::Public)
                        .annotation("JvmStatic")
                        .param(KtParam::new("value", KtType::int()))
                        .returns(KtType::cls("Priority"))
                        .body(
                            KtCode::new()
                                .blk("return when (value) {", |c| {
                                    c.line("1 -> REAL_TIME")
                                        .line("4 -> INTERACTIVE")
                                        .line("5 -> DATA")
                                        .line("else -> throw IllegalArgumentException(\"bad priority: $value\")")
                                }),
                        ),
                ),
        );

    // `@JvmInline value class` — exactly one read-only property.
    let zid = KtClass::value(
        "ZenohId",
        KtCtorParam::new("bytes", KtType::byte_array())
            .val()
            .vis(KtVis::Public),
    )
    .vis(KtVis::Public)
    .kdoc("A 16-byte peer identifier, carried by value.");

    // `data class` — every constructor parameter is a property.
    let sample = KtClass::data(
        "Sample",
        KtCtorParam::new("keyExpr", KtType::string())
            .val()
            .vis(KtVis::Public),
    )
    .vis(KtVis::Public)
    .ctor_param(
        KtCtorParam::new("payload", KtType::byte_array())
            .val()
            .vis(KtVis::Public),
    )
    .ctor_param(
        KtCtorParam::new("priority", KtType::cls("Priority"))
            .val()
            .vis(KtVis::Public)
            .default("Priority.DATA"),
    )
    .ctor_param(
        KtCtorParam::new("attachment", KtType::byte_array().nullable())
            .var()
            .vis(KtVis::Public)
            .annotation("JvmField")
            .default("null"),
    );

    // A `sealed interface` whose alternatives nest inside it: a `data class`
    // with a payload and a `data object` without one.
    let reply = KtClass::sealed_interface("Reply")
        .vis(KtVis::Public)
        .kdoc("Either a sample or the end of the stream.")
        .member(
            KtClass::data(
                "Value",
                KtCtorParam::new("sample", KtType::cls("Sample"))
                    .val()
                    .vis(KtVis::Public),
            )
            .vis(KtVis::Public)
            .implements(KtType::cls("Reply")),
        )
        .member(
            KtClass::data_object("Done")
                .vis(KtVis::Public)
                .implements(KtType::cls("Reply")),
        );

    KtFile::new("io.example.api")
        .decl(priority)
        .decl(zid)
        .decl(sample)
        .decl(reply)
}

/// The handle surface: an abstract base, a concrete subclass, an interface,
/// a `fun interface`, and a type alias.
fn session_fragment() -> KtFile {
    // `abstract class` with an `abstract` member (bodiless, and it says so),
    // a `@Volatile` property, and an interface it implements.
    let base = KtClass::class_with(KtClassModifier::Abstract, "NativeHandle")
        .vis(KtVis::Public)
        .kdoc("Owns a raw pointer into Rust and frees it exactly once.")
        .ctor_param(KtCtorParam::new("initialPtr", KtType::long()))
        .implements(KtType::cls("AutoCloseable"))
        .member(
            KtProperty::var("ptr")
                .ty(KtType::long())
                .vis(KtVis::Internal)
                .annotation("Volatile")
                .kdoc("Zero once closed.")
                .initializer("initialPtr"),
        )
        .member(
            KtProperty::val("isClosed")
                .ty(KtType::boolean())
                .vis(KtVis::Public)
                .accessors(KtCode::new().line("get() = ptr == 0L")),
        )
        .member(
            KtFun::new("freePtr")
                .vis(KtVis::Public)
                .modifier("abstract")
                .kdoc("Release the native allocation. Called once, under the lock.")
                .param(KtParam::new("ptr", KtType::long())),
        );

    // `open class` extending the abstract base and constructing it.
    let session = KtClass::class_with(KtClassModifier::Open, "Session")
        .vis(KtVis::Public)
        .annotation("Suppress(\"unused\")")
        .ctor_param(KtCtorParam::new("initialPtr", KtType::long()))
        .extends(KtType::cls("NativeHandle"), Some("initialPtr"))
        .implements(KtType::cls("io.example.api.Describable"))
        .member(
            KtFun::new("freePtr")
                .vis(KtVis::Public)
                .modifier("override")
                .param(KtParam::new("ptr", KtType::long()))
                .body(KtCode::new().line("JNINative.sessionFree(ptr)")),
        )
        .member(
            KtFun::new("describe")
                .vis(KtVis::Public)
                .modifier("override")
                .returns(KtType::string())
                .expr_body(KtCode::new().line("\"Session(0x${ptr.toString(16)})\"")),
        )
        // A generic method whose body uses every `KtCode` block form.
        .member(
            KtFun::new("get")
                .vis(KtVis::Public)
                .generic("R")
                .kdoc("Run a query, folding each reply into an accumulator.")
                .param(KtParam::new("selector", KtType::string()))
                .param(KtParam::new(
                    "onReply",
                    KtType::lambda(
                        [("reply".to_string(), KtType::cls("io.example.api.Reply"))],
                        KtType::var_r(),
                    ),
                ))
                .param(KtParam::new("timeoutMs", KtType::long()).default("10_000L"))
                .returns(KtType::generic("List", [KtType::var_r()]))
                .body(
                    KtCode::new()
                        .line("val acc = ArrayList<R>()")
                        .line("val guard = Guard.acquire(this)")
                        .import("io.example.internal.Guard")
                        .try_finally(
                            "",
                            KtCode::new().blk("JNINative.sessionGet(ptr, selector, timeoutMs) { raw ->", |c| {
                                c.line("acc.add(onReply(raw))")
                            }),
                            KtCode::new().line("guard.release()"),
                        )
                        .line("")
                        // A long call that the renderer breaks by width at its
                        // real nesting level.
                        .wline("reportQueryOutcome(selector, timeoutMs, acc.size, acc.isNotEmpty(), \"query finished\", System.nanoTime())")
                        .line("return acc"),
                ),
        )
        // The interface's member extension, implemented.
        .member(
            KtFun::new("label")
                .vis(KtVis::Public)
                .modifier("override")
                .receiver(KtType::cls("Sample"))
                .returns(KtType::string())
                .expr_body(KtCode::new().line("\"${keyExpr}@${describe()}\"")),
        )
        // A member extension of the class itself.
        .member(
            KtFun::new("toSample")
                .vis(KtVis::Public)
                .receiver(KtType::byte_array())
                .returns(KtType::cls("Sample"))
                .expr_body(KtCode::new().line("Sample(describe(), this)")),
        )
        // A nested class — its own scope, so its members may reuse names.
        .member(
            KtClass::class_("Config")
                .vis(KtVis::Public)
                .member(KtProperty::val("describe").initializer("\"config\"")),
        )
        .companion(
            KtCompanion::new()
                .vis(KtVis::Public)
                .member(
                    KtFun::new("open")
                        .vis(KtVis::Public)
                        .annotation("JvmStatic")
                        .param(KtParam::new("config", KtType::string()).default("\"{}\""))
                        .returns(KtType::cls("Session"))
                        .expr_body(KtCode::new().line("Session(JNINative.sessionOpen(config))")),
                ),
        );

    // A plain `interface`: bodiless members are abstract by position, and a
    // `KtFunSig` is exactly that.
    let describable = KtClass::interface_("Describable")
        .vis(KtVis::Public)
        .member(KtFunSig::new("describe").returns(KtType::string()))
        // A member extension: abstract here, supplied by the implementor.
        // `KtFunSig` carries a receiver too, so a signature does not quietly
        // become a plain member.
        .member(
            KtFunSig::new("label")
                .receiver(KtType::cls("Sample"))
                .returns(KtType::string()),
        );

    // A `fun interface` (SAM) — its single method cannot carry a body.
    let handler = KtFunInterface::new(
        "ReplyHandler",
        KtFunSig::new("onReply")
            .param(KtParam::new("reply", KtType::cls("Reply")))
            .returns(KtType::var_r()),
    )
    .vis(KtVis::Public)
    .type_param("out R")
    .kdoc("Invoked from the native thread for each reply.");

    // Top-level extension functions. The receiver is a type, not part of the
    // name, so it resolves through the import set and the name stays a plain
    // identifier the validator can check as one.
    let summary = KtFun::new("summary")
        .vis(KtVis::Public)
        .receiver(KtType::cls("Sample"))
        .returns(KtType::string())
        .expr_body(KtCode::new().line("\"$keyExpr (${payload.size} bytes)\""));

    // Generics render before the receiver, which renders before the name.
    let map_replies = KtFun::new("mapValues")
        .vis(KtVis::Public)
        .generic("R")
        .receiver(KtType::generic("List", [KtType::cls("Reply")]))
        .param(KtParam::new(
            "transform",
            KtType::lambda(
                [("sample".to_string(), KtType::cls("Sample"))],
                KtType::var_r(),
            ),
        ))
        .returns(KtType::generic("List", [KtType::var_r()]))
        .expr_body(
            KtCode::new().line("filterIsInstance<Reply.Value>().map { transform(it.sample) }"),
        );

    // An extension on a *function type*. The receiver needs parentheses here
    // or the `.` would bind to the return type instead.
    let as_raw = KtFun::new("asRaw")
        .vis(KtVis::Internal)
        .receiver(KtType::lambda(
            [("sample".to_string(), KtType::cls("Sample"))],
            KtType::unit(),
        ))
        .returns(KtType::cls("io.example.api.internal.RawSink"))
        // The proxy adapts a typed callback to the raw one the natives call,
        // so it has to narrow `Reply` to the `Sample` the receiver takes.
        .expr_body(
            KtCode::new().line("RawSink { raw -> if (raw is Reply.Value) this(raw.sample) }"),
        );

    KtFile::new("io.example.api")
        // FQNs named only from raw body text, which the model cannot see.
        .imports(["io.example.api.internal.JNINative".to_string()])
        .decl(base)
        .decl(describable)
        .decl(handler)
        .decl(session)
        .decl(summary)
        .decl(map_replies)
        .decl(as_raw)
        .decl(KtDecl::TypeAlias {
            vis: KtVis::Public,
            name: "SampleList".to_string(),
            target: KtType::generic("List", [KtType::cls("Sample")]),
        })
}

pub fn expr_body(self, c: KtCode) -> Self

Examples found in repository

examples/showcase.rs (line 213)

fn session_fragment() -> KtFile {
    // `abstract class` with an `abstract` member (bodiless, and it says so),
    // a `@Volatile` property, and an interface it implements.
    let base = KtClass::class_with(KtClassModifier::Abstract, "NativeHandle")
        .vis(KtVis::Public)
        .kdoc("Owns a raw pointer into Rust and frees it exactly once.")
        .ctor_param(KtCtorParam::new("initialPtr", KtType::long()))
        .implements(KtType::cls("AutoCloseable"))
        .member(
            KtProperty::var("ptr")
                .ty(KtType::long())
                .vis(KtVis::Internal)
                .annotation("Volatile")
                .kdoc("Zero once closed.")
                .initializer("initialPtr"),
        )
        .member(
            KtProperty::val("isClosed")
                .ty(KtType::boolean())
                .vis(KtVis::Public)
                .accessors(KtCode::new().line("get() = ptr == 0L")),
        )
        .member(
            KtFun::new("freePtr")
                .vis(KtVis::Public)
                .modifier("abstract")
                .kdoc("Release the native allocation. Called once, under the lock.")
                .param(KtParam::new("ptr", KtType::long())),
        );

    // `open class` extending the abstract base and constructing it.
    let session = KtClass::class_with(KtClassModifier::Open, "Session")
        .vis(KtVis::Public)
        .annotation("Suppress(\"unused\")")
        .ctor_param(KtCtorParam::new("initialPtr", KtType::long()))
        .extends(KtType::cls("NativeHandle"), Some("initialPtr"))
        .implements(KtType::cls("io.example.api.Describable"))
        .member(
            KtFun::new("freePtr")
                .vis(KtVis::Public)
                .modifier("override")
                .param(KtParam::new("ptr", KtType::long()))
                .body(KtCode::new().line("JNINative.sessionFree(ptr)")),
        )
        .member(
            KtFun::new("describe")
                .vis(KtVis::Public)
                .modifier("override")
                .returns(KtType::string())
                .expr_body(KtCode::new().line("\"Session(0x${ptr.toString(16)})\"")),
        )
        // A generic method whose body uses every `KtCode` block form.
        .member(
            KtFun::new("get")
                .vis(KtVis::Public)
                .generic("R")
                .kdoc("Run a query, folding each reply into an accumulator.")
                .param(KtParam::new("selector", KtType::string()))
                .param(KtParam::new(
                    "onReply",
                    KtType::lambda(
                        [("reply".to_string(), KtType::cls("io.example.api.Reply"))],
                        KtType::var_r(),
                    ),
                ))
                .param(KtParam::new("timeoutMs", KtType::long()).default("10_000L"))
                .returns(KtType::generic("List", [KtType::var_r()]))
                .body(
                    KtCode::new()
                        .line("val acc = ArrayList<R>()")
                        .line("val guard = Guard.acquire(this)")
                        .import("io.example.internal.Guard")
                        .try_finally(
                            "",
                            KtCode::new().blk("JNINative.sessionGet(ptr, selector, timeoutMs) { raw ->", |c| {
                                c.line("acc.add(onReply(raw))")
                            }),
                            KtCode::new().line("guard.release()"),
                        )
                        .line("")
                        // A long call that the renderer breaks by width at its
                        // real nesting level.
                        .wline("reportQueryOutcome(selector, timeoutMs, acc.size, acc.isNotEmpty(), \"query finished\", System.nanoTime())")
                        .line("return acc"),
                ),
        )
        // The interface's member extension, implemented.
        .member(
            KtFun::new("label")
                .vis(KtVis::Public)
                .modifier("override")
                .receiver(KtType::cls("Sample"))
                .returns(KtType::string())
                .expr_body(KtCode::new().line("\"${keyExpr}@${describe()}\"")),
        )
        // A member extension of the class itself.
        .member(
            KtFun::new("toSample")
                .vis(KtVis::Public)
                .receiver(KtType::byte_array())
                .returns(KtType::cls("Sample"))
                .expr_body(KtCode::new().line("Sample(describe(), this)")),
        )
        // A nested class — its own scope, so its members may reuse names.
        .member(
            KtClass::class_("Config")
                .vis(KtVis::Public)
                .member(KtProperty::val("describe").initializer("\"config\"")),
        )
        .companion(
            KtCompanion::new()
                .vis(KtVis::Public)
                .member(
                    KtFun::new("open")
                        .vis(KtVis::Public)
                        .annotation("JvmStatic")
                        .param(KtParam::new("config", KtType::string()).default("\"{}\""))
                        .returns(KtType::cls("Session"))
                        .expr_body(KtCode::new().line("Session(JNINative.sessionOpen(config))")),
                ),
        );

    // A plain `interface`: bodiless members are abstract by position, and a
    // `KtFunSig` is exactly that.
    let describable = KtClass::interface_("Describable")
        .vis(KtVis::Public)
        .member(KtFunSig::new("describe").returns(KtType::string()))
        // A member extension: abstract here, supplied by the implementor.
        // `KtFunSig` carries a receiver too, so a signature does not quietly
        // become a plain member.
        .member(
            KtFunSig::new("label")
                .receiver(KtType::cls("Sample"))
                .returns(KtType::string()),
        );

    // A `fun interface` (SAM) — its single method cannot carry a body.
    let handler = KtFunInterface::new(
        "ReplyHandler",
        KtFunSig::new("onReply")
            .param(KtParam::new("reply", KtType::cls("Reply")))
            .returns(KtType::var_r()),
    )
    .vis(KtVis::Public)
    .type_param("out R")
    .kdoc("Invoked from the native thread for each reply.");

    // Top-level extension functions. The receiver is a type, not part of the
    // name, so it resolves through the import set and the name stays a plain
    // identifier the validator can check as one.
    let summary = KtFun::new("summary")
        .vis(KtVis::Public)
        .receiver(KtType::cls("Sample"))
        .returns(KtType::string())
        .expr_body(KtCode::new().line("\"$keyExpr (${payload.size} bytes)\""));

    // Generics render before the receiver, which renders before the name.
    let map_replies = KtFun::new("mapValues")
        .vis(KtVis::Public)
        .generic("R")
        .receiver(KtType::generic("List", [KtType::cls("Reply")]))
        .param(KtParam::new(
            "transform",
            KtType::lambda(
                [("sample".to_string(), KtType::cls("Sample"))],
                KtType::var_r(),
            ),
        ))
        .returns(KtType::generic("List", [KtType::var_r()]))
        .expr_body(
            KtCode::new().line("filterIsInstance<Reply.Value>().map { transform(it.sample) }"),
        );

    // An extension on a *function type*. The receiver needs parentheses here
    // or the `.` would bind to the return type instead.
    let as_raw = KtFun::new("asRaw")
        .vis(KtVis::Internal)
        .receiver(KtType::lambda(
            [("sample".to_string(), KtType::cls("Sample"))],
            KtType::unit(),
        ))
        .returns(KtType::cls("io.example.api.internal.RawSink"))
        // The proxy adapts a typed callback to the raw one the natives call,
        // so it has to narrow `Reply` to the `Sample` the receiver takes.
        .expr_body(
            KtCode::new().line("RawSink { raw -> if (raw is Reply.Value) this(raw.sample) }"),
        );

    KtFile::new("io.example.api")
        // FQNs named only from raw body text, which the model cannot see.
        .imports(["io.example.api.internal.JNINative".to_string()])
        .decl(base)
        .decl(describable)
        .decl(handler)
        .decl(session)
        .decl(summary)
        .decl(map_replies)
        .decl(as_raw)
        .decl(KtDecl::TypeAlias {
            vis: KtVis::Public,
            name: "SampleList".to_string(),
            target: KtType::generic("List", [KtType::cls("Sample")]),
        })
}

/// The `external` surface — an object of natives, in its own subpackage.
fn natives_fragment() -> KtFile {
    let natives = KtClass::object_("JNINative")
        .vis(KtVis::Internal)
        .kdoc("One-to-one with the exported Rust symbols.")
        .member(
            KtFun::new("sessionOpen")
                .vis(KtVis::Internal)
                .param(KtParam::new("config", KtType::string()))
                .returns(KtType::long())
                .external(),
        )
        .member(
            KtFun::new("sessionFree")
                .vis(KtVis::Internal)
                .param(KtParam::new("ptr", KtType::long()))
                .external(),
        )
        .member(
            KtFun::new("sessionGet")
                .vis(KtVis::Internal)
                .param(KtParam::new("ptr", KtType::long()))
                .param(KtParam::new("selector", KtType::string()))
                .param(KtParam::new("timeoutMs", KtType::long()))
                .param(KtParam::new(
                    "sink",
                    KtType::lambda(
                        [("reply".to_string(), KtType::cls("io.example.api.Reply"))],
                        KtType::unit(),
                    ),
                ))
                .external(),
        );

    // A pre-rendered block, for text the model does not describe. Its name is
    // a merge identity, never emitted.
    let loader = KtDecl::Raw {
        name: "__loadNative".to_string(),
        code: KtCode::raw_reindent(
            "internal val __loaded: Boolean = run {\n\
             System.loadLibrary(\"example_jni\")\n\
             true\n\
             }",
        ),
    };

    let raw_sink = KtFunInterface::new(
        "RawSink",
        KtFunSig::new("accept").param(KtParam::new("reply", KtType::cls("io.example.api.Reply"))),
    )
    .vis(KtVis::Internal);

    KtFile::new("io.example.api.internal")
        .decl(raw_sink)
        .decl(natives)
        .decl(loader)
        // An FQN referenced only from raw text the model cannot see.
        .import("io.example.api.Reply")
}

/// A file in the default (root) package, exercising a banner override and
/// top-level declarations of every value kind.
fn root_fragment() -> KtFile {
    KtFile::new("")
        .banner("// Hand-tuned banner for the root package.")
        .decl(
            KtProperty::val("LIBRARY_VERSION")
                .ty(KtType::string())
                .vis(KtVis::Public)
                .kdoc("Version this binding was generated against.")
                .initializer("\"1.9.0\""),
        )
        // A keyword modifier rendered between visibility and `val`.
        .decl(
            KtProperty::val("PROTOCOL")
                .ty(KtType::string())
                .vis(KtVis::Public)
                .modifier("const")
                .initializer("\"tcp\""),
        )
        // A delegated property: `by <expr>` rather than `= <expr>`.
        .decl(
            KtProperty::val("defaultTimeout")
                .vis(KtVis::Internal)
                .ty(KtType::cls("java.time.Duration"))
                .delegate("lazy { Duration.ofSeconds(10) }"),
        )
        .decl(
            KtFun::new("describeAll")
                .vis(KtVis::Public)
                // Generic parameter lists are free-form text, so a bound is
                // written as given — it is not shortened against the imports.
                .generic("T : io.example.api.Describable")
                .param(KtParam::new(
                    "items",
                    KtType::generic("List", [KtType::var_("T")]),
                ))
                .returns(KtType::string())
                .expr_body(KtCode::new().line("items.joinToString { it.describe() }")),
        )
}

pub fn external(self) -> Self

external fun f() — natively implemented, and so bodiless.

Examples found in repository

examples/showcase.rs (line 379)

fn natives_fragment() -> KtFile {
    let natives = KtClass::object_("JNINative")
        .vis(KtVis::Internal)
        .kdoc("One-to-one with the exported Rust symbols.")
        .member(
            KtFun::new("sessionOpen")
                .vis(KtVis::Internal)
                .param(KtParam::new("config", KtType::string()))
                .returns(KtType::long())
                .external(),
        )
        .member(
            KtFun::new("sessionFree")
                .vis(KtVis::Internal)
                .param(KtParam::new("ptr", KtType::long()))
                .external(),
        )
        .member(
            KtFun::new("sessionGet")
                .vis(KtVis::Internal)
                .param(KtParam::new("ptr", KtType::long()))
                .param(KtParam::new("selector", KtType::string()))
                .param(KtParam::new("timeoutMs", KtType::long()))
                .param(KtParam::new(
                    "sink",
                    KtType::lambda(
                        [("reply".to_string(), KtType::cls("io.example.api.Reply"))],
                        KtType::unit(),
                    ),
                ))
                .external(),
        );

    // A pre-rendered block, for text the model does not describe. Its name is
    // a merge identity, never emitted.
    let loader = KtDecl::Raw {
        name: "__loadNative".to_string(),
        code: KtCode::raw_reindent(
            "internal val __loaded: Boolean = run {\n\
             System.loadLibrary(\"example_jni\")\n\
             true\n\
             }",
        ),
    };

    let raw_sink = KtFunInterface::new(
        "RawSink",
        KtFunSig::new("accept").param(KtParam::new("reply", KtType::cls("io.example.api.Reply"))),
    )
    .vis(KtVis::Internal);

    KtFile::new("io.example.api.internal")
        .decl(raw_sink)
        .decl(natives)
        .decl(loader)
        // An FQN referenced only from raw text the model cannot see.
        .import("io.example.api.Reply")
}

pub fn signature(&self) -> KtFunSig

This function’s signature: same name, generics, receiver, parameters and return type, with the body and modifiers dropped. What a concrete member looks like as an interface abstract.

Trait Implementations

impl Clone for KtFun

fn clone(&self) -> KtFun

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for KtFun

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl From<KtFun> for KtDecl

fn from(f: KtFun) -> Self

Converts to this type from the input type.

impl From<KtFunSig> for KtFun

fn from(s: KtFunSig) -> Self

A signature as a body-less function — an abstract member.