Suppress empty builder for all-required dictionaries (#17)

When every property is required, the generated <Foo>Builder carries
only build() with nothing to chain - dead weight. ts-gen now emits
just new(reqs) directly on the dictionary type with construction
inlined, skipping the wrapper struct.

Before:

  impl EmailSendResult {
      pub fn new(message_id: &str) -> EmailSendResult {
          Self::builder(message_id).build()
      }
      pub fn builder(message_id: &str) -> EmailSendResultBuilder {
          let inner: Self = JsCast::unchecked_into(js_sys::Object::new());
          inner.set_message_id(message_id);
          EmailSendResultBuilder { inner }
      }
  }
  pub struct EmailSendResultBuilder { inner: EmailSendResult }
  impl EmailSendResultBuilder {
      pub fn build(self) -> EmailSendResult { self.inner }
  }

After:

  impl EmailSendResult {
      pub fn new(message_id: &str) -> EmailSendResult {
          let inner: Self = JsCast::unchecked_into(js_sys::Object::new());
          inner.set_message_id(message_id);
          inner
      }
  }

Dictionaries with at least one optional field still get the full
new(reqs) + builder(reqs) + chainable wrapper treatment.

Author: guybedford

CONVENTIONS.md

@@ -262,6 +262,10 @@ let init = ResponseInit::builder().status(200.0).build();
 let init = ResponseInit::new();  // empty object
 ```
 
+If every property is required (no optionals), the builder would carry
+only `build()` and is suppressed — only `new(reqs)` is emitted, with
+construction inlined.
+
 ### Required-property cartesian product across union types
 
 When a required property has union-typed setter overloads (e.g.

src/codegen/classes.rs

@@ -298,6 +298,13 @@ fn generate_dictionary_factory(config: &ClassConfig) -> TokenStream {
         }
     }
 
+    // When every property is required, the builder type is dead weight: it
+    // would carry only `pub fn build(self) -> Foo` with nothing to chain,
+    // so we suppress it. `new(reqs)` still gets emitted but inlines the
+    // construction directly. See the dictionary-builder convention in
+    // `CONVENTIONS.md` for the rule.
+    let emit_builder = !optional_getters.is_empty();
+
     // Resolve each getter through the setter pipeline. Multi-overload
     // setters (e.g. `set_from(&str)` + `set_from_with_email_address(&EmailAddress)`
     // for `from: string | EmailAddress`) produce multiple sigs — we
@@ -607,7 +614,6 @@ fn generate_dictionary_factory(config: &ClassConfig) -> TokenStream {
         if !emitted_names.insert(full_suffix.clone()) {
             continue;
         }
-        let builder_ident = super::typemap::make_ident(&format!("builder{full_suffix}"));
         let new_ident = super::typemap::make_ident(&format!("new{full_suffix}"));
         let (generics, params_tokens) = generate_dictionary_params(
             &plan.value_params,
@@ -640,39 +646,67 @@ fn generate_dictionary_factory(config: &ClassConfig) -> TokenStream {
             super::doc_tokens(&Some(doc_text))
         };
 
-        // No-required case has zero `init_calls`, so we inline the
-        // factory directly into the struct literal where the field type
-        // pins inference. The required-args case keeps a `let inner:
-        // Self` so setter calls type-resolve before construction.
-        let body = if init_calls.is_empty() {
-            quote! {
-                #builder_name {
-                    inner: JsCast::unchecked_into(js_sys::Object::new()),
+        if emit_builder {
+            // `builder*` returns the wrapper struct so callers can chain
+            // setters; `new*` is just `Self::builder(reqs).build()`.
+            //
+            // No-required case has zero `init_calls`, so we inline the
+            // factory directly into the struct literal where the field type
+            // pins inference. The required-args case keeps a `let inner:
+            // Self` so setter calls type-resolve before construction.
+            let builder_body = if init_calls.is_empty() {
+                quote! {
+                    #builder_name {
+                        inner: JsCast::unchecked_into(js_sys::Object::new()),
+                    }
                 }
-            }
+            } else {
+                quote! {
+                    let inner: Self = JsCast::unchecked_into(js_sys::Object::new());
+                    #(#init_calls)*
+                    #builder_name { inner }
+                }
+            };
+            let builder_ident = super::typemap::make_ident(&format!("builder{full_suffix}"));
+            builder_variants.push(quote! {
+                #doc_attr
+                pub fn #builder_ident #generics (#params_tokens) -> #builder_name {
+                    #builder_body
+                }
+            });
+            new_variants.push(quote! {
+                #doc_attr
+                pub fn #new_ident #generics (#params_tokens) -> #rust_type {
+                    Self::#builder_ident(#(#arg_idents),*).build()
+                }
+            });
         } else {
-            quote! {
-                let inner: Self = JsCast::unchecked_into(js_sys::Object::new());
-                #(#init_calls)*
-                #builder_name { inner }
-            }
-        };
-        builder_variants.push(quote! {
-            #doc_attr
-            pub fn #builder_ident #generics (#params_tokens) -> #builder_name {
-                #body
-            }
-        });
-        new_variants.push(quote! {
-            #doc_attr
-            pub fn #new_ident #generics (#params_tokens) -> #rust_type {
-                Self::#builder_ident(#(#arg_idents),*).build()
-            }
-        });
+            // All-required dictionary: no builder to delegate to, so
+            // construction is inlined directly into `new*`. Returns
+            // `Self` rather than the wrapper struct.
+            let body = if init_calls.is_empty() {
+                quote! {
+                    JsCast::unchecked_into(js_sys::Object::new())
+                }
+            } else {
+                quote! {
+                    let inner: Self = JsCast::unchecked_into(js_sys::Object::new());
+                    #(#init_calls)*
+                    inner
+                }
+            };
+            new_variants.push(quote! {
+                #doc_attr
+                pub fn #new_ident #generics (#params_tokens) -> #rust_type {
+                    #body
+                }
+            });
+        }
     }
 
     // Fluent methods on the wrapper for optional fields. Required fields
     // are intentionally absent — they're only settable through `builder`.
