invalid/

invalid.rs

//! What a *broken* model looks like, and what the validator says about it.
//!
//! ```text
//! cargo run --example invalid
//! ```
//!
//! Two kinds of mistake are shown, and they are caught at different moments:
//!
//! * **Shapes the model refuses to build.** These never reach validation —
//!   the builder panics, or the type simply has nowhere to put the bad value.
//!   The last section demonstrates a few by catching the panics.
//! * **Everything else**, reported by [`KtFile::validate`] as a list of
//!   diagnostics with a scope path locating each one.
//!
//! The output is checked against `tests/golden/invalid.txt` by
//! `tests/examples.rs`.

use kotlin_codegen::{
    merge_files, Check, KtClass, KtClassModifier, KtCode, KtCompanion, KtCtorParam, KtDecl,
    KtEnumEntry, KtFile, KtFun, KtParam, KtProperty, KtType, KtVis, ValidationPolicy,
};

fn main() {
    println!("=== diagnostics (default: every check is an error) ===");
    for file in broken_files() {
        for d in file.validate() {
            println!("{d}");
        }
    }

    println!("\n=== merging refuses to produce anything ===");
    match merge_files(broken_files()) {
        Ok(_) => println!("unexpectedly merged"),
        // The Display of the error is what a build script would surface.
        Err(e) => print!("{e}"),
    }

    println!("\n=== the same model under `warn_all()` ===");
    let (files, warnings) = merge_files_warning();
    println!(
        "merged {} file(s) with {} warning(s); generation continues",
        files.len(),
        warnings.len()
    );

    println!("\n=== one check downgraded, another switched off ===");
    let policy = ValidationPolicy::new()
        .warn(Check::DuplicateFunction)
        .allow(Check::InvalidIdentifier);
    for file in broken_files() {
        for d in file.validate_with(&policy) {
            println!("{d}");
        }
    }

    println!("\n=== shapes the model will not build at all ===");
    for (what, outcome) in refused_shapes() {
        println!("{what}\n    -> {outcome}");
    }
}

/// Between them, these files trigger every check the validator can report.
fn broken_files() -> Vec<KtFile> {
    vec![
        broken_declarations(),
        // A package path that is not a dotted sequence of legal identifiers.
        KtFile::new("io..example.object").decl(KtFun::new("stillChecked").body(KtCode::new())),
    ]
}

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

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

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

/// Run a builder that is expected to panic and return its message, so the
/// example can show what the author would see.
fn refused(f: impl FnOnce() + std::panic::UnwindSafe) -> String {
    // The panic is the point here, so keep the default hook from printing a
    // backtrace over the example's output.
    let hook = std::panic::take_hook();
    std::panic::set_hook(Box::new(|_| {}));
    let result = std::panic::catch_unwind(f);
    std::panic::set_hook(hook);
    match result {
        Ok(()) => "built successfully (unexpected!)".to_string(),
        Err(payload) => payload
            .downcast_ref::<String>()
            .cloned()
            .or_else(|| payload.downcast_ref::<&str>().map(|s| s.to_string()))
            .unwrap_or_else(|| "panicked".to_string()),
    }
}