Enum TsObjectEntry 

pub enum TsObjectEntry {
    Prop(String, TsExpr),
    Shorthand(String),
    Method {
        name: String,
        is_async: bool,
        generics: Vec<String>,
        params: Vec<TsParam>,
        return_type: Option<TsType>,
        doc: Option<String>,
        inline: bool,
        body: Vec<TsStmt>,
    },
    Spread(TsExpr),
}

One entry of a TsExpr::Object literal. Only Prop existed before #1321 (events_fanout.rs’s own grounding never needed the other three) — workers.rs’s own dominant shape (Decision A, gap 1) is a literal object whose entries are shorthand async methods (every on call/on http/… wrapper attaches this way), its local capability-deps object mixes bare shorthand names with explicit key: value pairs, and three real sites spread another object into one (gap 2, folded in here rather than as its own top-level TsExpr variant — a spread only ever appears as an object- or array-literal entry in this file, never as a standalone expression, so scoping it to entry position is the narrower correct change).

Variants

Prop(String, TsExpr)

key: value.

Shorthand(String)

key alone — object-literal property shorthand, e.g. { cap1, cap2 }. Distinct from Prop(name, TsExpr::Ident(name)), which prints name: name, not the shorthand form real TypeScript property-shorthand text actually is.

Method

A shorthand async method entry, e.g. async foo(a: T) { ... }, — workers.rs’s own dominant shape (Decision A, gap 1): every wrapper helper (emit_call_wrapper, emit_event_wrapper, …) attaches to the returned compose surface this way — none of workers.rs’s own real sites annotates a return type, so return_type stayed unneeded until #1323’s own real gap: workers_entry.rs’s export default { fetch, scheduled?, queue? } entries all carry one (: Promise<Response>/: Promise<void>), the same field TsClassMethod::return_type already has for the declaration-position sibling this mirrors.

generics and doc (#1337’s own real gaps, both found only by the zero-diff fixture check — not the accepted proposal’s own citation, which searched the project-form fixture corpus only; 402_generic_instance_method is single-file form, and while 65_money_uses_time/64_full_time_commons ARE project form, the citation’s own doc-comment search used the wrong marker, /// rather than this language’s real ----delimited doc block — both gaps outside what that first pass actually checked):

• generics: a method on a generic type erases to {name}<{generics}>(self: {Type}<{generics}>, …) — Box.map<A, U>, the type’s own A plus the method’s own U. Bare names only, no bounds/defaults — every real generic parameter list this tree ever builds is (matching crate::printer::print_type’s own TsType::Named-only-name convention for the identical reason), so a full Vec<TsParam> (with its own unneeded ty/optional fields) would be the wrong shape here.
• doc: a JSDoc block immediately preceding the method entry, at the same indent — Timestamp.diff/Timestamp.add (65_money_uses_time) both carry one. Printed the identical way TsStmtKind::DocComment is (same escaping, same blank-line convention), reusing that one renderer rather than a second copy — this field exists because an object-entry method has no TsStmt slot of its own to hold a preceding statement in.

Fields

name: String

is_async: bool

generics: Vec<String>

params: Vec<TsParam>

return_type: Option<TsType>

doc: Option<String>

inline: bool

false (every method entry landed before #1337): body renders as an ordinary braced, multi-line block. true: body renders compactly on the SAME line as the signature — { <stmts>; }, reusing this crate’s own established compact-statement machinery (TsStmtKind::InlineBlock’s own sibling shape). A real gap #1337’s own zero-diff check found: emit_forwarded_methods’s own pre-conversion writeln! always built the WHOLE entry — signature and one-statement body alike — on one physical line (" {method}({params}): {ret} {{ return …; }},"), a genuinely different real shape from every other Method entry in this tree, all of which are multi-line.

body: Vec<TsStmt>

Spread(TsExpr)

...expr — an object-spread entry (Decision A, gap 2), e.g. { ...deps, identity: __caller }.

Trait Implementations

impl Clone for TsObjectEntry

fn clone(&self) -> TsObjectEntry

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for TsObjectEntry

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

Formats the value using the given formatter.