Enum KtType 

pub enum KtType {
    Named {
        fqn: String,
        args: Vec<KtType>,
        nullable: bool,
    },
    Function {
        params: Vec<(String, KtType)>,
        ret: Box<KtType>,
        nullable: bool,
    },
}

A Kotlin type reference.

Variants

Named

A named type: builtin (Int), type variable (R), or class FQN (io.zenoh.jni.ZKeyExpr), optionally generic (List<T>).

Fields

fqn: String

args: Vec<KtType>

nullable: bool

Function

A function type with named parameters: (je: String?, message: String) -> Unit.

Fields

params: Vec<(String, KtType)>

ret: Box<KtType>

nullable: bool

Implementations

impl KtType

pub const UNIT: &'static str = "Unit"

pub fn cls(fqn: impl Into<String>) -> Self

A named type (builtin, type variable, or class FQN).

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 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")
}

/// 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("");
            }),
        ),
    ]
}

pub fn generic( fqn: impl Into<String>, args: impl IntoIterator<Item = KtType>, ) -> Self

A generic named type, e.g. generic("List", [cls("io.x.Y")]).

Examples found in repository

examples/showcase.rs (line 230)

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 lambda( params: impl IntoIterator<Item = (String, KtType)>, ret: KtType, ) -> Self

A function type with named parameters.

Examples found in repository

examples/showcase.rs (lines 224-227)

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")
}

pub fn unit() -> Self

Examples found in repository

examples/showcase.rs (line 343)

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")
}

pub fn int() -> Self

Examples found in repository

examples/showcase.rs (line 68)

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)
}

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")
}

/// 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("");
            }),
        ),
    ]
}

pub fn long() -> Self

Examples found in repository

examples/invalid.rs (line 96)

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 170)

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")
}

pub fn boolean() -> Self

Examples found in repository

examples/invalid.rs (line 90)

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 182)

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 string() -> Self

Examples found in repository

examples/showcase.rs (line 110)

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 byte_array() -> Self

Examples found in repository

examples/showcase.rs (line 100)

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 any() -> Self

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

A bare type variable (R, A) — renders verbatim, never imported.

Examples found in repository

examples/showcase.rs (line 464)

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 var_r() -> Self

Shorthand for the ubiquitous R type variable.

Examples found in repository

examples/showcase.rs (line 226)

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 nullable(self) -> Self

This type made nullable (T?).

Examples found in repository

examples/showcase.rs (line 127)

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)
}

pub fn is_nullable(&self) -> bool

Whether this type is nullable (T? / ((…) -> …)?).

pub fn leaf_name(&self) -> Option<&str>

The (possibly dotted) name of a non-generic named type — None for function types and generics. This is the FQN-or-short-name string a leaf was constructed from.

pub fn simple_name(&self) -> Option<&str>

The simple (dot-free) name of a named type: last FQN segment, generic arguments ignored. None for function types.

pub fn render_receiver(&self, imports: &mut ImportSet) -> String

Render in extension-receiver position — fun <this>.name().

A function type needs parentheses there, or the . binds to its return type instead: fun ((Int) -> String).ext(), never fun (Int) -> String.ext(). A nullable one is already parenthesized by Self::render, so it is left alone.

use kotlin_codegen::{ImportSet, KtType};
let mut imports = ImportSet::new("io.p");
let f = KtType::lambda([("x".to_string(), KtType::int())], KtType::string());
assert_eq!(f.render_receiver(&mut imports), "((x: Int) -> String)");
assert_eq!(KtType::string().render_receiver(&mut imports), "String");

pub fn render(&self, imports: &mut ImportSet) -> String

Render to Kotlin source, registering imports in imports.

Trait Implementations

impl Clone for KtType

fn clone(&self) -> KtType

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for KtType

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

Formats the value using the given formatter.

impl Display for KtType

Renders the type with names exactly as constructed (FQNs stay fully qualified — no import shortening). For diagnostics and any context without an ImportSet.

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

Formats the value using the given formatter.

impl Eq for KtType

impl PartialEq for KtType

fn eq(&self, other: &KtType) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl StructuralPartialEq for KtType