[fidl][llcpp] improve union setting

Adds methods to directly set unions without explicitly allocating the
underneath data.

Bug: 60240
Change-Id: I893395375e2b8673966901dbf5b8295170d9244a
Reviewed-on: https://fuchsia-review.googlesource.com/c/fuchsia/+/472165
Reviewed-by: Yifei Teng <yifeit@google.com>
Commit-Queue: Vincent Belliard <vbelliard@google.com>
diff --git a/src/developer/shell/common/ast_builder.h b/src/developer/shell/common/ast_builder.h
index 4758f1b..a902063 100644
--- a/src/developer/shell/common/ast_builder.h
+++ b/src/developer/shell/common/ast_builder.h
@@ -102,8 +102,7 @@
   }
 
   llcpp::fuchsia::shell::ShellType TypeBuiltin(llcpp::fuchsia::shell::BuiltinType type) {
-    fidl::ObjectView<llcpp::fuchsia::shell::BuiltinType> copy(allocator_, type);
-    return llcpp::fuchsia::shell::ShellType::WithBuiltinType(copy);
+    return llcpp::fuchsia::shell::ShellType::WithBuiltinType(allocator_, type);
   }
 
   // The following methods generate a ShellType object for the given type.
diff --git a/src/developer/shell/console/command.cc b/src/developer/shell/console/command.cc
index dcd61fe..a1c10e5 100644
--- a/src/developer/shell/console/command.cc
+++ b/src/developer/shell/console/command.cc
@@ -173,9 +173,9 @@
 
   IdAndType VisitString(const parser::ast::String& node) override {
     AstBuilder::NodeId id = builder_->AddStringLiteral(node.value());
-    fidl::ObjectView<llcpp::fuchsia::shell::BuiltinType> builtin_type(
-        builder_->allocator(), llcpp::fuchsia::shell::BuiltinType::STRING);
-    return {.id = id, .type = llcpp::fuchsia::shell::ShellType::WithBuiltinType(builtin_type)};
+    return {.id = id,
+            .type = llcpp::fuchsia::shell::ShellType::WithBuiltinType(
+                builder_->allocator(), llcpp::fuchsia::shell::BuiltinType::STRING)};
   }
 
   IdAndType VisitObject(const parser::ast::Object& node) override {
@@ -187,11 +187,9 @@
 
     auto result = builder_->CloseObject();
     AstBuilder::NodeId id = result.value_node;
-
-    fidl::ObjectView<llcpp::fuchsia::shell::NodeId> shell_id(builder_->allocator(),
-                                                             result.schema_node);
-
-    return {.id = id, .type = llcpp::fuchsia::shell::ShellType::WithObjectSchema(shell_id)};
+    return {.id = id,
+            .type = llcpp::fuchsia::shell::ShellType::WithObjectSchema(builder_->allocator(),
+                                                                       result.schema_node)};
   }
 
   IdAndType VisitField(const parser::ast::Field& node) override {
diff --git a/src/lib/fidl/llcpp/tests/handle_test.cc b/src/lib/fidl/llcpp/tests/handle_test.cc
index 4d70b42..40ab3fe 100644
--- a/src/lib/fidl/llcpp/tests/handle_test.cc
+++ b/src/lib/fidl/llcpp/tests/handle_test.cc
@@ -82,13 +82,11 @@
     fidl::FidlAllocator allocator;
     test::HandleUnion u;
     if (field == 1) {
-      fidl::ObjectView<zx::event> e(allocator);
-      zx::event::create(0, e.get());
-      u = test::HandleUnion::WithH1(e);
+      u.set_h1(allocator);
+      zx::event::create(0, &u.mutable_h1());
     } else if (field == 2) {
-      fidl::ObjectView<test::HandleStruct> s(allocator);
-      zx::event::create(0, &s->h);
-      u = test::HandleUnion::WithH2(s);
+      u.set_h2(allocator);
+      zx::event::create(0, &u.mutable_h2().h);
     }
     completer.Reply(std::move(u));
   }
@@ -97,13 +95,12 @@
     fidl::FidlAllocator allocator;
     test::HandleUnionStruct u;
     if (field == 1) {
-      fidl::ObjectView<zx::event> e(allocator);
-      zx::event::create(0, e.get());
-      u.u = test::HandleUnion::WithH1(e);
+      zx::event event;
+      zx::event::create(0, &event);
+      u.u.set_h1(allocator, std::move(event));
     } else if (field == 2) {
-      fidl::ObjectView<test::HandleStruct> s(allocator);
-      zx::event::create(0, &s->h);
-      u.u = test::HandleUnion::WithH2(s);
+      u.u.set_h2(allocator);
+      zx::event::create(0, &u.u.mutable_h2().h);
     }
     completer.Reply(std::move(u));
   }
@@ -153,13 +150,12 @@
     fidl::FidlAllocator allocator;
     test::HandleUnion u;
     if (field == 1) {
-      fidl::ObjectView<zx::event> e(allocator);
-      zx::event::create(0, e.get());
-      u = test::HandleUnion::WithH1(e);
+      zx::event event;
+      zx::event::create(0, &event);
+      u.set_h1(allocator, std::move(event));
     } else if (field == 2) {
-      fidl::ObjectView<test::HandleStruct> s(allocator);
-      zx::event::create(0, &s->h);
-      u = test::HandleUnion::WithH2(s);
+      u.set_h2(allocator);
+      zx::event::create(0, &u.mutable_h2().h);
     }
     completer.Reply(std::move(u));
   }
@@ -170,13 +166,12 @@
       fidl::FidlAllocator allocator;
       fidl::ObjectView<test::HandleUnionStruct> u(allocator);
       if (field == 1) {
-        fidl::ObjectView<zx::event> e(allocator);
-        zx::event::create(0, e.get());
-        u->u = test::HandleUnion::WithH1(e);
+        zx::event event;
+        zx::event::create(0, &event);
+        u->u.set_h1(allocator, std::move(event));
       } else if (field == 2) {
-        fidl::ObjectView<test::HandleStruct> s(allocator);
-        zx::event::create(0, &s->h);
-        u->u = test::HandleUnion::WithH2(s);
+        u->u.set_h2(allocator);
+        zx::event::create(0, &u->u.mutable_h2().h);
       }
       completer.Reply(u);
     } else {
@@ -223,13 +218,13 @@
     test::HandleUnionOptionalStruct reply;
     if (defined) {
       if (field == 1) {
-        fidl::ObjectView<zx::event> e(allocator);
-        zx::event::create(0, e.get());
-        reply.u = test::HandleUnion::WithH1(e);
+        zx::event event;
+        zx::event::create(0, &event);
+        reply.u.set_h1(allocator, std::move(event));
       } else if (field == 2) {
         fidl::ObjectView<test::HandleStruct> s(allocator);
-        zx::event::create(0, &s->h);
-        reply.u = test::HandleUnion::WithH2(s);
+        reply.u.set_h2(allocator);
+        zx::event::create(0, &reply.u.mutable_h2().h);
       }
     }
     completer.Reply(std::move(reply));
diff --git a/tools/fidl/fidlgen_llcpp/codegen/fragment_union.tmpl.go b/tools/fidl/fidlgen_llcpp/codegen/fragment_union.tmpl.go
index 59c0338..b3e85e5 100644
--- a/tools/fidl/fidlgen_llcpp/codegen/fragment_union.tmpl.go
+++ b/tools/fidl/fidlgen_llcpp/codegen/fragment_union.tmpl.go
@@ -59,6 +59,14 @@
     result.set_{{ .Name }}(std::move(val));
     return result;
   }
+
+  template <typename... Args>
+  static {{ $.Name }} With{{ .UpperCamelCaseName }}(::fidl::AnyAllocator& allocator, Args&&... args) {
+    {{ $.Name }} result;
+    result.set_{{ .Name }}(::fidl::ObjectView<{{ .Type.LLDecl }}>(allocator,
+                           std::forward<Args>(args)...));
+    return result;
+  }
 {{ "" }}
   {{- range .DocComments }}
   //{{ . }}
@@ -68,11 +76,6 @@
     reset_ptr(static_cast<::fidl::tracking_ptr<void>>(std::move(elem)));
   }
 
-  void set_{{ .Name }}(::fidl::AnyAllocator& allocator) {
-    ordinal_ = Ordinal::{{ .TagName }};
-    set_{{ .Name }}(::fidl::ObjectView<{{ .Type.LLDecl }}>(allocator));
-  }
-
   template <typename... Args>
   void set_{{ .Name }}(::fidl::AnyAllocator& allocator, Args&&... args) {
     ordinal_ = Ordinal::{{ .TagName }};
diff --git a/tools/fidl/fidlgen_llcpp/goldens/arrays.h.golden b/tools/fidl/fidlgen_llcpp/goldens/arrays.h.golden
index 7198032..347c813 100644
--- a/tools/fidl/fidlgen_llcpp/goldens/arrays.h.golden
+++ b/tools/fidl/fidlgen_llcpp/goldens/arrays.h.golden
@@ -76,16 +76,20 @@
     return result;
   }
 
+  template <typename... Args>
+  static UnionSmallArray WithA(::fidl::AnyAllocator& allocator,
+                               Args&&... args) {
+    UnionSmallArray result;
+    result.set_a(::fidl::ObjectView<::fidl::Array<uint32_t, 2>>(
+        allocator, std::forward<Args>(args)...));
+    return result;
+  }
+
   void set_a(::fidl::tracking_ptr<::fidl::Array<uint32_t, 2>>&& elem) {
     ordinal_ = Ordinal::kA;
     reset_ptr(static_cast<::fidl::tracking_ptr<void>>(std::move(elem)));
   }
 
-  void set_a(::fidl::AnyAllocator& allocator) {
-    ordinal_ = Ordinal::kA;
-    set_a(::fidl::ObjectView<::fidl::Array<uint32_t, 2>>(allocator));
-  }
-
   template <typename... Args>
   void set_a(::fidl::AnyAllocator& allocator, Args&&... args) {
     ordinal_ = Ordinal::kA;
@@ -165,16 +169,20 @@
     return result;
   }
 
+  template <typename... Args>
+  static UnionLargeArray WithA(::fidl::AnyAllocator& allocator,
+                               Args&&... args) {
+    UnionLargeArray result;
+    result.set_a(::fidl::ObjectView<::fidl::Array<uint32_t, 100>>(
+        allocator, std::forward<Args>(args)...));
+    return result;
+  }
+
   void set_a(::fidl::tracking_ptr<::fidl::Array<uint32_t, 100>>&& elem) {
     ordinal_ = Ordinal::kA;
     reset_ptr(static_cast<::fidl::tracking_ptr<void>>(std::move(elem)));
   }
 
-  void set_a(::fidl::AnyAllocator& allocator) {
-    ordinal_ = Ordinal::kA;
-    set_a(::fidl::ObjectView<::fidl::Array<uint32_t, 100>>(allocator));
-  }
-
   template <typename... Args>
   void set_a(::fidl::AnyAllocator& allocator, Args&&... args) {
     ordinal_ = Ordinal::kA;
diff --git a/tools/fidl/fidlgen_llcpp/goldens/bindings_denylist.h.golden b/tools/fidl/fidlgen_llcpp/goldens/bindings_denylist.h.golden
index 16e70ab..cbe9c0f9 100644
--- a/tools/fidl/fidlgen_llcpp/goldens/bindings_denylist.h.golden
+++ b/tools/fidl/fidlgen_llcpp/goldens/bindings_denylist.h.golden
@@ -70,16 +70,19 @@
     return result;
   }
 
