Struct KtFunSig 

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

A function signature: everything a KtFun has except a body and modifiers.

This is what an abstract member is — a fun interface’s single method, an interface member, an abstract class member. Having no body field at all is what makes a bodied SAM method unrepresentable: a fun interface whose one method has a body has no abstract method, and does not compile.

Converts into KtFun (with KtBody::None) and so into KtDecl, for use as an interface member; KtFun::signature goes the other way.

Fields

name: String

vis: KtVis

annotations: Vec<String>

kdoc: Option<String>

generics: Vec<String>

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

receiver: Option<KtType>

Extension receiver: Some(Foo) → fun Foo.name(…). A separate field rather than part of name, so name stays a plain identifier that can be checked as one.

params: Vec<KtParam>

ret: Option<KtType>

Implementations

impl KtFunSig

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

Examples found in repository

examples/showcase.rs (line 290)

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 vis(self, v: KtVis) -> Self

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

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

Examples found in repository

examples/showcase.rs (line 296)

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

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

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

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

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

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

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

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

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

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

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

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

Examples found in repository

examples/showcase.rs (line 304)

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 returns(self, ty: KtType) -> Self

Examples found in repository

examples/showcase.rs (line 290)

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 KtFunSig

fn clone(&self) -> KtFunSig

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for KtFunSig

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

Formats the value using the given formatter.

impl From<KtFunSig> for KtFun

fn from(s: KtFunSig) -> Self

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

impl From<KtFunSig> for KtDecl

fn from(s: KtFunSig) -> Self

Converts to this type from the input type.