Struct KtParam 

pub struct KtParam {
    pub name: String,
    pub ty: KtType,
    pub default: Option<KtCode>,
}

A function parameter with an optional default-value expression.

Fields

name: String

ty: KtType

default: Option<KtCode>

Implementations

impl KtParam

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

Examples found in repository

examples/showcase.rs (line 83)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

examples/invalid.rs (line 89)

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

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

Examples found in repository

examples/showcase.rs (line 229)

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

Trait Implementations

impl Clone for KtParam

fn clone(&self) -> KtParam

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for KtParam

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

Formats the value using the given formatter.