+  template <typename... Args>
+  static OnlyLlcpp WithX(::fidl::AnyAllocator& allocator, Args&&... args) {
+    OnlyLlcpp result;
+    result.set_x(
+        ::fidl::ObjectView<uint32_t>(allocator, std::forward<Args>(args)...));
+    return result;
+  }
+
   void set_x(::fidl::tracking_ptr<uint32_t>&& elem) {
     ordinal_ = Ordinal::kX;
     reset_ptr(static_cast<::fidl::tracking_ptr<void>>(std::move(elem)));
   }
 
-  void set_x(::fidl::AnyAllocator& allocator) {
-    ordinal_ = Ordinal::kX;
-    set_x(::fidl::ObjectView<uint32_t>(allocator));
-  }
-
   template <typename... Args>
   void set_x(::fidl::AnyAllocator& allocator, Args&&... args) {
     ordinal_ = Ordinal::kX;
diff --git a/tools/fidl/fidlgen_llcpp/goldens/doc_comments.h.golden b/tools/fidl/fidlgen_llcpp/goldens/doc_comments.h.golden
index db320410..9fe78ec 100644
--- a/tools/fidl/fidlgen_llcpp/goldens/doc_comments.h.golden
+++ b/tools/fidl/fidlgen_llcpp/goldens/doc_comments.h.golden
@@ -640,6 +640,15 @@
     return result;
   }
 
+  template <typename... Args>
+  static StrictUnion WithField(::fidl::AnyAllocator& allocator,
+                               Args&&... args) {
+    StrictUnion result;
+    result.set_Field(
+        ::fidl::ObjectView<int32_t>(allocator, std::forward<Args>(args)...));
+    return result;
+  }
+
   // union member comment #1
   //
   // union member comment #3
@@ -648,11 +657,6 @@
     reset_ptr(static_cast<::fidl::tracking_ptr<void>>(std::move(elem)));
   }
 
-  void set_Field(::fidl::AnyAllocator& allocator) {
-    ordinal_ = Ordinal::kField;
-    set_Field(::fidl::ObjectView<int32_t>(allocator));
-  }
-
   template <typename... Args>
   void set_Field(::fidl::AnyAllocator& allocator, Args&&... args) {
     ordinal_ = Ordinal::kField;
@@ -738,6 +742,15 @@
     return result;
   }
 
+  template <typename... Args>
+  static FlexibleUnion WithField(::fidl::AnyAllocator& allocator,
+                                 Args&&... args) {
+    FlexibleUnion result;
+    result.set_Field(
+        ::fidl::ObjectView<int32_t>(allocator, std::forward<Args>(args)...));
+    return result;
+  }
+
   // union member comment #1
   //
   // union member comment #3
@@ -746,11 +759,6 @@
     reset_ptr(static_cast<::fidl::tracking_ptr<void>>(std::move(elem)));
   }
 
-  void set_Field(::fidl::AnyAllocator& allocator) {
-    ordinal_ = Ordinal::kField;
-    set_Field(::fidl::ObjectView<int32_t>(allocator));
-  }
-
   template <typename... Args>
   void set_Field(::fidl::AnyAllocator& allocator, Args&&... args) {
     ordinal_ = Ordinal::kField;
diff --git a/tools/fidl/fidlgen_llcpp/goldens/error.h.golden b/tools/fidl/fidlgen_llcpp/goldens/error.h.golden
index 30c13c96..d991ba0 100644
--- a/tools/fidl/fidlgen_llcpp/goldens/error.h.golden
+++ b/tools/fidl/fidlgen_llcpp/goldens/error.h.golden
@@ -76,6 +76,16 @@
     return result;
   }
 
+  template <typename... Args>
+  static Example_foo_Result WithResponse(::fidl::AnyAllocator& allocator,
+                                         Args&&... args) {
+    Example_foo_Result result;
+    result.set_response(
+        ::fidl::ObjectView<::llcpp::fidl::test::error::Example_foo_Response>(
+            allocator, std::forward<Args>(args)...));
+    return result;
+  }
+
   void set_response(
       ::fidl::tracking_ptr<::llcpp::fidl::test::error::Example_foo_Response>&&
           elem) {
@@ -83,13 +93,6 @@
     reset_ptr(static_cast<::fidl::tracking_ptr<void>>(std::move(elem)));
   }
 
-  void set_response(::fidl::AnyAllocator& allocator) {
-    ordinal_ = Ordinal::kResponse;
-    set_response(
-        ::fidl::ObjectView<::llcpp::fidl::test::error::Example_foo_Response>(
-            allocator));
-  }
-
   template <typename... Args>
   void set_response(::fidl::AnyAllocator& allocator, Args&&... args) {
     ordinal_ = Ordinal::kResponse;
@@ -117,16 +120,20 @@
     return result;
   }
 
+  template <typename... Args>
+  static Example_foo_Result WithErr(::fidl::AnyAllocator& allocator,
+                                    Args&&... args) {
+    Example_foo_Result result;
+    result.set_err(
+        ::fidl::ObjectView<uint32_t>(allocator, std::forward<Args>(args)...));
+    return result;
+  }
+
   void set_err(::fidl::tracking_ptr<uint32_t>&& elem) {
     ordinal_ = Ordinal::kErr;
     reset_ptr(static_cast<::fidl::tracking_ptr<void>>(std::move(elem)));
   }
 
-  void set_err(::fidl::AnyAllocator& allocator) {
-    ordinal_ = Ordinal::kErr;
-    set_err(::fidl::ObjectView<uint32_t>(allocator));
-  }
-
   template <typename... Args>
   void set_err(::fidl::AnyAllocator& allocator, Args&&... args) {
     ordinal_ = Ordinal::kErr;
diff --git a/tools/fidl/fidlgen_llcpp/goldens/handles_in_types.h.golden b/tools/fidl/fidlgen_llcpp/goldens/handles_in_types.h.golden
index f923b2d..6a6332b 100644
--- a/tools/fidl/fidlgen_llcpp/goldens/handles_in_types.h.golden
+++ b/tools/fidl/fidlgen_llcpp/goldens/handles_in_types.h.golden
@@ -82,16 +82,20 @@
     return result;
   }
 
+  template <typename... Args>
+  static UnionWithHandle WithH(::fidl::AnyAllocator& allocator,
+                               Args&&... args) {
+    UnionWithHandle result;
+    result.set_h(
+        ::fidl::ObjectView<::zx::vmo>(allocator, std::forward<Args>(args)...));
+    return result;
+  }
+
   void set_h(::fidl::tracking_ptr<::zx::vmo>&& elem) {
     ordinal_ = Ordinal::kH;
     reset_ptr(static_cast<::fidl::tracking_ptr<void>>(std::move(elem)));
   }
 
-  void set_h(::fidl::AnyAllocator& allocator) {
-    ordinal_ = Ordinal::kH;
-    set_h(::fidl::ObjectView<::zx::vmo>(allocator));
-  }
-
   template <typename... Args>
   void set_h(::fidl::AnyAllocator& allocator, Args&&... args) {
     ordinal_ = Ordinal::kH;
diff --git a/tools/fidl/fidlgen_llcpp/goldens/nullable.h.golden b/tools/fidl/fidlgen_llcpp/goldens/nullable.h.golden
index 0ba10c4..fe5b852 100644
--- a/tools/fidl/fidlgen_llcpp/goldens/nullable.h.golden
+++ b/tools/fidl/fidlgen_llcpp/goldens/nullable.h.golden
@@ -83,16 +83,19 @@
     return result;
   }
 
+  template <typename... Args>
+  static SimpleUnion WithA(::fidl::AnyAllocator& allocator, Args&&... args) {
+    SimpleUnion result;
+    result.set_a(
+        ::fidl::ObjectView<int32_t>(allocator, std::forward<Args>(args)...));
+    return result;
+  }
+
   void set_a(::fidl::tracking_ptr<int32_t>&& elem) {
     ordinal_ = Ordinal::kA;
     reset_ptr(static_cast<::fidl::tracking_ptr<void>>(std::move(elem)));
   }
 
-  void set_a(::fidl::AnyAllocator& allocator) {
-    ordinal_ = Ordinal::kA;
-    set_a(::fidl::ObjectView<int32_t>(allocator));
-  }
-
   template <typename... Args>
   void set_a(::fidl::AnyAllocator& allocator, Args&&... args) {
     ordinal_ = Ordinal::kA;
@@ -116,16 +119,19 @@
     return result;
   }
 
+  template <typename... Args>
+  static SimpleUnion WithB(::fidl::AnyAllocator& allocator, Args&&... args) {
+    SimpleUnion result;
+    result.set_b(
+        ::fidl::ObjectView<float>(allocator, std::forward<Args>(args)...));
+    return result;
+  }
+
   void set_b(::fidl::tracking_ptr<float>&& elem) {
     ordinal_ = Ordinal::kB;
     reset_ptr(static_cast<::fidl::tracking_ptr<void>>(std::move(elem)));
   }
 
-  void set_b(::fidl::AnyAllocator& allocator) {
-    ordinal_ = Ordinal::kB;
-    set_b(::fidl::ObjectView<float>(allocator));
-  }
-
   template <typename... Args>
   void set_b(::fidl::AnyAllocator& allocator, Args&&... args) {
     ordinal_ = Ordinal::kB;
diff --git a/tools/fidl/fidlgen_llcpp/goldens/placement_of_attributes.h.golden b/tools/fidl/fidlgen_llcpp/goldens/placement_of_attributes.h.golden
index 4955e77..a1d19ce 100644
--- a/tools/fidl/fidlgen_llcpp/goldens/placement_of_attributes.h.golden
+++ b/tools/fidl/fidlgen_llcpp/goldens/placement_of_attributes.h.golden
@@ -186,16 +186,20 @@
     return result;
   }
 
+  template <typename... Args>
+  static ExampleXUnion WithVariant(::fidl::AnyAllocator& allocator,
+                                   Args&&... args) {
+    ExampleXUnion result;
+    result.set_variant(
+        ::fidl::ObjectView<uint32_t>(allocator, std::forward<Args>(args)...));
+    return result;
+  }
+
   void set_variant(::fidl::tracking_ptr<uint32_t>&& elem) {
     ordinal_ = Ordinal::kVariant;
     reset_ptr(static_cast<::fidl::tracking_ptr<void>>(std::move(elem)));
   }
 
-  void set_variant(::fidl::AnyAllocator& allocator) {
-    ordinal_ = Ordinal::kVariant;
-    set_variant(::fidl::ObjectView<uint32_t>(allocator));
-  }
-
   template <typename... Args>
   void set_variant(::fidl::AnyAllocator& allocator, Args&&... args) {
     ordinal_ = Ordinal::kVariant;
@@ -271,16 +275,20 @@
     return result;
   }
 
+  template <typename... Args>
+  static ExampleUnion WithVariant(::fidl::AnyAllocator& allocator,
+                                  Args&&... args) {
+    ExampleUnion result;
+    result.set_variant(
+        ::fidl::ObjectView<uint32_t>(allocator, std::forward<Args>(args)...));
+    return result;
+  }
+
   void set_variant(::fidl::tracking_ptr<uint32_t>&& elem) {
     ordinal_ = Ordinal::kVariant;
     reset_ptr(static_cast<::fidl::tracking_ptr<void>>(std::move(elem)));
   }
 
