writer/msl tests: Replace std::make_unique<T> -> create<T>

create() is currently just a simple forwarder to std::make_unique<>, but
will be later replaced with a function that returns a raw pointer,
and owned by the context.

Bug: tint:322
Change-Id: I1756981b206c125d1dbf78ac178e0a7b60ec2941
Reviewed-on: https://dawn-review.googlesource.com/c/tint/+/32672
Commit-Queue: Ben Clayton <bclayton@google.com>
Reviewed-by: dan sinclair <dsinclair@chromium.org>

src/writer/msl/generator_impl_alias_type_test.cc

@@ -54,16 +54,14 @@ TEST_F(MslGeneratorImplTest, EmitConstructedType_Struct) {
   ast::type::F32Type f32;
 
   ast::StructMemberList members;
-  members.push_back(std::make_unique<ast::StructMember>(
+  members.push_back(
-      "a", &f32, ast::StructMemberDecorationList{}));
+      create<ast::StructMember>("a", &f32, ast::StructMemberDecorationList{}));
 
   ast::StructMemberDecorationList b_deco;
-  b_deco.push_back(
+  b_deco.push_back(create<ast::StructMemberOffsetDecoration>(4, Source{}));
-      std::make_unique<ast::StructMemberOffsetDecoration>(4, Source{}));
+  members.push_back(create<ast::StructMember>("b", &i32, std::move(b_deco)));
-  members.push_back(
-      std::make_unique<ast::StructMember>("b", &i32, std::move(b_deco)));
 
-  auto str = std::make_unique<ast::Struct>();
+  auto str = create<ast::Struct>();
   str->set_members(std::move(members));
 
   ast::type::StructType s("a", std::move(str));
@@ -81,16 +79,14 @@ TEST_F(MslGeneratorImplTest, EmitConstructedType_AliasStructIdent) {
   ast::type::F32Type f32;
 
   ast::StructMemberList members;
-  members.push_back(std::make_unique<ast::StructMember>(
+  members.push_back(
-      "a", &f32, ast::StructMemberDecorationList{}));
+      create<ast::StructMember>("a", &f32, ast::StructMemberDecorationList{}));
 
   ast::StructMemberDecorationList b_deco;
-  b_deco.push_back(
+  b_deco.push_back(create<ast::StructMemberOffsetDecoration>(4, Source{}));
-      std::make_unique<ast::StructMemberOffsetDecoration>(4, Source{}));
+  members.push_back(create<ast::StructMember>("b", &i32, std::move(b_deco)));
-  members.push_back(
-      std::make_unique<ast::StructMember>("b", &i32, std::move(b_deco)));
 
-  auto str = std::make_unique<ast::Struct>();
+  auto str = create<ast::Struct>();
   str->set_members(std::move(members));
 
   ast::type::StructType s("b", std::move(str));

src/writer/msl/generator_impl_array_accessor_test.cc

@@ -33,9 +33,9 @@ using MslGeneratorImplTest = TestHelper;
 
 TEST_F(MslGeneratorImplTest, EmitExpression_ArrayAccessor) {
   ast::type::I32Type i32;
-  auto lit = std::make_unique<ast::SintLiteral>(&i32, 5);
+  auto lit = create<ast::SintLiteral>(&i32, 5);
-  auto idx = std::make_unique<ast::ScalarConstructorExpression>(std::move(lit));
+  auto idx = create<ast::ScalarConstructorExpression>(std::move(lit));
-  auto ary = std::make_unique<ast::IdentifierExpression>("ary");
+  auto ary = create<ast::IdentifierExpression>("ary");
 
   ast::ArrayAccessorExpression expr(std::move(ary), std::move(idx));
 
@@ -44,8 +44,8 @@ TEST_F(MslGeneratorImplTest, EmitExpression_ArrayAccessor) {
 }
 
 TEST_F(MslGeneratorImplTest, EmitArrayAccessor) {
-  auto ary = std::make_unique<ast::IdentifierExpression>("ary");
+  auto ary = create<ast::IdentifierExpression>("ary");
-  auto idx = std::make_unique<ast::IdentifierExpression>("idx");
+  auto idx = create<ast::IdentifierExpression>("idx");
 
   ast::ArrayAccessorExpression expr(std::move(ary), std::move(idx));
 

src/writer/msl/generator_impl_assign_test.cc

@@ -30,8 +30,8 @@ namespace {
 using MslGeneratorImplTest = TestHelper;
 
 TEST_F(MslGeneratorImplTest, Emit_Assign) {
-  auto lhs = std::make_unique<ast::IdentifierExpression>("lhs");
+  auto lhs = create<ast::IdentifierExpression>("lhs");
-  auto rhs = std::make_unique<ast::IdentifierExpression>("rhs");
+  auto rhs = create<ast::IdentifierExpression>("rhs");
   ast::AssignmentStatement assign(std::move(lhs), std::move(rhs));
 
   gen.increment_indent();

src/writer/msl/generator_impl_binary_test.cc

@@ -38,8 +38,8 @@ using MslBinaryTest = TestParamHelper<BinaryData>;
 TEST_P(MslBinaryTest, Emit) {
   auto params = GetParam();
 
-  auto left = std::make_unique<ast::IdentifierExpression>("left");
+  auto left = create<ast::IdentifierExpression>("left");
-  auto right = std::make_unique<ast::IdentifierExpression>("right");
+  auto right = create<ast::IdentifierExpression>("right");
 
   ast::BinaryExpression expr(params.op, std::move(left), std::move(right));
 

src/writer/msl/generator_impl_bitcast_test.cc

@@ -31,7 +31,7 @@ using MslGeneratorImplTest = TestHelper;
 
 TEST_F(MslGeneratorImplTest, EmitExpression_Bitcast) {
   ast::type::F32Type f32;
-  auto id = std::make_unique<ast::IdentifierExpression>("id");
+  auto id = create<ast::IdentifierExpression>("id");
   ast::BitcastExpression bitcast(&f32, std::move(id));
 
   ASSERT_TRUE(gen.EmitExpression(&bitcast)) << gen.error();

src/writer/msl/generator_impl_block_test.cc

@@ -29,7 +29,7 @@ using MslGeneratorImplTest = TestHelper;
 
 TEST_F(MslGeneratorImplTest, Emit_Block) {
   ast::BlockStatement b;
-  b.append(std::make_unique<ast::DiscardStatement>());
+  b.append(create<ast::DiscardStatement>());
 
   gen.increment_indent();
 
@@ -42,7 +42,7 @@ TEST_F(MslGeneratorImplTest, Emit_Block) {
 
 TEST_F(MslGeneratorImplTest, Emit_Block_WithoutNewline) {
   ast::BlockStatement b;
-  b.append(std::make_unique<ast::DiscardStatement>());
+  b.append(create<ast::DiscardStatement>());
 
   gen.increment_indent();
 

src/writer/msl/generator_impl_call_test.cc

@@ -34,11 +34,10 @@ using MslGeneratorImplTest = TestHelper;
 TEST_F(MslGeneratorImplTest, EmitExpression_Call_WithoutParams) {
   ast::type::VoidType void_type;
 
-  auto id = std::make_unique<ast::IdentifierExpression>("my_func");
+  auto id = create<ast::IdentifierExpression>("my_func");
   ast::CallExpression call(std::move(id), {});
 
-  auto func = std::make_unique<ast::Function>("my_func", ast::VariableList{},
+  auto func = create<ast::Function>("my_func", ast::VariableList{}, &void_type);
-                                              &void_type);
   mod.AddFunction(std::move(func));
 
   ASSERT_TRUE(gen.EmitExpression(&call)) << gen.error();
@@ -48,14 +47,13 @@ TEST_F(MslGeneratorImplTest, EmitExpression_Call_WithoutParams) {
 TEST_F(MslGeneratorImplTest, EmitExpression_Call_WithParams) {
   ast::type::VoidType void_type;
 
-  auto id = std::make_unique<ast::IdentifierExpression>("my_func");
+  auto id = create<ast::IdentifierExpression>("my_func");
   ast::ExpressionList params;
-  params.push_back(std::make_unique<ast::IdentifierExpression>("param1"));
+  params.push_back(create<ast::IdentifierExpression>("param1"));
-  params.push_back(std::make_unique<ast::IdentifierExpression>("param2"));
+  params.push_back(create<ast::IdentifierExpression>("param2"));
   ast::CallExpression call(std::move(id), std::move(params));
 
-  auto func = std::make_unique<ast::Function>("my_func", ast::VariableList{},
+  auto func = create<ast::Function>("my_func", ast::VariableList{}, &void_type);
-                                              &void_type);
   mod.AddFunction(std::move(func));
 
   ASSERT_TRUE(gen.EmitExpression(&call)) << gen.error();
@@ -65,15 +63,14 @@ TEST_F(MslGeneratorImplTest, EmitExpression_Call_WithParams) {
 TEST_F(MslGeneratorImplTest, EmitStatement_Call) {
   ast::type::VoidType void_type;
 
-  auto id = std::make_unique<ast::IdentifierExpression>("my_func");
+  auto id = create<ast::IdentifierExpression>("my_func");
   ast::ExpressionList params;
-  params.push_back(std::make_unique<ast::IdentifierExpression>("param1"));
+  params.push_back(create<ast::IdentifierExpression>("param1"));
-  params.push_back(std::make_unique<ast::IdentifierExpression>("param2"));
+  params.push_back(create<ast::IdentifierExpression>("param2"));
   ast::CallStatement call(
-      std::make_unique<ast::CallExpression>(std::move(id), std::move(params)));
+      create<ast::CallExpression>(std::move(id), std::move(params)));
 
-  auto func = std::make_unique<ast::Function>("my_func", ast::VariableList{},
+  auto func = create<ast::Function>("my_func", ast::VariableList{}, &void_type);
-                                              &void_type);
   mod.AddFunction(std::move(func));
 
   gen.increment_indent();

src/writer/msl/generator_impl_case_test.cc

@@ -35,11 +35,11 @@ using MslGeneratorImplTest = TestHelper;
 TEST_F(MslGeneratorImplTest, Emit_Case) {
   ast::type::I32Type i32;
 
-  auto body = std::make_unique<ast::BlockStatement>();
+  auto body = create<ast::BlockStatement>();
-  body->append(std::make_unique<ast::BreakStatement>());
+  body->append(create<ast::BreakStatement>());
 
   ast::CaseSelectorList lit;
-  lit.push_back(std::make_unique<ast::SintLiteral>(&i32, 5));
+  lit.push_back(create<ast::SintLiteral>(&i32, 5));
   ast::CaseStatement c(std::move(lit), std::move(body));
 
   gen.increment_indent();
@@ -55,8 +55,8 @@ TEST_F(MslGeneratorImplTest, Emit_Case_BreaksByDefault) {
   ast::type::I32Type i32;
 
   ast::CaseSelectorList lit;
-  lit.push_back(std::make_unique<ast::SintLiteral>(&i32, 5));
+  lit.push_back(create<ast::SintLiteral>(&i32, 5));
-  ast::CaseStatement c(std::move(lit), std::make_unique<ast::BlockStatement>());
+  ast::CaseStatement c(std::move(lit), create<ast::BlockStatement>());
 
   gen.increment_indent();
 
@@ -70,11 +70,11 @@ TEST_F(MslGeneratorImplTest, Emit_Case_BreaksByDefault) {
 TEST_F(MslGeneratorImplTest, Emit_Case_WithFallthrough) {
   ast::type::I32Type i32;
 
-  auto body = std::make_unique<ast::BlockStatement>();
+  auto body = create<ast::BlockStatement>();
-  body->append(std::make_unique<ast::FallthroughStatement>());
+  body->append(create<ast::FallthroughStatement>());
 
   ast::CaseSelectorList lit;
-  lit.push_back(std::make_unique<ast::SintLiteral>(&i32, 5));
+  lit.push_back(create<ast::SintLiteral>(&i32, 5));
   ast::CaseStatement c(std::move(lit), std::move(body));
 
   gen.increment_indent();
@@ -89,12 +89,12 @@ TEST_F(MslGeneratorImplTest, Emit_Case_WithFallthrough) {
 TEST_F(MslGeneratorImplTest, Emit_Case_MultipleSelectors) {
   ast::type::I32Type i32;
 
-  auto body = std::make_unique<ast::BlockStatement>();
+  auto body = create<ast::BlockStatement>();
-  body->append(std::make_unique<ast::BreakStatement>());
+  body->append(create<ast::BreakStatement>());
 
   ast::CaseSelectorList lit;
-  lit.push_back(std::make_unique<ast::SintLiteral>(&i32, 5));
+  lit.push_back(create<ast::SintLiteral>(&i32, 5));
-  lit.push_back(std::make_unique<ast::SintLiteral>(&i32, 6));
+  lit.push_back(create<ast::SintLiteral>(&i32, 6));
   ast::CaseStatement c(std::move(lit), std::move(body));
 
   gen.increment_indent();
@@ -110,8 +110,8 @@ TEST_F(MslGeneratorImplTest, Emit_Case_MultipleSelectors) {
 TEST_F(MslGeneratorImplTest, Emit_Case_Default) {
   ast::CaseStatement c;
 
-  auto body = std::make_unique<ast::BlockStatement>();
+  auto body = create<ast::BlockStatement>();
-  body->append(std::make_unique<ast::BreakStatement>());
+  body->append(create<ast::BreakStatement>());
   c.set_body(std::move(body));
 
   gen.increment_indent();

src/writer/msl/generator_impl_cast_test.cc

@@ -34,7 +34,7 @@ TEST_F(MslGeneratorImplTest, EmitExpression_Cast_Scalar) {
   ast::type::F32Type f32;
 
   ast::ExpressionList params;
-  params.push_back(std::make_unique<ast::IdentifierExpression>("id"));
+  params.push_back(create<ast::IdentifierExpression>("id"));
 
   ast::TypeConstructorExpression cast(&f32, std::move(params));
 
@@ -47,7 +47,7 @@ TEST_F(MslGeneratorImplTest, EmitExpression_Cast_Vector) {
   ast::type::VectorType vec3(&f32, 3);
 
   ast::ExpressionList params;
-  params.push_back(std::make_unique<ast::IdentifierExpression>("id"));
+  params.push_back(create<ast::IdentifierExpression>("id"));
 
   ast::TypeConstructorExpression cast(&vec3, std::move(params));
 

src/writer/msl/generator_impl_constructor_test.cc

@@ -39,7 +39,7 @@ using MslGeneratorImplTest = TestHelper;
 
 TEST_F(MslGeneratorImplTest, EmitConstructor_Bool) {
   ast::type::BoolType bool_type;
-  auto lit = std::make_unique<ast::BoolLiteral>(&bool_type, false);
+  auto lit = create<ast::BoolLiteral>(&bool_type, false);
   ast::ScalarConstructorExpression expr(std::move(lit));
 
   ASSERT_TRUE(gen.EmitConstructor(&expr)) << gen.error();
@@ -48,7 +48,7 @@ TEST_F(MslGeneratorImplTest, EmitConstructor_Bool) {
 
 TEST_F(MslGeneratorImplTest, EmitConstructor_Int) {
   ast::type::I32Type i32;
-  auto lit = std::make_unique<ast::SintLiteral>(&i32, -12345);
+  auto lit = create<ast::SintLiteral>(&i32, -12345);
   ast::ScalarConstructorExpression expr(std::move(lit));
 
   ASSERT_TRUE(gen.EmitConstructor(&expr)) << gen.error();
@@ -57,7 +57,7 @@ TEST_F(MslGeneratorImplTest, EmitConstructor_Int) {
 
 TEST_F(MslGeneratorImplTest, EmitConstructor_UInt) {
   ast::type::U32Type u32;
-  auto lit = std::make_unique<ast::UintLiteral>(&u32, 56779);
+  auto lit = create<ast::UintLiteral>(&u32, 56779);
   ast::ScalarConstructorExpression expr(std::move(lit));
 
   ASSERT_TRUE(gen.EmitConstructor(&expr)) << gen.error();
@@ -67,8 +67,7 @@ TEST_F(MslGeneratorImplTest, EmitConstructor_UInt) {
 TEST_F(MslGeneratorImplTest, EmitConstructor_Float) {
   ast::type::F32Type f32;
   // Use a number close to 1<<30 but whose decimal representation ends in 0.
-  auto lit = std::make_unique<ast::FloatLiteral>(
+  auto lit = create<ast::FloatLiteral>(&f32, static_cast<float>((1 << 30) - 4));
-      &f32, static_cast<float>((1 << 30) - 4));
   ast::ScalarConstructorExpression expr(std::move(lit));
 
   ASSERT_TRUE(gen.EmitConstructor(&expr)) << gen.error();
@@ -78,10 +77,9 @@ TEST_F(MslGeneratorImplTest, EmitConstructor_Float) {
 TEST_F(MslGeneratorImplTest, EmitConstructor_Type_Float) {
   ast::type::F32Type f32;
 
-  auto lit = std::make_unique<ast::FloatLiteral>(&f32, -1.2e-5);
+  auto lit = create<ast::FloatLiteral>(&f32, -1.2e-5);
   ast::ExpressionList values;
-  values.push_back(
+  values.push_back(create<ast::ScalarConstructorExpression>(std::move(lit)));
-      std::make_unique<ast::ScalarConstructorExpression>(std::move(lit)));
 
   ast::TypeConstructorExpression expr(&f32, std::move(values));
 
@@ -92,10 +90,9 @@ TEST_F(MslGeneratorImplTest, EmitConstructor_Type_Float) {
 TEST_F(MslGeneratorImplTest, EmitConstructor_Type_Bool) {
   ast::type::BoolType b;
 
-  auto lit = std::make_unique<ast::BoolLiteral>(&b, true);
+  auto lit = create<ast::BoolLiteral>(&b, true);
   ast::ExpressionList values;
-  values.push_back(
+  values.push_back(create<ast::ScalarConstructorExpression>(std::move(lit)));
-      std::make_unique<ast::ScalarConstructorExpression>(std::move(lit)));
 
   ast::TypeConstructorExpression expr(&b, std::move(values));
 
@@ -106,10 +103,9 @@ TEST_F(MslGeneratorImplTest, EmitConstructor_Type_Bool) {
 TEST_F(MslGeneratorImplTest, EmitConstructor_Type_Int) {
   ast::type::I32Type i32;
 
-  auto lit = std::make_unique<ast::SintLiteral>(&i32, -12345);
+  auto lit = create<ast::SintLiteral>(&i32, -12345);
   ast::ExpressionList values;
-  values.push_back(
+  values.push_back(create<ast::ScalarConstructorExpression>(std::move(lit)));
-      std::make_unique<ast::ScalarConstructorExpression>(std::move(lit)));
 
   ast::TypeConstructorExpression expr(&i32, std::move(values));
 
@@ -120,10 +116,9 @@ TEST_F(MslGeneratorImplTest, EmitConstructor_Type_Int) {
 TEST_F(MslGeneratorImplTest, EmitConstructor_Type_Uint) {
   ast::type::U32Type u32;
 
-  auto lit = std::make_unique<ast::UintLiteral>(&u32, 12345);
+  auto lit = create<ast::UintLiteral>(&u32, 12345);
   ast::ExpressionList values;
-  values.push_back(
+  values.push_back(create<ast::ScalarConstructorExpression>(std::move(lit)));
-      std::make_unique<ast::ScalarConstructorExpression>(std::move(lit)));
 
   ast::TypeConstructorExpression expr(&u32, std::move(values));
 
@@ -135,16 +130,13 @@ TEST_F(MslGeneratorImplTest, EmitConstructor_Type_Vec) {
   ast::type::F32Type f32;
   ast::type::VectorType vec(&f32, 3);
 
-  auto lit1 = std::make_unique<ast::FloatLiteral>(&f32, 1.f);
+  auto lit1 = create<ast::FloatLiteral>(&f32, 1.f);
-  auto lit2 = std::make_unique<ast::FloatLiteral>(&f32, 2.f);
+  auto lit2 = create<ast::FloatLiteral>(&f32, 2.f);
-  auto lit3 = std::make_unique<ast::FloatLiteral>(&f32, 3.f);
+  auto lit3 = create<ast::FloatLiteral>(&f32, 3.f);
   ast::ExpressionList values;
-  values.push_back(
+  values.push_back(create<ast::ScalarConstructorExpression>(std::move(lit1)));
-      std::make_unique<ast::ScalarConstructorExpression>(std::move(lit1)));
+  values.push_back(create<ast::ScalarConstructorExpression>(std::move(lit2)));
-  values.push_back(
+  values.push_back(create<ast::ScalarConstructorExpression>(std::move(lit3)));
-      std::make_unique<ast::ScalarConstructorExpression>(std::move(lit2)));
-  values.push_back(
-      std::make_unique<ast::ScalarConstructorExpression>(std::move(lit3)));
 
   ast::TypeConstructorExpression expr(&vec, std::move(values));
 
@@ -174,23 +166,20 @@ TEST_F(MslGeneratorImplTest, EmitConstructor_Type_Mat) {
   ast::ExpressionList mat_values;
 
   for (size_t i = 0; i < 2; i++) {
-    auto lit1 = std::make_unique<ast::FloatLiteral>(
+    auto lit1 =
-        &f32, static_cast<float>(1 + (i * 2)));
+        create<ast::FloatLiteral>(&f32, static_cast<float>(1 + (i * 2)));
-    auto lit2 = std::make_unique<ast::FloatLiteral>(
+    auto lit2 =
-        &f32, static_cast<float>(2 + (i * 2)));
+        create<ast::FloatLiteral>(&f32, static_cast<float>(2 + (i * 2)));
-    auto lit3 = std::make_unique<ast::FloatLiteral>(
+    auto lit3 =
-        &f32, static_cast<float>(3 + (i * 2)));
+        create<ast::FloatLiteral>(&f32, static_cast<float>(3 + (i * 2)));
 
     ast::ExpressionList values;
-    values.push_back(
+    values.push_back(create<ast::ScalarConstructorExpression>(std::move(lit1)));
-        std::make_unique<ast::ScalarConstructorExpression>(std::move(lit1)));
+    values.push_back(create<ast::ScalarConstructorExpression>(std::move(lit2)));
-    values.push_back(
+    values.push_back(create<ast::ScalarConstructorExpression>(std::move(lit3)));
-        std::make_unique<ast::ScalarConstructorExpression>(std::move(lit2)));
-    values.push_back(
-        std::make_unique<ast::ScalarConstructorExpression>(std::move(lit3)));
 
-    mat_values.push_back(std::make_unique<ast::TypeConstructorExpression>(
+    mat_values.push_back(
-        &vec, std::move(values)));
+        create<ast::TypeConstructorExpression>(&vec, std::move(values)));
   }
 
   ast::TypeConstructorExpression expr(&mat, std::move(mat_values));
@@ -212,23 +201,20 @@ TEST_F(MslGeneratorImplTest, EmitConstructor_Type_Array) {
   ast::ExpressionList ary_values;
 
   for (size_t i = 0; i < 3; i++) {
-    auto lit1 = std::make_unique<ast::FloatLiteral>(
+    auto lit1 =
-        &f32, static_cast<float>(1 + (i * 3)));
+        create<ast::FloatLiteral>(&f32, static_cast<float>(1 + (i * 3)));
-    auto lit2 = std::make_unique<ast::FloatLiteral>(
+    auto lit2 =
-        &f32, static_cast<float>(2 + (i * 3)));
+        create<ast::FloatLiteral>(&f32, static_cast<float>(2 + (i * 3)));
-    auto lit3 = std::make_unique<ast::FloatLiteral>(
+    auto lit3 =
-        &f32, static_cast<float>(3 + (i * 3)));
+        create<ast::FloatLiteral>(&f32, static_cast<float>(3 + (i * 3)));
 
     ast::ExpressionList values;
-    values.push_back(
+    values.push_back(create<ast::ScalarConstructorExpression>(std::move(lit1)));
-        std::make_unique<ast::ScalarConstructorExpression>(std::move(lit1)));
+    values.push_back(create<ast::ScalarConstructorExpression>(std::move(lit2)));
-    values.push_back(
+    values.push_back(create<ast::ScalarConstructorExpression>(std::move(lit3)));
-        std::make_unique<ast::ScalarConstructorExpression>(std::move(lit2)));
-    values.push_back(
-        std::make_unique<ast::ScalarConstructorExpression>(std::move(lit3)));
 
-    ary_values.push_back(std::make_unique<ast::TypeConstructorExpression>(
+    ary_values.push_back(
-        &vec, std::move(values)));
+        create<ast::TypeConstructorExpression>(&vec, std::move(values)));
   }
 
   ast::TypeConstructorExpression expr(&ary, std::move(ary_values));

src/writer/msl/generator_impl_function_entry_point_data_test.cc

@@ -52,16 +52,16 @@ TEST_F(MslGeneratorImplTest, Emit_Function_EntryPointData_Vertex_Input) {
   ast::type::F32Type f32;
   ast::type::I32Type i32;
 
-  auto foo_var = std::make_unique<ast::DecoratedVariable>(
+  auto foo_var = create<ast::DecoratedVariable>(
-      std::make_unique<ast::Variable>("foo", ast::StorageClass::kInput, &f32));
+      create<ast::Variable>("foo", ast::StorageClass::kInput, &f32));
 
   ast::VariableDecorationList decos;
-  decos.push_back(std::make_unique<ast::LocationDecoration>(0, Source{}));
+  decos.push_back(create<ast::LocationDecoration>(0, Source{}));
   foo_var->set_decorations(std::move(decos));
 
-  auto bar_var = std::make_unique<ast::DecoratedVariable>(
+  auto bar_var = create<ast::DecoratedVariable>(
-      std::make_unique<ast::Variable>("bar", ast::StorageClass::kInput, &i32));
+      create<ast::Variable>("bar", ast::StorageClass::kInput, &i32));
-  decos.push_back(std::make_unique<ast::LocationDecoration>(1, Source{}));
+  decos.push_back(create<ast::LocationDecoration>(1, Source{}));
   bar_var->set_decorations(std::move(decos));
 
   td.RegisterVariableForTesting(foo_var.get());
@@ -71,19 +71,18 @@ TEST_F(MslGeneratorImplTest, Emit_Function_EntryPointData_Vertex_Input) {
   mod.AddGlobalVariable(std::move(bar_var));
 
   ast::VariableList params;
-  auto func =
+  auto func = create<ast::Function>("vtx_main", std::move(params), &f32);
-      std::make_unique<ast::Function>("vtx_main", std::move(params), &f32);
+  func->add_decoration(
-  func->add_decoration(std::make_unique<ast::StageDecoration>(
+      create<ast::StageDecoration>(ast::PipelineStage::kVertex, Source{}));
-      ast::PipelineStage::kVertex, Source{}));
   auto* func_ptr = func.get();
 
-  auto body = std::make_unique<ast::BlockStatement>();
+  auto body = create<ast::BlockStatement>();
-  body->append(std::make_unique<ast::AssignmentStatement>(
+  body->append(create<ast::AssignmentStatement>(
-      std::make_unique<ast::IdentifierExpression>("foo"),
+      create<ast::IdentifierExpression>("foo"),
-      std::make_unique<ast::IdentifierExpression>("foo")));
+      create<ast::IdentifierExpression>("foo")));
-  body->append(std::make_unique<ast::AssignmentStatement>(
+  body->append(create<ast::AssignmentStatement>(
-      std::make_unique<ast::IdentifierExpression>("bar"),
+      create<ast::IdentifierExpression>("bar"),
-      std::make_unique<ast::IdentifierExpression>("bar")));
+      create<ast::IdentifierExpression>("bar")));
   func->set_body(std::move(body));
 
   mod.AddFunction(std::move(func));
@@ -111,16 +110,16 @@ TEST_F(MslGeneratorImplTest, Emit_Function_EntryPointData_Vertex_Output) {
   ast::type::F32Type f32;
   ast::type::I32Type i32;
 
-  auto foo_var = std::make_unique<ast::DecoratedVariable>(
+  auto foo_var = create<ast::DecoratedVariable>(
-      std::make_unique<ast::Variable>("foo", ast::StorageClass::kOutput, &f32));
+      create<ast::Variable>("foo", ast::StorageClass::kOutput, &f32));
 
   ast::VariableDecorationList decos;
-  decos.push_back(std::make_unique<ast::LocationDecoration>(0, Source{}));
+  decos.push_back(create<ast::LocationDecoration>(0, Source{}));
   foo_var->set_decorations(std::move(decos));
 
-  auto bar_var = std::make_unique<ast::DecoratedVariable>(
+  auto bar_var = create<ast::DecoratedVariable>(
-      std::make_unique<ast::Variable>("bar", ast::StorageClass::kOutput, &i32));
+      create<ast::Variable>("bar", ast::StorageClass::kOutput, &i32));
-  decos.push_back(std::make_unique<ast::LocationDecoration>(1, Source{}));
+  decos.push_back(create<ast::LocationDecoration>(1, Source{}));
   bar_var->set_decorations(std::move(decos));
 
   td.RegisterVariableForTesting(foo_var.get());
@@ -130,19 +129,18 @@ TEST_F(MslGeneratorImplTest, Emit_Function_EntryPointData_Vertex_Output) {
   mod.AddGlobalVariable(std::move(bar_var));
 
   ast::VariableList params;
-  auto func =
+  auto func = create<ast::Function>("vtx_main", std::move(params), &f32);
-      std::make_unique<ast::Function>("vtx_main", std::move(params), &f32);
+  func->add_decoration(
-  func->add_decoration(std::make_unique<ast::StageDecoration>(
+      create<ast::StageDecoration>(ast::PipelineStage::kVertex, Source{}));
-      ast::PipelineStage::kVertex, Source{}));
   auto* func_ptr = func.get();
 
-  auto body = std::make_unique<ast::BlockStatement>();
+  auto body = create<ast::BlockStatement>();
-  body->append(std::make_unique<ast::AssignmentStatement>(
+  body->append(create<ast::AssignmentStatement>(
-      std::make_unique<ast::IdentifierExpression>("foo"),
+      create<ast::IdentifierExpression>("foo"),
-      std::make_unique<ast::IdentifierExpression>("foo")));
+      create<ast::IdentifierExpression>("foo")));
-  body->append(std::make_unique<ast::AssignmentStatement>(
+  body->append(create<ast::AssignmentStatement>(
-      std::make_unique<ast::IdentifierExpression>("bar"),
+      create<ast::IdentifierExpression>("bar"),
-      std::make_unique<ast::IdentifierExpression>("bar")));
+      create<ast::IdentifierExpression>("bar")));
   func->set_body(std::move(body));
 
   mod.AddFunction(std::move(func));
@@ -170,16 +168,16 @@ TEST_F(MslGeneratorImplTest, Emit_Function_EntryPointData_Fragment_Input) {
   ast::type::F32Type f32;
   ast::type::I32Type i32;
 
-  auto foo_var = std::make_unique<ast::DecoratedVariable>(
+  auto foo_var = create<ast::DecoratedVariable>(
-      std::make_unique<ast::Variable>("foo", ast::StorageClass::kInput, &f32));
+      create<ast::Variable>("foo", ast::StorageClass::kInput, &f32));
 
   ast::VariableDecorationList decos;
-  decos.push_back(std::make_unique<ast::LocationDecoration>(0, Source{}));
+  decos.push_back(create<ast::LocationDecoration>(0, Source{}));
   foo_var->set_decorations(std::move(decos));
 
-  auto bar_var = std::make_unique<ast::DecoratedVariable>(
+  auto bar_var = create<ast::DecoratedVariable>(
-      std::make_unique<ast::Variable>("bar", ast::StorageClass::kInput, &i32));
+      create<ast::Variable>("bar", ast::StorageClass::kInput, &i32));
-  decos.push_back(std::make_unique<ast::LocationDecoration>(1, Source{}));
+  decos.push_back(create<ast::LocationDecoration>(1, Source{}));
   bar_var->set_decorations(std::move(decos));
 
   td.RegisterVariableForTesting(foo_var.get());
@@ -189,18 +187,18 @@ TEST_F(MslGeneratorImplTest, Emit_Function_EntryPointData_Fragment_Input) {
   mod.AddGlobalVariable(std::move(bar_var));
 
   ast::VariableList params;
-  auto func = std::make_unique<ast::Function>("main", std::move(params), &f32);
+  auto func = create<ast::Function>("main", std::move(params), &f32);
-  func->add_decoration(std::make_unique<ast::StageDecoration>(
+  func->add_decoration(
-      ast::PipelineStage::kFragment, Source{}));
+      create<ast::StageDecoration>(ast::PipelineStage::kFragment, Source{}));
   auto* func_ptr = func.get();
 
-  auto body = std::make_unique<ast::BlockStatement>();
+  auto body = create<ast::BlockStatement>();
-  body->append(std::make_unique<ast::AssignmentStatement>(
+  body->append(create<ast::AssignmentStatement>(
-      std::make_unique<ast::IdentifierExpression>("foo"),
+      create<ast::IdentifierExpression>("foo"),
-      std::make_unique<ast::IdentifierExpression>("foo")));
+      create<ast::IdentifierExpression>("foo")));
-  body->append(std::make_unique<ast::AssignmentStatement>(
+  body->append(create<ast::AssignmentStatement>(
-      std::make_unique<ast::IdentifierExpression>("bar"),
+      create<ast::IdentifierExpression>("bar"),
-      std::make_unique<ast::IdentifierExpression>("bar")));
+      create<ast::IdentifierExpression>("bar")));
   func->set_body(std::move(body));
 
   mod.AddFunction(std::move(func));
@@ -228,16 +226,16 @@ TEST_F(MslGeneratorImplTest, Emit_Function_EntryPointData_Fragment_Output) {
   ast::type::F32Type f32;
   ast::type::I32Type i32;
 
-  auto foo_var = std::make_unique<ast::DecoratedVariable>(
+  auto foo_var = create<ast::DecoratedVariable>(
-      std::make_unique<ast::Variable>("foo", ast::StorageClass::kOutput, &f32));
+      create<ast::Variable>("foo", ast::StorageClass::kOutput, &f32));
 
   ast::VariableDecorationList decos;
-  decos.push_back(std::make_unique<ast::LocationDecoration>(0, Source{}));
+  decos.push_back(create<ast::LocationDecoration>(0, Source{}));
   foo_var->set_decorations(std::move(decos));
 
-  auto bar_var = std::make_unique<ast::DecoratedVariable>(
+  auto bar_var = create<ast::DecoratedVariable>(
-      std::make_unique<ast::Variable>("bar", ast::StorageClass::kOutput, &i32));
+      create<ast::Variable>("bar", ast::StorageClass::kOutput, &i32));
-  decos.push_back(std::make_unique<ast::LocationDecoration>(1, Source{}));
+  decos.push_back(create<ast::LocationDecoration>(1, Source{}));
   bar_var->set_decorations(std::move(decos));
 
   td.RegisterVariableForTesting(foo_var.get());
@@ -247,18 +245,18 @@ TEST_F(MslGeneratorImplTest, Emit_Function_EntryPointData_Fragment_Output) {
   mod.AddGlobalVariable(std::move(bar_var));
 
   ast::VariableList params;
-  auto func = std::make_unique<ast::Function>("main", std::move(params), &f32);
+  auto func = create<ast::Function>("main", std::move(params), &f32);
-  func->add_decoration(std::make_unique<ast::StageDecoration>(
+  func->add_decoration(
-      ast::PipelineStage::kFragment, Source{}));
+      create<ast::StageDecoration>(ast::PipelineStage::kFragment, Source{}));
   auto* func_ptr = func.get();
 
-  auto body = std::make_unique<ast::BlockStatement>();
+  auto body = create<ast::BlockStatement>();
-  body->append(std::make_unique<ast::AssignmentStatement>(
+  body->append(create<ast::AssignmentStatement>(
-      std::make_unique<ast::IdentifierExpression>("foo"),
+      create<ast::IdentifierExpression>("foo"),
-      std::make_unique<ast::IdentifierExpression>("foo")));
+      create<ast::IdentifierExpression>("foo")));
-  body->append(std::make_unique<ast::AssignmentStatement>(
+  body->append(create<ast::AssignmentStatement>(
-      std::make_unique<ast::IdentifierExpression>("bar"),
+      create<ast::IdentifierExpression>("bar"),
-      std::make_unique<ast::IdentifierExpression>("bar")));
+      create<ast::IdentifierExpression>("bar")));
   func->set_body(std::move(body));
 
   mod.AddFunction(std::move(func));
@@ -283,16 +281,16 @@ TEST_F(MslGeneratorImplTest, Emit_Function_EntryPointData_Compute_Input) {
   ast::type::F32Type f32;
   ast::type::I32Type i32;
 
-  auto foo_var = std::make_unique<ast::DecoratedVariable>(
+  auto foo_var = create<ast::DecoratedVariable>(
-      std::make_unique<ast::Variable>("foo", ast::StorageClass::kInput, &f32));
+      create<ast::Variable>("foo", ast::StorageClass::kInput, &f32));
 
   ast::VariableDecorationList decos;
-  decos.push_back(std::make_unique<ast::LocationDecoration>(0, Source{}));
+  decos.push_back(create<ast::LocationDecoration>(0, Source{}));
   foo_var->set_decorations(std::move(decos));
 
-  auto bar_var = std::make_unique<ast::DecoratedVariable>(
+  auto bar_var = create<ast::DecoratedVariable>(
-      std::make_unique<ast::Variable>("bar", ast::StorageClass::kInput, &i32));
+      create<ast::Variable>("bar", ast::StorageClass::kInput, &i32));
-  decos.push_back(std::make_unique<ast::LocationDecoration>(1, Source{}));
+  decos.push_back(create<ast::LocationDecoration>(1, Source{}));
   bar_var->set_decorations(std::move(decos));
 
   td.RegisterVariableForTesting(foo_var.get());
@@ -302,18 +300,18 @@ TEST_F(MslGeneratorImplTest, Emit_Function_EntryPointData_Compute_Input) {
   mod.AddGlobalVariable(std::move(bar_var));
 
   ast::VariableList params;
-  auto func = std::make_unique<ast::Function>("main", std::move(params), &f32);
+  auto func = create<ast::Function>("main", std::move(params), &f32);
-  func->add_decoration(std::make_unique<ast::StageDecoration>(
+  func->add_decoration(
-      ast::PipelineStage::kCompute, Source{}));
+      create<ast::StageDecoration>(ast::PipelineStage::kCompute, Source{}));
   auto* func_ptr = func.get();
 
-  auto body = std::make_unique<ast::BlockStatement>();
+  auto body = create<ast::BlockStatement>();
-  body->append(std::make_unique<ast::AssignmentStatement>(
+  body->append(create<ast::AssignmentStatement>(
-      std::make_unique<ast::IdentifierExpression>("foo"),
+      create<ast::IdentifierExpression>("foo"),
-      std::make_unique<ast::IdentifierExpression>("foo")));
+      create<ast::IdentifierExpression>("foo")));
-  body->append(std::make_unique<ast::AssignmentStatement>(
+  body->append(create<ast::AssignmentStatement>(
-      std::make_unique<ast::IdentifierExpression>("bar"),
+      create<ast::IdentifierExpression>("bar"),
-      std::make_unique<ast::IdentifierExpression>("bar")));
+      create<ast::IdentifierExpression>("bar")));
   func->set_body(std::move(body));
 
   mod.AddFunction(std::move(func));
@@ -333,16 +331,16 @@ TEST_F(MslGeneratorImplTest, Emit_Function_EntryPointData_Compute_Output) {
   ast::type::F32Type f32;
   ast::type::I32Type i32;
 
-  auto foo_var = std::make_unique<ast::DecoratedVariable>(
+  auto foo_var = create<ast::DecoratedVariable>(
-      std::make_unique<ast::Variable>("foo", ast::StorageClass::kOutput, &f32));
+      create<ast::Variable>("foo", ast::StorageClass::kOutput, &f32));
 
   ast::VariableDecorationList decos;
-  decos.push_back(std::make_unique<ast::LocationDecoration>(0, Source{}));
+  decos.push_back(create<ast::LocationDecoration>(0, Source{}));
   foo_var->set_decorations(std::move(decos));
 
-  auto bar_var = std::make_unique<ast::DecoratedVariable>(
+  auto bar_var = create<ast::DecoratedVariable>(
-      std::make_unique<ast::Variable>("bar", ast::StorageClass::kOutput, &i32));
+      create<ast::Variable>("bar", ast::StorageClass::kOutput, &i32));
-  decos.push_back(std::make_unique<ast::LocationDecoration>(1, Source{}));
+  decos.push_back(create<ast::LocationDecoration>(1, Source{}));
   bar_var->set_decorations(std::move(decos));
 
   td.RegisterVariableForTesting(foo_var.get());
@@ -352,18 +350,18 @@ TEST_F(MslGeneratorImplTest, Emit_Function_EntryPointData_Compute_Output) {
   mod.AddGlobalVariable(std::move(bar_var));
 
   ast::VariableList params;
-  auto func = std::make_unique<ast::Function>("main", std::move(params), &f32);
+  auto func = create<ast::Function>("main", std::move(params), &f32);
-  func->add_decoration(std::make_unique<ast::StageDecoration>(
+  func->add_decoration(
-      ast::PipelineStage::kCompute, Source{}));
+      create<ast::StageDecoration>(ast::PipelineStage::kCompute, Source{}));
   auto* func_ptr = func.get();
 
-  auto body = std::make_unique<ast::BlockStatement>();
+  auto body = create<ast::BlockStatement>();
-  body->append(std::make_unique<ast::AssignmentStatement>(
+  body->append(create<ast::AssignmentStatement>(
-      std::make_unique<ast::IdentifierExpression>("foo"),
+      create<ast::IdentifierExpression>("foo"),
-      std::make_unique<ast::IdentifierExpression>("foo")));
+      create<ast::IdentifierExpression>("foo")));
-  body->append(std::make_unique<ast::AssignmentStatement>(
+  body->append(create<ast::AssignmentStatement>(
-      std::make_unique<ast::IdentifierExpression>("bar"),
+      create<ast::IdentifierExpression>("bar"),
-      std::make_unique<ast::IdentifierExpression>("bar")));
+      create<ast::IdentifierExpression>("bar")));
   func->set_body(std::move(body));
 
   mod.AddFunction(std::move(func));
@@ -389,20 +387,18 @@ TEST_F(MslGeneratorImplTest, Emit_Function_EntryPointData_Builtins) {
   ast::type::VoidType void_type;
   ast::type::VectorType vec4(&f32, 4);
 
-  auto coord_var =
+  auto coord_var = create<ast::DecoratedVariable>(
-      std::make_unique<ast::DecoratedVariable>(std::make_unique<ast::Variable>(
+      create<ast::Variable>("coord", ast::StorageClass::kInput, &vec4));
-          "coord", ast::StorageClass::kInput, &vec4));
 
   ast::VariableDecorationList decos;
-  decos.push_back(std::make_unique<ast::BuiltinDecoration>(
+  decos.push_back(
-      ast::Builtin::kFragCoord, Source{}));
+      create<ast::BuiltinDecoration>(ast::Builtin::kFragCoord, Source{}));
   coord_var->set_decorations(std::move(decos));
 
-  auto depth_var =
+  auto depth_var = create<ast::DecoratedVariable>(
-      std::make_unique<ast::DecoratedVariable>(std::make_unique<ast::Variable>(
+      create<ast::Variable>("depth", ast::StorageClass::kOutput, &f32));
-          "depth", ast::StorageClass::kOutput, &f32));
+  decos.push_back(
-  decos.push_back(std::make_unique<ast::BuiltinDecoration>(
+      create<ast::BuiltinDecoration>(ast::Builtin::kFragDepth, Source{}));
-      ast::Builtin::kFragDepth, Source{}));
   depth_var->set_decorations(std::move(decos));
 
   td.RegisterVariableForTesting(coord_var.get());
@@ -412,18 +408,17 @@ TEST_F(MslGeneratorImplTest, Emit_Function_EntryPointData_Builtins) {
   mod.AddGlobalVariable(std::move(depth_var));
 
   ast::VariableList params;
-  auto func =
+  auto func = create<ast::Function>("main", std::move(params), &void_type);
-      std::make_unique<ast::Function>("main", std::move(params), &void_type);
+  func->add_decoration(
-  func->add_decoration(std::make_unique<ast::StageDecoration>(
+      create<ast::StageDecoration>(ast::PipelineStage::kFragment, Source{}));
-      ast::PipelineStage::kFragment, Source{}));
   auto* func_ptr = func.get();
 
-  auto body = std::make_unique<ast::BlockStatement>();
+  auto body = create<ast::BlockStatement>();
-  body->append(std::make_unique<ast::AssignmentStatement>(
+  body->append(create<ast::AssignmentStatement>(
-      std::make_unique<ast::IdentifierExpression>("depth"),
+      create<ast::IdentifierExpression>("depth"),
-      std::make_unique<ast::MemberAccessorExpression>(
+      create<ast::MemberAccessorExpression>(
-          std::make_unique<ast::IdentifierExpression>("coord"),
+          create<ast::IdentifierExpression>("coord"),
-          std::make_unique<ast::IdentifierExpression>("x"))));
+          create<ast::IdentifierExpression>("x"))));
   func->set_body(std::move(body));
 
   mod.AddFunction(std::move(func));

src/writer/msl/generator_impl_if_test.cc

@@ -29,9 +29,9 @@ namespace {
 using MslGeneratorImplTest = TestHelper;
 
 TEST_F(MslGeneratorImplTest, Emit_If) {
-  auto cond = std::make_unique<ast::IdentifierExpression>("cond");
+  auto cond = create<ast::IdentifierExpression>("cond");
-  auto body = std::make_unique<ast::BlockStatement>();
+  auto body = create<ast::BlockStatement>();
-  body->append(std::make_unique<ast::ReturnStatement>());
+  body->append(create<ast::ReturnStatement>());
 
   ast::IfStatement i(std::move(cond), std::move(body));
 
@@ -45,17 +45,17 @@ TEST_F(MslGeneratorImplTest, Emit_If) {
 }
 
 TEST_F(MslGeneratorImplTest, Emit_IfWithElseIf) {
-  auto else_cond = std::make_unique<ast::IdentifierExpression>("else_cond");
+  auto else_cond = create<ast::IdentifierExpression>("else_cond");
-  auto else_body = std::make_unique<ast::BlockStatement>();
+  auto else_body = create<ast::BlockStatement>();
-  else_body->append(std::make_unique<ast::ReturnStatement>());
+  else_body->append(create<ast::ReturnStatement>());
 
   ast::ElseStatementList elses;
-  elses.push_back(std::make_unique<ast::ElseStatement>(std::move(else_cond),
+  elses.push_back(
-                                                       std::move(else_body)));
+      create<ast::ElseStatement>(std::move(else_cond), std::move(else_body)));
 
-  auto cond = std::make_unique<ast::IdentifierExpression>("cond");
+  auto cond = create<ast::IdentifierExpression>("cond");
-  auto body = std::make_unique<ast::BlockStatement>();
+  auto body = create<ast::BlockStatement>();
-  body->append(std::make_unique<ast::ReturnStatement>());
+  body->append(create<ast::ReturnStatement>());
 
   ast::IfStatement i(std::move(cond), std::move(body));
   i.set_else_statements(std::move(elses));
@@ -72,15 +72,15 @@ TEST_F(MslGeneratorImplTest, Emit_IfWithElseIf) {
 }
 
 TEST_F(MslGeneratorImplTest, Emit_IfWithElse) {
-  auto else_body = std::make_unique<ast::BlockStatement>();
+  auto else_body = create<ast::BlockStatement>();
-  else_body->append(std::make_unique<ast::ReturnStatement>());
+  else_body->append(create<ast::ReturnStatement>());
 
   ast::ElseStatementList elses;
-  elses.push_back(std::make_unique<ast::ElseStatement>(std::move(else_body)));
+  elses.push_back(create<ast::ElseStatement>(std::move(else_body)));
 
-  auto cond = std::make_unique<ast::IdentifierExpression>("cond");
+  auto cond = create<ast::IdentifierExpression>("cond");
-  auto body = std::make_unique<ast::BlockStatement>();
+  auto body = create<ast::BlockStatement>();
-  body->append(std::make_unique<ast::ReturnStatement>());
+  body->append(create<ast::ReturnStatement>());
 
   ast::IfStatement i(std::move(cond), std::move(body));
   i.set_else_statements(std::move(elses));
@@ -97,22 +97,22 @@ TEST_F(MslGeneratorImplTest, Emit_IfWithElse) {
 }
 
 TEST_F(MslGeneratorImplTest, Emit_IfWithMultiple) {
-  auto else_cond = std::make_unique<ast::IdentifierExpression>("else_cond");
+  auto else_cond = create<ast::IdentifierExpression>("else_cond");
 
-  auto else_body = std::make_unique<ast::BlockStatement>();
+  auto else_body = create<ast::BlockStatement>();
-  else_body->append(std::make_unique<ast::ReturnStatement>());
+  else_body->append(create<ast::ReturnStatement>());
 
-  auto else_body_2 = std::make_unique<ast::BlockStatement>();
+  auto else_body_2 = create<ast::BlockStatement>();
-  else_body_2->append(std::make_unique<ast::ReturnStatement>());
+  else_body_2->append(create<ast::ReturnStatement>());
 
   ast::ElseStatementList elses;
-  elses.push_back(std::make_unique<ast::ElseStatement>(std::move(else_cond),
+  elses.push_back(
-                                                       std::move(else_body)));
+      create<ast::ElseStatement>(std::move(else_cond), std::move(else_body)));
-  elses.push_back(std::make_unique<ast::ElseStatement>(std::move(else_body_2)));
+  elses.push_back(create<ast::ElseStatement>(std::move(else_body_2)));
 
-  auto cond = std::make_unique<ast::IdentifierExpression>("cond");
+  auto cond = create<ast::IdentifierExpression>("cond");
-  auto body = std::make_unique<ast::BlockStatement>();
+  auto body = create<ast::BlockStatement>();
-  body->append(std::make_unique<ast::ReturnStatement>());
+  body->append(create<ast::ReturnStatement>());
 
   ast::IfStatement i(std::move(cond), std::move(body));
   i.set_else_statements(std::move(elses));

src/writer/msl/generator_impl_import_test.cc

@@ -55,10 +55,10 @@ TEST_P(MslImportData_SingleParamTest, FloatScalar) {
   ast::type::F32Type f32;
 
   ast::ExpressionList params;
-  params.push_back(std::make_unique<ast::ScalarConstructorExpression>(
+  params.push_back(create<ast::ScalarConstructorExpression>(
-      std::make_unique<ast::FloatLiteral>(&f32, 1.f)));
+      create<ast::FloatLiteral>(&f32, 1.f)));
 
-  auto ident = std::make_unique<ast::IdentifierExpression>(param.name);
+  auto ident = create<ast::IdentifierExpression>(param.name);
   auto* ident_ptr = ident.get();
 
   ast::CallExpression call(std::move(ident), std::move(params));
@@ -99,10 +99,10 @@ TEST_F(MslGeneratorImplTest, MslImportData_SingleParamTest_IntScalar) {
   ast::type::I32Type i32;
 
   ast::ExpressionList params;
-  params.push_back(std::make_unique<ast::ScalarConstructorExpression>(
+  params.push_back(create<ast::ScalarConstructorExpression>(
-      std::make_unique<ast::SintLiteral>(&i32, 1)));
+      create<ast::SintLiteral>(&i32, 1)));
 
-  ast::CallExpression expr(std::make_unique<ast::IdentifierExpression>("abs"),
+  ast::CallExpression expr(create<ast::IdentifierExpression>("abs"),
                            std::move(params));
 
   ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
@@ -118,14 +118,13 @@ TEST_P(MslImportData_DualParamTest, FloatScalar) {
   ast::type::F32Type f32;
 
   ast::ExpressionList params;
-  params.push_back(std::make_unique<ast::ScalarConstructorExpression>(
+  params.push_back(create<ast::ScalarConstructorExpression>(
-      std::make_unique<ast::FloatLiteral>(&f32, 1.f)));
+      create<ast::FloatLiteral>(&f32, 1.f)));
-  params.push_back(std::make_unique<ast::ScalarConstructorExpression>(
+  params.push_back(create<ast::ScalarConstructorExpression>(
-      std::make_unique<ast::FloatLiteral>(&f32, 2.f)));
+      create<ast::FloatLiteral>(&f32, 2.f)));
 
-  ast::CallExpression expr(
+  ast::CallExpression expr(create<ast::IdentifierExpression>(param.name),
-      std::make_unique<ast::IdentifierExpression>(param.name),
+                           std::move(params));
-      std::move(params));
 
   ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
   ASSERT_TRUE(gen.EmitCall(&expr)) << gen.error();
@@ -150,29 +149,28 @@ TEST_P(MslImportData_DualParam_VectorTest, FloatVector) {
   ast::type::VectorType vec(&f32, 3);
 
   ast::ExpressionList type_params;
-  type_params.push_back(std::make_unique<ast::ScalarConstructorExpression>(
+  type_params.push_back(create<ast::ScalarConstructorExpression>(
-      std::make_unique<ast::FloatLiteral>(&f32, 1.f)));
+      create<ast::FloatLiteral>(&f32, 1.f)));
-  type_params.push_back(std::make_unique<ast::ScalarConstructorExpression>(
+  type_params.push_back(create<ast::ScalarConstructorExpression>(
-      std::make_unique<ast::FloatLiteral>(&f32, 2.f)));
+      create<ast::FloatLiteral>(&f32, 2.f)));
-  type_params.push_back(std::make_unique<ast::ScalarConstructorExpression>(
+  type_params.push_back(create<ast::ScalarConstructorExpression>(
-      std::make_unique<ast::FloatLiteral>(&f32, 3.f)));
+      create<ast::FloatLiteral>(&f32, 3.f)));
 
   ast::ExpressionList params;
-  params.push_back(std::make_unique<ast::TypeConstructorExpression>(
+  params.push_back(
-      &vec, std::move(type_params)));
+      create<ast::TypeConstructorExpression>(&vec, std::move(type_params)));
 
-  type_params.push_back(std::make_unique<ast::ScalarConstructorExpression>(
+  type_params.push_back(create<ast::ScalarConstructorExpression>(
-      std::make_unique<ast::FloatLiteral>(&f32, 4.f)));
+      create<ast::FloatLiteral>(&f32, 4.f)));
-  type_params.push_back(std::make_unique<ast::ScalarConstructorExpression>(
+  type_params.push_back(create<ast::ScalarConstructorExpression>(
-      std::make_unique<ast::FloatLiteral>(&f32, 5.f)));
+      create<ast::FloatLiteral>(&f32, 5.f)));
-  type_params.push_back(std::make_unique<ast::ScalarConstructorExpression>(
+  type_params.push_back(create<ast::ScalarConstructorExpression>(
-      std::make_unique<ast::FloatLiteral>(&f32, 6.f)));
+      create<ast::FloatLiteral>(&f32, 6.f)));
-  params.push_back(std::make_unique<ast::TypeConstructorExpression>(
+  params.push_back(
-      &vec, std::move(type_params)));
+      create<ast::TypeConstructorExpression>(&vec, std::move(type_params)));
 
-  ast::CallExpression expr(
+  ast::CallExpression expr(create<ast::IdentifierExpression>(param.name),
-      std::make_unique<ast::IdentifierExpression>(param.name),
+                           std::move(params));
-      std::move(params));
 
   ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
   ASSERT_TRUE(gen.EmitCall(&expr)) << gen.error();
@@ -191,14 +189,13 @@ TEST_P(MslImportData_DualParam_Int_Test, IntScalar) {
   ast::type::I32Type i32;
 
   ast::ExpressionList params;
-  params.push_back(std::make_unique<ast::ScalarConstructorExpression>(
+  params.push_back(create<ast::ScalarConstructorExpression>(
-      std::make_unique<ast::SintLiteral>(&i32, 1)));
+      create<ast::SintLiteral>(&i32, 1)));
-  params.push_back(std::make_unique<ast::ScalarConstructorExpression>(
+  params.push_back(create<ast::ScalarConstructorExpression>(
-      std::make_unique<ast::SintLiteral>(&i32, 2)));
+      create<ast::SintLiteral>(&i32, 2)));
 
-  ast::CallExpression expr(
+  ast::CallExpression expr(create<ast::IdentifierExpression>(param.name),
-      std::make_unique<ast::IdentifierExpression>(param.name),
+                           std::move(params));
-      std::move(params));
 
   ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
   ASSERT_TRUE(gen.EmitCall(&expr)) << gen.error();
@@ -216,16 +213,15 @@ TEST_P(MslImportData_TripleParamTest, FloatScalar) {
   ast::type::F32Type f32;
 
   ast::ExpressionList params;
-  params.push_back(std::make_unique<ast::ScalarConstructorExpression>(
+  params.push_back(create<ast::ScalarConstructorExpression>(
-      std::make_unique<ast::FloatLiteral>(&f32, 1.f)));
+      create<ast::FloatLiteral>(&f32, 1.f)));
-  params.push_back(std::make_unique<ast::ScalarConstructorExpression>(
+  params.push_back(create<ast::ScalarConstructorExpression>(
-      std::make_unique<ast::FloatLiteral>(&f32, 2.f)));
+      create<ast::FloatLiteral>(&f32, 2.f)));
-  params.push_back(std::make_unique<ast::ScalarConstructorExpression>(
+  params.push_back(create<ast::ScalarConstructorExpression>(
-      std::make_unique<ast::FloatLiteral>(&f32, 3.f)));
+      create<ast::FloatLiteral>(&f32, 3.f)));
 
-  ast::CallExpression expr(
+  ast::CallExpression expr(create<ast::IdentifierExpression>(param.name),
-      std::make_unique<ast::IdentifierExpression>(param.name),
+                           std::move(params));
-      std::move(params));
 
   ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
   ASSERT_TRUE(gen.EmitCall(&expr)) << gen.error();
@@ -248,16 +244,15 @@ TEST_P(MslImportData_TripleParam_Int_Test, IntScalar) {
   ast::type::I32Type i32;
 
   ast::ExpressionList params;
-  params.push_back(std::make_unique<ast::ScalarConstructorExpression>(
+  params.push_back(create<ast::ScalarConstructorExpression>(
-      std::make_unique<ast::SintLiteral>(&i32, 1)));
+      create<ast::SintLiteral>(&i32, 1)));
-  params.push_back(std::make_unique<ast::ScalarConstructorExpression>(
+  params.push_back(create<ast::ScalarConstructorExpression>(
-      std::make_unique<ast::SintLiteral>(&i32, 2)));
+      create<ast::SintLiteral>(&i32, 2)));
-  params.push_back(std::make_unique<ast::ScalarConstructorExpression>(
+  params.push_back(create<ast::ScalarConstructorExpression>(
-      std::make_unique<ast::SintLiteral>(&i32, 3)));
+      create<ast::SintLiteral>(&i32, 3)));
 
-  ast::CallExpression expr(
+  ast::CallExpression expr(create<ast::IdentifierExpression>(param.name),
-      std::make_unique<ast::IdentifierExpression>(param.name),
+                           std::move(params));
-      std::move(params));
 
   ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
   ASSERT_TRUE(gen.EmitCall(&expr)) << gen.error();
@@ -273,15 +268,13 @@ TEST_F(MslGeneratorImplTest, MslImportData_Determinant) {
   ast::type::F32Type f32;
   ast::type::MatrixType mat(&f32, 3, 3);
 
-  auto var = std::make_unique<ast::Variable>(
+  auto var = create<ast::Variable>("var", ast::StorageClass::kFunction, &mat);
-      "var", ast::StorageClass::kFunction, &mat);
 
   ast::ExpressionList params;
-  params.push_back(std::make_unique<ast::IdentifierExpression>("var"));
+  params.push_back(create<ast::IdentifierExpression>("var"));
 
-  ast::CallExpression expr(
+  ast::CallExpression expr(create<ast::IdentifierExpression>("determinant"),
-      std::make_unique<ast::IdentifierExpression>("determinant"),
+                           std::move(params));
-      std::move(params));
 
   mod.AddGlobalVariable(std::move(var));
 

src/writer/msl/generator_impl_intrinsic_test.cc

@@ -71,18 +71,15 @@ TEST_F(MslGeneratorImplTest, DISABLED_Intrinsic_OuterProduct) {
   ast::type::VectorType vec2(&f32, 2);
   ast::type::VectorType vec3(&f32, 3);
 
-  auto a =
+  auto a = create<ast::Variable>("a", ast::StorageClass::kNone, &vec2);
-      std::make_unique<ast::Variable>("a", ast::StorageClass::kNone, &vec2);
+  auto b = create<ast::Variable>("b", ast::StorageClass::kNone, &vec3);
-  auto b =
-      std::make_unique<ast::Variable>("b", ast::StorageClass::kNone, &vec3);
 
   ast::ExpressionList params;
-  params.push_back(std::make_unique<ast::IdentifierExpression>("a"));
+  params.push_back(create<ast::IdentifierExpression>("a"));
-  params.push_back(std::make_unique<ast::IdentifierExpression>("b"));
+  params.push_back(create<ast::IdentifierExpression>("b"));
 
-  ast::CallExpression call(
+  ast::CallExpression call(create<ast::IdentifierExpression>("outer_product"),
-      std::make_unique<ast::IdentifierExpression>("outer_product"),
+                           std::move(params));
-      std::move(params));
 
   td.RegisterVariableForTesting(a.get());
   td.RegisterVariableForTesting(b.get());
@@ -107,10 +104,10 @@ TEST_F(MslGeneratorImplTest, Intrinsic_Call) {
   ast::type::VectorType vec(&f32, 3);
 
   ast::ExpressionList params;
-  params.push_back(std::make_unique<ast::IdentifierExpression>("param1"));
+  params.push_back(create<ast::IdentifierExpression>("param1"));
-  params.push_back(std::make_unique<ast::IdentifierExpression>("param2"));
+  params.push_back(create<ast::IdentifierExpression>("param2"));
 
-  ast::CallExpression call(std::make_unique<ast::IdentifierExpression>("dot"),
+  ast::CallExpression call(create<ast::IdentifierExpression>("dot"),
                            std::move(params));
 
   ast::Variable v1("param1", ast::StorageClass::kFunction, &vec);

src/writer/msl/generator_impl_loop_test.cc

@@ -36,8 +36,8 @@ namespace {
 using MslGeneratorImplTest = TestHelper;
 
 TEST_F(MslGeneratorImplTest, Emit_Loop) {
-  auto body = std::make_unique<ast::BlockStatement>();
+  auto body = create<ast::BlockStatement>();
-  body->append(std::make_unique<ast::DiscardStatement>());
+  body->append(create<ast::DiscardStatement>());
 
   ast::LoopStatement l(std::move(body), {});
 
@@ -51,11 +51,11 @@ TEST_F(MslGeneratorImplTest, Emit_Loop) {
 }
 
 TEST_F(MslGeneratorImplTest, Emit_LoopWithContinuing) {
-  auto body = std::make_unique<ast::BlockStatement>();
+  auto body = create<ast::BlockStatement>();
-  body->append(std::make_unique<ast::DiscardStatement>());
+  body->append(create<ast::DiscardStatement>());
 
-  auto continuing = std::make_unique<ast::BlockStatement>();
+  auto continuing = create<ast::BlockStatement>();
-  continuing->append(std::make_unique<ast::ReturnStatement>());
+  continuing->append(create<ast::ReturnStatement>());
 
   ast::LoopStatement l(std::move(body), std::move(continuing));
 
@@ -79,24 +79,24 @@ TEST_F(MslGeneratorImplTest, Emit_LoopWithContinuing) {
 TEST_F(MslGeneratorImplTest, Emit_LoopNestedWithContinuing) {
   ast::type::F32Type f32;
 
-  auto body = std::make_unique<ast::BlockStatement>();
+  auto body = create<ast::BlockStatement>();
-  body->append(std::make_unique<ast::DiscardStatement>());
+  body->append(create<ast::DiscardStatement>());
 
-  auto continuing = std::make_unique<ast::BlockStatement>();
+  auto continuing = create<ast::BlockStatement>();
-  continuing->append(std::make_unique<ast::ReturnStatement>());
+  continuing->append(create<ast::ReturnStatement>());
 
-  auto inner = std::make_unique<ast::LoopStatement>(std::move(body),
+  auto inner =
-                                                    std::move(continuing));
+      create<ast::LoopStatement>(std::move(body), std::move(continuing));
 
-  body = std::make_unique<ast::BlockStatement>();
+  body = create<ast::BlockStatement>();
   body->append(std::move(inner));
 
-  auto lhs = std::make_unique<ast::IdentifierExpression>("lhs");
+  auto lhs = create<ast::IdentifierExpression>("lhs");
-  auto rhs = std::make_unique<ast::IdentifierExpression>("rhs");
+  auto rhs = create<ast::IdentifierExpression>("rhs");
 
-  continuing = std::make_unique<ast::BlockStatement>();
+  continuing = create<ast::BlockStatement>();
-  continuing->append(std::make_unique<ast::AssignmentStatement>(
+  continuing->append(
-      std::move(lhs), std::move(rhs)));
+      create<ast::AssignmentStatement>(std::move(lhs), std::move(rhs)));
 
   ast::LoopStatement outer(std::move(body), std::move(continuing));
 
@@ -151,23 +151,21 @@ TEST_F(MslGeneratorImplTest, Emit_LoopWithVarUsedInContinuing) {
 
   ast::type::F32Type f32;
 
-  auto var = std::make_unique<ast::Variable>(
+  auto var = create<ast::Variable>("lhs", ast::StorageClass::kFunction, &f32);
-      "lhs", ast::StorageClass::kFunction, &f32);
+  var->set_constructor(create<ast::ScalarConstructorExpression>(
-  var->set_constructor(std::make_unique<ast::ScalarConstructorExpression>(
+      create<ast::FloatLiteral>(&f32, 2.4)));
-      std::make_unique<ast::FloatLiteral>(&f32, 2.4)));
 
-  auto body = std::make_unique<ast::BlockStatement>();
+  auto body = create<ast::BlockStatement>();
-  body->append(std::make_unique<ast::VariableDeclStatement>(std::move(var)));
+  body->append(create<ast::VariableDeclStatement>(std::move(var)));
-  body->append(std::make_unique<ast::VariableDeclStatement>(
+  body->append(create<ast::VariableDeclStatement>(
-      std::make_unique<ast::Variable>("other", ast::StorageClass::kFunction,
+      create<ast::Variable>("other", ast::StorageClass::kFunction, &f32)));
-                                      &f32)));
 
-  auto lhs = std::make_unique<ast::IdentifierExpression>("lhs");
+  auto lhs = create<ast::IdentifierExpression>("lhs");
-  auto rhs = std::make_unique<ast::IdentifierExpression>("rhs");
+  auto rhs = create<ast::IdentifierExpression>("rhs");
 
-  auto continuing = std::make_unique<ast::BlockStatement>();
+  auto continuing = create<ast::BlockStatement>();
-  continuing->append(std::make_unique<ast::AssignmentStatement>(
+  continuing->append(
-      std::move(lhs), std::move(rhs)));
+      create<ast::AssignmentStatement>(std::move(lhs), std::move(rhs)));
 
   gen.increment_indent();
 

src/writer/msl/generator_impl_member_accessor_test.cc

@@ -29,8 +29,8 @@ namespace {
 using MslGeneratorImplTest = TestHelper;
 
 TEST_F(MslGeneratorImplTest, EmitExpression_MemberAccessor) {
-  auto str = std::make_unique<ast::IdentifierExpression>("str");
+  auto str = create<ast::IdentifierExpression>("str");
-  auto mem = std::make_unique<ast::IdentifierExpression>("mem");
+  auto mem = create<ast::IdentifierExpression>("mem");
 
   ast::MemberAccessorExpression expr(std::move(str), std::move(mem));
 

src/writer/msl/generator_impl_module_constant_test.cc

@@ -40,18 +40,17 @@ TEST_F(MslGeneratorImplTest, Emit_ModuleConstant) {
   ast::type::ArrayType ary(&f32, 3);
 
   ast::ExpressionList exprs;
-  exprs.push_back(std::make_unique<ast::ScalarConstructorExpression>(
+  exprs.push_back(create<ast::ScalarConstructorExpression>(
-      std::make_unique<ast::FloatLiteral>(&f32, 1.0f)));
+      create<ast::FloatLiteral>(&f32, 1.0f)));
-  exprs.push_back(std::make_unique<ast::ScalarConstructorExpression>(
+  exprs.push_back(create<ast::ScalarConstructorExpression>(
-      std::make_unique<ast::FloatLiteral>(&f32, 2.0f)));
+      create<ast::FloatLiteral>(&f32, 2.0f)));
-  exprs.push_back(std::make_unique<ast::ScalarConstructorExpression>(
+  exprs.push_back(create<ast::ScalarConstructorExpression>(
-      std::make_unique<ast::FloatLiteral>(&f32, 3.0f)));
+      create<ast::FloatLiteral>(&f32, 3.0f)));
 
-  auto var =
+  auto var = create<ast::Variable>("pos", ast::StorageClass::kNone, &ary);
-      std::make_unique<ast::Variable>("pos", ast::StorageClass::kNone, &ary);
   var->set_is_const(true);
   var->set_constructor(
-      std::make_unique<ast::TypeConstructorExpression>(&ary, std::move(exprs)));
+      create<ast::TypeConstructorExpression>(&ary, std::move(exprs)));
 
   ASSERT_TRUE(gen.EmitProgramConstVariable(var.get())) << gen.error();
   EXPECT_EQ(
@@ -63,14 +62,14 @@ TEST_F(MslGeneratorImplTest, Emit_SpecConstant) {
   ast::type::F32Type f32;
 
   ast::VariableDecorationList decos;
-  decos.push_back(std::make_unique<ast::ConstantIdDecoration>(23, Source{}));
+  decos.push_back(create<ast::ConstantIdDecoration>(23, Source{}));
 
-  auto var = std::make_unique<ast::DecoratedVariable>(
+  auto var = create<ast::DecoratedVariable>(
-      std::make_unique<ast::Variable>("pos", ast::StorageClass::kNone, &f32));
+      create<ast::Variable>("pos", ast::StorageClass::kNone, &f32));
   var->set_decorations(std::move(decos));
   var->set_is_const(true);
-  var->set_constructor(std::make_unique<ast::ScalarConstructorExpression>(
+  var->set_constructor(create<ast::ScalarConstructorExpression>(
-      std::make_unique<ast::FloatLiteral>(&f32, 3.0f)));
+      create<ast::FloatLiteral>(&f32, 3.0f)));
 
   ASSERT_TRUE(gen.EmitProgramConstVariable(var.get())) << gen.error();
   EXPECT_EQ(gen.result(), "constant float pos [[function_constant(23)]];\n");

src/writer/msl/generator_impl_return_test.cc

@@ -39,7 +39,7 @@ TEST_F(MslGeneratorImplTest, Emit_Return) {
 }
 
 TEST_F(MslGeneratorImplTest, Emit_ReturnWithValue) {
-  auto expr = std::make_unique<ast::IdentifierExpression>("expr");
+  auto expr = create<ast::IdentifierExpression>("expr");
   ast::ReturnStatement r(std::move(expr));
 
   gen.increment_indent();

src/writer/msl/generator_impl_switch_test.cc

@@ -33,26 +33,26 @@ namespace {
 using MslGeneratorImplTest = TestHelper;
 
 TEST_F(MslGeneratorImplTest, Emit_Switch) {
-  auto def = std::make_unique<ast::CaseStatement>();
+  auto def = create<ast::CaseStatement>();
-  auto def_body = std::make_unique<ast::BlockStatement>();
+  auto def_body = create<ast::BlockStatement>();
-  def_body->append(std::make_unique<ast::BreakStatement>());
+  def_body->append(create<ast::BreakStatement>());
   def->set_body(std::move(def_body));
 
   ast::type::I32Type i32;
   ast::CaseSelectorList case_val;
-  case_val.push_back(std::make_unique<ast::SintLiteral>(&i32, 5));
+  case_val.push_back(create<ast::SintLiteral>(&i32, 5));
 
-  auto case_body = std::make_unique<ast::BlockStatement>();
+  auto case_body = create<ast::BlockStatement>();
-  case_body->append(std::make_unique<ast::BreakStatement>());
+  case_body->append(create<ast::BreakStatement>());
 
-  auto case_stmt = std::make_unique<ast::CaseStatement>(std::move(case_val),
+  auto case_stmt =
-                                                        std::move(case_body));
+      create<ast::CaseStatement>(std::move(case_val), std::move(case_body));
 
   ast::CaseStatementList body;
   body.push_back(std::move(case_stmt));
   body.push_back(std::move(def));
 
-  auto cond = std::make_unique<ast::IdentifierExpression>("cond");
+  auto cond = create<ast::IdentifierExpression>("cond");
   ast::SwitchStatement s(std::move(cond), std::move(body));
 
   gen.increment_indent();

src/writer/msl/generator_impl_test.cc

@@ -50,10 +50,9 @@ using MslGeneratorImplTest = TestHelper;
 TEST_F(MslGeneratorImplTest, Generate) {
   ast::type::VoidType void_type;
 
-  auto func = std::make_unique<ast::Function>("my_func", ast::VariableList{},
+  auto func = create<ast::Function>("my_func", ast::VariableList{}, &void_type);
-                                              &void_type);
+  func->add_decoration(
-  func->add_decoration(std::make_unique<ast::StageDecoration>(
+      create<ast::StageDecoration>(ast::PipelineStage::kCompute, Source{}));
-      ast::PipelineStage::kCompute, Source{}));
   mod.AddFunction(std::move(func));
 
   ASSERT_TRUE(gen.Generate()) << gen.error();
@@ -157,24 +156,18 @@ TEST_F(MslGeneratorImplTest, calculate_alignment_size_struct) {
   ast::type::F32Type f32;
 
   ast::StructMemberDecorationList decos;
-  decos.push_back(
+  decos.push_back(create<ast::StructMemberOffsetDecoration>(4, Source{}));
-      std::make_unique<ast::StructMemberOffsetDecoration>(4, Source{}));
 
   ast::StructMemberList members;
-  members.push_back(
+  members.push_back(create<ast::StructMember>("a", &i32, std::move(decos)));
-      std::make_unique<ast::StructMember>("a", &i32, std::move(decos)));
 
-  decos.push_back(
+  decos.push_back(create<ast::StructMemberOffsetDecoration>(32, Source{}));
-      std::make_unique<ast::StructMemberOffsetDecoration>(32, Source{}));
+  members.push_back(create<ast::StructMember>("b", &f32, std::move(decos)));
-  members.push_back(
-      std::make_unique<ast::StructMember>("b", &f32, std::move(decos)));
 
-  decos.push_back(
+  decos.push_back(create<ast::StructMemberOffsetDecoration>(128, Source{}));
-      std::make_unique<ast::StructMemberOffsetDecoration>(128, Source{}));
+  members.push_back(create<ast::StructMember>("c", &f32, std::move(decos)));
-  members.push_back(
-      std::make_unique<ast::StructMember>("c", &f32, std::move(decos)));
 
-  auto str = std::make_unique<ast::Struct>();
+  auto str = create<ast::Struct>();
   str->set_members(std::move(members));
 
   ast::type::StructType s("S", std::move(str));
@@ -188,44 +181,32 @@ TEST_F(MslGeneratorImplTest, calculate_alignment_size_struct_of_struct) {
   ast::type::VectorType fvec(&f32, 3);
 
   ast::StructMemberDecorationList decos;
-  decos.push_back(
+  decos.push_back(create<ast::StructMemberOffsetDecoration>(0, Source{}));
-      std::make_unique<ast::StructMemberOffsetDecoration>(0, Source{}));
 
   ast::StructMemberList members;
-  members.push_back(
+  members.push_back(create<ast::StructMember>("a", &i32, std::move(decos)));
-      std::make_unique<ast::StructMember>("a", &i32, std::move(decos)));
 
-  decos.push_back(
+  decos.push_back(create<ast::StructMemberOffsetDecoration>(16, Source{}));
-      std::make_unique<ast::StructMemberOffsetDecoration>(16, Source{}));
+  members.push_back(create<ast::StructMember>("b", &fvec, std::move(decos)));
-  members.push_back(
-      std::make_unique<ast::StructMember>("b", &fvec, std::move(decos)));
 
-  decos.push_back(
+  decos.push_back(create<ast::StructMemberOffsetDecoration>(32, Source{}));
-      std::make_unique<ast::StructMemberOffsetDecoration>(32, Source{}));
+  members.push_back(create<ast::StructMember>("c", &f32, std::move(decos)));
-  members.push_back(
-      std::make_unique<ast::StructMember>("c", &f32, std::move(decos)));
 
-  auto inner_str = std::make_unique<ast::Struct>();
+  auto inner_str = create<ast::Struct>();
   inner_str->set_members(std::move(members));
 
   ast::type::StructType inner_s("Inner", std::move(inner_str));
 
-  decos.push_back(
+  decos.push_back(create<ast::StructMemberOffsetDecoration>(0, Source{}));
-      std::make_unique<ast::StructMemberOffsetDecoration>(0, Source{}));
+  members.push_back(create<ast::StructMember>("d", &f32, std::move(decos)));
-  members.push_back(
-      std::make_unique<ast::StructMember>("d", &f32, std::move(decos)));
 
-  decos.push_back(
+  decos.push_back(create<ast::StructMemberOffsetDecoration>(32, Source{}));
-      std::make_unique<ast::StructMemberOffsetDecoration>(32, Source{}));
+  members.push_back(create<ast::StructMember>("e", &inner_s, std::move(decos)));
-  members.push_back(
-      std::make_unique<ast::StructMember>("e", &inner_s, std::move(decos)));
 
-  decos.push_back(
+  decos.push_back(create<ast::StructMemberOffsetDecoration>(64, Source{}));
-      std::make_unique<ast::StructMemberOffsetDecoration>(64, Source{}));
+  members.push_back(create<ast::StructMember>("f", &f32, std::move(decos)));
-  members.push_back(
-      std::make_unique<ast::StructMember>("f", &f32, std::move(decos)));
 
-  auto outer_str = std::make_unique<ast::Struct>();
+  auto outer_str = create<ast::Struct>();
   outer_str->set_members(std::move(members));
 
   ast::type::StructType outer_s("Outer", std::move(outer_str));

src/writer/msl/generator_impl_type_test.cc

@@ -176,16 +176,14 @@ TEST_F(MslGeneratorImplTest, EmitType_Struct) {
   ast::type::F32Type f32;
 
   ast::StructMemberList members;
-  members.push_back(std::make_unique<ast::StructMember>(
+  members.push_back(
-      "a", &i32, ast::StructMemberDecorationList{}));
+      create<ast::StructMember>("a", &i32, ast::StructMemberDecorationList{}));
 
   ast::StructMemberDecorationList b_deco;
-  b_deco.push_back(
+  b_deco.push_back(create<ast::StructMemberOffsetDecoration>(4, Source{}));
-      std::make_unique<ast::StructMemberOffsetDecoration>(4, Source{}));
+  members.push_back(create<ast::StructMember>("b", &f32, std::move(b_deco)));
-  members.push_back(
-      std::make_unique<ast::StructMember>("b", &f32, std::move(b_deco)));
 
-  auto str = std::make_unique<ast::Struct>();
+  auto str = create<ast::Struct>();
   str->set_members(std::move(members));
 
   ast::type::StructType s("S", std::move(str));
@@ -199,16 +197,14 @@ TEST_F(MslGeneratorImplTest, EmitType_StructDecl) {
   ast::type::F32Type f32;
 
   ast::StructMemberList members;
-  members.push_back(std::make_unique<ast::StructMember>(
+  members.push_back(
-      "a", &i32, ast::StructMemberDecorationList{}));
+      create<ast::StructMember>("a", &i32, ast::StructMemberDecorationList{}));
 
   ast::StructMemberDecorationList b_deco;
-  b_deco.push_back(
+  b_deco.push_back(create<ast::StructMemberOffsetDecoration>(4, Source{}));
-      std::make_unique<ast::StructMemberOffsetDecoration>(4, Source{}));
+  members.push_back(create<ast::StructMember>("b", &f32, std::move(b_deco)));
-  members.push_back(
-      std::make_unique<ast::StructMember>("b", &f32, std::move(b_deco)));
 
-  auto str = std::make_unique<ast::Struct>();
+  auto str = create<ast::Struct>();
   str->set_members(std::move(members));
 
   ast::type::StructType s("S", std::move(str));
@@ -226,24 +222,18 @@ TEST_F(MslGeneratorImplTest, EmitType_Struct_InjectPadding) {
   ast::type::F32Type f32;
 
   ast::StructMemberDecorationList decos;
-  decos.push_back(
+  decos.push_back(create<ast::StructMemberOffsetDecoration>(4, Source{}));
-      std::make_unique<ast::StructMemberOffsetDecoration>(4, Source{}));
 
   ast::StructMemberList members;
-  members.push_back(
+  members.push_back(create<ast::StructMember>("a", &i32, std::move(decos)));
-      std::make_unique<ast::StructMember>("a", &i32, std::move(decos)));
 
-  decos.push_back(
+  decos.push_back(create<ast::StructMemberOffsetDecoration>(32, Source{}));
-      std::make_unique<ast::StructMemberOffsetDecoration>(32, Source{}));
+  members.push_back(create<ast::StructMember>("b", &f32, std::move(decos)));
-  members.push_back(
-      std::make_unique<ast::StructMember>("b", &f32, std::move(decos)));
 
-  decos.push_back(
+  decos.push_back(create<ast::StructMemberOffsetDecoration>(128, Source{}));
-      std::make_unique<ast::StructMemberOffsetDecoration>(128, Source{}));
+  members.push_back(create<ast::StructMember>("c", &f32, std::move(decos)));
-  members.push_back(
-      std::make_unique<ast::StructMember>("c", &f32, std::move(decos)));
 
-  auto str = std::make_unique<ast::Struct>();
+  auto str = create<ast::Struct>();
   str->set_members(std::move(members));
 
   ast::type::StructType s("S", std::move(str));
@@ -265,14 +255,14 @@ TEST_F(MslGeneratorImplTest, EmitType_Struct_NameCollision) {
   ast::type::F32Type f32;
 
   ast::StructMemberList members;
-  members.push_back(std::make_unique<ast::StructMember>(
+  members.push_back(create<ast::StructMember>(
       "main", &i32, ast::StructMemberDecorationList{}));
 
   ast::StructMemberDecorationList b_deco;
   members.push_back(
-      std::make_unique<ast::StructMember>("float", &f32, std::move(b_deco)));
+      create<ast::StructMember>("float", &f32, std::move(b_deco)));
 
-  auto str = std::make_unique<ast::Struct>();
+  auto str = create<ast::Struct>();
   str->set_members(std::move(members));
 
   ast::type::StructType s("S", std::move(str));
@@ -291,19 +281,16 @@ TEST_F(MslGeneratorImplTest, DISABLED_EmitType_Struct_WithDecoration) {
   ast::type::F32Type f32;
 
   ast::StructMemberList members;
-  members.push_back(std::make_unique<ast::StructMember>(
+  members.push_back(
-      "a", &i32, ast::StructMemberDecorationList{}));
+      create<ast::StructMember>("a", &i32, ast::StructMemberDecorationList{}));
 
   ast::StructMemberDecorationList b_deco;
-  b_deco.push_back(
+  b_deco.push_back(create<ast::StructMemberOffsetDecoration>(4, Source{}));
-      std::make_unique<ast::StructMemberOffsetDecoration>(4, Source{}));
+  members.push_back(create<ast::StructMember>("b", &f32, std::move(b_deco)));
-  members.push_back(
-      std::make_unique<ast::StructMember>("b", &f32, std::move(b_deco)));
 
   ast::StructDecorationList decos;
-  decos.push_back(std::make_unique<ast::StructBlockDecoration>(Source{}));
+  decos.push_back(create<ast::StructBlockDecoration>(Source{}));
-  auto str =
+  auto str = create<ast::Struct>(std::move(decos), std::move(members));
-      std::make_unique<ast::Struct>(std::move(decos), std::move(members));
 
   ast::type::StructType s("S", std::move(str));
 

src/writer/msl/generator_impl_unary_op_test.cc

@@ -39,7 +39,7 @@ using MslUnaryOpTest = TestParamHelper<UnaryOpData>;
 TEST_P(MslUnaryOpTest, Emit) {
   auto params = GetParam();
 
-  auto expr = std::make_unique<ast::IdentifierExpression>("expr");
+  auto expr = create<ast::IdentifierExpression>("expr");
   ast::UnaryOpExpression op(params.op, std::move(expr));
 
   ASSERT_TRUE(gen.EmitExpression(&op)) << gen.error();

src/writer/msl/generator_impl_variable_decl_statement_test.cc

@@ -42,8 +42,7 @@ using MslGeneratorImplTest = TestHelper;
 
 TEST_F(MslGeneratorImplTest, Emit_VariableDeclStatement) {
   ast::type::F32Type f32;
-  auto var =
+  auto var = create<ast::Variable>("a", ast::StorageClass::kNone, &f32);
-      std::make_unique<ast::Variable>("a", ast::StorageClass::kNone, &f32);
 
   ast::VariableDeclStatement stmt(std::move(var));
 
@@ -55,8 +54,7 @@ TEST_F(MslGeneratorImplTest, Emit_VariableDeclStatement) {
 
 TEST_F(MslGeneratorImplTest, Emit_VariableDeclStatement_Const) {
   ast::type::F32Type f32;
-  auto var =
+  auto var = create<ast::Variable>("a", ast::StorageClass::kNone, &f32);
-      std::make_unique<ast::Variable>("a", ast::StorageClass::kNone, &f32);
   var->set_is_const(true);
 
   ast::VariableDeclStatement stmt(std::move(var));
@@ -71,8 +69,7 @@ TEST_F(MslGeneratorImplTest, Emit_VariableDeclStatement_Array) {
   ast::type::F32Type f32;
   ast::type::ArrayType ary(&f32, 5);
 
-  auto var =
+  auto var = create<ast::Variable>("a", ast::StorageClass::kNone, &ary);
-      std::make_unique<ast::Variable>("a", ast::StorageClass::kNone, &ary);
 
   ast::VariableDeclStatement stmt(std::move(var));
 
@@ -86,21 +83,19 @@ TEST_F(MslGeneratorImplTest, Emit_VariableDeclStatement_Struct) {
   ast::type::F32Type f32;
 
   ast::StructMemberList members;
-  members.push_back(std::make_unique<ast::StructMember>(
+  members.push_back(
-      "a", &f32, ast::StructMemberDecorationList{}));
+      create<ast::StructMember>("a", &f32, ast::StructMemberDecorationList{}));
 
   ast::StructMemberDecorationList b_deco;
-  b_deco.push_back(
+  b_deco.push_back(create<ast::StructMemberOffsetDecoration>(4, Source{}));
-      std::make_unique<ast::StructMemberOffsetDecoration>(4, Source{}));
+  members.push_back(create<ast::StructMember>("b", &f32, std::move(b_deco)));
-  members.push_back(
-      std::make_unique<ast::StructMember>("b", &f32, std::move(b_deco)));
 
-  auto str = std::make_unique<ast::Struct>();
+  auto str = create<ast::Struct>();
   str->set_members(std::move(members));
 
   ast::type::StructType s("S", std::move(str));
 
-  auto var = std::make_unique<ast::Variable>("a", ast::StorageClass::kNone, &s);
+  auto var = create<ast::Variable>("a", ast::StorageClass::kNone, &s);
 
   ast::VariableDeclStatement stmt(std::move(var));
 
@@ -115,8 +110,7 @@ TEST_F(MslGeneratorImplTest, Emit_VariableDeclStatement_Vector) {
   ast::type::F32Type f32;
   ast::type::VectorType vec(&f32, 2);
 
-  auto var =
+  auto var = create<ast::Variable>("a", ast::StorageClass::kFunction, &vec);
-      std::make_unique<ast::Variable>("a", ast::StorageClass::kFunction, &vec);
 
   ast::VariableDeclStatement stmt(std::move(var));
 
@@ -129,8 +123,7 @@ TEST_F(MslGeneratorImplTest, Emit_VariableDeclStatement_Vector) {
 TEST_F(MslGeneratorImplTest, Emit_VariableDeclStatement_Matrix) {
   ast::type::F32Type f32;
   ast::type::MatrixType mat(&f32, 2, 3);
-  auto var =
+  auto var = create<ast::Variable>("a", ast::StorageClass::kFunction, &mat);
-      std::make_unique<ast::Variable>("a", ast::StorageClass::kFunction, &mat);
 
   ast::VariableDeclStatement stmt(std::move(var));
 
@@ -142,8 +135,7 @@ TEST_F(MslGeneratorImplTest, Emit_VariableDeclStatement_Matrix) {
 
 TEST_F(MslGeneratorImplTest, Emit_VariableDeclStatement_Private) {
   ast::type::F32Type f32;
-  auto var =
+  auto var = create<ast::Variable>("a", ast::StorageClass::kPrivate, &f32);
-      std::make_unique<ast::Variable>("a", ast::StorageClass::kPrivate, &f32);
 
   ast::VariableDeclStatement stmt(std::move(var));
 
@@ -154,11 +146,10 @@ TEST_F(MslGeneratorImplTest, Emit_VariableDeclStatement_Private) {
 }
 
 TEST_F(MslGeneratorImplTest, Emit_VariableDeclStatement_Initializer_Private) {
-  auto ident = std::make_unique<ast::IdentifierExpression>("initializer");
+  auto ident = create<ast::IdentifierExpression>("initializer");
 
   ast::type::F32Type f32;
-  auto var =
+  auto var = create<ast::Variable>("a", ast::StorageClass::kNone, &f32);
-      std::make_unique<ast::Variable>("a", ast::StorageClass::kNone, &f32);
   var->set_constructor(std::move(ident));
 
   ast::VariableDeclStatement stmt(std::move(var));
@@ -174,10 +165,9 @@ TEST_F(MslGeneratorImplTest, Emit_VariableDeclStatement_Initializer_ZeroVec) {
 
   ast::ExpressionList values;
   auto zero_vec =
-      std::make_unique<ast::TypeConstructorExpression>(&vec, std::move(values));
+      create<ast::TypeConstructorExpression>(&vec, std::move(values));
 
-  auto var =
+  auto var = create<ast::Variable>("a", ast::StorageClass::kNone, &vec);
-      std::make_unique<ast::Variable>("a", ast::StorageClass::kNone, &vec);
   var->set_constructor(std::move(zero_vec));
 
   ast::VariableDeclStatement stmt(std::move(var));

src/writer/msl/test_helper.h

@@ -15,6 +15,9 @@
 #ifndef SRC_WRITER_MSL_TEST_HELPER_H_
 #define SRC_WRITER_MSL_TEST_HELPER_H_
 
+#include <memory>
+#include <utility>
+
 #include "gtest/gtest.h"
 #include "src/ast/module.h"
 #include "src/context.h"
@@ -26,12 +29,19 @@ namespace writer {
 namespace msl {
 
 /// Helper class for testing
-template <typename T>
+template <typename BASE>
-class TestHelperBase : public T {
+class TestHelperBase : public BASE {
  public:
   TestHelperBase() : td(&ctx, &mod), gen(&ctx, &mod) {}
   ~TestHelperBase() = default;
 
+  /// @return a `std::unique_ptr` to a new `T` constructed with `args`
+  /// @param args the arguments to forward to the constructor for `T`
+  template <typename T, typename... ARGS>
+  std::unique_ptr<T> create(ARGS&&... args) {
+    return std::make_unique<T>(std::forward<ARGS>(args)...);
+  }
+
   /// The context
   Context ctx;
   /// The module