+    // (Empty when `!emit_builder`, since there's nothing to chain.)
     let mut builder_methods: Vec<TokenStream> = Vec::new();
     for g in &optional_getters {
         for sig in resolve_setter_sigs(g) {
@@ -700,21 +734,31 @@ fn generate_dictionary_factory(config: &ClassConfig) -> TokenStream {
         }
     }
 
-    quote! {
-        impl #rust_type {
-            #(#new_variants)*
-            #(#builder_variants)*
-        }
+    if emit_builder {
+        quote! {
+            impl #rust_type {
+                #(#new_variants)*
+                #(#builder_variants)*
+            }
 
-        pub struct #builder_name {
-            inner: #rust_type,
-        }
+            pub struct #builder_name {
+                inner: #rust_type,
+            }
 
-        impl #builder_name {
-            #(#builder_methods)*
+            impl #builder_name {
+                #(#builder_methods)*
 
-            pub fn build(self) -> #rust_type {
-                self.inner
+                pub fn build(self) -> #rust_type {
+                    self.inner
+                }
+            }
+        }
+    } else {
+        // All-required dictionary: the builder would be empty, so we
+        // emit only `new*` factories on the dictionary type itself.
+        quote! {
+            impl #rust_type {
+                #(#new_variants)*
             }
         }
     }

tests/fixtures/empty-builder-suppression.d.ts

@@ -0,0 +1,36 @@
+// Fixture: dictionary builder is suppressed when there are no optional
+// fields to chain.
+//
+// When every property is required, the generated `FooBuilder` would only
+// have `pub fn build(self) -> Foo` — pure dead weight. ts-gen detects
+// this and emits only `new(reqs) -> Foo` with the construction inlined.
+
+/** All fields required → no builder, only `new`. */
+interface AllRequired {
+  /** The thing's name. */
+  name: string;
+  /** The thing's count. */
+  count: number;
+}
+
+/** Has at least one optional field → builder still emitted. */
+interface HasOptional {
+  /** Required. */
+  name: string;
+  /** Optional. */
+  count?: number;
+}
+
+/** All optional → zero-arg `new()` and `builder()` with chainable setters. */
+interface AllOptional {
+  /** Optional. */
+  name?: string;
+  /** Optional. */
+  count?: number;
+}
+
+/** Single required field, no optionals → no builder, just `new`. */
+interface SingleRequired {
+  /** The id. */
+  id: string;
+}