-  void set_variant(::fidl::AnyAllocator& allocator) {
-    ordinal_ = Ordinal::kVariant;
-    set_variant(::fidl::ObjectView<uint32_t>(allocator));
-  }
-
   template <typename... Args>
   void set_variant(::fidl::AnyAllocator& allocator, Args&&... args) {
     ordinal_ = Ordinal::kVariant;
diff --git a/tools/fidl/fidlgen_llcpp/goldens/protocols.h.golden b/tools/fidl/fidlgen_llcpp/goldens/protocols.h.golden
index fd48b0e..78e32ab39 100644
--- a/tools/fidl/fidlgen_llcpp/goldens/protocols.h.golden
+++ b/tools/fidl/fidlgen_llcpp/goldens/protocols.h.golden
@@ -105,6 +105,17 @@
     return result;
   }
 
+  template <typename... Args>
+  static WithErrorSyntax_ResponseAsStruct_Result WithResponse(
+      ::fidl::AnyAllocator& allocator, Args&&... args) {
+    WithErrorSyntax_ResponseAsStruct_Result result;
+    result.set_response(
+        ::fidl::ObjectView<::llcpp::fidl::test::protocols::
+                               WithErrorSyntax_ResponseAsStruct_Response>(
+            allocator, std::forward<Args>(args)...));
+    return result;
+  }
+
   void set_response(::fidl::tracking_ptr<
                     ::llcpp::fidl::test::protocols::
                         WithErrorSyntax_ResponseAsStruct_Response>&& elem) {
@@ -112,14 +123,6 @@
     reset_ptr(static_cast<::fidl::tracking_ptr<void>>(std::move(elem)));
   }
 
-  void set_response(::fidl::AnyAllocator& allocator) {
-    ordinal_ = Ordinal::kResponse;
-    set_response(
-        ::fidl::ObjectView<::llcpp::fidl::test::protocols::
-                               WithErrorSyntax_ResponseAsStruct_Response>(
-            allocator));
-  }
-
   template <typename... Args>
   void set_response(::fidl::AnyAllocator& allocator, Args&&... args) {
     ordinal_ = Ordinal::kResponse;
@@ -154,16 +157,20 @@
     return result;
   }
 
+  template <typename... Args>
+  static WithErrorSyntax_ResponseAsStruct_Result WithErr(
+      ::fidl::AnyAllocator& allocator, Args&&... args) {
+    WithErrorSyntax_ResponseAsStruct_Result result;
+    result.set_err(
+        ::fidl::ObjectView<uint32_t>(allocator, std::forward<Args>(args)...));
+    return result;
+  }
+
   void set_err(::fidl::tracking_ptr<uint32_t>&& elem) {
     ordinal_ = Ordinal::kErr;
     reset_ptr(static_cast<::fidl::tracking_ptr<void>>(std::move(elem)));
   }
 
-  void set_err(::fidl::AnyAllocator& allocator) {
-    ordinal_ = Ordinal::kErr;
-    set_err(::fidl::ObjectView<uint32_t>(allocator));
-  }
-
   template <typename... Args>
   void set_err(::fidl::AnyAllocator& allocator, Args&&... args) {
     ordinal_ = Ordinal::kErr;
@@ -260,6 +267,17 @@
     return result;
   }
 
+  template <typename... Args>
+  static WithErrorSyntax_ErrorAsPrimitive_Result WithResponse(
+      ::fidl::AnyAllocator& allocator, Args&&... args) {
+    WithErrorSyntax_ErrorAsPrimitive_Result result;
+    result.set_response(
+        ::fidl::ObjectView<::llcpp::fidl::test::protocols::
+                               WithErrorSyntax_ErrorAsPrimitive_Response>(
+            allocator, std::forward<Args>(args)...));
+    return result;
+  }
+
   void set_response(::fidl::tracking_ptr<
                     ::llcpp::fidl::test::protocols::
                         WithErrorSyntax_ErrorAsPrimitive_Response>&& elem) {
@@ -267,14 +285,6 @@
     reset_ptr(static_cast<::fidl::tracking_ptr<void>>(std::move(elem)));
   }
 
-  void set_response(::fidl::AnyAllocator& allocator) {
-    ordinal_ = Ordinal::kResponse;
-    set_response(
-        ::fidl::ObjectView<::llcpp::fidl::test::protocols::
-                               WithErrorSyntax_ErrorAsPrimitive_Response>(
-            allocator));
-  }
-
   template <typename... Args>
   void set_response(::fidl::AnyAllocator& allocator, Args&&... args) {
     ordinal_ = Ordinal::kResponse;
@@ -309,16 +319,20 @@
     return result;
   }
 
+  template <typename... Args>
+  static WithErrorSyntax_ErrorAsPrimitive_Result WithErr(
+      ::fidl::AnyAllocator& allocator, Args&&... args) {
+    WithErrorSyntax_ErrorAsPrimitive_Result result;
+    result.set_err(
+        ::fidl::ObjectView<uint32_t>(allocator, std::forward<Args>(args)...));
+    return result;
+  }
+
   void set_err(::fidl::tracking_ptr<uint32_t>&& elem) {
     ordinal_ = Ordinal::kErr;
     reset_ptr(static_cast<::fidl::tracking_ptr<void>>(std::move(elem)));
   }
 
-  void set_err(::fidl::AnyAllocator& allocator) {
-    ordinal_ = Ordinal::kErr;
-    set_err(::fidl::ObjectView<uint32_t>(allocator));
-  }
-
   template <typename... Args>
   void set_err(::fidl::AnyAllocator& allocator, Args&&... args) {
     ordinal_ = Ordinal::kErr;
@@ -414,6 +428,17 @@
     return result;
   }
 
+  template <typename... Args>
+  static WithErrorSyntax_ErrorAsEnum_Result WithResponse(
+      ::fidl::AnyAllocator& allocator, Args&&... args) {
+    WithErrorSyntax_ErrorAsEnum_Result result;
+    result.set_response(
+        ::fidl::ObjectView<::llcpp::fidl::test::protocols::
+                               WithErrorSyntax_ErrorAsEnum_Response>(
+            allocator, std::forward<Args>(args)...));
+    return result;
+  }
+
   void set_response(
       ::fidl::tracking_ptr<::llcpp::fidl::test::protocols::
                                WithErrorSyntax_ErrorAsEnum_Response>&& elem) {
@@ -421,13 +446,6 @@
     reset_ptr(static_cast<::fidl::tracking_ptr<void>>(std::move(elem)));
   }
 
-  void set_response(::fidl::AnyAllocator& allocator) {
-    ordinal_ = Ordinal::kResponse;
-    set_response(::fidl::ObjectView<::llcpp::fidl::test::protocols::
-                                        WithErrorSyntax_ErrorAsEnum_Response>(
-        allocator));
-  }
-
   template <typename... Args>
   void set_response(::fidl::AnyAllocator& allocator, Args&&... args) {
     ordinal_ = Ordinal::kResponse;
@@ -460,18 +478,22 @@
     return result;
   }
 
+  template <typename... Args>
+  static WithErrorSyntax_ErrorAsEnum_Result WithErr(
+      ::fidl::AnyAllocator& allocator, Args&&... args) {
+    WithErrorSyntax_ErrorAsEnum_Result result;
+    result.set_err(
+        ::fidl::ObjectView<::llcpp::fidl::test::protocols::ErrorEnun>(
+            allocator, std::forward<Args>(args)...));
+    return result;
+  }
+
   void set_err(
       ::fidl::tracking_ptr<::llcpp::fidl::test::protocols::ErrorEnun>&& elem) {
     ordinal_ = Ordinal::kErr;
     reset_ptr(static_cast<::fidl::tracking_ptr<void>>(std::move(elem)));
   }
 
-  void set_err(::fidl::AnyAllocator& allocator) {
-    ordinal_ = Ordinal::kErr;
-    set_err(::fidl::ObjectView<::llcpp::fidl::test::protocols::ErrorEnun>(
-        allocator));
-  }
-
   template <typename... Args>
   void set_err(::fidl::AnyAllocator& allocator, Args&&... args) {
     ordinal_ = Ordinal::kErr;
diff --git a/tools/fidl/fidlgen_llcpp/goldens/request_flexible_envelope.h.golden b/tools/fidl/fidlgen_llcpp/goldens/request_flexible_envelope.h.golden
index d03b209..9d5a50e 100644
--- a/tools/fidl/fidlgen_llcpp/goldens/request_flexible_envelope.h.golden
+++ b/tools/fidl/fidlgen_llcpp/goldens/request_flexible_envelope.h.golden
@@ -74,16 +74,19 @@
     return result;
   }
 
+  template <typename... Args>
+  static StrictFoo WithS(::fidl::AnyAllocator& allocator, Args&&... args) {
+    StrictFoo result;
+    result.set_s(::fidl::ObjectView<::fidl::StringView>(
+        allocator, std::forward<Args>(args)...));
+    return result;
+  }
+
   void set_s(::fidl::tracking_ptr<::fidl::StringView>&& elem) {
     ordinal_ = Ordinal::kS;
     reset_ptr(static_cast<::fidl::tracking_ptr<void>>(std::move(elem)));
   }
 
-  void set_s(::fidl::AnyAllocator& allocator) {
-    ordinal_ = Ordinal::kS;
-    set_s(::fidl::ObjectView<::fidl::StringView>(allocator));
-  }
-
   template <typename... Args>
   void set_s(::fidl::AnyAllocator& allocator, Args&&... args) {
     ordinal_ = Ordinal::kS;
@@ -108,16 +111,19 @@
     return result;
   }
 
+  template <typename... Args>
+  static StrictFoo WithI(::fidl::AnyAllocator& allocator, Args&&... args) {
+    StrictFoo result;
+    result.set_i(
+        ::fidl::ObjectView<int32_t>(allocator, std::forward<Args>(args)...));
+    return result;
+  }
+
   void set_i(::fidl::tracking_ptr<int32_t>&& elem) {
     ordinal_ = Ordinal::kI;
     reset_ptr(static_cast<::fidl::tracking_ptr<void>>(std::move(elem)));
   }
 
-  void set_i(::fidl::AnyAllocator& allocator) {
-    ordinal_ = Ordinal::kI;
-    set_i(::fidl::ObjectView<int32_t>(allocator));
-  }
-
   template <typename... Args>
   void set_i(::fidl::AnyAllocator& allocator, Args&&... args) {
     ordinal_ = Ordinal::kI;
@@ -204,16 +210,19 @@
     return result;
   }
 
+  template <typename... Args>
+  static FlexibleFoo WithS(::fidl::AnyAllocator& allocator, Args&&... args) {
+    FlexibleFoo result;
+    result.set_s(::fidl::ObjectView<::fidl::StringView>(
+        allocator, std::forward<Args>(args)...));
+    return result;
+  }
+
   void set_s(::fidl::tracking_ptr<::fidl::StringView>&& elem) {
     ordinal_ = Ordinal::kS;
     reset_ptr(static_cast<::fidl::tracking_ptr<void>>(std::move(elem)));
   }
 
-  void set_s(::fidl::AnyAllocator& allocator) {
-    ordinal_ = Ordinal::kS;
-    set_s(::fidl::ObjectView<::fidl::StringView>(allocator));
-  }
-
   template <typename... Args>
   void set_s(::fidl::AnyAllocator& allocator, Args&&... args) {
     ordinal_ = Ordinal::kS;
@@ -238,16 +247,19 @@
     return result;
   }
 
+  template <typename... Args>
+  static FlexibleFoo WithI(::fidl::AnyAllocator& allocator, Args&&... args) {
+    FlexibleFoo result;
+    result.set_i(
+        ::fidl::ObjectView<int32_t>(allocator, std::forward<Args>(args)...));
+    return result;
+  }
+
   void set_i(::fidl::tracking_ptr<int32_t>&& elem) {
     ordinal_ = Ordinal::kI;
     reset_ptr(static_cast<::fidl::tracking_ptr<void>>(std::move(elem)));
   }
 
