A1: class kind carries its own primary constructor

[milyin]

First step of #6. Based on docs/validation-umbrella.

KtClass was one struct with a kind tag where every field applied to every
kind. ctor_params sat there for every kind including the ones Kotlin gives no
constructor, and the renderer printed it — object Foo(x: Int) rendered happily
and did not compile.

Moving the constructor into the kind makes four shapes unrepresentable rather
than merely detectable:

Was buildable	Now
object Foo(x: Int), and the same for data object / interface / sealed interface / companion object	those variants have no field to hold constructor parameters
data class Foo with no properties	KtClass::data(name, first) takes the first, so zero is not expressible
value class Foo with zero or two properties	KtClassKind::Value { field } holds exactly one

Plain and Abstract fold into Class { modifier: Option<KtClassModifier> },
which also makes open and sealed classes expressible for the first time.

On the two panics

ctor_param() and the new entry() panic when handed to a kind that cannot
hold them. A panic is a runtime check, which this umbrella is otherwise trying
to avoid — but the check is at build time with a precise message, and the
invalid value still cannot exist, so nothing invalid can ever reach the
renderer. The alternative that avoids it entirely is typestate, which is far
too much machinery for this crate.

Verification

All 34 pre-existing golden-string tests pass untouched — the rendered output
is byte-identical, so this is a pure representation change. Seven tests added
covering the new invariants: the three class modifiers rendering, value-class
arity, data-class minimum, the three panics, and an enum with a primary
constructor. cargo clippy --all-targets clean.

Consumer migration (prebindgen-jni, 9 sites) is deliberately out of scope per
the umbrella and lands later.

[Copilot]

Pull request overview

This PR refactors the Kotlin declaration model so that class “kind” variants carry their own payload (primary constructor params / enum entries), making several Kotlin-invalid shapes unrepresentable at construction time and adjusting the renderer + tests to use the new API.

Changes:

• Restructures KtClassKind to embed ctor params / enum entries per variant and introduces KtClassModifier + new KtClass constructors/builders (class_, class_with, data, value, enum_, etc.).
• Updates rendering and import-collection to consume the new ctor_params() / entries() accessors and keyword() mapping.
• Updates and extends tests to cover the new invariants and panic-on-invalid-builder-usage behavior; updates validation design doc snippet.

Reviewed changes

Copilot reviewed 5 out of 5 changed files in this pull request and generated 2 comments.

Show a summary per file

File	Description
src/model.rs	Introduces KtClassModifier, refactors KtClassKind to carry ctor/entries, adds new builders and accessors, and adds build-time panics for invalid builder usage.
src/render.rs	Updates rendering and import collection to use KtClass::ctor_params() and KtClassKind::entries()/keyword() after the model refactor.
src/tests.rs	Migrates tests to the new builder API and adds new tests for the intended invariants and panics.
src/lib.rs	Re-exports the new KtClassModifier public API.
docs/validation.md	Updates the A1 design doc snippet to reflect interface/sealed-interface payload changes.

Suppressed comments (3)

src/render.rs:226

• The if !matches!(c.kind, KtClassKind::Companion) ... condition immediately above tries to move kind out of &KtClass (non-Copy). Borrow c.kind in the matches! call (matches!(&c.kind, ...)).

        out.push(' ');
        out.push_str(&c.name);
    }

src/model.rs:420

• KtClass::value is documented as wrapping exactly one property, but it currently accepts a plain ctor parameter (prop: None) or var, which would allow building a value class shape Kotlin rejects. Enforce that the field is a val at construction time with a clear panic message (consistent with other build-time checks in this PR).

    /// A `@JvmInline value class` wrapping exactly one property.
    pub fn value(name: impl Into<String>, field: KtCtorParam) -> Self {
        Self::new(
            KtClassKind::Value {
                field: Box::new(field),

src/model.rs:486

• ctor_param still allows building invalid shapes:

• For KtClassKind::Data, it will accept ctor params that are not val/var properties (Kotlin requires data-class primary ctor params to be properties).
• For KtClassKind::Value, the panic message claims the kind has no primary constructor, but a value class does have one; it just can't accept additional parameters.
  Tighten the match to validate Data params and provide a value-class-specific panic.

            other => panic!(
                "`{}` has no primary constructor to add parameter `{}` to",
                other.keyword(),
                p.name
            ),

---

💡 Add Copilot custom instructions for smarter, more guided reviews. Learn how to get started.