tests/snapshots/coverage.rs

@@ -24,20 +24,9 @@ extern "C" {
 }
 impl NumberIndexed {
     pub fn new(length: f64) -> NumberIndexed {
-        Self::builder(length).build()
-    }
-    pub fn builder(length: f64) -> NumberIndexedBuilder {
         let inner: Self = JsCast::unchecked_into(js_sys::Object::new());
         inner.set_length(length);
-        NumberIndexedBuilder { inner }
-    }
-}
-pub struct NumberIndexedBuilder {
-    inner: NumberIndexed,
-}
-impl NumberIndexedBuilder {
-    pub fn build(self) -> NumberIndexed {
-        self.inner
+        inner
     }
 }
 #[wasm_bindgen]
@@ -52,20 +41,9 @@ extern "C" {
 }
 impl MixedWithIndex {
     pub fn new(name: &str) -> MixedWithIndex {
-        Self::builder(name).build()
-    }
-    pub fn builder(name: &str) -> MixedWithIndexBuilder {
         let inner: Self = JsCast::unchecked_into(js_sys::Object::new());
         inner.set_name(name);
-        MixedWithIndexBuilder { inner }
-    }
-}
-pub struct MixedWithIndexBuilder {
-    inner: MixedWithIndex,
-}
-impl MixedWithIndexBuilder {
-    pub fn build(self) -> MixedWithIndex {
-        self.inner
+        inner
     }
 }
 #[wasm_bindgen]
@@ -80,20 +58,9 @@ extern "C" {
 }
 impl HasName {
     pub fn new(name: &str) -> HasName {
-        Self::builder(name).build()
-    }
-    pub fn builder(name: &str) -> HasNameBuilder {
         let inner: Self = JsCast::unchecked_into(js_sys::Object::new());
         inner.set_name(name);
-        HasNameBuilder { inner }
-    }
-}
-pub struct HasNameBuilder {
-    inner: HasName,
-}
-impl HasNameBuilder {
-    pub fn build(self) -> HasName {
-        self.inner
+        inner
     }
 }
 #[wasm_bindgen]
@@ -108,20 +75,9 @@ extern "C" {
 }
 impl HasAge {
     pub fn new(age: f64) -> HasAge {
-        Self::builder(age).build()
-    }
-    pub fn builder(age: f64) -> HasAgeBuilder {
         let inner: Self = JsCast::unchecked_into(js_sys::Object::new());
         inner.set_age(age);
-        HasAgeBuilder { inner }
-    }
-}
-pub struct HasAgeBuilder {
-    inner: HasAge,
-}
-impl HasAgeBuilder {
-    pub fn build(self) -> HasAge {
-        self.inner
+        inner
     }
 }
 #[allow(dead_code)]
@@ -261,21 +217,10 @@ extern "C" {
 }
 impl LinkedList {
     pub fn new(data: &JsValue, next: Option<&LinkedList>) -> LinkedList {
-        Self::builder(data, next).build()
-    }
-    pub fn builder(data: &JsValue, next: Option<&LinkedList>) -> LinkedListBuilder {
         let inner: Self = JsCast::unchecked_into(js_sys::Object::new());
         inner.set_data(data);
         inner.set_next(next);
-        LinkedListBuilder { inner }
-    }
-}
-pub struct LinkedListBuilder {
-    inner: LinkedList,
-}
-impl LinkedListBuilder {
-    pub fn build(self) -> LinkedList {
-        self.inner
+        inner
     }
 }
 #[wasm_bindgen]
@@ -333,20 +278,9 @@ extern "C" {
 }
 impl MultiExtend {
     pub fn new(id: &str) -> MultiExtend {
-        Self::builder(id).build()
-    }
-    pub fn builder(id: &str) -> MultiExtendBuilder {
         let inner: Self = JsCast::unchecked_into(js_sys::Object::new());
         inner.set_id(id);
-        MultiExtendBuilder { inner }
-    }
-}
-pub struct MultiExtendBuilder {
-    inner: MultiExtend,
-}
-impl MultiExtendBuilder {
-    pub fn build(self) -> MultiExtend {
-        self.inner
+        inner
     }
 }
 #[wasm_bindgen]