-  void set_i(::fidl::AnyAllocator& allocator) {
-    ordinal_ = Ordinal::kI;
-    set_i(::fidl::ObjectView<int32_t>(allocator));
-  }
-
   template <typename... Args>
   void set_i(::fidl::AnyAllocator& allocator, Args&&... args) {
     ordinal_ = Ordinal::kI;
diff --git a/tools/fidl/fidlgen_llcpp/goldens/union.h.golden b/tools/fidl/fidlgen_llcpp/goldens/union.h.golden
index aa05fa9..7ffb319 100644
--- a/tools/fidl/fidlgen_llcpp/goldens/union.h.golden
+++ b/tools/fidl/fidlgen_llcpp/goldens/union.h.golden
@@ -98,16 +98,19 @@
     return result;
   }
 
+  template <typename... Args>
+  static Union WithPrimitive(::fidl::AnyAllocator& allocator, Args&&... args) {
+    Union result;
+    result.set_Primitive(
+        ::fidl::ObjectView<int32_t>(allocator, std::forward<Args>(args)...));
+    return result;
+  }
+
   void set_Primitive(::fidl::tracking_ptr<int32_t>&& elem) {
     ordinal_ = Ordinal::kPrimitive;
     reset_ptr(static_cast<::fidl::tracking_ptr<void>>(std::move(elem)));
   }
 
-  void set_Primitive(::fidl::AnyAllocator& allocator) {
-    ordinal_ = Ordinal::kPrimitive;
-    set_Primitive(::fidl::ObjectView<int32_t>(allocator));
-  }
-
   template <typename... Args>
   void set_Primitive(::fidl::AnyAllocator& allocator, Args&&... args) {
     ordinal_ = Ordinal::kPrimitive;
@@ -135,18 +138,21 @@
     return result;
   }
 
+  template <typename... Args>
+  static Union WithStringNeedsConstructor(::fidl::AnyAllocator& allocator,
+                                          Args&&... args) {
+    Union result;
+    result.set_StringNeedsConstructor(::fidl::ObjectView<::fidl::StringView>(
+        allocator, std::forward<Args>(args)...));
+    return result;
+  }
+
   void set_StringNeedsConstructor(
       ::fidl::tracking_ptr<::fidl::StringView>&& elem) {
     ordinal_ = Ordinal::kStringNeedsConstructor;
     reset_ptr(static_cast<::fidl::tracking_ptr<void>>(std::move(elem)));
   }
 
-  void set_StringNeedsConstructor(::fidl::AnyAllocator& allocator) {
-    ordinal_ = Ordinal::kStringNeedsConstructor;
-    set_StringNeedsConstructor(
-        ::fidl::ObjectView<::fidl::StringView>(allocator));
-  }
-
   template <typename... Args>
   void set_StringNeedsConstructor(::fidl::AnyAllocator& allocator,
                                   Args&&... args) {
@@ -175,18 +181,22 @@
     return result;
   }
 
+  template <typename... Args>
+  static Union WithVectorStringAlsoNeedsConstructor(
+      ::fidl::AnyAllocator& allocator, Args&&... args) {
+    Union result;
+    result.set_VectorStringAlsoNeedsConstructor(
+        ::fidl::ObjectView<::fidl::VectorView<::fidl::StringView>>(
+            allocator, std::forward<Args>(args)...));
+    return result;
+  }
+
   void set_VectorStringAlsoNeedsConstructor(
       ::fidl::tracking_ptr<::fidl::VectorView<::fidl::StringView>>&& elem) {
     ordinal_ = Ordinal::kVectorStringAlsoNeedsConstructor;
     reset_ptr(static_cast<::fidl::tracking_ptr<void>>(std::move(elem)));
   }
 
-  void set_VectorStringAlsoNeedsConstructor(::fidl::AnyAllocator& allocator) {
-    ordinal_ = Ordinal::kVectorStringAlsoNeedsConstructor;
-    set_VectorStringAlsoNeedsConstructor(
-        ::fidl::ObjectView<::fidl::VectorView<::fidl::StringView>>(allocator));
-  }
-
   template <typename... Args>
   void set_VectorStringAlsoNeedsConstructor(::fidl::AnyAllocator& allocator,
                                             Args&&... args) {
@@ -287,16 +297,20 @@
     return result;
   }
 
+  template <typename... Args>
+  static StrictUnion WithPrimitive(::fidl::AnyAllocator& allocator,
+                                   Args&&... args) {
+    StrictUnion result;
+    result.set_Primitive(
+        ::fidl::ObjectView<int32_t>(allocator, std::forward<Args>(args)...));
+    return result;
+  }
+
   void set_Primitive(::fidl::tracking_ptr<int32_t>&& elem) {
     ordinal_ = Ordinal::kPrimitive;
     reset_ptr(static_cast<::fidl::tracking_ptr<void>>(std::move(elem)));
   }
 
-  void set_Primitive(::fidl::AnyAllocator& allocator) {
-    ordinal_ = Ordinal::kPrimitive;
-    set_Primitive(::fidl::ObjectView<int32_t>(allocator));
-  }
-
   template <typename... Args>
   void set_Primitive(::fidl::AnyAllocator& allocator, Args&&... args) {
     ordinal_ = Ordinal::kPrimitive;
@@ -324,18 +338,21 @@
     return result;
   }
 
+  template <typename... Args>
+  static StrictUnion WithStringNeedsConstructor(::fidl::AnyAllocator& allocator,
+                                                Args&&... args) {
+    StrictUnion result;
+    result.set_StringNeedsConstructor(::fidl::ObjectView<::fidl::StringView>(
+        allocator, std::forward<Args>(args)...));
+    return result;
+  }
+
   void set_StringNeedsConstructor(
       ::fidl::tracking_ptr<::fidl::StringView>&& elem) {
     ordinal_ = Ordinal::kStringNeedsConstructor;
     reset_ptr(static_cast<::fidl::tracking_ptr<void>>(std::move(elem)));
   }
 
-  void set_StringNeedsConstructor(::fidl::AnyAllocator& allocator) {
-    ordinal_ = Ordinal::kStringNeedsConstructor;
-    set_StringNeedsConstructor(
-        ::fidl::ObjectView<::fidl::StringView>(allocator));
-  }
-
   template <typename... Args>
   void set_StringNeedsConstructor(::fidl::AnyAllocator& allocator,
                                   Args&&... args) {
@@ -364,18 +381,22 @@
     return result;
   }
 
+  template <typename... Args>
+  static StrictUnion WithVectorStringAlsoNeedsConstructor(
+      ::fidl::AnyAllocator& allocator, Args&&... args) {
+    StrictUnion result;
+    result.set_VectorStringAlsoNeedsConstructor(
+        ::fidl::ObjectView<::fidl::VectorView<::fidl::StringView>>(
+            allocator, std::forward<Args>(args)...));
+    return result;
+  }
+
   void set_VectorStringAlsoNeedsConstructor(
       ::fidl::tracking_ptr<::fidl::VectorView<::fidl::StringView>>&& elem) {
     ordinal_ = Ordinal::kVectorStringAlsoNeedsConstructor;
     reset_ptr(static_cast<::fidl::tracking_ptr<void>>(std::move(elem)));
   }
 
-  void set_VectorStringAlsoNeedsConstructor(::fidl::AnyAllocator& allocator) {
-    ordinal_ = Ordinal::kVectorStringAlsoNeedsConstructor;
-    set_VectorStringAlsoNeedsConstructor(
-        ::fidl::ObjectView<::fidl::VectorView<::fidl::StringView>>(allocator));
-  }
-
   template <typename... Args>
   void set_VectorStringAlsoNeedsConstructor(::fidl::AnyAllocator& allocator,
                                             Args&&... args) {
@@ -476,16 +497,20 @@
     return result;
   }
 
+  template <typename... Args>
+  static StrictSimpleXUnion WithI(::fidl::AnyAllocator& allocator,
+                                  Args&&... args) {
+    StrictSimpleXUnion result;
+    result.set_i(
+        ::fidl::ObjectView<int32_t>(allocator, std::forward<Args>(args)...));
+    return result;
+  }
+
   void set_i(::fidl::tracking_ptr<int32_t>&& elem) {
     ordinal_ = Ordinal::kI;
     reset_ptr(static_cast<::fidl::tracking_ptr<void>>(std::move(elem)));
   }
 
-  void set_i(::fidl::AnyAllocator& allocator) {
-    ordinal_ = Ordinal::kI;
-    set_i(::fidl::ObjectView<int32_t>(allocator));
-  }
-
   template <typename... Args>
   void set_i(::fidl::AnyAllocator& allocator, Args&&... args) {
     ordinal_ = Ordinal::kI;
@@ -509,16 +534,20 @@
     return result;
   }
 
+  template <typename... Args>
+  static StrictSimpleXUnion WithF(::fidl::AnyAllocator& allocator,
+                                  Args&&... args) {
+    StrictSimpleXUnion result;
+    result.set_f(
+        ::fidl::ObjectView<float>(allocator, std::forward<Args>(args)...));
+    return result;
+  }
+
   void set_f(::fidl::tracking_ptr<float>&& elem) {
     ordinal_ = Ordinal::kF;
     reset_ptr(static_cast<::fidl::tracking_ptr<void>>(std::move(elem)));
   }
 
-  void set_f(::fidl::AnyAllocator& allocator) {
-    ordinal_ = Ordinal::kF;
-    set_f(::fidl::ObjectView<float>(allocator));
-  }
-
   template <typename... Args>
   void set_f(::fidl::AnyAllocator& allocator, Args&&... args) {
     ordinal_ = Ordinal::kF;
@@ -543,16 +572,20 @@
     return result;
   }
 
+  template <typename... Args>
+  static StrictSimpleXUnion WithS(::fidl::AnyAllocator& allocator,
+                                  Args&&... args) {
+    StrictSimpleXUnion result;
+    result.set_s(::fidl::ObjectView<::fidl::StringView>(
+        allocator, std::forward<Args>(args)...));
+    return result;
+  }
+
   void set_s(::fidl::tracking_ptr<::fidl::StringView>&& elem) {
     ordinal_ = Ordinal::kS;
     reset_ptr(static_cast<::fidl::tracking_ptr<void>>(std::move(elem)));
   }
 
-  void set_s(::fidl::AnyAllocator& allocator) {
-    ordinal_ = Ordinal::kS;
-    set_s(::fidl::ObjectView<::fidl::StringView>(allocator));
-  }
-
   template <typename... Args>
   void set_s(::fidl::AnyAllocator& allocator, Args&&... args) {
     ordinal_ = Ordinal::kS;
@@ -645,16 +678,19 @@
     return result;
   }
 
+  template <typename... Args>
+  static StrictFoo WithS(::fidl::AnyAllocator& allocator, Args&&... args) {
+    StrictFoo result;
+    result.set_s(::fidl::ObjectView<::fidl::StringView>(
+        allocator, std::forward<Args>(args)...));
+    return result;
+  }
+
   void set_s(::fidl::tracking_ptr<::fidl::StringView>&& elem) {
     ordinal_ = Ordinal::kS;
     reset_ptr(static_cast<::fidl::tracking_ptr<void>>(std::move(elem)));
   }
 
-  void set_s(::fidl::AnyAllocator& allocator) {
-    ordinal_ = Ordinal::kS;
-    set_s(::fidl::ObjectView<::fidl::StringView>(allocator));
-  }
-
   template <typename... Args>
   void set_s(::fidl::AnyAllocator& allocator, Args&&... args) {
     ordinal_ = Ordinal::kS;
@@ -679,16 +715,19 @@
     return result;
   }
 
