showcase/

showcase.rs

//! Every construct the model can emit, in one runnable generator.
//!
//! This is what a real code generator does: build `KtFile` fragments, merge
//! them so each package collapses to one file, validate, and render. Run it
//! with:
//!
//! ```text
//! cargo run --example showcase
//! ```
//!
//! The output is checked against `tests/golden/showcase.txt` by
//! `tests/examples.rs`, so this doubles as a readable regression test for the
//! renderer.

use kotlin_codegen::{
    escape_kotlin_ident, is_kotlin_hard_keyword, is_valid_kotlin_ident, is_valid_kotlin_package,
    mangle_kotlin_ident, mangle_kotlin_package, merge_files, merged_file_path, KtClass,
    KtClassModifier, KtCode, KtCompanion, KtCtorParam, KtDecl, KtEnumEntry, KtFile, KtFun,
    KtFunInterface, KtFunSig, KtParam, KtProperty, KtType, KtVis,
};

fn main() {
    let fragments = vec![
        types_fragment(),
        session_fragment(),
        natives_fragment(),
        root_fragment(),
    ];

    let files = merge_files(fragments).expect("the showcase model is valid");

    println!("=== generated files ===");
    for file in &files {
        let path = merged_file_path(std::path::Path::new("kotlin"), file, "Generated");
        println!("\n--- {} ---", path.display());
        print!("{}", file.render());
    }

    println!("\n=== identifier helpers ===");
    for raw in ["myValue", "my-field", "2fast", "object", "data", ""] {
        let quoted = format!("{raw:?}");
        let mangled = format!("{:?}", mangle_kotlin_ident(raw));
        let escaped = format!("{:?}", escape_kotlin_ident(raw));
        let valid = is_valid_kotlin_ident(raw);
        let keyword = is_kotlin_hard_keyword(raw);
        println!(
            "{quoted:>10} -> valid={valid:<5} keyword={keyword:<5} \
             mangled={mangled:<10} escaped={escaped}"
        );
    }
    for raw in ["io.example.api", "fun.my-pkg", "io..jni."] {
        let quoted = format!("{raw:?}");
        let mangled = format!("{:?}", mangle_kotlin_package(raw));
        let valid = is_valid_kotlin_package(raw);
        println!("{quoted:>16} -> valid={valid:<5} mangled={mangled}");
    }
}

/// Data-carrying types: enum, data class, value class, and a sealed
/// interface whose alternatives nest inside it.
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() }")),
        )
}