Revert "[ast] Remove unused constructors and setters."

This reverts commit 4d28b27935.

Reason for revert: Seeing weird build breakage ...

Original change's description:
> [ast] Remove unused constructors and setters.
>
> This CL removes unused default constructors and various set methods
> from the AST classes where they are not longer required.
>
> Change-Id: Ic437911c62d8c9e4354a1fa6bdc8483ce7511daf
> Reviewed-on: https://dawn-review.googlesource.com/c/tint/+/34641
> Auto-Submit: dan sinclair <dsinclair@chromium.org>
> Reviewed-by: Ben Clayton <bclayton@google.com>
> Commit-Queue: dan sinclair <dsinclair@chromium.org>

TBR=dsinclair@chromium.org,bclayton@google.com

Change-Id: I9d5bf6fd6d47131650c964cad4e17a1cbe86b040
No-Presubmit: true
No-Tree-Checks: true
No-Try: true
Reviewed-on: https://dawn-review.googlesource.com/c/tint/+/34682
Reviewed-by: dan sinclair <dsinclair@chromium.org>
Commit-Queue: dan sinclair <dsinclair@chromium.org>

src/ast/array_accessor_expression.cc

@@ -20,6 +20,8 @@
 namespace tint {
 namespace ast {
 
+ArrayAccessorExpression::ArrayAccessorExpression() : Base() {}
+
 ArrayAccessorExpression::ArrayAccessorExpression(Expression* array,
                                                  Expression* idx_expr)
     : Base(), array_(array), idx_expr_(idx_expr) {}

src/ast/array_accessor_expression.h

@@ -28,6 +28,8 @@ namespace ast {
 class ArrayAccessorExpression
     : public Castable<ArrayAccessorExpression, Expression> {
  public:
+  /// Constructor
+  ArrayAccessorExpression();
   /// Constructor
   /// @param array the array
   /// @param idx_expr the index expression
@@ -43,6 +45,9 @@ class ArrayAccessorExpression
   ArrayAccessorExpression(ArrayAccessorExpression&&);
   ~ArrayAccessorExpression() override;
 
+  /// Sets the array
+  /// @param array the array
+  void set_array(Expression* array) { array_ = array; }
   /// @returns the array
   Expression* array() const { return array_; }
 

src/ast/array_accessor_expression_test.cc

@@ -43,10 +43,7 @@ TEST_F(ArrayAccessorExpressionTest, CreateWithSource) {
 }
 
 TEST_F(ArrayAccessorExpressionTest, IsArrayAccessor) {
-  auto* ary = create<IdentifierExpression>("ary");
-  auto* idx = create<IdentifierExpression>("idx");
-
-  ArrayAccessorExpression exp(ary, idx);
+  ArrayAccessorExpression exp;
   EXPECT_TRUE(exp.Is<ArrayAccessorExpression>());
 }
 
@@ -61,14 +58,16 @@ TEST_F(ArrayAccessorExpressionTest, IsValid) {
 TEST_F(ArrayAccessorExpressionTest, IsValid_MissingArray) {
   auto* idx = create<IdentifierExpression>("idx");
 
-  ArrayAccessorExpression exp(nullptr, idx);
+  ArrayAccessorExpression exp;
+  exp.set_idx_expr(idx);
   EXPECT_FALSE(exp.IsValid());
 }
 
 TEST_F(ArrayAccessorExpressionTest, IsValid_MissingIndex) {
   auto* ary = create<IdentifierExpression>("ary");
 
-  ArrayAccessorExpression exp(ary, nullptr);
+  ArrayAccessorExpression exp;
+  exp.set_array(ary);
   EXPECT_FALSE(exp.IsValid());
 }
 

src/ast/assignment_statement.cc

@@ -20,6 +20,8 @@
 namespace tint {
 namespace ast {
 
+AssignmentStatement::AssignmentStatement() : Base() {}
+
 AssignmentStatement::AssignmentStatement(Expression* lhs, Expression* rhs)
     : Base(), lhs_(lhs), rhs_(rhs) {}
 

src/ast/assignment_statement.h

@@ -28,6 +28,8 @@ namespace ast {
 /// An assignment statement
 class AssignmentStatement : public Castable<AssignmentStatement, Statement> {
  public:
+  /// Constructor
+  AssignmentStatement();
   /// Constructor
   /// @param lhs the left side of the expression
   /// @param rhs the right side of the expression
@@ -41,8 +43,15 @@ class AssignmentStatement : public Castable<AssignmentStatement, Statement> {
   AssignmentStatement(AssignmentStatement&&);
   ~AssignmentStatement() override;
 
+  /// Sets the left side of the statement
+  /// @param lhs the left side to set
+  void set_lhs(Expression* lhs) { lhs_ = lhs; }
   /// @returns the left side expression
   Expression* lhs() const { return lhs_; }
+
+  /// Sets the right side of the statement
+  /// @param rhs the right side to set
+  void set_rhs(Expression* rhs) { rhs_ = rhs; }
   /// @returns the right side expression
   Expression* rhs() const { return rhs_; }
 

src/ast/assignment_statement_test.cc

@@ -61,14 +61,16 @@ TEST_F(AssignmentStatementTest, IsValid) {
 TEST_F(AssignmentStatementTest, IsValid_MissingLHS) {
   auto* rhs = create<IdentifierExpression>("rhs");
 
-  AssignmentStatement stmt(nullptr, rhs);
+  AssignmentStatement stmt;
+  stmt.set_rhs(rhs);
   EXPECT_FALSE(stmt.IsValid());
 }
 
 TEST_F(AssignmentStatementTest, IsValid_MissingRHS) {
   auto* lhs = create<IdentifierExpression>("lhs");
 
-  AssignmentStatement stmt(lhs, nullptr);
+  AssignmentStatement stmt;
+  stmt.set_lhs(lhs);
   EXPECT_FALSE(stmt.IsValid());
 }
 

src/ast/binary_expression.cc

@@ -20,6 +20,8 @@
 namespace tint {
 namespace ast {
 
+BinaryExpression::BinaryExpression() : Base() {}
+
 BinaryExpression::BinaryExpression(BinaryOp op,
                                    Expression* lhs,
                                    Expression* rhs)

src/ast/binary_expression.h

@@ -50,6 +50,8 @@ enum class BinaryOp {
 /// An binary expression
 class BinaryExpression : public Castable<BinaryExpression, Expression> {
  public:
+  /// Constructor
+  BinaryExpression();
   /// Constructor
   /// @param op the operation type
   /// @param lhs the left side of the expression
@@ -68,6 +70,9 @@ class BinaryExpression : public Castable<BinaryExpression, Expression> {
   BinaryExpression(BinaryExpression&&);
   ~BinaryExpression() override;
 
+  /// Sets the binary op type
+  /// @param op the binary op type
+  void set_op(BinaryOp op) { op_ = op; }
   /// @returns the binary op type
   BinaryOp op() const { return op_; }
 
@@ -108,8 +113,15 @@ class BinaryExpression : public Castable<BinaryExpression, Expression> {
   /// @returns true if the op is modulo
   bool IsModulo() const { return op_ == BinaryOp::kModulo; }
 
+  /// Sets the left side of the expression
+  /// @param lhs the left side to set
+  void set_lhs(Expression* lhs) { lhs_ = lhs; }
   /// @returns the left side expression
   Expression* lhs() const { return lhs_; }
+
+  /// Sets the right side of the expression
+  /// @param rhs the right side to set
+  void set_rhs(Expression* rhs) { rhs_ = rhs; }
   /// @returns the right side expression
   Expression* rhs() const { return rhs_; }
 

src/ast/binary_expression_test.cc

@@ -46,11 +46,8 @@ TEST_F(BinaryExpressionTest, Creation_WithSource) {
   EXPECT_EQ(src.range.begin.column, 2u);
 }
 
-TEST_F(BinaryExpressionTest, IsBinary) {
-  auto* lhs = create<IdentifierExpression>("lhs");
-  auto* rhs = create<IdentifierExpression>("rhs");
-
-  BinaryExpression r(BinaryOp::kEqual, lhs, rhs);
+TEST_F(BinaryExpressionTest, IsBinaryal) {
+  BinaryExpression r;
   EXPECT_TRUE(r.Is<BinaryExpression>());
 }
 
@@ -65,7 +62,9 @@ TEST_F(BinaryExpressionTest, IsValid) {
 TEST_F(BinaryExpressionTest, IsValid_Null_LHS) {
   auto* rhs = create<IdentifierExpression>("rhs");
 
-  BinaryExpression r(BinaryOp::kEqual, nullptr, rhs);
+  BinaryExpression r;
+  r.set_op(BinaryOp::kEqual);
+  r.set_rhs(rhs);
   EXPECT_FALSE(r.IsValid());
 }
 
@@ -80,7 +79,9 @@ TEST_F(BinaryExpressionTest, IsValid_Invalid_LHS) {
 TEST_F(BinaryExpressionTest, IsValid_Null_RHS) {
   auto* lhs = create<IdentifierExpression>("lhs");
 
-  BinaryExpression r(BinaryOp::kEqual, lhs, nullptr);
+  BinaryExpression r;
+  r.set_op(BinaryOp::kEqual);
+  r.set_lhs(lhs);
   EXPECT_FALSE(r.IsValid());
 }
 

src/ast/bitcast_expression.cc

@@ -20,6 +20,8 @@
 namespace tint {
 namespace ast {
 
+BitcastExpression::BitcastExpression() : Base() {}
+
 BitcastExpression::BitcastExpression(type::Type* type, Expression* expr)
     : Base(), type_(type), expr_(expr) {}
 

src/ast/bitcast_expression.h

@@ -28,6 +28,8 @@ namespace ast {
 /// A bitcast expression
 class BitcastExpression : public Castable<BitcastExpression, Expression> {
  public:
+  /// Constructor
+  BitcastExpression();
   /// Constructor
   /// @param type the type
   /// @param expr the expr
@@ -41,8 +43,15 @@ class BitcastExpression : public Castable<BitcastExpression, Expression> {
   BitcastExpression(BitcastExpression&&);
   ~BitcastExpression() override;
 
+  /// Sets the type
+  /// @param type the type
+  void set_type(type::Type* type) { type_ = type; }
   /// @returns the left side expression
   type::Type* type() const { return type_; }
+
+  /// Sets the expr
+  /// @param expr the expression
+  void set_expr(Expression* expr) { expr_ = expr; }
   /// @returns the expression
   Expression* expr() const { return expr_; }
 

src/ast/bitcast_expression_test.cc

@@ -44,10 +44,7 @@ TEST_F(BitcastExpressionTest, CreateWithSource) {
 }
 
 TEST_F(BitcastExpressionTest, IsBitcast) {
-  type::F32 f32;
-  auto* expr = create<IdentifierExpression>("expr");
-
-  BitcastExpression exp(&f32, expr);
+  BitcastExpression exp;
   EXPECT_TRUE(exp.Is<BitcastExpression>());
 }
 
@@ -62,14 +59,16 @@ TEST_F(BitcastExpressionTest, IsValid) {
 TEST_F(BitcastExpressionTest, IsValid_MissingType) {
   auto* expr = create<IdentifierExpression>("expr");
 
-  BitcastExpression exp(nullptr, expr);
+  BitcastExpression exp;
+  exp.set_expr(expr);
   EXPECT_FALSE(exp.IsValid());
 }
 
 TEST_F(BitcastExpressionTest, IsValid_MissingExpr) {
   type::F32 f32;
 
-  BitcastExpression exp(&f32, nullptr);
+  BitcastExpression exp;
+  exp.set_type(&f32);
   EXPECT_FALSE(exp.IsValid());
 }
 

src/ast/call_expression.cc

@@ -20,6 +20,8 @@
 namespace tint {
 namespace ast {
 
+CallExpression::CallExpression() : Base() {}
+
 CallExpression::CallExpression(Expression* func, ExpressionList params)
     : Base(), func_(func), params_(params) {}
 

src/ast/call_expression.h

@@ -27,6 +27,8 @@ namespace ast {
 /// A call expression
 class CallExpression : public Castable<CallExpression, Expression> {
  public:
+  /// Constructor
+  CallExpression();
   /// Constructor
   /// @param func the function
   /// @param params the parameters
@@ -40,8 +42,15 @@ class CallExpression : public Castable<CallExpression, Expression> {
   CallExpression(CallExpression&&);
   ~CallExpression() override;
 
+  /// Sets the func
+  /// @param func the func
+  void set_func(Expression* func) { func_ = func; }
   /// @returns the func
   Expression* func() const { return func_; }
+
+  /// Sets the parameters
+  /// @param params the parameters
+  void set_params(ExpressionList params) { params_ = params; }
   /// @returns the parameters
   const ExpressionList& params() const { return params_; }
 

src/ast/call_expression_test.cc

@@ -59,7 +59,7 @@ TEST_F(CallExpressionTest, IsValid) {
 }
 
 TEST_F(CallExpressionTest, IsValid_MissingFunction) {
-  CallExpression stmt(nullptr, {});
+  CallExpression stmt;
   EXPECT_FALSE(stmt.IsValid());
 }
 

src/ast/call_statement.cc

@@ -21,6 +21,8 @@
 namespace tint {
 namespace ast {
 
+CallStatement::CallStatement() : Base() {}
+
 CallStatement::CallStatement(CallExpression* call) : Base(), call_(call) {}
 
 CallStatement::CallStatement(CallStatement&&) = default;

src/ast/call_statement.h

@@ -27,6 +27,8 @@ namespace ast {
 /// A call expression
 class CallStatement : public Castable<CallStatement, Statement> {
  public:
+  /// Constructor
+  CallStatement();
   /// Constructor
   /// @param call the function
   explicit CallStatement(CallExpression* call);
@@ -34,6 +36,9 @@ class CallStatement : public Castable<CallStatement, Statement> {
   CallStatement(CallStatement&&);
   ~CallStatement() override;
 
+  /// Sets the call expression
+  /// @param call the call
+  void set_expr(CallExpression* call) { call_ = call; }
   /// @returns the call expression
   CallExpression* expr() const { return call_; }
 

src/ast/call_statement_test.cc

@@ -33,7 +33,7 @@ TEST_F(CallStatementTest, Creation) {
 }
 
 TEST_F(CallStatementTest, IsCall) {
-  CallStatement c(nullptr);
+  CallStatement c;
   EXPECT_TRUE(c.Is<CallStatement>());
 }
 
@@ -44,13 +44,12 @@ TEST_F(CallStatementTest, IsValid) {
 }
 
 TEST_F(CallStatementTest, IsValid_MissingExpr) {
-  CallStatement c(nullptr);
+  CallStatement c;
   EXPECT_FALSE(c.IsValid());
 }
 
 TEST_F(CallStatementTest, IsValid_InvalidExpr) {
-  CallExpression stmt(nullptr, {});
-  CallStatement c(&stmt);
+  CallStatement c(create<CallExpression>());
   EXPECT_FALSE(c.IsValid());
 }
 

src/ast/case_statement.h

@@ -52,6 +52,11 @@ class CaseStatement : public Castable<CaseStatement, Statement> {
   CaseStatement(CaseStatement&&);
   ~CaseStatement() override;
 
+  /// Sets the selectors for the case statement
+  /// @param selectors the selectors to set
+  void set_selectors(CaseSelectorList selectors) {
+    selectors_ = std::move(selectors);
+  }
   /// @returns the case selectors, empty if none set
   const CaseSelectorList& selectors() const { return selectors_; }
   /// @returns true if this is a default statement

src/ast/case_statement_test.cc

@@ -82,7 +82,8 @@ TEST_F(CaseStatementTest, IsDefault_WithoutSelectors) {
   auto* body = create<BlockStatement>();
   body->append(create<DiscardStatement>());
 
-  CaseStatement c(body);
+  CaseStatement c(create<BlockStatement>());
+  c.set_body(body);
   EXPECT_TRUE(c.IsDefault());
 }
 
@@ -91,7 +92,8 @@ TEST_F(CaseStatementTest, IsDefault_WithSelectors) {
   CaseSelectorList b;
   b.push_back(create<SintLiteral>(&i32, 2));
 
-  CaseStatement c(b, create<BlockStatement>());
+  CaseStatement c(create<BlockStatement>());
+  c.set_selectors(b);
   EXPECT_FALSE(c.IsDefault());
 }
 

src/ast/decorated_variable.h

@@ -28,7 +28,6 @@ namespace ast {
 class DecoratedVariable : public Castable<DecoratedVariable, Variable> {
  public:
   /// Create a new empty decorated variable statement
-  /// Note, used by the `Clone` method.
   DecoratedVariable();
   /// Create a decorated variable from an existing variable
   /// @param var the variable to initialize from

src/ast/decorated_variable_test.cc

@@ -107,8 +107,7 @@ TEST_F(DecoratedVariableTest, IsValid) {
 }
 
 TEST_F(DecoratedVariableTest, IsDecorated) {
-  type::I32 t;
-  DecoratedVariable dv(create<Variable>("my_var", StorageClass::kNone, &t));
+  DecoratedVariable dv;
   EXPECT_TRUE(dv.Is<DecoratedVariable>());
 }
 

src/ast/else_statement.h

@@ -51,11 +51,17 @@ class ElseStatement : public Castable<ElseStatement, Statement> {
   ElseStatement(ElseStatement&&);
   ~ElseStatement() override;
 
+  /// Sets the condition for the else statement
+  /// @param condition the condition to set
+  void set_condition(Expression* condition) { condition_ = condition; }
   /// @returns the else condition or nullptr if none set
   Expression* condition() const { return condition_; }
   /// @returns true if the else has a condition
   bool HasCondition() const { return condition_ != nullptr; }
 
+  /// Sets the else body
+  /// @param body the else body
+  void set_body(BlockStatement* body) { body_ = body; }
   /// @returns the else body
   const BlockStatement* body() const { return body_; }
   /// @returns the else body

src/ast/else_statement_test.cc

@@ -90,7 +90,7 @@ TEST_F(ElseStatementTest, IsValid_WithNullBodyStatement) {
 }
 
 TEST_F(ElseStatementTest, IsValid_InvalidCondition) {
-  auto* cond = create<ScalarConstructorExpression>(nullptr);
+  auto* cond = create<ScalarConstructorExpression>();
   ElseStatement e(cond, create<BlockStatement>());
   EXPECT_FALSE(e.IsValid());
 }

src/ast/function.cc

@@ -28,6 +28,8 @@
 namespace tint {
 namespace ast {
 
+Function::Function() = default;
+
 Function::Function(const std::string& name,
                    VariableList params,
                    type::Type* return_type,

src/ast/function.h

@@ -50,7 +50,8 @@ class Function : public Castable<Function, Node> {
     SetDecoration* set = nullptr;
   };
 
-  /// Create a function
+  /// Create a new empty function statement
+  Function();  /// Create a function
   /// @param name the function name
   /// @param params the function parameters
   /// @param return_type the return type
@@ -75,8 +76,15 @@ class Function : public Castable<Function, Node> {
 
   ~Function() override;
 
+  /// Sets the function name
+  /// @param name the name to set
+  void set_name(const std::string& name) { name_ = name; }
   /// @returns the function name
   const std::string& name() { return name_; }
+
+  /// Sets the function parameters
+  /// @param params the function parameters
+  void set_params(VariableList params) { params_ = std::move(params); }
   /// @returns the function params
   const VariableList& params() const { return params_; }
 

src/ast/if_statement_test.cc

@@ -67,8 +67,8 @@ TEST_F(IfStatementTest, IsValid_WithElseStatements) {
   body->append(create<DiscardStatement>());
 
   ElseStatementList else_stmts;
-  else_stmts.push_back(create<ElseStatement>(
-      create<IdentifierExpression>("Ident"), create<BlockStatement>()));
+  else_stmts.push_back(create<ElseStatement>(create<BlockStatement>()));
+  else_stmts[0]->set_condition(create<IdentifierExpression>("Ident"));
   else_stmts.push_back(create<ElseStatement>(create<BlockStatement>()));
 
   IfStatement stmt(cond, body);
@@ -119,8 +119,8 @@ TEST_F(IfStatementTest, IsValid_NullElseStatement) {
   body->append(create<DiscardStatement>());
 
   ElseStatementList else_stmts;
-  else_stmts.push_back(create<ElseStatement>(
-      create<IdentifierExpression>("Ident"), create<BlockStatement>()));
+  else_stmts.push_back(create<ElseStatement>(create<BlockStatement>()));
+  else_stmts[0]->set_condition(create<IdentifierExpression>("Ident"));
   else_stmts.push_back(create<ElseStatement>(create<BlockStatement>()));
   else_stmts.push_back(nullptr);
 
@@ -135,8 +135,8 @@ TEST_F(IfStatementTest, IsValid_InvalidElseStatement) {
   body->append(create<DiscardStatement>());
 
   ElseStatementList else_stmts;
-  else_stmts.push_back(create<ElseStatement>(create<IdentifierExpression>(""),
-                                             create<BlockStatement>()));
+  else_stmts.push_back(create<ElseStatement>(create<BlockStatement>()));
+  else_stmts[0]->set_condition(create<IdentifierExpression>(""));
 
   IfStatement stmt(cond, body);
   stmt.set_else_statements(else_stmts);
@@ -164,8 +164,8 @@ TEST_F(IfStatementTest, IsValid_ElseNotLast) {
 
   ElseStatementList else_stmts;
   else_stmts.push_back(create<ElseStatement>(create<BlockStatement>()));
-  else_stmts.push_back(create<ElseStatement>(
-      create<IdentifierExpression>("ident"), create<BlockStatement>()));
+  else_stmts.push_back(create<ElseStatement>(create<BlockStatement>()));
+  else_stmts[1]->set_condition(create<IdentifierExpression>("ident"));
 
   IfStatement stmt(cond, body);
   stmt.set_else_statements(else_stmts);
@@ -205,9 +205,11 @@ TEST_F(IfStatementTest, ToStr_WithElseStatements) {
   else_body->append(create<DiscardStatement>());
 
   ElseStatementList else_stmts;
-  else_stmts.push_back(create<ElseStatement>(
-      create<IdentifierExpression>("ident"), else_if_body));
-  else_stmts.push_back(create<ElseStatement>(else_body));
+  else_stmts.push_back(create<ElseStatement>(create<BlockStatement>()));
+  else_stmts[0]->set_condition(create<IdentifierExpression>("ident"));
+  else_stmts[0]->set_body(else_if_body);
+  else_stmts.push_back(create<ElseStatement>(create<BlockStatement>()));
+  else_stmts[1]->set_body(else_body);
 
   IfStatement stmt(cond, body);
   stmt.set_else_statements(else_stmts);

src/ast/location_decoration.h

@@ -29,7 +29,7 @@ class LocationDecoration
   /// constructor
   /// @param value the location value
   /// @param source the source of this decoration
-  LocationDecoration(uint32_t value, const Source& source);
+  explicit LocationDecoration(uint32_t value, const Source& source);
   ~LocationDecoration() override;
 
   /// @returns the location value

src/ast/member_accessor_expression.cc

@@ -20,6 +20,8 @@
 namespace tint {
 namespace ast {
 
+MemberAccessorExpression::MemberAccessorExpression() = default;
+
 MemberAccessorExpression::MemberAccessorExpression(Expression* structure,
                                                    IdentifierExpression* member)
     : Base(), struct_(structure), member_(member) {}

src/ast/member_accessor_expression.h

@@ -30,6 +30,8 @@ namespace ast {
 class MemberAccessorExpression
     : public Castable<MemberAccessorExpression, Expression> {
  public:
+  /// Constructor
+  MemberAccessorExpression();
   /// Constructor
   /// @param structure the structure
   /// @param member the member
@@ -45,8 +47,15 @@ class MemberAccessorExpression
   MemberAccessorExpression(MemberAccessorExpression&&);
   ~MemberAccessorExpression() override;
 
+  /// Sets the structure
+  /// @param structure the structure
+  void set_structure(Expression* structure) { struct_ = structure; }
   /// @returns the structure
   Expression* structure() const { return struct_; }
+
+  /// Sets the member
+  /// @param member the member
+  void set_member(IdentifierExpression* member) { member_ = member; }
   /// @returns the member expression
   IdentifierExpression* member() const { return member_; }
 

src/ast/member_accessor_expression_test.cc

@@ -45,10 +45,7 @@ TEST_F(MemberAccessorExpressionTest, Creation_WithSource) {
 }
 
 TEST_F(MemberAccessorExpressionTest, IsMemberAccessor) {
-  auto* str = create<IdentifierExpression>("structure");
-  auto* mem = create<IdentifierExpression>("member");
-
-  MemberAccessorExpression stmt(str, mem);
+  MemberAccessorExpression stmt;
   EXPECT_TRUE(stmt.Is<MemberAccessorExpression>());
 }
 
@@ -63,7 +60,8 @@ TEST_F(MemberAccessorExpressionTest, IsValid) {
 TEST_F(MemberAccessorExpressionTest, IsValid_NullStruct) {
   auto* mem = create<IdentifierExpression>("member");
 
-  MemberAccessorExpression stmt(nullptr, mem);
+  MemberAccessorExpression stmt;
+  stmt.set_member(mem);
   EXPECT_FALSE(stmt.IsValid());
 }
 
@@ -78,7 +76,8 @@ TEST_F(MemberAccessorExpressionTest, IsValid_InvalidStruct) {
 TEST_F(MemberAccessorExpressionTest, IsValid_NullMember) {
   auto* str = create<IdentifierExpression>("structure");
 
-  MemberAccessorExpression stmt(str, nullptr);
+  MemberAccessorExpression stmt;
+  stmt.set_structure(str);
   EXPECT_FALSE(stmt.IsValid());
 }
 

src/ast/module_test.cc

@@ -139,8 +139,7 @@ TEST_F(ModuleTest, IsValid_Null_Function) {
 }
 
 TEST_F(ModuleTest, IsValid_Invalid_Function) {
-  VariableList p;
-  auto* func = create<Function>("", p, nullptr, nullptr);
+  auto* func = create<Function>();
 
   Module m;
   m.AddFunction(func);

src/ast/scalar_constructor_expression.cc

@@ -20,6 +20,8 @@
 namespace tint {
 namespace ast {
 
+ScalarConstructorExpression::ScalarConstructorExpression() : Base() {}
+
 ScalarConstructorExpression::ScalarConstructorExpression(Literal* literal)
     : literal_(literal) {}
 

src/ast/scalar_constructor_expression.h

@@ -28,6 +28,8 @@ namespace ast {
 class ScalarConstructorExpression
     : public Castable<ScalarConstructorExpression, ConstructorExpression> {
  public:
+  /// Constructor
+  ScalarConstructorExpression();
   /// Constructor
   /// @param literal the const literal
   explicit ScalarConstructorExpression(Literal* literal);
@@ -39,6 +41,9 @@ class ScalarConstructorExpression
   ScalarConstructorExpression(ScalarConstructorExpression&&);
   ~ScalarConstructorExpression() override;
 
+  /// Set the literal value
+  /// @param literal the literal
+  void set_literal(Literal* literal) { literal_ = literal; }
   /// @returns the literal value
   Literal* literal() const { return literal_; }
 

src/ast/scalar_constructor_expression_test.cc

@@ -48,7 +48,7 @@ TEST_F(ScalarConstructorExpressionTest, IsValid) {
 }
 
 TEST_F(ScalarConstructorExpressionTest, IsValid_MissingLiteral) {
-  ScalarConstructorExpression c(nullptr);
+  ScalarConstructorExpression c;
   EXPECT_FALSE(c.IsValid());
 }
 

src/ast/struct.cc

@@ -21,6 +21,8 @@
 namespace tint {
 namespace ast {
 
+Struct::Struct() : Base() {}
+
 Struct::Struct(StructMemberList members)
     : Base(), members_(std::move(members)) {}
 

src/ast/struct.h

@@ -29,6 +29,8 @@ namespace ast {
 /// A struct statement.
 class Struct : public Castable<Struct, Node> {
  public:
+  /// Create a new empty struct statement
+  Struct();
   /// Create a new struct statement
   /// @param members The struct members
   explicit Struct(StructMemberList members);

src/ast/struct_member.cc

@@ -21,6 +21,8 @@
 namespace tint {
 namespace ast {
 
+StructMember::StructMember() = default;
+
 StructMember::StructMember(const std::string& name,
                            type::Type* type,
                            StructMemberDecorationList decorations)

src/ast/struct_member.h

@@ -31,6 +31,8 @@ namespace ast {
 /// A struct member statement.
 class StructMember : public Castable<StructMember, Node> {
  public:
+  /// Create a new empty struct member statement
+  StructMember();
   /// Create a new struct member statement
   /// @param name The struct member name
   /// @param type The struct member type
@@ -52,8 +54,14 @@ class StructMember : public Castable<StructMember, Node> {
 
   ~StructMember() override;
 
+  /// Sets the name
+  /// @param name the name to set
+  void set_name(const std::string& name) { name_ = name; }
   /// @returns the name
   const std::string& name() const { return name_; }
+  /// Sets the type
+  /// @param type the type to set
+  void set_type(type::Type* type) { type_ = type; }
   /// @returns the type
   type::Type* type() const { return type_; }
   /// Sets the decorations

src/ast/struct_test.cc

@@ -87,7 +87,7 @@ TEST_F(StructTest, CreationWithSourceAndDecorations) {
 }
 
 TEST_F(StructTest, IsValid) {
-  Struct s({});
+  Struct s;
   EXPECT_TRUE(s.IsValid());
 }
 

src/ast/switch_statement.cc

@@ -21,6 +21,8 @@
 namespace tint {
 namespace ast {
 
+SwitchStatement::SwitchStatement() : Base() {}
+
 SwitchStatement::SwitchStatement(Expression* condition, CaseStatementList body)
     : condition_(condition), body_(body) {}
 

src/ast/switch_statement.h

@@ -29,6 +29,8 @@ namespace ast {
 /// A switch statement
 class SwitchStatement : public Castable<SwitchStatement, Statement> {
  public:
+  /// Constructor
+  SwitchStatement();
   /// Constructor
   /// @param condition the switch condition
   /// @param body the switch body
@@ -44,6 +46,9 @@ class SwitchStatement : public Castable<SwitchStatement, Statement> {
   SwitchStatement(SwitchStatement&&);
   ~SwitchStatement() override;
 
+  /// Sets the condition for the switch statement
+  /// @param condition the condition to set
+  void set_condition(Expression* condition) { condition_ = condition; }
   /// @returns the switch condition or nullptr if none set
   Expression* condition() const { return condition_; }
   /// @returns true if this is a default statement

src/ast/switch_statement_test.cc

@@ -56,16 +56,7 @@ TEST_F(SwitchStatementTest, Creation_WithSource) {
 }
 
 TEST_F(SwitchStatementTest, IsSwitch) {
-  type::I32 i32;
-
-  CaseSelectorList lit;
-  lit.push_back(create<SintLiteral>(&i32, 2));
-
-  auto* ident = create<IdentifierExpression>("ident");
-  CaseStatementList body;
-  body.push_back(create<CaseStatement>(lit, create<BlockStatement>()));
-
-  SwitchStatement stmt(ident, body);
+  SwitchStatement stmt;
   EXPECT_TRUE(stmt.Is<SwitchStatement>());
 }
 
@@ -92,7 +83,8 @@ TEST_F(SwitchStatementTest, IsValid_Null_Condition) {
   CaseStatementList body;
   body.push_back(create<CaseStatement>(lit, create<BlockStatement>()));
 
-  SwitchStatement stmt(nullptr, body);
+  SwitchStatement stmt;
+  stmt.set_body(body);
   EXPECT_FALSE(stmt.IsValid());
 }
 

src/ast/type/struct_type_test.cc

@@ -40,16 +40,14 @@ namespace {
 using StructTest = TestHelper;
 
 TEST_F(StructTest, Creation) {
-  StructMemberList members;
-  auto* impl = create<ast::Struct>(members);
+  auto* impl = create<ast::Struct>();
   auto* ptr = impl;
   Struct s{"S", impl};
   EXPECT_EQ(s.impl(), ptr);
 }
 
 TEST_F(StructTest, Is) {
-  StructMemberList members;
-  auto* impl = create<ast::Struct>(members);
+  auto* impl = create<ast::Struct>();
   Struct s{"S", impl};
   Type* ty = &s;
   EXPECT_FALSE(ty->Is<AccessControl>());
@@ -68,8 +66,7 @@ TEST_F(StructTest, Is) {
 }
 
 TEST_F(StructTest, TypeName) {
-  StructMemberList members;
-  auto* impl = create<ast::Struct>(members);
+  auto* impl = create<ast::Struct>();
   Struct s{"my_struct", impl};
   EXPECT_EQ(s.type_name(), "__struct_my_struct");
 }

src/ast/type_constructor_expression.cc

@@ -20,6 +20,8 @@
 namespace tint {
 namespace ast {
 
+TypeConstructorExpression::TypeConstructorExpression() : Base() {}
+
 TypeConstructorExpression::TypeConstructorExpression(type::Type* type,
                                                      ExpressionList values)
     : Base(), type_(type), values_(std::move(values)) {}

src/ast/type_constructor_expression.h

@@ -28,10 +28,11 @@ namespace ast {
 class TypeConstructorExpression
     : public Castable<TypeConstructorExpression, ConstructorExpression> {
  public:
+  TypeConstructorExpression();
   /// Constructor
   /// @param type the type
   /// @param values the values
-  TypeConstructorExpression(type::Type* type, ExpressionList values);
+  explicit TypeConstructorExpression(type::Type* type, ExpressionList values);
   /// Constructor
   /// @param source the constructor source
   /// @param type the type
@@ -43,8 +44,15 @@ class TypeConstructorExpression
   TypeConstructorExpression(TypeConstructorExpression&&);
   ~TypeConstructorExpression() override;
 
+  /// Set the type
+  /// @param type the type
+  void set_type(type::Type* type) { type_ = type; }
   /// @returns the type
   type::Type* type() const { return type_; }
+
+  /// Set the values
+  /// @param values the values
+  void set_values(ExpressionList values) { values_ = std::move(values); }
   /// @returns the values
   const ExpressionList& values() const { return values_; }
 

src/ast/type_constructor_expression_test.cc

@@ -52,11 +52,7 @@ TEST_F(TypeConstructorExpressionTest, Creation_WithSource) {
 }
 
 TEST_F(TypeConstructorExpressionTest, IsTypeConstructor) {
-  type::F32 f32;
-  ExpressionList expr;
-  expr.push_back(create<IdentifierExpression>("expr"));
-
-  TypeConstructorExpression t(&f32, expr);
+  TypeConstructorExpression t;
   EXPECT_TRUE(t.Is<TypeConstructorExpression>());
 }
 
@@ -81,7 +77,8 @@ TEST_F(TypeConstructorExpressionTest, IsValid_NullType) {
   ExpressionList expr;
   expr.push_back(create<IdentifierExpression>("expr"));
 
-  TypeConstructorExpression t(nullptr, expr);
+  TypeConstructorExpression t;
+  t.set_values(expr);
   EXPECT_FALSE(t.IsValid());
 }
 

src/ast/unary_op_expression.cc

@@ -20,6 +20,8 @@
 namespace tint {
 namespace ast {
 
+UnaryOpExpression::UnaryOpExpression() : Base() {}
+
 UnaryOpExpression::UnaryOpExpression(UnaryOp op, Expression* expr)
     : Base(), op_(op), expr_(expr) {}
 

src/ast/unary_op_expression.h

@@ -28,6 +28,8 @@ namespace ast {
 /// A unary op expression
 class UnaryOpExpression : public Castable<UnaryOpExpression, Expression> {
  public:
+  /// Constructor
+  UnaryOpExpression();
   /// Constructor
   /// @param op the op
   /// @param expr the expr
@@ -41,8 +43,15 @@ class UnaryOpExpression : public Castable<UnaryOpExpression, Expression> {
   UnaryOpExpression(UnaryOpExpression&&);
   ~UnaryOpExpression() override;
 
+  /// Sets the op
+  /// @param op the op
+  void set_op(UnaryOp op) { op_ = op; }
   /// @returns the op
   UnaryOp op() const { return op_; }
+
+  /// Sets the expr
+  /// @param expr the expression
+  void set_expr(Expression* expr) { expr_ = expr; }
   /// @returns the expression
   Expression* expr() const { return expr_; }
 

src/ast/unary_op_expression_test.cc

@@ -42,8 +42,7 @@ TEST_F(UnaryOpExpressionTest, Creation_WithSource) {
 }
 
 TEST_F(UnaryOpExpressionTest, IsUnaryOp) {
-  auto* ident = create<IdentifierExpression>("ident");
-  UnaryOpExpression u(UnaryOp::kNot, ident);
+  UnaryOpExpression u;
   EXPECT_TRUE(u.Is<UnaryOpExpression>());
 }
 
@@ -54,7 +53,8 @@ TEST_F(UnaryOpExpressionTest, IsValid) {
 }
 
 TEST_F(UnaryOpExpressionTest, IsValid_NullExpression) {
-  UnaryOpExpression u(UnaryOp::kNot, nullptr);
+  UnaryOpExpression u;
+  u.set_op(UnaryOp::kNot);
   EXPECT_FALSE(u.IsValid());
 }
 

src/ast/variable.cc

@@ -39,9 +39,11 @@ Variable::Variable(Variable&&) = default;
 Variable::~Variable() = default;
 
 Variable* Variable::Clone(CloneContext* ctx) const {
-  auto* cloned =
-      ctx->mod->create<Variable>(name(), storage_class(), ctx->Clone(type()));
+  auto* cloned = ctx->mod->create<Variable>();
   cloned->set_source(ctx->Clone(source()));
+  cloned->set_name(name());
+  cloned->set_storage_class(storage_class());
+  cloned->set_type(ctx->Clone(type()));
   cloned->set_constructor(ctx->Clone(constructor()));
   cloned->set_is_const(is_const());
   return cloned;

src/ast/variable.h

@@ -78,6 +78,8 @@ namespace ast {
 /// The storage class for a formal parameter is always StorageClass::kNone.
 class Variable : public Castable<Variable, Node> {
  public:
+  /// Create a new empty variable statement
+  Variable();
   /// Create a variable
   /// @param name the variables name
   /// @param sc the variable storage class
@@ -147,10 +149,6 @@ class Variable : public Castable<Variable, Node> {
   void to_str(std::ostream& out, size_t indent) const override;
 
  protected:
-  /// Constructor
-  /// Used by the DecoratedVariable constructor.
-  Variable();
-
   /// Output information for this variable.
   /// @param out the stream to write to
   /// @param indent number of spaces to indent the node when writing

src/ast/variable_decl_statement.cc

@@ -20,6 +20,8 @@
 namespace tint {
 namespace ast {
 
+VariableDeclStatement::VariableDeclStatement() : Base() {}
+
 VariableDeclStatement::VariableDeclStatement(Variable* variable)
     : Base(), variable_(variable) {}
 

src/ast/variable_decl_statement.h

@@ -29,6 +29,8 @@ namespace ast {
 class VariableDeclStatement
     : public Castable<VariableDeclStatement, Statement> {
  public:
+  /// Constructor
+  VariableDeclStatement();
   /// Constructor
   /// @param variable the variable
   explicit VariableDeclStatement(Variable* variable);
@@ -40,6 +42,9 @@ class VariableDeclStatement
   VariableDeclStatement(VariableDeclStatement&&);
   ~VariableDeclStatement() override;
 
+  /// Sets the variable
+  /// @param variable the variable to set
+  void set_variable(Variable* variable) { variable_ = variable; }
   /// @returns the variable
   Variable* variable() const { return variable_; }
 

src/ast/variable_decl_statement_test.cc

@@ -43,10 +43,7 @@ TEST_F(VariableDeclStatementTest, Creation_WithSource) {
 }
 
 TEST_F(VariableDeclStatementTest, IsVariableDecl) {
-  type::F32 f32;
-  auto* var = create<Variable>("a", StorageClass::kNone, &f32);
-
-  VariableDeclStatement s(var);
+  VariableDeclStatement s;
   EXPECT_TRUE(s.Is<VariableDeclStatement>());
 }
 
@@ -65,7 +62,7 @@ TEST_F(VariableDeclStatementTest, IsValid_InvalidVariable) {
 }
 
 TEST_F(VariableDeclStatementTest, IsValid_NullVariable) {
-  VariableDeclStatement stmt(nullptr);
+  VariableDeclStatement stmt;
   EXPECT_FALSE(stmt.IsValid());
 }
 

src/ast/variable_test.cc

@@ -53,9 +53,14 @@ TEST_F(VariableTest, CreationWithSource) {
 }
 
 TEST_F(VariableTest, CreationEmpty) {
-  type::I32 t;
   Source s{Source::Range{Source::Location{27, 4}, Source::Location{27, 7}}};
-  Variable v(s, "a_var", StorageClass::kWorkgroup, &t);
+  Variable v;
+  v.set_source(s);
+  v.set_storage_class(StorageClass::kWorkgroup);
+  v.set_name("a_var");
+
+  type::I32 t;
+  v.set_type(&t);
 
   EXPECT_EQ(v.name(), "a_var");
   EXPECT_EQ(v.storage_class(), StorageClass::kWorkgroup);
@@ -91,7 +96,7 @@ TEST_F(VariableTest, IsValid_MissingType) {
 }
 
 TEST_F(VariableTest, IsValid_MissingBoth) {
-  Variable v("", StorageClass::kNone, nullptr);
+  Variable v;
   EXPECT_FALSE(v.IsValid());
 }
 

src/reader/spirv/function.cc

@@ -2137,13 +2137,12 @@ bool FunctionEmitter::EmitSwitchStart(const BlockInfo& block_info) {
   assert(construct->begin_id == block_info.id);
   const auto* branch = block_info.basic_block->terminator();
 
+  auto* const switch_stmt =
+      AddStatement(create<ast::SwitchStatement>())->As<ast::SwitchStatement>();
   const auto selector_id = branch->GetSingleWordInOperand(0);
   // Generate the code for the selector.
   auto selector = MakeExpression(selector_id);
-
-  ast::CaseStatementList list;
-  auto* swch = create<ast::SwitchStatement>(selector.expr, list);
-  auto* const switch_stmt = AddStatement(swch)->As<ast::SwitchStatement>();
+  switch_stmt->set_condition(selector.expr);
 
   // First, push the statement block for the entire switch.  All the actual
   // work is done by completion actions of the case/default clauses.
@@ -2195,6 +2194,12 @@ bool FunctionEmitter::EmitSwitchStart(const BlockInfo& block_info) {
   // Push them on in reverse order.
   const auto last_clause_index = clause_heads.size() - 1;
   for (size_t i = last_clause_index;; --i) {
+    // Create the case clause.  Temporarily put it in the wrong order
+    // on the case statement list.
+    cases->emplace_back(
+        create<ast::CaseStatement>(create<ast::BlockStatement>()));
+    auto* clause = cases->back();
+
     // Create a list of integer literals for the selector values leading to
     // this case clause.
     ast::CaseSelectorList selectors;
@@ -2215,20 +2220,14 @@ bool FunctionEmitter::EmitSwitchStart(const BlockInfo& block_info) {
               create<ast::SintLiteral>(selector.type, value32));
         }
       }
+      clause->set_selectors(selectors);
     }
 
     // Where does this clause end?
     const auto end_id = (i + 1 < clause_heads.size()) ? clause_heads[i + 1]->id
                                                       : construct->end_id;
 
-    // Create the case clause.  Temporarily put it in the wrong order
-    // on the case statement list.
-    cases->emplace_back(create<ast::CaseStatement>(selectors, nullptr));
-    auto* clause = cases->back();
-
     PushNewStatementBlock(construct, end_id, [clause](StatementBlock* s) {
-      // The `set_body` method of CaseStatement can be removed if this set
-      // is removed.
       clause->set_body(s->statements_);
     });
 

src/reader/wgsl/parser_impl.cc

@@ -1745,13 +1745,14 @@ Maybe<ast::CaseStatement*> ParserImpl::switch_body() {
   auto source = t.source();
   next();  // Consume the peek
 
-  ast::CaseSelectorList selector_list;
+  auto* stmt = create<ast::CaseStatement>(create<ast::BlockStatement>());
+  stmt->set_source(source);
   if (t.IsCase()) {
     auto selectors = expect_case_selectors();
     if (selectors.errored)
       return Failure::kErrored;
 
-    selector_list = std::move(selectors.value);
+    stmt->set_selectors(std::move(selectors.value));
   }
 
   const char* use = "case statement";
@@ -1766,7 +1767,9 @@ Maybe<ast::CaseStatement*> ParserImpl::switch_body() {
   if (!body.matched)
     return add_error(body.source, "expected case body");
 
-  return create<ast::CaseStatement>(source, selector_list, body.value);
+  stmt->set_body(body.value);
+
+  return stmt;
 }
 
 // case_selectors

src/scope_stack_test.cc

@@ -14,7 +14,6 @@
 #include "src/scope_stack.h"
 
 #include "gtest/gtest.h"
-#include "src/ast/type/f32_type.h"
 #include "src/ast/variable.h"
 
 namespace tint {
@@ -32,8 +31,7 @@ TEST_F(ScopeStackTest, Global) {
 }
 
 TEST_F(ScopeStackTest, Global_SetWithPointer) {
-  ast::type::F32 f32;
-  ast::Variable v("test", ast::StorageClass::kNone, &f32);
+  ast::Variable v;
   v.set_name("my_var");
 
   ScopeStack<ast::Variable*> s;

src/writer/hlsl/generator_impl_alias_type_test.cc

@@ -50,7 +50,8 @@ TEST_F(HlslGeneratorImplTest_Alias, EmitAlias_Struct) {
   ast::type::I32 i32;
   ast::type::F32 f32;
 
-  auto* str = create<ast::Struct>(ast::StructMemberList{
+  auto* str = create<ast::Struct>();
+  str->set_members({
       create<ast::StructMember>("a", &f32, ast::StructMemberDecorationList{}),
       create<ast::StructMember>(
           "b", &i32,

src/writer/hlsl/generator_impl_function_test.cc

@@ -279,7 +279,8 @@ TEST_F(HlslGeneratorImplTest_Function,
   members.push_back(create<ast::StructMember>(
       "coord", &vec4, ast::StructMemberDecorationList{}));
 
-  auto* str = create<ast::Struct>(members);
+  auto* str = create<ast::Struct>();
+  str->set_members(members);
 
   ast::type::Struct s("Uniforms", str);
 
@@ -344,7 +345,8 @@ TEST_F(HlslGeneratorImplTest_Function,
   b_deco.push_back(create<ast::StructMemberOffsetDecoration>(4, Source{}));
   members.push_back(create<ast::StructMember>("b", &f32, b_deco));
 
-  auto* str = create<ast::Struct>(members);
+  auto* str = create<ast::Struct>();
+  str->set_members(members);
 
   ast::type::Struct s("Data", str);
   ast::type::AccessControl ac(ast::AccessControl::kReadWrite, &s);
@@ -402,7 +404,8 @@ TEST_F(HlslGeneratorImplTest_Function,
   b_deco.push_back(create<ast::StructMemberOffsetDecoration>(4, Source{}));
   members.push_back(create<ast::StructMember>("b", &f32, b_deco));
 
-  auto* str = create<ast::Struct>(members);
+  auto* str = create<ast::Struct>();
+  str->set_members(members);
 
   ast::type::Struct s("Data", str);
   ast::type::AccessControl ac(ast::AccessControl::kReadOnly, &s);
@@ -460,7 +463,8 @@ TEST_F(HlslGeneratorImplTest_Function,
   b_deco.push_back(create<ast::StructMemberOffsetDecoration>(4, Source{}));
   members.push_back(create<ast::StructMember>("b", &f32, b_deco));
 
-  auto* str = create<ast::Struct>(members);
+  auto* str = create<ast::Struct>();
+  str->set_members(members);
 
   ast::type::Struct s("Data", str);
   ast::type::AccessControl ac(ast::AccessControl::kReadWrite, &s);

src/writer/hlsl/generator_impl_member_accessor_test.cc

@@ -54,7 +54,8 @@ TEST_F(HlslGeneratorImplTest_MemberAccessor, EmitExpression_MemberAccessor) {
   deco.push_back(create<ast::StructMemberOffsetDecoration>(0, Source{}));
   members.push_back(create<ast::StructMember>("mem", &f32, deco));
 
-  auto* strct = create<ast::Struct>(members);
+  auto* strct = create<ast::Struct>();
+  strct->set_members(members);
 
   ast::type::Struct s("Str", strct);
 
@@ -97,7 +98,8 @@ TEST_F(HlslGeneratorImplTest_MemberAccessor,
   b_deco.push_back(create<ast::StructMemberOffsetDecoration>(4, Source{}));
   members.push_back(create<ast::StructMember>("b", &f32, b_deco));
 
-  auto* str = create<ast::Struct>(members);
+  auto* str = create<ast::Struct>();
+  str->set_members(members);
 
   ast::type::Struct s("Data", str);
 
@@ -140,7 +142,8 @@ TEST_F(HlslGeneratorImplTest_MemberAccessor,
   b_deco.push_back(create<ast::StructMemberOffsetDecoration>(4, Source{}));
   members.push_back(create<ast::StructMember>("b", &f32, b_deco));
 
-  auto* str = create<ast::Struct>(members);
+  auto* str = create<ast::Struct>();
+  str->set_members(members);
 
   ast::type::Struct s("Data", str);
 
@@ -177,7 +180,8 @@ TEST_F(HlslGeneratorImplTest_MemberAccessor,
   ast::type::I32 i32;
   ast::type::Matrix mat(&f32, 3, 2);
 
-  auto* str = create<ast::Struct>(ast::StructMemberList{
+  auto* str = create<ast::Struct>();
+  str->set_members({
       create<ast::StructMember>(
           "z", &i32,
           ast::StructMemberDecorationList{
@@ -245,7 +249,8 @@ TEST_F(HlslGeneratorImplTest_MemberAccessor,
   b_deco.push_back(create<ast::StructMemberOffsetDecoration>(4, Source{}));
   members.push_back(create<ast::StructMember>("a", &mat, b_deco));
 
-  auto* str = create<ast::Struct>(members);
+  auto* str = create<ast::Struct>();
+  str->set_members(members);
 
   ast::type::Struct s("Data", str);
 
@@ -300,7 +305,8 @@ TEST_F(HlslGeneratorImplTest_MemberAccessor,
   b_deco.push_back(create<ast::StructMemberOffsetDecoration>(4, Source{}));
   members.push_back(create<ast::StructMember>("a", &mat, b_deco));
 
-  auto* str = create<ast::Struct>(members);
+  auto* str = create<ast::Struct>();
+  str->set_members(members);
 
   ast::type::Struct s("Data", str);
 
@@ -350,7 +356,8 @@ TEST_F(HlslGeneratorImplTest_MemberAccessor,
   b_deco.push_back(create<ast::StructMemberOffsetDecoration>(4, Source{}));
   members.push_back(create<ast::StructMember>("a", &mat, b_deco));
 
-  auto* str = create<ast::Struct>(members);
+  auto* str = create<ast::Struct>();
+  str->set_members(members);
 
   ast::type::Struct s("Data", str);
 
@@ -392,7 +399,8 @@ TEST_F(
   deco.push_back(create<ast::StructMemberOffsetDecoration>(0, Source{}));
   members.push_back(create<ast::StructMember>("a", &mat, deco));
 
-  auto* str = create<ast::Struct>(members);
+  auto* str = create<ast::Struct>();
+  str->set_members(members);
 
   ast::type::Struct s("Data", str);
 
@@ -438,7 +446,8 @@ TEST_F(HlslGeneratorImplTest_MemberAccessor,
   b_deco.push_back(create<ast::StructMemberOffsetDecoration>(16, Source{}));
   members.push_back(create<ast::StructMember>("a", &mat, b_deco));
 
-  auto* str = create<ast::Struct>(members);
+  auto* str = create<ast::Struct>();
+  str->set_members(members);
 
   ast::type::Struct s("Data", str);
 
@@ -485,7 +494,8 @@ TEST_F(HlslGeneratorImplTest_MemberAccessor,
   a_deco.push_back(create<ast::StructMemberOffsetDecoration>(0, Source{}));
   members.push_back(create<ast::StructMember>("a", &ary, a_deco));
 
-  auto* str = create<ast::Struct>(members);
+  auto* str = create<ast::Struct>();
+  str->set_members(members);
 
   ast::type::Struct s("Data", str);
 
@@ -529,7 +539,8 @@ TEST_F(HlslGeneratorImplTest_MemberAccessor,
   a_deco.push_back(create<ast::StructMemberOffsetDecoration>(0, Source{}));
   members.push_back(create<ast::StructMember>("a", &ary, a_deco));
 
-  auto* str = create<ast::Struct>(members);
+  auto* str = create<ast::Struct>();
+  str->set_members(members);
 
   ast::type::Struct s("Data", str);
 
@@ -585,7 +596,8 @@ TEST_F(HlslGeneratorImplTest_MemberAccessor,
   b_deco.push_back(create<ast::StructMemberOffsetDecoration>(4, Source{}));
   members.push_back(create<ast::StructMember>("b", &f32, b_deco));
 
-  auto* str = create<ast::Struct>(members);
+  auto* str = create<ast::Struct>();
+  str->set_members(members);
 
   ast::type::Struct s("Data", str);
 
@@ -631,7 +643,8 @@ TEST_F(HlslGeneratorImplTest_MemberAccessor,
   a_deco.push_back(create<ast::StructMemberOffsetDecoration>(0, Source{}));
   members.push_back(create<ast::StructMember>("a", &ary, a_deco));
 
-  auto* str = create<ast::Struct>(members);
+  auto* str = create<ast::Struct>();
+  str->set_members(members);
 
   ast::type::Struct s("Data", str);
 
@@ -683,7 +696,8 @@ TEST_F(HlslGeneratorImplTest_MemberAccessor,
   b_deco.push_back(create<ast::StructMemberOffsetDecoration>(4, Source{}));
   members.push_back(create<ast::StructMember>("b", &f32, b_deco));
 
-  auto* str = create<ast::Struct>(members);
+  auto* str = create<ast::Struct>();
+  str->set_members(members);
 
   ast::type::Struct s("Data", str);
 
@@ -734,7 +748,8 @@ TEST_F(HlslGeneratorImplTest_MemberAccessor,
   b_deco.push_back(create<ast::StructMemberOffsetDecoration>(16, Source{}));
   members.push_back(create<ast::StructMember>("b", &fvec3, b_deco));
 
-  auto* str = create<ast::Struct>(members);
+  auto* str = create<ast::Struct>();
+  str->set_members(members);
 
   ast::type::Struct s("Data", str);
 
@@ -780,7 +795,8 @@ TEST_F(HlslGeneratorImplTest_MemberAccessor,
   b_deco.push_back(create<ast::StructMemberOffsetDecoration>(16, Source{}));
   members.push_back(create<ast::StructMember>("b", &fvec3, b_deco));
 
-  auto* str = create<ast::Struct>(members);
+  auto* str = create<ast::Struct>();
+  str->set_members(members);
 
   ast::type::Struct s("Data", str);
 
@@ -835,7 +851,8 @@ TEST_F(HlslGeneratorImplTest_MemberAccessor,
   ast::type::Vector ivec3(&i32, 3);
   ast::type::Vector fvec3(&f32, 3);
 
-  auto* data_str = create<ast::Struct>(ast::StructMemberList{
+  auto* data_str = create<ast::Struct>();
+  data_str->set_members({
       create<ast::StructMember>(
           "a", &ivec3,
           ast::StructMemberDecorationList{
@@ -851,7 +868,8 @@ TEST_F(HlslGeneratorImplTest_MemberAccessor,
   ast::type::Array ary(&data, 4);
   ary.set_decorations({create<ast::StrideDecoration>(32, Source{})});
 
-  auto* pre_str = create<ast::Struct>(ast::StructMemberList{
+  auto* pre_str = create<ast::Struct>();
+  pre_str->set_members({
       create<ast::StructMember>(
           "c", &ary,
           ast::StructMemberDecorationList{
@@ -906,7 +924,8 @@ TEST_F(HlslGeneratorImplTest_MemberAccessor,
   ast::StructMemberList members;
   ast::StructMemberDecorationList deco;
 
-  auto* data_str = create<ast::Struct>(ast::StructMemberList{
+  auto* data_str = create<ast::Struct>();
+  data_str->set_members({
       create<ast::StructMember>(
           "a", &ivec3,
           ast::StructMemberDecorationList{
@@ -922,8 +941,8 @@ TEST_F(HlslGeneratorImplTest_MemberAccessor,
   ast::type::Array ary(&data, 4);
   ary.set_decorations({create<ast::StrideDecoration>(32, Source{})});
 
-  auto* pre_str =
-      create<ast::Struct>(ast::StructMemberList{create<ast::StructMember>(
+  auto* pre_str = create<ast::Struct>();
+  pre_str->set_members({create<ast::StructMember>(
       "c", &ary,
       ast::StructMemberDecorationList{
           create<ast::StructMemberOffsetDecoration>(0, Source{})})});
@@ -976,7 +995,8 @@ TEST_F(
   ast::type::Vector ivec3(&i32, 3);
   ast::type::Vector fvec3(&f32, 3);
 
-  auto* data_str = create<ast::Struct>(ast::StructMemberList{
+  auto* data_str = create<ast::Struct>();
+  data_str->set_members({
       create<ast::StructMember>(
           "a", &ivec3,
           ast::StructMemberDecorationList{
@@ -992,8 +1012,8 @@ TEST_F(
   ast::type::Array ary(&data, 4);
   ary.set_decorations({create<ast::StrideDecoration>(32, Source{})});
 
-  auto* pre_str =
-      create<ast::Struct>(ast::StructMemberList{create<ast::StructMember>(
+  auto* pre_str = create<ast::Struct>();
+  pre_str->set_members({create<ast::StructMember>(
       "c", &ary,
       ast::StructMemberDecorationList{
           create<ast::StructMemberOffsetDecoration>(0, Source{})})});
@@ -1045,7 +1065,8 @@ TEST_F(HlslGeneratorImplTest_MemberAccessor,
   ast::type::Vector ivec3(&i32, 3);
   ast::type::Vector fvec3(&f32, 3);
 
-  auto* data_str = create<ast::Struct>(ast::StructMemberList{
+  auto* data_str = create<ast::Struct>();
+  data_str->set_members({
       create<ast::StructMember>(
           "a", &ivec3,
           ast::StructMemberDecorationList{
@@ -1061,8 +1082,8 @@ TEST_F(HlslGeneratorImplTest_MemberAccessor,
   ast::type::Array ary(&data, 4);
   ary.set_decorations({create<ast::StrideDecoration>(32, Source{})});
 
-  auto* pre_str =
-      create<ast::Struct>(ast::StructMemberList{create<ast::StructMember>(
+  auto* pre_str = create<ast::Struct>();
+  pre_str->set_members({create<ast::StructMember>(
       "c", &ary,
       ast::StructMemberDecorationList{
           create<ast::StructMemberOffsetDecoration>(0, Source{})})});
@@ -1115,7 +1136,8 @@ TEST_F(HlslGeneratorImplTest_MemberAccessor,
   ast::type::Vector ivec3(&i32, 3);
   ast::type::Vector fvec3(&f32, 3);
 
-  auto* data_str = create<ast::Struct>(ast::StructMemberList{
+  auto* data_str = create<ast::Struct>();
+  data_str->set_members({
       create<ast::StructMember>(
           "a", &ivec3,
           ast::StructMemberDecorationList{
@@ -1131,8 +1153,8 @@ TEST_F(HlslGeneratorImplTest_MemberAccessor,
   ast::type::Array ary(&data, 4);
   ary.set_decorations({create<ast::StrideDecoration>(32, Source{})});
 
-  auto* pre_str =
-      create<ast::Struct>(ast::StructMemberList{create<ast::StructMember>(
+  auto* pre_str = create<ast::Struct>();
+  pre_str->set_members({create<ast::StructMember>(
       "c", &ary,
       ast::StructMemberDecorationList{
           create<ast::StructMemberOffsetDecoration>(0, Source{})})});
@@ -1196,7 +1218,8 @@ TEST_F(HlslGeneratorImplTest_MemberAccessor,
   ast::type::Vector ivec3(&i32, 3);
   ast::type::Vector fvec3(&f32, 3);
 
-  auto* data_str = create<ast::Struct>(ast::StructMemberList{
+  auto* data_str = create<ast::Struct>();
+  data_str->set_members({
       create<ast::StructMember>(
           "a", &ivec3,
           ast::StructMemberDecorationList{
@@ -1212,8 +1235,8 @@ TEST_F(HlslGeneratorImplTest_MemberAccessor,
   ast::type::Array ary(&data, 4);
   ary.set_decorations({create<ast::StrideDecoration>(32, Source{})});
 
-  auto* pre_str =
-      create<ast::Struct>(ast::StructMemberList{create<ast::StructMember>(
+  auto* pre_str = create<ast::Struct>();
+  pre_str->set_members({create<ast::StructMember>(
       "c", &ary,
       ast::StructMemberDecorationList{
           create<ast::StructMemberOffsetDecoration>(0, Source{})})});

src/writer/hlsl/generator_impl_type_test.cc

@@ -181,7 +181,8 @@ TEST_F(HlslGeneratorImplTest_Type, EmitType_StructDecl) {
   b_deco.push_back(create<ast::StructMemberOffsetDecoration>(4, Source{}));
   members.push_back(create<ast::StructMember>("b", &f32, b_deco));
 
-  auto* str = create<ast::Struct>(members);
+  auto* str = create<ast::Struct>();
+  str->set_members(members);
 
   ast::type::Struct s("S", str);
 
@@ -205,7 +206,8 @@ TEST_F(HlslGeneratorImplTest_Type, EmitType_Struct) {
   b_deco.push_back(create<ast::StructMemberOffsetDecoration>(4, Source{}));
   members.push_back(create<ast::StructMember>("b", &f32, b_deco));
 
-  auto* str = create<ast::Struct>(members);
+  auto* str = create<ast::Struct>();
+  str->set_members(members);
 
   ast::type::Struct s("S", str);
 
@@ -229,7 +231,8 @@ TEST_F(HlslGeneratorImplTest_Type, DISABLED_EmitType_Struct_InjectPadding) {
   decos.push_back(create<ast::StructMemberOffsetDecoration>(128, Source{}));
   members.push_back(create<ast::StructMember>("c", &f32, decos));
 
-  auto* str = create<ast::Struct>(members);
+  auto* str = create<ast::Struct>();
+  str->set_members(members);
 
   ast::type::Struct s("S", str);
 
@@ -255,7 +258,8 @@ TEST_F(HlslGeneratorImplTest_Type, EmitType_Struct_NameCollision) {
   ast::StructMemberDecorationList b_deco;
   members.push_back(create<ast::StructMember>("float", &f32, b_deco));
 
-  auto* str = create<ast::Struct>(members);
+  auto* str = create<ast::Struct>();
+  str->set_members(members);
 
   ast::type::Struct s("S", str);
 

src/writer/msl/generator_impl_alias_type_test.cc

@@ -61,7 +61,8 @@ TEST_F(MslGeneratorImplTest, EmitConstructedType_Struct) {
   b_deco.push_back(create<ast::StructMemberOffsetDecoration>(4, Source{}));
   members.push_back(create<ast::StructMember>("b", &i32, b_deco));
 
-  auto* str = create<ast::Struct>(members);
+  auto* str = create<ast::Struct>();
+  str->set_members(members);
 
   ast::type::Struct s("a", str);
 
@@ -85,7 +86,8 @@ TEST_F(MslGeneratorImplTest, EmitConstructedType_AliasStructIdent) {
   b_deco.push_back(create<ast::StructMemberOffsetDecoration>(4, Source{}));
   members.push_back(create<ast::StructMember>("b", &i32, b_deco));
 
-  auto* str = create<ast::Struct>(members);
+  auto* str = create<ast::Struct>();
+  str->set_members(members);
 
   ast::type::Struct s("b", str);
   ast::type::Alias alias("a", &s);

src/writer/msl/generator_impl_function_test.cc

@@ -295,7 +295,8 @@ TEST_F(MslGeneratorImplTest,
   b_deco.push_back(create<ast::StructMemberOffsetDecoration>(4, Source{}));
   members.push_back(create<ast::StructMember>("b", &f32, b_deco));
 
-  auto* str = create<ast::Struct>(members);
+  auto* str = create<ast::Struct>();
+  str->set_members(members);
 
   ast::type::Struct s("Data", str);
   ast::type::AccessControl ac(ast::AccessControl::kReadWrite, &s);
@@ -362,7 +363,8 @@ TEST_F(MslGeneratorImplTest,
   b_deco.push_back(create<ast::StructMemberOffsetDecoration>(4, Source{}));
   members.push_back(create<ast::StructMember>("b", &f32, b_deco));
 
-  auto* str = create<ast::Struct>(members);
+  auto* str = create<ast::Struct>();
+  str->set_members(members);
 
   ast::type::Struct s("Data", str);
   ast::type::AccessControl ac(ast::AccessControl::kReadOnly, &s);
@@ -729,7 +731,8 @@ TEST_F(MslGeneratorImplTest,
   b_deco.push_back(create<ast::StructMemberOffsetDecoration>(4, Source{}));
   members.push_back(create<ast::StructMember>("b", &f32, b_deco));
 
-  auto* str = create<ast::Struct>(members);
+  auto* str = create<ast::Struct>();
+  str->set_members(members);
 
   ast::type::Struct s("Data", str);
   ast::type::AccessControl ac(ast::AccessControl::kReadWrite, &s);
@@ -815,7 +818,8 @@ TEST_F(MslGeneratorImplTest,
   b_deco.push_back(create<ast::StructMemberOffsetDecoration>(4, Source{}));
   members.push_back(create<ast::StructMember>("b", &f32, b_deco));
 
-  auto* str = create<ast::Struct>(members);
+  auto* str = create<ast::Struct>();
+  str->set_members(members);
 
   ast::type::Struct s("Data", str);
   ast::type::AccessControl ac(ast::AccessControl::kReadOnly, &s);

src/writer/msl/generator_impl_test.cc

@@ -168,7 +168,8 @@ TEST_F(MslGeneratorImplTest, calculate_alignment_size_struct) {
   decos.push_back(create<ast::StructMemberOffsetDecoration>(128, Source{}));
   members.push_back(create<ast::StructMember>("c", &f32, decos));
 
-  auto* str = create<ast::Struct>(members);
+  auto* str = create<ast::Struct>();
+  str->set_members(members);
 
   ast::type::Struct s("S", str);
 
@@ -192,7 +193,8 @@ TEST_F(MslGeneratorImplTest, calculate_alignment_size_struct_of_struct) {
   decos.push_back(create<ast::StructMemberOffsetDecoration>(32, Source{}));
   members.push_back(create<ast::StructMember>("c", &f32, decos));
 
-  auto* inner_str = create<ast::Struct>(members);
+  auto* inner_str = create<ast::Struct>();
+  inner_str->set_members(members);
 
   ast::type::Struct inner_s("Inner", inner_str);
 
@@ -205,7 +207,8 @@ TEST_F(MslGeneratorImplTest, calculate_alignment_size_struct_of_struct) {
   decos.push_back(create<ast::StructMemberOffsetDecoration>(64, Source{}));
   members.push_back(create<ast::StructMember>("f", &f32, decos));
 
-  auto* outer_str = create<ast::Struct>(members);
+  auto* outer_str = create<ast::Struct>();
+  outer_str->set_members(members);
 
   ast::type::Struct outer_s("Outer", outer_str);
 

src/writer/msl/generator_impl_type_test.cc

@@ -183,7 +183,8 @@ TEST_F(MslGeneratorImplTest, EmitType_Struct) {
   b_deco.push_back(create<ast::StructMemberOffsetDecoration>(4, Source{}));
   members.push_back(create<ast::StructMember>("b", &f32, b_deco));
 
-  auto* str = create<ast::Struct>(members);
+  auto* str = create<ast::Struct>();
+  str->set_members(members);
 
   ast::type::Struct s("S", str);
 
@@ -203,7 +204,8 @@ TEST_F(MslGeneratorImplTest, EmitType_StructDecl) {
   b_deco.push_back(create<ast::StructMemberOffsetDecoration>(4, Source{}));
   members.push_back(create<ast::StructMember>("b", &f32, b_deco));
 
-  auto* str = create<ast::Struct>(members);
+  auto* str = create<ast::Struct>();
+  str->set_members(members);
 
   ast::type::Struct s("S", str);
 
@@ -219,7 +221,8 @@ TEST_F(MslGeneratorImplTest, EmitType_Struct_InjectPadding) {
   ast::type::I32 i32;
   ast::type::F32 f32;
 
-  auto* str = create<ast::Struct>(ast::StructMemberList{
+  auto* str = create<ast::Struct>();
+  str->set_members({
       create<ast::StructMember>(
           "a", &i32,
           ast::StructMemberDecorationList{
@@ -259,7 +262,8 @@ TEST_F(MslGeneratorImplTest, EmitType_Struct_NameCollision) {
   ast::StructMemberDecorationList b_deco;
   members.push_back(create<ast::StructMember>("float", &f32, b_deco));
 
-  auto* str = create<ast::Struct>(members);
+  auto* str = create<ast::Struct>();
+  str->set_members(members);
 
   ast::type::Struct s("S", str);
 

src/writer/msl/generator_impl_variable_decl_statement_test.cc

@@ -90,7 +90,8 @@ TEST_F(MslGeneratorImplTest, Emit_VariableDeclStatement_Struct) {
   b_deco.push_back(create<ast::StructMemberOffsetDecoration>(4, Source{}));
   members.push_back(create<ast::StructMember>("b", &f32, b_deco));
 
-  auto* str = create<ast::Struct>(members);
+  auto* str = create<ast::Struct>();
+  str->set_members(members);
 
   ast::type::Struct s("S", str);
 

src/writer/spirv/builder_type_test.cc

@@ -279,7 +279,7 @@ TEST_F(BuilderTest_Type, ReturnsGeneratedPtr) {
 }
 
 TEST_F(BuilderTest_Type, GenerateStruct_Empty) {
-  auto* s = create<ast::Struct>(ast::StructMemberList{});
+  auto* s = create<ast::Struct>();
   ast::type::Struct s_type("S", s);
 
   auto id = b.GenerateTypeIfNeeded(&s_type);

src/writer/wgsl/generator_impl_alias_type_test.cc

@@ -51,7 +51,8 @@ TEST_F(WgslGeneratorImplTest, EmitConstructedType_Struct) {
   b_deco.push_back(create<ast::StructMemberOffsetDecoration>(4, Source{}));
   members.push_back(create<ast::StructMember>("b", &i32, b_deco));
 
-  auto* str = create<ast::Struct>(members);
+  auto* str = create<ast::Struct>();
+  str->set_members(members);
 
   ast::type::Struct s("A", str);
   ast::type::Alias alias("B", &s);
@@ -79,7 +80,8 @@ TEST_F(WgslGeneratorImplTest, EmitAlias_ToStruct) {
   b_deco.push_back(create<ast::StructMemberOffsetDecoration>(4, Source{}));
   members.push_back(create<ast::StructMember>("b", &i32, b_deco));
 
-  auto* str = create<ast::Struct>(members);
+  auto* str = create<ast::Struct>();
+  str->set_members(members);
 
   ast::type::Struct s("A", str);
   ast::type::Alias alias("B", &s);

src/writer/wgsl/generator_impl_type_test.cc

@@ -185,7 +185,8 @@ TEST_F(WgslGeneratorImplTest, EmitType_Struct) {
   b_deco.push_back(create<ast::StructMemberOffsetDecoration>(4, Source{}));
   members.push_back(create<ast::StructMember>("b", &f32, b_deco));
 
-  auto* str = create<ast::Struct>(members);
+  auto* str = create<ast::Struct>();
+  str->set_members(members);
 
   ast::type::Struct s("S", str);
 
@@ -205,7 +206,8 @@ TEST_F(WgslGeneratorImplTest, EmitType_StructDecl) {
   b_deco.push_back(create<ast::StructMemberOffsetDecoration>(4, Source{}));
   members.push_back(create<ast::StructMember>("b", &f32, b_deco));
 
-  auto* str = create<ast::Struct>(members);
+  auto* str = create<ast::Struct>();
+  str->set_members(members);
 
   ast::type::Struct s("S", str);