+  template <typename... Args>
+  static StrictFoo WithI(::fidl::AnyAllocator& allocator, Args&&... args) {
+    StrictFoo result;
+    result.set_i(
+        ::fidl::ObjectView<int32_t>(allocator, std::forward<Args>(args)...));
+    return result;
+  }
+
   void set_i(::fidl::tracking_ptr<int32_t>&& elem) {
     ordinal_ = Ordinal::kI;
     reset_ptr(static_cast<::fidl::tracking_ptr<void>>(std::move(elem)));
   }
 
-  void set_i(::fidl::AnyAllocator& allocator) {
-    ordinal_ = Ordinal::kI;
-    set_i(::fidl::ObjectView<int32_t>(allocator));
-  }
-
   template <typename... Args>
   void set_i(::fidl::AnyAllocator& allocator, Args&&... args) {
     ordinal_ = Ordinal::kI;
@@ -773,16 +812,20 @@
     return result;
   }
 
+  template <typename... Args>
+  static StrictBoundedXUnion WithV(::fidl::AnyAllocator& allocator,
+                                   Args&&... args) {
+    StrictBoundedXUnion result;
+    result.set_v(::fidl::ObjectView<::fidl::VectorView<uint8_t>>(
+        allocator, std::forward<Args>(args)...));
+    return result;
+  }
+
   void set_v(::fidl::tracking_ptr<::fidl::VectorView<uint8_t>>&& elem) {
     ordinal_ = Ordinal::kV;
     reset_ptr(static_cast<::fidl::tracking_ptr<void>>(std::move(elem)));
   }
 
-  void set_v(::fidl::AnyAllocator& allocator) {
-    ordinal_ = Ordinal::kV;
-    set_v(::fidl::ObjectView<::fidl::VectorView<uint8_t>>(allocator));
-  }
-
   template <typename... Args>
   void set_v(::fidl::AnyAllocator& allocator, Args&&... args) {
     ordinal_ = Ordinal::kV;
@@ -862,16 +905,20 @@
     return result;
   }
 
+  template <typename... Args>
+  static ReverseOrdinalUnion WithSecond(::fidl::AnyAllocator& allocator,
+                                        Args&&... args) {
+    ReverseOrdinalUnion result;
+    result.set_second(
+        ::fidl::ObjectView<uint32_t>(allocator, std::forward<Args>(args)...));
+    return result;
+  }
+
   void set_second(::fidl::tracking_ptr<uint32_t>&& elem) {
     ordinal_ = Ordinal::kSecond;
     reset_ptr(static_cast<::fidl::tracking_ptr<void>>(std::move(elem)));
   }
 
-  void set_second(::fidl::AnyAllocator& allocator) {
-    ordinal_ = Ordinal::kSecond;
-    set_second(::fidl::ObjectView<uint32_t>(allocator));
-  }
-
   template <typename... Args>
   void set_second(::fidl::AnyAllocator& allocator, Args&&... args) {
     ordinal_ = Ordinal::kSecond;
@@ -896,16 +943,20 @@
     return result;
   }
 
+  template <typename... Args>
+  static ReverseOrdinalUnion WithFirst(::fidl::AnyAllocator& allocator,
+                                       Args&&... args) {
+    ReverseOrdinalUnion result;
+    result.set_first(
+        ::fidl::ObjectView<uint32_t>(allocator, std::forward<Args>(args)...));
+    return result;
+  }
+
   void set_first(::fidl::tracking_ptr<uint32_t>&& elem) {
     ordinal_ = Ordinal::kFirst;
     reset_ptr(static_cast<::fidl::tracking_ptr<void>>(std::move(elem)));
   }
 
-  void set_first(::fidl::AnyAllocator& allocator) {
-    ordinal_ = Ordinal::kFirst;
-    set_first(::fidl::ObjectView<uint32_t>(allocator));
-  }
-
   template <typename... Args>
   void set_first(::fidl::AnyAllocator& allocator, Args&&... args) {
     ordinal_ = Ordinal::kFirst;
@@ -993,18 +1044,21 @@
     return result;
   }
 
+  template <typename... Args>
+  static StrictPizzaOrPasta WithPizza(::fidl::AnyAllocator& allocator,
+                                      Args&&... args) {
+    StrictPizzaOrPasta result;
+    result.set_pizza(::fidl::ObjectView<::llcpp::fidl::test::union_::Pizza>(
+        allocator, std::forward<Args>(args)...));
+    return result;
+  }
+
   void set_pizza(
       ::fidl::tracking_ptr<::llcpp::fidl::test::union_::Pizza>&& elem) {
     ordinal_ = Ordinal::kPizza;
     reset_ptr(static_cast<::fidl::tracking_ptr<void>>(std::move(elem)));
   }
 
-  void set_pizza(::fidl::AnyAllocator& allocator) {
-    ordinal_ = Ordinal::kPizza;
-    set_pizza(
-        ::fidl::ObjectView<::llcpp::fidl::test::union_::Pizza>(allocator));
-  }
-
   template <typename... Args>
   void set_pizza(::fidl::AnyAllocator& allocator, Args&&... args) {
     ordinal_ = Ordinal::kPizza;
@@ -1032,18 +1086,21 @@
     return result;
   }
 
+  template <typename... Args>
+  static StrictPizzaOrPasta WithPasta(::fidl::AnyAllocator& allocator,
+                                      Args&&... args) {
+    StrictPizzaOrPasta result;
+    result.set_pasta(::fidl::ObjectView<::llcpp::fidl::test::union_::Pasta>(
+        allocator, std::forward<Args>(args)...));
+    return result;
+  }
+
   void set_pasta(
       ::fidl::tracking_ptr<::llcpp::fidl::test::union_::Pasta>&& elem) {
     ordinal_ = Ordinal::kPasta;
     reset_ptr(static_cast<::fidl::tracking_ptr<void>>(std::move(elem)));
   }
 
-  void set_pasta(::fidl::AnyAllocator& allocator) {
-    ordinal_ = Ordinal::kPasta;
-    set_pasta(
-        ::fidl::ObjectView<::llcpp::fidl::test::union_::Pasta>(allocator));
-  }
-
   template <typename... Args>
   void set_pasta(::fidl::AnyAllocator& allocator, Args&&... args) {
     ordinal_ = Ordinal::kPasta;
@@ -1135,18 +1192,21 @@
     return result;
   }
 
+  template <typename... Args>
+  static PizzaOrPasta WithPizza(::fidl::AnyAllocator& allocator,
+                                Args&&... args) {
+    PizzaOrPasta result;
+    result.set_pizza(::fidl::ObjectView<::llcpp::fidl::test::union_::Pizza>(
+        allocator, std::forward<Args>(args)...));
+    return result;
+  }
+
   void set_pizza(
       ::fidl::tracking_ptr<::llcpp::fidl::test::union_::Pizza>&& elem) {
     ordinal_ = Ordinal::kPizza;
     reset_ptr(static_cast<::fidl::tracking_ptr<void>>(std::move(elem)));
   }
 
-  void set_pizza(::fidl::AnyAllocator& allocator) {
-    ordinal_ = Ordinal::kPizza;
-    set_pizza(
-        ::fidl::ObjectView<::llcpp::fidl::test::union_::Pizza>(allocator));
-  }
-
   template <typename... Args>
   void set_pizza(::fidl::AnyAllocator& allocator, Args&&... args) {
     ordinal_ = Ordinal::kPizza;
@@ -1174,18 +1234,21 @@
     return result;
   }
 
+  template <typename... Args>
+  static PizzaOrPasta WithPasta(::fidl::AnyAllocator& allocator,
+                                Args&&... args) {
+    PizzaOrPasta result;
+    result.set_pasta(::fidl::ObjectView<::llcpp::fidl::test::union_::Pasta>(
+        allocator, std::forward<Args>(args)...));
+    return result;
+  }
+
   void set_pasta(
       ::fidl::tracking_ptr<::llcpp::fidl::test::union_::Pasta>&& elem) {
     ordinal_ = Ordinal::kPasta;
     reset_ptr(static_cast<::fidl::tracking_ptr<void>>(std::move(elem)));
   }
 
-  void set_pasta(::fidl::AnyAllocator& allocator) {
-    ordinal_ = Ordinal::kPasta;
-    set_pasta(
-        ::fidl::ObjectView<::llcpp::fidl::test::union_::Pasta>(allocator));
-  }
-
   template <typename... Args>
   void set_pasta(::fidl::AnyAllocator& allocator, Args&&... args) {
     ordinal_ = Ordinal::kPasta;
@@ -1277,18 +1340,21 @@
     return result;
   }
 
+  template <typename... Args>
+  static FlexiblePizzaOrPasta WithPizza(::fidl::AnyAllocator& allocator,
+                                        Args&&... args) {
+    FlexiblePizzaOrPasta result;
+    result.set_pizza(::fidl::ObjectView<::llcpp::fidl::test::union_::Pizza>(
+        allocator, std::forward<Args>(args)...));
+    return result;
+  }
+
   void set_pizza(
       ::fidl::tracking_ptr<::llcpp::fidl::test::union_::Pizza>&& elem) {
     ordinal_ = Ordinal::kPizza;
     reset_ptr(static_cast<::fidl::tracking_ptr<void>>(std::move(elem)));
   }
 
-  void set_pizza(::fidl::AnyAllocator& allocator) {
-    ordinal_ = Ordinal::kPizza;
-    set_pizza(
-        ::fidl::ObjectView<::llcpp::fidl::test::union_::Pizza>(allocator));
-  }
-
   template <typename... Args>
   void set_pizza(::fidl::AnyAllocator& allocator, Args&&... args) {
     ordinal_ = Ordinal::kPizza;
@@ -1316,18 +1382,21 @@
     return result;
   }
 
+  template <typename... Args>
+  static FlexiblePizzaOrPasta WithPasta(::fidl::AnyAllocator& allocator,
+                                        Args&&... args) {
+    FlexiblePizzaOrPasta result;
+    result.set_pasta(::fidl::ObjectView<::llcpp::fidl::test::union_::Pasta>(
+        allocator, std::forward<Args>(args)...));
+    return result;
+  }
+
   void set_pasta(
       ::fidl::tracking_ptr<::llcpp::fidl::test::union_::Pasta>&& elem) {
     ordinal_ = Ordinal::kPasta;
     reset_ptr(static_cast<::fidl::tracking_ptr<void>>(std::move(elem)));
   }
 
-  void set_pasta(::fidl::AnyAllocator& allocator) {
-    ordinal_ = Ordinal::kPasta;
-    set_pasta(
-        ::fidl::ObjectView<::llcpp::fidl::test::union_::Pasta>(allocator));
-  }
-
   template <typename... Args>
   void set_pasta(::fidl::AnyAllocator& allocator, Args&&... args) {
     ordinal_ = Ordinal::kPasta;
@@ -1416,18 +1485,21 @@
     return result;
   }
 
+  template <typename... Args>
+  static ExplicitPizzaOrPasta WithPizza(::fidl::AnyAllocator& allocator,
+                                        Args&&... args) {
+    ExplicitPizzaOrPasta result;
+    result.set_pizza(::fidl::ObjectView<::llcpp::fidl::test::union_::Pizza>(
+        allocator, std::forward<Args>(args)...));
+    return result;
+  }
+
   void set_pizza(
       ::fidl::tracking_ptr<::llcpp::fidl::test::union_::Pizza>&& elem) {
     ordinal_ = Ordinal::kPizza;
     reset_ptr(static_cast<::fidl::tracking_ptr<void>>(std::move(elem)));
   }
 
-  void set_pizza(::fidl::AnyAllocator& allocator) {
-    ordinal_ = Ordinal::kPizza;
-    set_pizza(
-        ::fidl::ObjectView<::llcpp::fidl::test::union_::Pizza>(allocator));
-  }
-
   template <typename... Args>
   void set_pizza(::fidl::AnyAllocator& allocator, Args&&... args) {
     ordinal_ = Ordinal::kPizza;
@@ -1455,18 +1527,21 @@
     return result;
   }
 
+  template <typename... Args>
+  static ExplicitPizzaOrPasta WithPasta(::fidl::AnyAllocator& allocator,
+                                        Args&&... args) {
+    ExplicitPizzaOrPasta result;
+    result.set_pasta(::fidl::ObjectView<::llcpp::fidl::test::union_::Pasta>(
+        allocator, std::forward<Args>(args)...));
+    return result;
+  }
+
   void set_pasta(
       ::fidl::tracking_ptr<::llcpp::fidl::test::union_::Pasta>&& elem) {
     ordinal_ = Ordinal::kPasta;
     reset_ptr(static_cast<::fidl::tracking_ptr<void>>(std::move(elem)));
   }
 
-  void set_pasta(::fidl::AnyAllocator& allocator) {
-    ordinal_ = Ordinal::kPasta;
-    set_pasta(
-        ::fidl::ObjectView<::llcpp::fidl::test::union_::Pasta>(allocator));
-  }
-
   template <typename... Args>
   void set_pasta(::fidl::AnyAllocator& allocator, Args&&... args) {
     ordinal_ = Ordinal::kPasta;
@@ -1558,16 +1633,20 @@
     return result;
   }
 
+  template <typename... Args>
+  static OlderSimpleUnion WithI(::fidl::AnyAllocator& allocator,
+                                Args&&... args) {
+    OlderSimpleUnion result;
+    result.set_i(
+        ::fidl::ObjectView<int64_t>(allocator, std::forward<Args>(args)...));
+    return result;
+  }
+
   void set_i(::fidl::tracking_ptr<int64_t>&& elem) {
     ordinal_ = Ordinal::kI;
     reset_ptr(static_cast<::fidl::tracking_ptr<void>>(std::move(elem)));
   }
 
-  void set_i(::fidl::AnyAllocator& allocator) {
-    ordinal_ = Ordinal::kI;
-    set_i(::fidl::ObjectView<int64_t>(allocator));
-  }
-
   template <typename... Args>
   void set_i(::fidl::AnyAllocator& allocator, Args&&... args) {
     ordinal_ = Ordinal::kI;
@@ -1591,16 +1670,20 @@
     return result;
   }
 
+  template <typename... Args>
+  static OlderSimpleUnion WithF(::fidl::AnyAllocator& allocator,
+                                Args&&... args) {
+    OlderSimpleUnion result;
+    result.set_f(
+        ::fidl::ObjectView<float>(allocator, std::forward<Args>(args)...));
+    return result;
+  }
+
   void set_f(::fidl::tracking_ptr<float>&& elem) {
     ordinal_ = Ordinal::kF;
     reset_ptr(static_cast<::fidl::tracking_ptr<void>>(std::move(elem)));
   }
 
-  void set_f(::fidl::AnyAllocator& allocator) {
-    ordinal_ = Ordinal::kF;
-    set_f(::fidl::ObjectView<float>(allocator));
-  }
-
   template <typename... Args>
   void set_f(::fidl::AnyAllocator& allocator, Args&&... args) {
     ordinal_ = Ordinal::kF;
@@ -1684,16 +1767,20 @@
     return result;
   }
 
+  template <typename... Args>
+  static NewerSimpleUnion WithI(::fidl::AnyAllocator& allocator,
+                                Args&&... args) {
+    NewerSimpleUnion result;
+    result.set_i(
+        ::fidl::ObjectView<int64_t>(allocator, std::forward<Args>(args)...));
+    return result;
+  }
+
   void set_i(::fidl::tracking_ptr<int64_t>&& elem) {
     ordinal_ = Ordinal::kI;
     reset_ptr(static_cast<::fidl::tracking_ptr<void>>(std::move(elem)));
   }
 
-  void set_i(::fidl::AnyAllocator& allocator) {
-    ordinal_ = Ordinal::kI;
-    set_i(::fidl::ObjectView<int64_t>(allocator));
-  }
-
   template <typename... Args>
   void set_i(::fidl::AnyAllocator& allocator, Args&&... args) {
     ordinal_ = Ordinal::kI;
@@ -1718,16 +1805,20 @@
     return result;
   }
 
+  template <typename... Args>
+  static NewerSimpleUnion WithS(::fidl::AnyAllocator& allocator,
+                                Args&&... args) {
+    NewerSimpleUnion result;
+    result.set_s(::fidl::ObjectView<::fidl::StringView>(
+        allocator, std::forward<Args>(args)...));
+    return result;
+  }
+
   void set_s(::fidl::tracking_ptr<::fidl::StringView>&& elem) {
     ordinal_ = Ordinal::kS;
     reset_ptr(static_cast<::fidl::tracking_ptr<void>>(std::move(elem)));
   }
 
-  void set_s(::fidl::AnyAllocator& allocator) {
-    ordinal_ = Ordinal::kS;
-    set_s(::fidl::ObjectView<::fidl::StringView>(allocator));
-  }
-
   template <typename... Args>
   void set_s(::fidl::AnyAllocator& allocator, Args&&... args) {
     ordinal_ = Ordinal::kS;
@@ -1753,18 +1844,21 @@
     return result;
   }
 
+  template <typename... Args>
+  static NewerSimpleUnion WithV(::fidl::AnyAllocator& allocator,
+                                Args&&... args) {
+    NewerSimpleUnion result;
+    result.set_v(::fidl::ObjectView<::fidl::VectorView<::fidl::StringView>>(
+        allocator, std::forward<Args>(args)...));
+    return result;
+  }
+
   void set_v(
       ::fidl::tracking_ptr<::fidl::VectorView<::fidl::StringView>>&& elem) {
     ordinal_ = Ordinal::kV;
     reset_ptr(static_cast<::fidl::tracking_ptr<void>>(std::move(elem)));
   }
 
-  void set_v(::fidl::AnyAllocator& allocator) {
-    ordinal_ = Ordinal::kV;
-    set_v(
-        ::fidl::ObjectView<::fidl::VectorView<::fidl::StringView>>(allocator));
-  }
-
   template <typename... Args>
   void set_v(::fidl::AnyAllocator& allocator, Args&&... args) {
     ordinal_ = Ordinal::kV;
@@ -1860,16 +1954,20 @@
     return result;
   }
 
+  template <typename... Args>
+  static FlexibleUnion WithPrimitive(::fidl::AnyAllocator& allocator,
+                                     Args&&... args) {
+    FlexibleUnion result;
+    result.set_Primitive(
+        ::fidl::ObjectView<int32_t>(allocator, std::forward<Args>(args)...));
+    return result;
+  }
+
   void set_Primitive(::fidl::tracking_ptr<int32_t>&& elem) {
     ordinal_ = Ordinal::kPrimitive;
     reset_ptr(static_cast<::fidl::tracking_ptr<void>>(std::move(elem)));
   }
 
-  void set_Primitive(::fidl::AnyAllocator& allocator) {
-    ordinal_ = Ordinal::kPrimitive;
-    set_Primitive(::fidl::ObjectView<int32_t>(allocator));
-  }
-
   template <typename... Args>
   void set_Primitive(::fidl::AnyAllocator& allocator, Args&&... args) {
     ordinal_ = Ordinal::kPrimitive;
@@ -1897,18 +1995,21 @@
     return result;
   }
 
+  template <typename... Args>
+  static FlexibleUnion WithStringNeedsConstructor(
+      ::fidl::AnyAllocator& allocator, Args&&... args) {
+    FlexibleUnion result;
+    result.set_StringNeedsConstructor(::fidl::ObjectView<::fidl::StringView>(
+        allocator, std::forward<Args>(args)...));
+    return result;
+  }
+
   void set_StringNeedsConstructor(
       ::fidl::tracking_ptr<::fidl::StringView>&& elem) {
     ordinal_ = Ordinal::kStringNeedsConstructor;
     reset_ptr(static_cast<::fidl::tracking_ptr<void>>(std::move(elem)));
   }
 
-  void set_StringNeedsConstructor(::fidl::AnyAllocator& allocator) {
-    ordinal_ = Ordinal::kStringNeedsConstructor;
-    set_StringNeedsConstructor(
-        ::fidl::ObjectView<::fidl::StringView>(allocator));
-  }
-
   template <typename... Args>
   void set_StringNeedsConstructor(::fidl::AnyAllocator& allocator,
                                   Args&&... args) {
@@ -1937,18 +2038,22 @@
     return result;
   }
 
+  template <typename... Args>
+  static FlexibleUnion WithVectorStringAlsoNeedsConstructor(
+      ::fidl::AnyAllocator& allocator, Args&&... args) {
+    FlexibleUnion result;
+    result.set_VectorStringAlsoNeedsConstructor(
+        ::fidl::ObjectView<::fidl::VectorView<::fidl::StringView>>(
+            allocator, std::forward<Args>(args)...));
+    return result;
+  }
+
   void set_VectorStringAlsoNeedsConstructor(
       ::fidl::tracking_ptr<::fidl::VectorView<::fidl::StringView>>&& elem) {
     ordinal_ = Ordinal::kVectorStringAlsoNeedsConstructor;
     reset_ptr(static_cast<::fidl::tracking_ptr<void>>(std::move(elem)));
   }
 
-  void set_VectorStringAlsoNeedsConstructor(::fidl::AnyAllocator& allocator) {
-    ordinal_ = Ordinal::kVectorStringAlsoNeedsConstructor;
-    set_VectorStringAlsoNeedsConstructor(
-        ::fidl::ObjectView<::fidl::VectorView<::fidl::StringView>>(allocator));
-  }
-
   template <typename... Args>
   void set_VectorStringAlsoNeedsConstructor(::fidl::AnyAllocator& allocator,
                                             Args&&... args) {
@@ -2047,16 +2152,19 @@
     return result;
   }
 
+  template <typename... Args>
+  static FlexibleFoo WithS(::fidl::AnyAllocator& allocator, Args&&... args) {
+    FlexibleFoo result;
+    result.set_s(::fidl::ObjectView<::fidl::StringView>(
+        allocator, std::forward<Args>(args)...));
+    return result;
+  }
+
   void set_s(::fidl::tracking_ptr<::fidl::StringView>&& elem) {
     ordinal_ = Ordinal::kS;
     reset_ptr(static_cast<::fidl::tracking_ptr<void>>(std::move(elem)));
   }
 
-  void set_s(::fidl::AnyAllocator& allocator) {
-    ordinal_ = Ordinal::kS;
-    set_s(::fidl::ObjectView<::fidl::StringView>(allocator));
-  }
-
   template <typename... Args>
   void set_s(::fidl::AnyAllocator& allocator, Args&&... args) {
     ordinal_ = Ordinal::kS;
@@ -2081,16 +2189,19 @@
     return result;
   }
 
+  template <typename... Args>
+  static FlexibleFoo WithI(::fidl::AnyAllocator& allocator, Args&&... args) {
+    FlexibleFoo result;
+    result.set_i(
+        ::fidl::ObjectView<int32_t>(allocator, std::forward<Args>(args)...));
+    return result;
+  }
+
   void set_i(::fidl::tracking_ptr<int32_t>&& elem) {
     ordinal_ = Ordinal::kI;
     reset_ptr(static_cast<::fidl::tracking_ptr<void>>(std::move(elem)));
   }
 
-  void set_i(::fidl::AnyAllocator& allocator) {
-    ordinal_ = Ordinal::kI;
-    set_i(::fidl::ObjectView<int32_t>(allocator));
-  }
-
   template <typename... Args>
   void set_i(::fidl::AnyAllocator& allocator, Args&&... args) {
     ordinal_ = Ordinal::kI;
@@ -2174,16 +2285,20 @@
     return result;
   }
 
+  template <typename... Args>
+  static FieldCollision WithFieldCollisionTag(::fidl::AnyAllocator& allocator,
+                                              Args&&... args) {
+    FieldCollision result;
+    result.set_field_collision_tag(
+        ::fidl::ObjectView<int32_t>(allocator, std::forward<Args>(args)...));
+    return result;
+  }
+
   void set_field_collision_tag(::fidl::tracking_ptr<int32_t>&& elem) {
     ordinal_ = Ordinal::kFieldCollisionTag;
     reset_ptr(static_cast<::fidl::tracking_ptr<void>>(std::move(elem)));
   }
 
-  void set_field_collision_tag(::fidl::AnyAllocator& allocator) {
-    ordinal_ = Ordinal::kFieldCollisionTag;
-    set_field_collision_tag(::fidl::ObjectView<int32_t>(allocator));
-  }
-
   template <typename... Args>
   void set_field_collision_tag(::fidl::AnyAllocator& allocator,
                                Args&&... args) {
@@ -2265,16 +2380,19 @@
     return result;
   }
 
+  template <typename... Args>
+  static ExplicitXUnion WithI(::fidl::AnyAllocator& allocator, Args&&... args) {
+    ExplicitXUnion result;
+    result.set_i(
+        ::fidl::ObjectView<int64_t>(allocator, std::forward<Args>(args)...));
+    return result;
+  }
+
   void set_i(::fidl::tracking_ptr<int64_t>&& elem) {
     ordinal_ = Ordinal::kI;
     reset_ptr(static_cast<::fidl::tracking_ptr<void>>(std::move(elem)));
   }
 
-  void set_i(::fidl::AnyAllocator& allocator) {
-    ordinal_ = Ordinal::kI;
-    set_i(::fidl::ObjectView<int64_t>(allocator));
-  }
-
   template <typename... Args>
   void set_i(::fidl::AnyAllocator& allocator, Args&&... args) {
     ordinal_ = Ordinal::kI;
@@ -2298,16 +2416,19 @@
     return result;
   }
 
+  template <typename... Args>
+  static ExplicitXUnion WithF(::fidl::AnyAllocator& allocator, Args&&... args) {
+    ExplicitXUnion result;
+    result.set_f(
+        ::fidl::ObjectView<float>(allocator, std::forward<Args>(args)...));
+    return result;
+  }
+
   void set_f(::fidl::tracking_ptr<float>&& elem) {
     ordinal_ = Ordinal::kF;
     reset_ptr(static_cast<::fidl::tracking_ptr<void>>(std::move(elem)));
   }
 
-  void set_f(::fidl::AnyAllocator& allocator) {
-    ordinal_ = Ordinal::kF;
-    set_f(::fidl::ObjectView<float>(allocator));
-  }
-
   template <typename... Args>
   void set_f(::fidl::AnyAllocator& allocator, Args&&... args) {
     ordinal_ = Ordinal::kF;
@@ -2389,16 +2510,20 @@
     return result;
   }
 
+  template <typename... Args>
+  static ExplicitUnion WithPrimitive(::fidl::AnyAllocator& allocator,
+                                     Args&&... args) {
+    ExplicitUnion result;
+    result.set_Primitive(
+        ::fidl::ObjectView<int32_t>(allocator, std::forward<Args>(args)...));
+    return result;
+  }
+
   void set_Primitive(::fidl::tracking_ptr<int32_t>&& elem) {
     ordinal_ = Ordinal::kPrimitive;
     reset_ptr(static_cast<::fidl::tracking_ptr<void>>(std::move(elem)));
   }
 
-  void set_Primitive(::fidl::AnyAllocator& allocator) {
-    ordinal_ = Ordinal::kPrimitive;
-    set_Primitive(::fidl::ObjectView<int32_t>(allocator));
-  }
-
   template <typename... Args>
   void set_Primitive(::fidl::AnyAllocator& allocator, Args&&... args) {
     ordinal_ = Ordinal::kPrimitive;
@@ -2426,18 +2551,21 @@
     return result;
   }
 
+  template <typename... Args>
+  static ExplicitUnion WithStringNeedsConstructor(
+      ::fidl::AnyAllocator& allocator, Args&&... args) {
+    ExplicitUnion result;
+    result.set_StringNeedsConstructor(::fidl::ObjectView<::fidl::StringView>(
+        allocator, std::forward<Args>(args)...));
+    return result;
+  }
+
   void set_StringNeedsConstructor(
       ::fidl::tracking_ptr<::fidl::StringView>&& elem) {
     ordinal_ = Ordinal::kStringNeedsConstructor;
     reset_ptr(static_cast<::fidl::tracking_ptr<void>>(std::move(elem)));
   }
 
-  void set_StringNeedsConstructor(::fidl::AnyAllocator& allocator) {
-    ordinal_ = Ordinal::kStringNeedsConstructor;
-    set_StringNeedsConstructor(
-        ::fidl::ObjectView<::fidl::StringView>(allocator));
-  }
-
   template <typename... Args>
   void set_StringNeedsConstructor(::fidl::AnyAllocator& allocator,
                                   Args&&... args) {
@@ -2526,16 +2654,20 @@
     return result;
   }
 
+  template <typename... Args>
+  static ExplicitStrictFoo WithS(::fidl::AnyAllocator& allocator,
+                                 Args&&... args) {
+    ExplicitStrictFoo result;
+    result.set_s(::fidl::ObjectView<::fidl::StringView>(
+        allocator, std::forward<Args>(args)...));
+    return result;
+  }
+
   void set_s(::fidl::tracking_ptr<::fidl::StringView>&& elem) {
     ordinal_ = Ordinal::kS;
     reset_ptr(static_cast<::fidl::tracking_ptr<void>>(std::move(elem)));
   }
 
-  void set_s(::fidl::AnyAllocator& allocator) {
-    ordinal_ = Ordinal::kS;
-    set_s(::fidl::ObjectView<::fidl::StringView>(allocator));
-  }
-
   template <typename... Args>
   void set_s(::fidl::AnyAllocator& allocator, Args&&... args) {
     ordinal_ = Ordinal::kS;
@@ -2560,16 +2692,20 @@
     return result;
   }
 
+  template <typename... Args>
+  static ExplicitStrictFoo WithI(::fidl::AnyAllocator& allocator,
+                                 Args&&... args) {
+    ExplicitStrictFoo result;
+    result.set_i(
+        ::fidl::ObjectView<int32_t>(allocator, std::forward<Args>(args)...));
+    return result;
+  }
+
   void set_i(::fidl::tracking_ptr<int32_t>&& elem) {
     ordinal_ = Ordinal::kI;
     reset_ptr(static_cast<::fidl::tracking_ptr<void>>(std::move(elem)));
   }
 
-  void set_i(::fidl::AnyAllocator& allocator) {
-    ordinal_ = Ordinal::kI;
-    set_i(::fidl::ObjectView<int32_t>(allocator));
-  }
-
   template <typename... Args>
   void set_i(::fidl::AnyAllocator& allocator, Args&&... args) {
     ordinal_ = Ordinal::kI;
@@ -2656,16 +2792,19 @@
     return result;
   }
 
+  template <typename... Args>
+  static ExplicitFoo WithS(::fidl::AnyAllocator& allocator, Args&&... args) {
+    ExplicitFoo result;
+    result.set_s(::fidl::ObjectView<::fidl::StringView>(
+        allocator, std::forward<Args>(args)...));
+    return result;
+  }
+
   void set_s(::fidl::tracking_ptr<::fidl::StringView>&& elem) {
     ordinal_ = Ordinal::kS;
     reset_ptr(static_cast<::fidl::tracking_ptr<void>>(std::move(elem)));
   }
 
-  void set_s(::fidl::AnyAllocator& allocator) {
-    ordinal_ = Ordinal::kS;
-    set_s(::fidl::ObjectView<::fidl::StringView>(allocator));
-  }
-
   template <typename... Args>
   void set_s(::fidl::AnyAllocator& allocator, Args&&... args) {
     ordinal_ = Ordinal::kS;
@@ -2690,16 +2829,19 @@
     return result;
   }
 
+  template <typename... Args>
+  static ExplicitFoo WithI(::fidl::AnyAllocator& allocator, Args&&... args) {
+    ExplicitFoo result;
+    result.set_i(
+        ::fidl::ObjectView<int32_t>(allocator, std::forward<Args>(args)...));
+    return result;
+  }
+
   void set_i(::fidl::tracking_ptr<int32_t>&& elem) {
     ordinal_ = Ordinal::kI;
     reset_ptr(static_cast<::fidl::tracking_ptr<void>>(std::move(elem)));
   }
 
-  void set_i(::fidl::AnyAllocator& allocator) {
-    ordinal_ = Ordinal::kI;
-    set_i(::fidl::ObjectView<int32_t>(allocator));
-  }
-
   template <typename... Args>
   void set_i(::fidl::AnyAllocator& allocator, Args&&... args) {
     ordinal_ = Ordinal::kI;
@@ -2783,18 +2925,21 @@
     return result;
   }
 
+  template <typename... Args>
+  static XUnionContainingEmptyStruct WithEmpty(::fidl::AnyAllocator& allocator,
+                                               Args&&... args) {
+    XUnionContainingEmptyStruct result;
+    result.set_empty(::fidl::ObjectView<::llcpp::fidl::test::union_::Empty>(
+        allocator, std::forward<Args>(args)...));
+    return result;
+  }
+
   void set_empty(
       ::fidl::tracking_ptr<::llcpp::fidl::test::union_::Empty>&& elem) {
     ordinal_ = Ordinal::kEmpty;
     reset_ptr(static_cast<::fidl::tracking_ptr<void>>(std::move(elem)));
   }
 
-  void set_empty(::fidl::AnyAllocator& allocator) {
-    ordinal_ = Ordinal::kEmpty;
-    set_empty(
-        ::fidl::ObjectView<::llcpp::fidl::test::union_::Empty>(allocator));
-  }
-
   template <typename... Args>
   void set_empty(::fidl::AnyAllocator& allocator, Args&&... args) {
     ordinal_ = Ordinal::kEmpty;
diff --git a/tools/fidl/fidlgen_llcpp/goldens/union_sandwich.h.golden b/tools/fidl/fidlgen_llcpp/goldens/union_sandwich.h.golden
index 0bdc7ae..46d3f91 100644
--- a/tools/fidl/fidlgen_llcpp/goldens/union_sandwich.h.golden
+++ b/tools/fidl/fidlgen_llcpp/goldens/union_sandwich.h.golden
@@ -79,16 +79,20 @@
     return result;
   }
 
+  template <typename... Args>
+  static UnionSize8Alignment4 WithVariant(::fidl::AnyAllocator& allocator,
+                                          Args&&... args) {
+    UnionSize8Alignment4 result;
+    result.set_variant(
+        ::fidl::ObjectView<uint32_t>(allocator, std::forward<Args>(args)...));
+    return result;
+  }
+
   void set_variant(::fidl::tracking_ptr<uint32_t>&& elem) {
     ordinal_ = Ordinal::kVariant;
     reset_ptr(static_cast<::fidl::tracking_ptr<void>>(std::move(elem)));
   }
 
-  void set_variant(::fidl::AnyAllocator& allocator) {
-    ordinal_ = Ordinal::kVariant;
-    set_variant(::fidl::ObjectView<uint32_t>(allocator));
-  }
-
   template <typename... Args>
   void set_variant(::fidl::AnyAllocator& allocator, Args&&... args) {
     ordinal_ = Ordinal::kVariant;
@@ -168,16 +172,20 @@
     return result;
   }
 
+  template <typename... Args>
+  static UnionSize36Alignment4 WithVariant(::fidl::AnyAllocator& allocator,
+                                           Args&&... args) {
+    UnionSize36Alignment4 result;
+    result.set_variant(::fidl::ObjectView<::fidl::Array<uint8_t, 32>>(
+        allocator, std::forward<Args>(args)...));
+    return result;
+  }
+
   void set_variant(::fidl::tracking_ptr<::fidl::Array<uint8_t, 32>>&& elem) {
     ordinal_ = Ordinal::kVariant;
     reset_ptr(static_cast<::fidl::tracking_ptr<void>>(std::move(elem)));
   }
 
-  void set_variant(::fidl::AnyAllocator& allocator) {
-    ordinal_ = Ordinal::kVariant;
-    set_variant(::fidl::ObjectView<::fidl::Array<uint8_t, 32>>(allocator));
-  }
-
   template <typename... Args>
   void set_variant(::fidl::AnyAllocator& allocator, Args&&... args) {
     ordinal_ = Ordinal::kVariant;
@@ -257,16 +265,20 @@
     return result;
   }
 
+  template <typename... Args>
+  static UnionSize12Alignment4 WithVariant(::fidl::AnyAllocator& allocator,
+                                           Args&&... args) {
+    UnionSize12Alignment4 result;
+    result.set_variant(::fidl::ObjectView<::fidl::Array<uint8_t, 6>>(
+        allocator, std::forward<Args>(args)...));
+    return result;
+  }
+
   void set_variant(::fidl::tracking_ptr<::fidl::Array<uint8_t, 6>>&& elem) {
     ordinal_ = Ordinal::kVariant;
     reset_ptr(static_cast<::fidl::tracking_ptr<void>>(std::move(elem)));
   }
 
-  void set_variant(::fidl::AnyAllocator& allocator) {
-    ordinal_ = Ordinal::kVariant;
-    set_variant(::fidl::ObjectView<::fidl::Array<uint8_t, 6>>(allocator));
-  }
-
   template <typename... Args>
   void set_variant(::fidl::AnyAllocator& allocator, Args&&... args) {
     ordinal_ = Ordinal::kVariant;
@@ -347,6 +359,17 @@
     return result;
   }
 
+  template <typename... Args>
+  static UnionSize24Alignment8 WithVariant(::fidl::AnyAllocator& allocator,
+                                           Args&&... args) {
+    UnionSize24Alignment8 result;
+    result.set_variant(
+        ::fidl::ObjectView<
+            ::llcpp::fidl::test::unionsandwich::StructSize16Alignment8>(
+            allocator, std::forward<Args>(args)...));
+    return result;
+  }
+
   void set_variant(
       ::fidl::tracking_ptr<
           ::llcpp::fidl::test::unionsandwich::StructSize16Alignment8>&& elem) {
@@ -354,13 +377,6 @@
     reset_ptr(static_cast<::fidl::tracking_ptr<void>>(std::move(elem)));
   }
 
-  void set_variant(::fidl::AnyAllocator& allocator) {
-    ordinal_ = Ordinal::kVariant;
-    set_variant(::fidl::ObjectView<
-                ::llcpp::fidl::test::unionsandwich::StructSize16Alignment8>(
-        allocator));
-  }
-
   template <typename... Args>
   void set_variant(::fidl::AnyAllocator& allocator, Args&&... args) {
     ordinal_ = Ordinal::kVariant;
diff --git a/tools/fidl/fidlgen_rust/goldens/protocol_request.rs.golden b/tools/fidl/fidlgen_rust/goldens/protocol_request.rs.golden
index 3181dcc..888c77b 100644
--- a/tools/fidl/fidlgen_rust/goldens/protocol_request.rs.golden
+++ b/tools/fidl/fidlgen_rust/goldens/protocol_request.rs.golden
@@ -311,13 +311,11 @@
 }
 
 pub trait ParentProxyInterface: Send + Sync {
-    type GetChildResponseFut: std::future::Future<
-        Output = Result<(fidl::endpoints::ClientEnd<ChildMarker>), fidl::Error>,
-    > + Send;
+    type GetChildResponseFut: std::future::Future<Output = Result<(fidl::endpoints::ClientEnd<ChildMarker>), fidl::Error>>
+        + Send;
     fn get_child(&self) -> Self::GetChildResponseFut;
-    type GetChildRequestResponseFut: std::future::Future<
-        Output = Result<(fidl::endpoints::ServerEnd<ChildMarker>), fidl::Error>,
-    > + Send;
+    type GetChildRequestResponseFut: std::future::Future<Output = Result<(fidl::endpoints::ServerEnd<ChildMarker>), fidl::Error>>
+        + Send;
     fn get_child_request(&self) -> Self::GetChildRequestResponseFut;
     fn take_child(&self, c: fidl::endpoints::ClientEnd<ChildMarker>) -> Result<(), fidl::Error>;
     fn take_child_request(
diff --git a/tools/fidl/fidlgen_rust/goldens/protocols.rs.golden b/tools/fidl/fidlgen_rust/goldens/protocols.rs.golden
index 35107b0..d7a1d50 100644
--- a/tools/fidl/fidlgen_rust/goldens/protocols.rs.golden
+++ b/tools/fidl/fidlgen_rust/goldens/protocols.rs.golden
@@ -136,17 +136,15 @@
     type NoRequestEmptyResponseResponseFut: std::future::Future<Output = Result<(), fidl::Error>>
         + Send;
     fn no_request_empty_response(&self) -> Self::NoRequestEmptyResponseResponseFut;
-    type NoRequestWithResponseResponseFut: std::future::Future<
-        Output = Result<(String), fidl::Error>,
-    > + Send;
+    type NoRequestWithResponseResponseFut: std::future::Future<Output = Result<(String), fidl::Error>>
+        + Send;
     fn no_request_with_response(&self) -> Self::NoRequestWithResponseResponseFut;
     fn with_request_no_response(&self, arg: &str) -> Result<(), fidl::Error>;
     type WithRequestEmptyResponseResponseFut: std::future::Future<Output = Result<(), fidl::Error>>
         + Send;
     fn with_request_empty_response(&self, arg: &str) -> Self::WithRequestEmptyResponseResponseFut;
-    type WithRequestWithResponseResponseFut: std::future::Future<
-        Output = Result<(String), fidl::Error>,
-    > + Send;
+    type WithRequestWithResponseResponseFut: std::future::Future<Output = Result<(String), fidl::Error>>
+        + Send;
     fn with_request_with_response(&self, arg: &str) -> Self::WithRequestWithResponseResponseFut;
     type OnEmptyResponseResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
     type OnWithResponseResponseFut: std::future::Future<Output = Result<(String), fidl::Error>>
@@ -1470,17 +1468,14 @@
 }
 
 pub trait WithErrorSyntaxProxyInterface: Send + Sync {
-    type ResponseAsStructResponseFut: std::future::Future<
-        Output = Result<(WithErrorSyntaxResponseAsStructResult), fidl::Error>,
-    > + Send;
+    type ResponseAsStructResponseFut: std::future::Future<Output = Result<(WithErrorSyntaxResponseAsStructResult), fidl::Error>>
+        + Send;
     fn response_as_struct(&self) -> Self::ResponseAsStructResponseFut;
-    type ErrorAsPrimitiveResponseFut: std::future::Future<
-        Output = Result<(WithErrorSyntaxErrorAsPrimitiveResult), fidl::Error>,
-    > + Send;
+    type ErrorAsPrimitiveResponseFut: std::future::Future<Output = Result<(WithErrorSyntaxErrorAsPrimitiveResult), fidl::Error>>
+        + Send;
     fn error_as_primitive(&self) -> Self::ErrorAsPrimitiveResponseFut;
-    type ErrorAsEnumResponseFut: std::future::Future<
-        Output = Result<(WithErrorSyntaxErrorAsEnumResult), fidl::Error>,
-    > + Send;
+    type ErrorAsEnumResponseFut: std::future::Future<Output = Result<(WithErrorSyntaxErrorAsEnumResult), fidl::Error>>
+        + Send;
     fn error_as_enum(&self) -> Self::ErrorAsEnumResponseFut;
 }
 
diff --git a/tools/fidl/fidlgen_rust/goldens/request_flexible_envelope.rs.golden b/tools/fidl/fidlgen_rust/goldens/request_flexible_envelope.rs.golden
index 9c1c64e..fe75a0c7 100644
--- a/tools/fidl/fidlgen_rust/goldens/request_flexible_envelope.rs.golden
+++ b/tools/fidl/fidlgen_rust/goldens/request_flexible_envelope.rs.golden
@@ -90,16 +90,14 @@
 }
 
 pub trait ProtocolProxyInterface: Send + Sync {
-    type RequestStrictResponseFlexibleResponseFut: std::future::Future<
-        Output = Result<(FlexibleFoo), fidl::Error>,
-    > + Send;
+    type RequestStrictResponseFlexibleResponseFut: std::future::Future<Output = Result<(FlexibleFoo), fidl::Error>>
+        + Send;
     fn request_strict_response_flexible(
         &self,
         s: &mut StrictFoo,
     ) -> Self::RequestStrictResponseFlexibleResponseFut;
-    type RequestFlexibleResponseStrictResponseFut: std::future::Future<
-        Output = Result<(StrictFoo), fidl::Error>,
-    > + Send;
+    type RequestFlexibleResponseStrictResponseFut: std::future::Future<Output = Result<(StrictFoo), fidl::Error>>
+        + Send;
     fn request_flexible_response_strict(
         &self,
         s: &mut FlexibleFoo,
diff --git a/tools/fidl/fidlgen_rust/goldens/union.rs.golden b/tools/fidl/fidlgen_rust/goldens/union.rs.golden
index 4bee189..95acf31 100644
--- a/tools/fidl/fidlgen_rust/goldens/union.rs.golden
+++ b/tools/fidl/fidlgen_rust/goldens/union.rs.golden
@@ -628,15 +628,13 @@
 }
 
 pub trait TestProtocolProxyInterface: Send + Sync {
-    type StrictXUnionHenceResponseMayBeStackAllocatedResponseFut: std::future::Future<
-        Output = Result<(StrictBoundedXUnion), fidl::Error>,
-    > + Send;
+    type StrictXUnionHenceResponseMayBeStackAllocatedResponseFut: std::future::Future<Output = Result<(StrictBoundedXUnion), fidl::Error>>
+        + Send;
     fn strict_x_union_hence_response_may_be_stack_allocated(
         &self,
     ) -> Self::StrictXUnionHenceResponseMayBeStackAllocatedResponseFut;
-    type FlexibleXUnionHenceResponseMustBeHeapAllocatedResponseFut: std::future::Future<
-        Output = Result<(OlderSimpleUnion), fidl::Error>,
-    > + Send;
+    type FlexibleXUnionHenceResponseMustBeHeapAllocatedResponseFut: std::future::Future<Output = Result<(OlderSimpleUnion), fidl::Error>>
+        + Send;
     fn flexible_x_union_hence_response_must_be_heap_allocated(
         &self,
     ) -> Self::FlexibleXUnionHenceResponseMustBeHeapAllocatedResponseFut;