tint: Clean up Func() usage

Drop the vector typename from the initializer lists. These don't really
provide any significant help in understanding the arguments types, as
the list of element types can be easily inferred.

This is done to simplify the refactor ast::VariableList ->
ast::ParameterList.

Bug: tint:1580
Change-Id: Ibf8564ca9b2bafd2eaa2e4aa54c29be6bbe7a682
Reviewed-on: https://dawn-review.googlesource.com/c/dawn/+/93600
Reviewed-by: Antonio Maiorano <amaiorano@google.com>
Commit-Queue: Ben Clayton <bclayton@chromium.org>

src/tint/ast/function_test.cc

@@ -26,11 +26,10 @@ namespace {
 using FunctionTest = TestHelper;
 
 TEST_F(FunctionTest, Creation) {
-    VariableList params;
+    VariableList params{Param("var", ty.i32())};
-    params.push_back(Param("var", ty.i32()));
     auto* var = params[0];
 
-    auto* f = Func("func", params, ty.void_(), StatementList{}, AttributeList{});
+    auto* f = Func("func", params, ty.void_(), {});
     EXPECT_EQ(f->symbol, Symbols().Get("func"));
     ASSERT_EQ(f->params.size(), 1u);
     EXPECT_TRUE(f->return_type->Is<ast::Void>());
@@ -38,11 +37,9 @@ TEST_F(FunctionTest, Creation) {
 }
 
 TEST_F(FunctionTest, Creation_WithSource) {
-    VariableList params;
+    VariableList params{Param("var", ty.i32())};
-    params.push_back(Param("var", ty.i32()));
 
-    auto* f = Func(Source{Source::Location{20, 2}}, "func", params, ty.void_(), StatementList{},
+    auto* f = Func(Source{Source::Location{20, 2}}, "func", params, ty.void_(), {});
-                   AttributeList{});
     auto src = f->source;
     EXPECT_EQ(src.range.begin.line, 20u);
     EXPECT_EQ(src.range.begin.column, 2u);
@@ -52,7 +49,7 @@ TEST_F(FunctionTest, Assert_InvalidName) {
     EXPECT_FATAL_FAILURE(
         {
             ProgramBuilder b;
-            b.Func("", VariableList{}, b.ty.void_(), StatementList{}, AttributeList{});
+            b.Func("", {}, b.ty.void_(), {});
         },
         "internal compiler error");
 }
@@ -61,7 +58,7 @@ TEST_F(FunctionTest, Assert_Null_ReturnType) {
     EXPECT_FATAL_FAILURE(
         {
             ProgramBuilder b;
-            b.Func("f", VariableList{}, nullptr, StatementList{}, AttributeList{});
+            b.Func("f", {}, nullptr, {});
         },
         "internal compiler error");
 }
@@ -74,7 +71,7 @@ TEST_F(FunctionTest, Assert_Null_Param) {
             params.push_back(b.Param("var", b.ty.i32()));
             params.push_back(nullptr);
 
-            b.Func("f", params, b.ty.void_(), StatementList{}, AttributeList{});
+            b.Func("f", params, b.ty.void_(), {});
         },
         "internal compiler error");
 }
@@ -84,7 +81,7 @@ TEST_F(FunctionTest, Assert_DifferentProgramID_Symbol) {
         {
             ProgramBuilder b1;
             ProgramBuilder b2;
-            b1.Func(b2.Sym("func"), VariableList{}, b1.ty.void_(), StatementList{});
+            b1.Func(b2.Sym("func"), {}, b1.ty.void_(), {});
         },
         "internal compiler error");
 }
@@ -94,8 +91,7 @@ TEST_F(FunctionTest, Assert_DifferentProgramID_Param) {
         {
             ProgramBuilder b1;
             ProgramBuilder b2;
-            b1.Func("func", VariableList{b2.Param("var", b2.ty.i32())}, b1.ty.void_(),
+            b1.Func("func", {b2.Param("var", b2.ty.i32())}, b1.ty.void_(), {});
-                    StatementList{});
         },
         "internal compiler error");
 }
@@ -105,8 +101,8 @@ TEST_F(FunctionTest, Assert_DifferentProgramID_Attr) {
         {
             ProgramBuilder b1;
             ProgramBuilder b2;
-            b1.Func("func", VariableList{}, b1.ty.void_(), StatementList{},
+            b1.Func("func", {}, b1.ty.void_(), {},
-                    AttributeList{
+                    {
                         b2.WorkgroupSize(2_i, 4_i, 6_i),
                     });
         },
@@ -118,8 +114,8 @@ TEST_F(FunctionTest, Assert_DifferentProgramID_ReturnAttr) {
         {
             ProgramBuilder b1;
             ProgramBuilder b2;
-            b1.Func("func", VariableList{}, b1.ty.void_(), StatementList{}, AttributeList{},
+            b1.Func("func", {}, b1.ty.void_(), {}, {},
-                    AttributeList{
+                    {
                         b2.WorkgroupSize(2_i, 4_i, 6_i),
                     });
         },
@@ -133,7 +129,7 @@ TEST_F(FunctionTest, Assert_NonConstParam) {
             VariableList params;
             params.push_back(b.Var("var", b.ty.i32(), ast::StorageClass::kNone));
 
-            b.Func("f", params, b.ty.void_(), StatementList{}, AttributeList{});
+            b.Func("f", params, b.ty.void_(), {});
         },
         "internal compiler error");
 }
@@ -141,7 +137,7 @@ TEST_F(FunctionTest, Assert_NonConstParam) {
 using FunctionListTest = TestHelper;
 
 TEST_F(FunctionListTest, FindSymbol) {
-    auto* func = Func("main", VariableList{}, ty.f32(), StatementList{}, ast::AttributeList{});
+    auto* func = Func("main", {}, ty.f32(), {});
     FunctionList list;
     list.Add(func);
     EXPECT_EQ(func, list.Find(Symbols().Register("main")));
@@ -153,12 +149,12 @@ TEST_F(FunctionListTest, FindSymbolMissing) {
 }
 
 TEST_F(FunctionListTest, FindSymbolStage) {
-    auto* fs = Func("main", VariableList{}, ty.f32(), StatementList{},
+    auto* fs = Func("main", {}, ty.f32(), {},
-                    ast::AttributeList{
+                    {
                         Stage(PipelineStage::kFragment),
                     });
-    auto* vs = Func("main", VariableList{}, ty.f32(), StatementList{},
+    auto* vs = Func("main", {}, ty.f32(), {},
-                    ast::AttributeList{
+                    {
                         Stage(PipelineStage::kVertex),
                     });
     FunctionList list;
@@ -170,8 +166,8 @@ TEST_F(FunctionListTest, FindSymbolStage) {
 
 TEST_F(FunctionListTest, FindSymbolStageMissing) {
     FunctionList list;
-    list.Add(Func("main", VariableList{}, ty.f32(), StatementList{},
+    list.Add(Func("main", {}, ty.f32(), {},
-                  ast::AttributeList{
+                  {
                       Stage(PipelineStage::kFragment),
                   }));
     EXPECT_EQ(nullptr, list.Find(Symbols().Register("main"), PipelineStage::kVertex));
@@ -179,8 +175,8 @@ TEST_F(FunctionListTest, FindSymbolStageMissing) {
 
 TEST_F(FunctionListTest, HasStage) {
     FunctionList list;
-    list.Add(Func("main", VariableList{}, ty.f32(), StatementList{},
+    list.Add(Func("main", {}, ty.f32(), {},
-                  ast::AttributeList{
+                  {
                       Stage(PipelineStage::kFragment),
                   }));
     EXPECT_TRUE(list.HasStage(PipelineStage::kFragment));

src/tint/ast/module_test.cc

@@ -26,7 +26,7 @@ TEST_F(ModuleTest, Creation) {
 }
 
 TEST_F(ModuleTest, LookupFunction) {
-    auto* func = Func("main", VariableList{}, ty.f32(), StatementList{}, ast::AttributeList{});
+    auto* func = Func("main", {}, ty.f32(), {});
 
     Program program(std::move(*this));
     EXPECT_EQ(func, program.AST().Functions().Find(program.Symbols().Get("main")));

src/tint/inspector/test_inspector_builder.cc

@@ -28,7 +28,7 @@ InspectorBuilder::InspectorBuilder() = default;
 InspectorBuilder::~InspectorBuilder() = default;
 
 void InspectorBuilder::MakeEmptyBodyFunction(std::string name, ast::AttributeList attributes) {
-    Func(name, ast::VariableList(), ty.void_(), ast::StatementList{Return()}, attributes);
+    Func(name, {}, ty.void_(), {Return()}, attributes);
 }
 
 void InspectorBuilder::MakeCallerBodyFunction(std::string caller,
@@ -41,7 +41,7 @@ void InspectorBuilder::MakeCallerBodyFunction(std::string caller,
     }
     body.push_back(Return());
 
-    Func(caller, ast::VariableList(), ty.void_(), body, attributes);
+    Func(caller, {}, ty.void_(), body, attributes);
 }
 
 const ast::Struct* InspectorBuilder::MakeInOutStruct(
@@ -67,7 +67,7 @@ const ast::Function* InspectorBuilder::MakePlainGlobalReferenceBodyFunction(
     stmts.emplace_back(Assign("local_" + var, var));
     stmts.emplace_back(Return());
 
-    return Func(func, ast::VariableList(), ty.void_(), stmts, attributes);
+    return Func(func, {}, ty.void_(), stmts, attributes);
 }
 
 bool InspectorBuilder::ContainsName(const std::vector<StageVariable>& vec,
@@ -169,7 +169,7 @@ void InspectorBuilder::MakeStructVariableReferenceBodyFunction(
 
     stmts.emplace_back(Return());
 
-    Func(func_name, ast::VariableList(), ty.void_(), stmts, ast::AttributeList{});
+    Func(func_name, {}, ty.void_(), stmts);
 }
 
 void InspectorBuilder::AddSampler(const std::string& name, uint32_t group, uint32_t binding) {
@@ -221,7 +221,7 @@ const ast::Function* InspectorBuilder::MakeSamplerReferenceBodyFunction(
         Assign(result_name, Call("textureSample", texture_name, sampler_name, coords_name)));
     stmts.emplace_back(Return());
 
-    return Func(func_name, ast::VariableList(), ty.void_(), stmts, attributes);
+    return Func(func_name, {}, ty.void_(), stmts, attributes);
 }
 
 const ast::Function* InspectorBuilder::MakeSamplerReferenceBodyFunction(
@@ -242,7 +242,7 @@ const ast::Function* InspectorBuilder::MakeSamplerReferenceBodyFunction(
                                                      coords_name, array_index)));
     stmts.emplace_back(Return());
 
-    return Func(func_name, ast::VariableList(), ty.void_(), stmts, attributes);
+    return Func(func_name, {}, ty.void_(), stmts, attributes);
 }
 
 const ast::Function* InspectorBuilder::MakeComparisonSamplerReferenceBodyFunction(
@@ -262,7 +262,7 @@ const ast::Function* InspectorBuilder::MakeComparisonSamplerReferenceBodyFunctio
                                                      sampler_name, coords_name, depth_name)));
     stmts.emplace_back(Return());
 
-    return Func(func_name, ast::VariableList(), ty.void_(), stmts, attributes);
+    return Func(func_name, {}, ty.void_(), stmts, attributes);
 }
 
 const ast::Type* InspectorBuilder::GetBaseType(ResourceBinding::SampledKind sampled_kind) {
@@ -323,7 +323,7 @@ const ast::Function* InspectorBuilder::MakeStorageTextureBodyFunction(
     stmts.emplace_back(Assign("dim", Call("textureDimensions", st_name)));
     stmts.emplace_back(Return());
 
-    return Func(func_name, ast::VariableList(), ty.void_(), stmts, attributes);
+    return Func(func_name, {}, ty.void_(), stmts, attributes);
 }
 
 std::function<const ast::Type*()> InspectorBuilder::GetTypeFunction(ComponentType component,

src/tint/program_builder.cc

@@ -126,9 +126,11 @@ const ast::Statement* ProgramBuilder::WrapInStatement(const ast::Statement* stmt
 }
 
 const ast::Function* ProgramBuilder::WrapInFunction(const ast::StatementList stmts) {
-    return Func(
+    return Func("test_function", {}, ty.void_(), std::move(stmts),
-        "test_function", {}, ty.void_(), std::move(stmts),
+                {
-        {create<ast::StageAttribute>(ast::PipelineStage::kCompute), WorkgroupSize(1_i, 1_i, 1_i)});
+                    create<ast::StageAttribute>(ast::PipelineStage::kCompute),
+                    WorkgroupSize(1_i, 1_i, 1_i),
+                });
 }
 
 }  // namespace tint

src/tint/resolver/array_accessor_test.cc

@@ -225,13 +225,12 @@ TEST_F(ResolverIndexAccessorTest, Array_Dynamic_I32) {
     auto* a = Let("a", ty.array<f32, 3>(), array<f32, 3>());
     auto* idx = Var("idx", ty.i32(), Construct(ty.i32()));
     auto* f = Var("f", ty.f32(), IndexAccessor("a", Expr(Source{{12, 34}}, idx)));
-    Func("my_func", ast::VariableList{}, ty.void_(),
+    Func("my_func", {}, ty.void_(),
          {
              Decl(a),
              Decl(idx),
              Decl(f),
-         },
+         });
-         ast::AttributeList{});
 
     EXPECT_TRUE(r()->Resolve());
     EXPECT_EQ(r()->error(), "");
@@ -242,12 +241,11 @@ TEST_F(ResolverIndexAccessorTest, Array_Literal_F32) {
     // var f : f32 = a[2.0f];
     auto* a = Let("a", ty.array<f32, 3>(), array<f32, 3>());
     auto* f = Var("a_2", ty.f32(), IndexAccessor("a", Expr(Source{{12, 34}}, 2_f)));
-    Func("my_func", ast::VariableList{}, ty.void_(),
+    Func("my_func", {}, ty.void_(),
          {
              Decl(a),
              Decl(f),
-         },
+         });
-         ast::AttributeList{});
     EXPECT_FALSE(r()->Resolve());
     EXPECT_EQ(r()->error(), "12:34 error: index must be of type 'i32' or 'u32', found: 'f32'");
 }
@@ -257,12 +255,11 @@ TEST_F(ResolverIndexAccessorTest, Array_Literal_I32) {
     // var f : f32 = a[2i];
     auto* a = Let("a", ty.array<f32, 3>(), array<f32, 3>());
     auto* f = Var("a_2", ty.f32(), IndexAccessor("a", 2_i));
-    Func("my_func", ast::VariableList{}, ty.void_(),
+    Func("my_func", {}, ty.void_(),
          {
              Decl(a),
              Decl(f),
-         },
+         });
-         ast::AttributeList{});
     EXPECT_TRUE(r()->Resolve()) << r()->error();
 }
 

src/tint/resolver/attribute_validation_test.cc

@@ -128,7 +128,9 @@ TEST_P(FunctionParameterAttributeTest, IsValid) {
     auto& params = GetParam();
 
     Func("main",
-         ast::VariableList{Param("a", ty.vec4<f32>(), createAttributes({}, *this, params.kind))},
+         {
+             Param("a", ty.vec4<f32>(), createAttributes({}, *this, params.kind)),
+         },
          ty.void_(), {});
 
     if (params.should_pass) {
@@ -161,8 +163,11 @@ using FunctionReturnTypeAttributeTest = TestWithParams;
 TEST_P(FunctionReturnTypeAttributeTest, IsValid) {
     auto& params = GetParam();
 
-    Func("main", ast::VariableList{}, ty.f32(), ast::StatementList{Return(1_f)}, {},
+    Func("main", {}, ty.f32(),
-         createAttributes({}, *this, params.kind));
+         {
+             Return(1_f),
+         },
+         {}, createAttributes({}, *this, params.kind));
 
     if (params.should_pass) {
         EXPECT_TRUE(r()->Resolve()) << r()->error();
@@ -195,9 +200,15 @@ namespace EntryPointInputAndOutputTests {
 using ComputeShaderParameterAttributeTest = TestWithParams;
 TEST_P(ComputeShaderParameterAttributeTest, IsValid) {
     auto& params = GetParam();
-    auto* p = Param("a", ty.vec4<f32>(), createAttributes(Source{{12, 34}}, *this, params.kind));
+    Func("main",
-    Func("main", ast::VariableList{p}, ty.void_(), {},
+         {
-         {Stage(ast::PipelineStage::kCompute), WorkgroupSize(1_i)});
+             Param("a", ty.vec4<f32>(), createAttributes(Source{{12, 34}}, *this, params.kind)),
+         },
+         ty.void_(), {},
+         {
+             Stage(ast::PipelineStage::kCompute),
+             WorkgroupSize(1_i),
+         });
 
     if (params.should_pass) {
         EXPECT_TRUE(r()->Resolve()) << r()->error();
@@ -242,7 +253,10 @@ TEST_P(FragmentShaderParameterAttributeTest, IsValid) {
         attrs.push_back(Builtin(Source{{34, 56}}, ast::Builtin::kPosition));
     }
     auto* p = Param("a", ty.vec4<f32>(), attrs);
-    Func("frag_main", {p}, ty.void_(), {}, {Stage(ast::PipelineStage::kFragment)});
+    Func("frag_main", {p}, ty.void_(), {},
+         {
+             Stage(ast::PipelineStage::kFragment),
+         });
 
     if (params.should_pass) {
         EXPECT_TRUE(r()->Resolve()) << r()->error();
@@ -276,8 +290,16 @@ TEST_P(VertexShaderParameterAttributeTest, IsValid) {
         attrs.push_back(Location(Source{{34, 56}}, 2));
     }
     auto* p = Param("a", ty.vec4<f32>(), attrs);
-    Func("vertex_main", ast::VariableList{p}, ty.vec4<f32>(), {Return(Construct(ty.vec4<f32>()))},
+    Func("vertex_main", {p}, ty.vec4<f32>(),
-         {Stage(ast::PipelineStage::kVertex)}, {Builtin(ast::Builtin::kPosition)});
+         {
+             Return(Construct(ty.vec4<f32>())),
+         },
+         {
+             Stage(ast::PipelineStage::kVertex),
+         },
+         {
+             Builtin(ast::Builtin::kPosition),
+         });
 
     if (params.should_pass) {
         EXPECT_TRUE(r()->Resolve()) << r()->error();
@@ -316,8 +338,14 @@ INSTANTIATE_TEST_SUITE_P(ResolverAttributeValidationTest,
 using ComputeShaderReturnTypeAttributeTest = TestWithParams;
 TEST_P(ComputeShaderReturnTypeAttributeTest, IsValid) {
     auto& params = GetParam();
-    Func("main", ast::VariableList{}, ty.vec4<f32>(), {Return(Construct(ty.vec4<f32>(), 1_f))},
+    Func("main", {}, ty.vec4<f32>(),
-         {Stage(ast::PipelineStage::kCompute), WorkgroupSize(1_i)},
+         {
+             Return(Construct(ty.vec4<f32>(), 1_f)),
+         },
+         {
+             Stage(ast::PipelineStage::kCompute),
+             WorkgroupSize(1_i),
+         },
          createAttributes(Source{{12, 34}}, *this, params.kind));
 
     if (params.should_pass) {
@@ -363,7 +391,10 @@ TEST_P(FragmentShaderReturnTypeAttributeTest, IsValid) {
     auto attrs = createAttributes(Source{{12, 34}}, *this, params.kind);
     attrs.push_back(Location(Source{{34, 56}}, 2));
     Func("frag_main", {}, ty.vec4<f32>(), {Return(Construct(ty.vec4<f32>()))},
-         {Stage(ast::PipelineStage::kFragment)}, attrs);
+         {
+             Stage(ast::PipelineStage::kFragment),
+         },
+         attrs);
 
     if (params.should_pass) {
         EXPECT_TRUE(r()->Resolve()) << r()->error();
@@ -413,8 +444,14 @@ TEST_P(VertexShaderReturnTypeAttributeTest, IsValid) {
     if (params.kind != AttributeKind::kBuiltin) {
         attrs.push_back(Builtin(Source{{34, 56}}, ast::Builtin::kPosition));
     }
-    Func("vertex_main", ast::VariableList{}, ty.vec4<f32>(), {Return(Construct(ty.vec4<f32>()))},
+    Func("vertex_main", {}, ty.vec4<f32>(),
-         {Stage(ast::PipelineStage::kVertex)}, attrs);
+         {
+             Return(Construct(ty.vec4<f32>())),
+         },
+         {
+             Stage(ast::PipelineStage::kVertex),
+         },
+         attrs);
 
     if (params.should_pass) {
         EXPECT_TRUE(r()->Resolve()) << r()->error();
@@ -450,8 +487,13 @@ INSTANTIATE_TEST_SUITE_P(ResolverAttributeValidationTest,
 
 using EntryPointParameterAttributeTest = TestWithParams;
 TEST_F(EntryPointParameterAttributeTest, DuplicateAttribute) {
-    Func("main", ast::VariableList{}, ty.f32(), ast::StatementList{Return(1_f)},
+    Func("main", {}, ty.f32(),
-         {Stage(ast::PipelineStage::kFragment)},
+         {
+             Return(1_f),
+         },
+         {
+             Stage(ast::PipelineStage::kFragment),
+         },
          {
              Location(Source{{12, 34}}, 2),
              Location(Source{{56, 78}}, 3),
@@ -471,15 +513,23 @@ TEST_F(EntryPointParameterAttributeTest, DuplicateInternalAttribute) {
                         Disable(ast::DisabledValidation::kBindingPointCollision),
                         Disable(ast::DisabledValidation::kEntryPointParameter),
                     });
-    Func("f", {s}, ty.void_(), {}, {Stage(ast::PipelineStage::kFragment)});
+    Func("f", {s}, ty.void_(), {},
+         {
+             Stage(ast::PipelineStage::kFragment),
+         });
 
     EXPECT_TRUE(r()->Resolve()) << r()->error();
 }
 
 using EntryPointReturnTypeAttributeTest = ResolverTest;
 TEST_F(EntryPointReturnTypeAttributeTest, DuplicateAttribute) {
-    Func("main", ast::VariableList{}, ty.f32(), ast::StatementList{Return(1_f)},
+    Func("main", {}, ty.f32(),
-         ast::AttributeList{Stage(ast::PipelineStage::kFragment)},
+         {
+             Return(1_f),
+         },
+         {
+             Stage(ast::PipelineStage::kFragment),
+         },
          ast::AttributeList{
              Location(Source{{12, 34}}, 2),
              Location(Source{{56, 78}}, 3),
@@ -492,7 +542,10 @@ TEST_F(EntryPointReturnTypeAttributeTest, DuplicateAttribute) {
 }
 
 TEST_F(EntryPointReturnTypeAttributeTest, DuplicateInternalAttribute) {
-    Func("f", {}, ty.i32(), {Return(1_i)}, {Stage(ast::PipelineStage::kFragment)},
+    Func("f", {}, ty.i32(), {Return(1_i)},
+         {
+             Stage(ast::PipelineStage::kFragment),
+         },
          ast::AttributeList{
              Disable(ast::DisabledValidation::kBindingPointCollision),
              Disable(ast::DisabledValidation::kEntryPointParameter),
@@ -972,7 +1025,9 @@ TEST_F(ResourceAttributeTest, BindingPointUsedTwiceByEntryPoint) {
              Decl(Var("b", ty.vec4<f32>(), ast::StorageClass::kNone,
                       Call("textureLoad", "B", vec2<i32>(1_i, 2_i), 0_i))),
          },
-         {Stage(ast::PipelineStage::kFragment)});
+         {
+             Stage(ast::PipelineStage::kFragment),
+         });
 
     EXPECT_FALSE(r()->Resolve());
     EXPECT_EQ(
@@ -1000,13 +1055,17 @@ TEST_F(ResourceAttributeTest, BindingPointUsedTwiceByDifferentEntryPoints) {
              Decl(Var("a", ty.vec4<f32>(), ast::StorageClass::kNone,
                       Call("textureLoad", "A", vec2<i32>(1_i, 2_i), 0_i))),
          },
-         {Stage(ast::PipelineStage::kFragment)});
+         {
+             Stage(ast::PipelineStage::kFragment),
+         });
     Func("F_B", {}, ty.void_(),
          {
              Decl(Var("b", ty.vec4<f32>(), ast::StorageClass::kNone,
                       Call("textureLoad", "B", vec2<i32>(1_i, 2_i), 0_i))),
          },
-         {Stage(ast::PipelineStage::kFragment)});
+         {
+             Stage(ast::PipelineStage::kFragment),
+         });
 
     EXPECT_TRUE(r()->Resolve()) << r()->error();
 }
@@ -1033,10 +1092,14 @@ TEST_F(InvariantAttributeTests, InvariantWithPosition) {
     auto* param =
         Param("p", ty.vec4<f32>(),
               {Invariant(Source{{12, 34}}), Builtin(Source{{56, 78}}, ast::Builtin::kPosition)});
-    Func("main", ast::VariableList{param}, ty.vec4<f32>(),
+    Func("main", {param}, ty.vec4<f32>(),
-         ast::StatementList{Return(Construct(ty.vec4<f32>()))},
+         {
-         ast::AttributeList{Stage(ast::PipelineStage::kFragment)},
+             Return(Construct(ty.vec4<f32>())),
-         ast::AttributeList{
+         },
+         {
+             Stage(ast::PipelineStage::kFragment),
+         },
+         {
              Location(0),
          });
     EXPECT_TRUE(r()->Resolve()) << r()->error();
@@ -1044,10 +1107,14 @@ TEST_F(InvariantAttributeTests, InvariantWithPosition) {
 
 TEST_F(InvariantAttributeTests, InvariantWithoutPosition) {
     auto* param = Param("p", ty.vec4<f32>(), {Invariant(Source{{12, 34}}), Location(0)});
-    Func("main", ast::VariableList{param}, ty.vec4<f32>(),
+    Func("main", {param}, ty.vec4<f32>(),
-         ast::StatementList{Return(Construct(ty.vec4<f32>()))},
+         {
-         ast::AttributeList{Stage(ast::PipelineStage::kFragment)},
+             Return(Construct(ty.vec4<f32>())),
-         ast::AttributeList{
+         },
+         {
+             Stage(ast::PipelineStage::kFragment),
+         },
+         {
              Location(0),
          });
     EXPECT_FALSE(r()->Resolve());
@@ -1135,10 +1202,17 @@ TEST_P(InterpolateParameterTest, All) {
     auto& params = GetParam();
 
     Func("main",
-         ast::VariableList{
+         {
              Param("a", ty.f32(),
-                   {Location(0), Interpolate(Source{{12, 34}}, params.type, params.sampling)})},
+                   {
-         ty.void_(), {}, ast::AttributeList{Stage(ast::PipelineStage::kFragment)});
+                       Location(0),
+                       Interpolate(Source{{12, 34}}, params.type, params.sampling),
+                   }),
+         },
+         ty.void_(), {},
+         {
+             Stage(ast::PipelineStage::kFragment),
+         });
 
     if (params.should_pass) {
         EXPECT_TRUE(r()->Resolve()) << r()->error();
@@ -1154,10 +1228,17 @@ TEST_P(InterpolateParameterTest, IntegerScalar) {
     auto& params = GetParam();
 
     Func("main",
-         ast::VariableList{
+         {
              Param("a", ty.i32(),
-                   {Location(0), Interpolate(Source{{12, 34}}, params.type, params.sampling)})},
+                   {
-         ty.void_(), {}, ast::AttributeList{Stage(ast::PipelineStage::kFragment)});
+                       Location(0),
+                       Interpolate(Source{{12, 34}}, params.type, params.sampling),
+                   }),
+         },
+         ty.void_(), {},
+         {
+             Stage(ast::PipelineStage::kFragment),
+         });
 
     if (params.type != ast::InterpolationType::kFlat) {
         EXPECT_FALSE(r()->Resolve());
@@ -1178,10 +1259,17 @@ TEST_P(InterpolateParameterTest, IntegerVector) {
     auto& params = GetParam();
 
     Func("main",
-         ast::VariableList{
+         {
              Param("a", ty.vec4<u32>(),
-                   {Location(0), Interpolate(Source{{12, 34}}, params.type, params.sampling)})},
+                   {
-         ty.void_(), {}, ast::AttributeList{Stage(ast::PipelineStage::kFragment)});
+                       Location(0),
+                       Interpolate(Source{{12, 34}}, params.type, params.sampling),
+                   }),
+         },
+         ty.void_(), {},
+         {
+             Stage(ast::PipelineStage::kFragment),
+         });
 
     if (params.type != ast::InterpolationType::kFlat) {
         EXPECT_FALSE(r()->Resolve());
@@ -1217,8 +1305,10 @@ INSTANTIATE_TEST_SUITE_P(
         Params{ast::InterpolationType::kFlat, ast::InterpolationSampling::kSample, false}));
 
 TEST_F(InterpolateTest, FragmentInput_Integer_MissingFlatInterpolation) {
-    Func("main", ast::VariableList{Param(Source{{12, 34}}, "a", ty.i32(), {Location(0)})},
+    Func("main", {Param(Source{{12, 34}}, "a", ty.i32(), {Location(0)})}, ty.void_(), {},
-         ty.void_(), {}, ast::AttributeList{Stage(ast::PipelineStage::kFragment)});
+         {
+             Stage(ast::PipelineStage::kFragment),
+         });
 
     EXPECT_FALSE(r()->Resolve());
     EXPECT_EQ(
@@ -1231,8 +1321,13 @@ TEST_F(InterpolateTest, VertexOutput_Integer_MissingFlatInterpolation) {
                                  Member("pos", ty.vec4<f32>(), {Builtin(ast::Builtin::kPosition)}),
                                  Member(Source{{12, 34}}, "u", ty.u32(), {Location(0)}),
                              });
-    Func("main", {}, ty.Of(s), {Return(Construct(ty.Of(s)))},
+    Func("main", {}, ty.Of(s),
-         ast::AttributeList{Stage(ast::PipelineStage::kVertex)});
+         {
+             Return(Construct(ty.Of(s))),
+         },
+         {
+             Stage(ast::PipelineStage::kVertex),
+         });
 
     EXPECT_FALSE(r()->Resolve());
     EXPECT_EQ(
@@ -1243,11 +1338,18 @@ note: while analysing entry point 'main')");
 
 TEST_F(InterpolateTest, MissingLocationAttribute_Parameter) {
     Func("main",
-         ast::VariableList{Param("a", ty.vec4<f32>(),
+         {
-                                 {Builtin(ast::Builtin::kPosition),
+             Param("a", ty.vec4<f32>(),
-                                  Interpolate(Source{{12, 34}}, ast::InterpolationType::kFlat,
+                   {
-                                              ast::InterpolationSampling::kNone)})},
+                       Builtin(ast::Builtin::kPosition),
-         ty.void_(), {}, ast::AttributeList{Stage(ast::PipelineStage::kFragment)});
+                       Interpolate(Source{{12, 34}}, ast::InterpolationType::kFlat,
+                                   ast::InterpolationSampling::kNone),
+                   }),
+         },
+         ty.void_(), {},
+         {
+             Stage(ast::PipelineStage::kFragment),
+         });
 
     EXPECT_FALSE(r()->Resolve());
     EXPECT_EQ(r()->error(),
@@ -1255,11 +1357,18 @@ TEST_F(InterpolateTest, MissingLocationAttribute_Parameter) {
 }
 
 TEST_F(InterpolateTest, MissingLocationAttribute_ReturnType) {
-    Func("main", {}, ty.vec4<f32>(), {Return(Construct(ty.vec4<f32>()))},
+    Func("main", {}, ty.vec4<f32>(),
-         ast::AttributeList{Stage(ast::PipelineStage::kVertex)},
+         {
-         {Builtin(ast::Builtin::kPosition),
+             Return(Construct(ty.vec4<f32>())),
-          Interpolate(Source{{12, 34}}, ast::InterpolationType::kFlat,
+         },
-                      ast::InterpolationSampling::kNone)});
+         {
+             Stage(ast::PipelineStage::kVertex),
+         },
+         {
+             Builtin(ast::Builtin::kPosition),
+             Interpolate(Source{{12, 34}}, ast::InterpolationType::kFlat,
+                         ast::InterpolationSampling::kNone),
+         });
 
     EXPECT_FALSE(r()->Resolve());
     EXPECT_EQ(r()->error(),

src/tint/resolver/builtin_validation_test.cc

@@ -38,8 +38,14 @@ TEST_F(ResolverBuiltinValidationTest, InvalidPipelineStageDirect) {
 
     auto* dpdx =
         create<ast::CallExpression>(Source{{3, 4}}, Expr("dpdx"), ast::ExpressionList{Expr(1_f)});
-    Func(Source{{1, 2}}, "func", ast::VariableList{}, ty.void_(), {CallStmt(dpdx)},
+    Func(Source{{1, 2}}, "func", {}, ty.void_(),
-         {Stage(ast::PipelineStage::kCompute), WorkgroupSize(1_i)});
+         {
+             CallStmt(dpdx),
+         },
+         {
+             Stage(ast::PipelineStage::kCompute),
+             WorkgroupSize(1_i),
+         });
 
     EXPECT_FALSE(r()->Resolve());
     EXPECT_EQ(r()->error(), "3:4 error: built-in cannot be used by compute pipeline stage");

src/tint/resolver/builtins_validation_test.cc

@@ -93,8 +93,7 @@ TEST_P(ResolverBuiltinsStageTest, All_input) {
     const Params& params = GetParam();
 
     auto* p = Global("p", ty.vec4<f32>(), ast::StorageClass::kPrivate);
-    auto* input = Param("input", params.type(*this),
+    auto* input = Param("input", params.type(*this), {Builtin(Source{{12, 34}}, params.builtin)});
-                        ast::AttributeList{Builtin(Source{{12, 34}}, params.builtin)});
     switch (params.stage) {
         case ast::PipelineStage::kVertex:
             Func("main", {input}, ty.vec4<f32>(), {Return(p)}, {Stage(ast::PipelineStage::kVertex)},
@@ -105,7 +104,10 @@ TEST_P(ResolverBuiltinsStageTest, All_input) {
             break;
         case ast::PipelineStage::kCompute:
             Func("main", {input}, ty.void_(), {},
-                 ast::AttributeList{Stage(ast::PipelineStage::kCompute), WorkgroupSize(1_i)});
+                 {
+                     Stage(ast::PipelineStage::kCompute),
+                     WorkgroupSize(1_i),
+                 });
             break;
         default:
             break;
@@ -130,10 +132,20 @@ TEST_F(ResolverBuiltinsValidationTest, FragDepthIsInput_Fail) {
     // fn fs_main(
     //   @builtin(frag_depth) fd: f32,
     // ) -> @location(0) f32 { return 1.0; }
-    auto* fd = Param("fd", ty.f32(),
+    Func("fs_main",
-                     ast::AttributeList{Builtin(Source{{12, 34}}, ast::Builtin::kFragDepth)});
+         {
-    Func("fs_main", ast::VariableList{fd}, ty.f32(), {Return(1_f)},
+             Param("fd", ty.f32(), {Builtin(Source{{12, 34}}, ast::Builtin::kFragDepth)}),
-         ast::AttributeList{Stage(ast::PipelineStage::kFragment)}, {Location(0)});
+         },
+         ty.f32(),
+         {
+             Return(1_f),
+         },
+         {
+             Stage(ast::PipelineStage::kFragment),
+         },
+         {
+             Location(0),
+         });
     EXPECT_FALSE(r()->Resolve());
     EXPECT_EQ(r()->error(),
               "12:34 error: builtin(frag_depth) cannot be used in input of "
@@ -149,11 +161,24 @@ TEST_F(ResolverBuiltinsValidationTest, FragDepthIsInputStruct_Fail) {
 
     auto* s = Structure(
         "MyInputs",
-        {Member("frag_depth", ty.f32(),
+        {
-                ast::AttributeList{Builtin(Source{{12, 34}}, ast::Builtin::kFragDepth)})});
+            Member("frag_depth", ty.f32(), {Builtin(Source{{12, 34}}, ast::Builtin::kFragDepth)}),
+        });
 
-    Func("fragShader", {Param("arg", ty.Of(s))}, ty.f32(), {Return(1_f)},
+    Func("fragShader",
-         {Stage(ast::PipelineStage::kFragment)}, {Location(0)});
+         {
+             Param("arg", ty.Of(s)),
+         },
+         ty.f32(),
+         {
+             Return(1_f),
+         },
+         {
+             Stage(ast::PipelineStage::kFragment),
+         },
+         {
+             Location(0),
+         });
     EXPECT_FALSE(r()->Resolve());
     EXPECT_EQ(r()->error(),
               "12:34 error: builtin(frag_depth) cannot be used in input of "
@@ -184,11 +209,25 @@ TEST_F(ResolverBuiltinsValidationTest, PositionNotF32_Struct_Fail) {
     // @fragment
     // fn fragShader(is_front: MyInputs) -> @location(0) f32 { return 1.0; }
 
-    auto* m = Member("position", ty.vec4<u32>(),
+    auto* s =
-                     ast::AttributeList{Builtin(Source{{12, 34}}, ast::Builtin::kPosition)});
+        Structure("MyInputs", {
-    auto* s = Structure("MyInputs", {m});
+                                  Member("position", ty.vec4<u32>(),
-    Func("fragShader", {Param("arg", ty.Of(s))}, ty.f32(), {Return(1_f)},
+                                         {Builtin(Source{{12, 34}}, ast::Builtin::kPosition)}),
-         {Stage(ast::PipelineStage::kFragment)}, {Location(0)});
+                              });
+    Func("fragShader",
+         {
+             Param("arg", ty.Of(s)),
+         },
+         ty.f32(),
+         {
+             Return(1_f),
+         },
+         {
+             Stage(ast::PipelineStage::kFragment),
+         },
+         {
+             Location(0),
+         });
 
     EXPECT_FALSE(r()->Resolve());
     EXPECT_EQ(r()->error(), "12:34 error: store type of builtin(position) must be 'vec4<f32>'");
@@ -211,11 +250,21 @@ TEST_F(ResolverBuiltinsValidationTest, FragDepthNotF32_Struct_Fail) {
     // @fragment
     // fn fragShader(is_front: MyInputs) -> @location(0) f32 { return 1.0; }
 
-    auto* m = Member("frag_depth", ty.i32(),
+    auto* s = Structure(
-                     ast::AttributeList{Builtin(Source{{12, 34}}, ast::Builtin::kFragDepth)});
+        "MyInputs",
-    auto* s = Structure("MyInputs", {m});
+        {
-    Func("fragShader", {Param("arg", ty.Of(s))}, ty.f32(), {Return(1_f)},
+            Member("frag_depth", ty.i32(), {Builtin(Source{{12, 34}}, ast::Builtin::kFragDepth)}),
-         {Stage(ast::PipelineStage::kFragment)}, {Location(0)});
+        });
+    Func("fragShader", {Param("arg", ty.Of(s))}, ty.f32(),
+         {
+             Return(1_f),
+         },
+         {
+             Stage(ast::PipelineStage::kFragment),
+         },
+         {
+             Location(0),
+         });
 
     EXPECT_FALSE(r()->Resolve());
     EXPECT_EQ(r()->error(), "12:34 error: store type of builtin(frag_depth) must be 'f32'");
@@ -228,10 +277,11 @@ TEST_F(ResolverBuiltinsValidationTest, SampleMaskNotU32_Struct_Fail) {
     // @fragment
     // fn fragShader(is_front: MyInputs) -> @location(0) f32 { return 1.0; }
 
-    auto* s = Structure(
+    auto* s =
-        "MyInputs",
+        Structure("MyInputs",
-        {Member("m", ty.f32(),
+                  {
-                ast::AttributeList{Builtin(Source{{12, 34}}, ast::Builtin::kSampleMask)})});
+                      Member("m", ty.f32(), {Builtin(Source{{12, 34}}, ast::Builtin::kSampleMask)}),
+                  });
     Func("fragShader", {Param("arg", ty.Of(s))}, ty.f32(), {Return(1_f)},
          {Stage(ast::PipelineStage::kFragment)}, {Location(0)});
 
@@ -254,10 +304,20 @@ TEST_F(ResolverBuiltinsValidationTest, SampleMaskIsNotU32_Fail) {
     // fn fs_main(
     //   @builtin(sample_mask) arg: bool
     // ) -> @location(0) f32 { return 1.0; }
-    auto* arg = Param("arg", ty.bool_(),
+    Func("fs_main",
-                      ast::AttributeList{Builtin(Source{{12, 34}}, ast::Builtin::kSampleMask)});
+         {
-    Func("fs_main", ast::VariableList{arg}, ty.f32(), {Return(1_f)},
+             Param("arg", ty.bool_(), {Builtin(Source{{12, 34}}, ast::Builtin::kSampleMask)}),
-         ast::AttributeList{Stage(ast::PipelineStage::kFragment)}, {Location(0)});
+         },
+         ty.f32(),
+         {
+             Return(1_f),
+         },
+         {
+             Stage(ast::PipelineStage::kFragment),
+         },
+         {
+             Location(0),
+         });
     EXPECT_FALSE(r()->Resolve());
     EXPECT_EQ(r()->error(), "12:34 error: store type of builtin(sample_mask) must be 'u32'");
 }
@@ -271,8 +331,9 @@ TEST_F(ResolverBuiltinsValidationTest, SampleIndexIsNotU32_Struct_Fail) {
 
     auto* s = Structure(
         "MyInputs",
-        {Member("m", ty.f32(),
+        {
-                ast::AttributeList{Builtin(Source{{12, 34}}, ast::Builtin::kSampleIndex)})});
+            Member("m", ty.f32(), {Builtin(Source{{12, 34}}, ast::Builtin::kSampleIndex)}),
+        });
     Func("fragShader", {Param("arg", ty.Of(s))}, ty.f32(), {Return(1_f)},
          {Stage(ast::PipelineStage::kFragment)}, {Location(0)});
 
@@ -285,10 +346,17 @@ TEST_F(ResolverBuiltinsValidationTest, SampleIndexIsNotU32_Fail) {
     // fn fs_main(
     //   @builtin(sample_index) arg: bool
     // ) -> @location(0) f32 { return 1.0; }
-    auto* arg = Param("arg", ty.bool_(),
+    Func("fs_main",
-                      ast::AttributeList{Builtin(Source{{12, 34}}, ast::Builtin::kSampleIndex)});
+         {
-    Func("fs_main", ast::VariableList{arg}, ty.f32(), {Return(1_f)},
+             Param("arg", ty.bool_(), {Builtin(Source{{12, 34}}, ast::Builtin::kSampleIndex)}),
-         ast::AttributeList{Stage(ast::PipelineStage::kFragment)}, {Location(0)});
+         },
+         ty.f32(), {Return(1_f)},
+         {
+             Stage(ast::PipelineStage::kFragment),
+         },
+         {
+             Location(0),
+         });
     EXPECT_FALSE(r()->Resolve());
     EXPECT_EQ(r()->error(), "12:34 error: store type of builtin(sample_index) must be 'u32'");
 }
@@ -298,10 +366,17 @@ TEST_F(ResolverBuiltinsValidationTest, PositionIsNotF32_Fail) {
     // fn fs_main(
     //   @builtin(kPosition) p: vec3<f32>,
     // ) -> @location(0) f32 { return 1.0; }
-    auto* p = Param("p", ty.vec3<f32>(),
+    Func("fs_main",
-                    ast::AttributeList{Builtin(Source{{12, 34}}, ast::Builtin::kPosition)});
+         {
-    Func("fs_main", ast::VariableList{p}, ty.f32(), {Return(1_f)},
+             Param("p", ty.vec3<f32>(), {Builtin(Source{{12, 34}}, ast::Builtin::kPosition)}),
-         ast::AttributeList{Stage(ast::PipelineStage::kFragment)}, {Location(0)});
+         },
+         ty.f32(), {Return(1_f)},
+         {
+             Stage(ast::PipelineStage::kFragment),
+         },
+         {
+             Location(0),
+         });
     EXPECT_FALSE(r()->Resolve());
     EXPECT_EQ(r()->error(), "12:34 error: store type of builtin(position) must be 'vec4<f32>'");
 }
@@ -310,9 +385,8 @@ TEST_F(ResolverBuiltinsValidationTest, FragDepthIsNotF32_Fail) {
     // @fragment
     // fn fs_main() -> @builtin(kFragDepth) f32 { var fd: i32; return fd; }
     auto* fd = Var("fd", ty.i32());
-    Func("fs_main", {}, ty.i32(), {Decl(fd), Return(fd)},
+    Func("fs_main", {}, ty.i32(), {Decl(fd), Return(fd)}, {Stage(ast::PipelineStage::kFragment)},
-         ast::AttributeList{Stage(ast::PipelineStage::kFragment)},
+         {Builtin(Source{{12, 34}}, ast::Builtin::kFragDepth)});
-         ast::AttributeList{Builtin(Source{{12, 34}}, ast::Builtin::kFragDepth)});
     EXPECT_FALSE(r()->Resolve());
     EXPECT_EQ(r()->error(), "12:34 error: store type of builtin(frag_depth) must be 'f32'");
 }
@@ -323,12 +397,10 @@ TEST_F(ResolverBuiltinsValidationTest, VertexIndexIsNotU32_Fail) {
     //   @builtin(kVertexIndex) vi : f32,
     //   @builtin(kPosition) p :vec4<f32>
     // ) -> @builtin(kPosition) vec4<f32> { return vec4<f32>(); }
-    auto* p = Param("p", ty.vec4<f32>(), ast::AttributeList{Builtin(ast::Builtin::kPosition)});
+    auto* p = Param("p", ty.vec4<f32>(), {Builtin(ast::Builtin::kPosition)});
-    auto* vi = Param("vi", ty.f32(),
+    auto* vi = Param("vi", ty.f32(), {Builtin(Source{{12, 34}}, ast::Builtin::kVertexIndex)});
-                     ast::AttributeList{Builtin(Source{{12, 34}}, ast::Builtin::kVertexIndex)});
+    Func("main", {vi, p}, ty.vec4<f32>(), {Return(Expr("p"))}, {Stage(ast::PipelineStage::kVertex)},
-    Func("main", ast::VariableList{vi, p}, ty.vec4<f32>(), {Return(Expr("p"))},
+         {Builtin(ast::Builtin::kPosition)});
-         ast::AttributeList{Stage(ast::PipelineStage::kVertex)},
-         ast::AttributeList{Builtin(ast::Builtin::kPosition)});
     EXPECT_FALSE(r()->Resolve());
     EXPECT_EQ(r()->error(), "12:34 error: store type of builtin(vertex_index) must be 'u32'");
 }
@@ -339,12 +411,10 @@ TEST_F(ResolverBuiltinsValidationTest, InstanceIndexIsNotU32) {
     //   @builtin(kInstanceIndex) ii : f32,
     //   @builtin(kPosition) p :vec4<f32>
     // ) -> @builtin(kPosition) vec4<f32> { return vec4<f32>(); }
-    auto* p = Param("p", ty.vec4<f32>(), ast::AttributeList{Builtin(ast::Builtin::kPosition)});
+    auto* p = Param("p", ty.vec4<f32>(), {Builtin(ast::Builtin::kPosition)});
-    auto* ii = Param("ii", ty.f32(),
+    auto* ii = Param("ii", ty.f32(), {Builtin(Source{{12, 34}}, ast::Builtin::kInstanceIndex)});
-                     ast::AttributeList{Builtin(Source{{12, 34}}, ast::Builtin::kInstanceIndex)});
+    Func("main", {ii, p}, ty.vec4<f32>(), {Return(Expr("p"))}, {Stage(ast::PipelineStage::kVertex)},
-    Func("main", ast::VariableList{ii, p}, ty.vec4<f32>(), {Return(Expr("p"))},
+         {Builtin(ast::Builtin::kPosition)});
-         ast::AttributeList{Stage(ast::PipelineStage::kVertex)},
-         ast::AttributeList{Builtin(ast::Builtin::kPosition)});
     EXPECT_FALSE(r()->Resolve());
     EXPECT_EQ(r()->error(), "12:34 error: store type of builtin(instance_index) must be 'u32'");
 }
@@ -357,14 +427,13 @@ TEST_F(ResolverBuiltinsValidationTest, FragmentBuiltin_Pass) {
     //   @builtin(sample_index) si: u32,
     //   @builtin(sample_mask) sm : u32
     // ) -> @builtin(frag_depth) f32 { var fd: f32; return fd; }
-    auto* p = Param("p", ty.vec4<f32>(), ast::AttributeList{Builtin(ast::Builtin::kPosition)});
+    auto* p = Param("p", ty.vec4<f32>(), {Builtin(ast::Builtin::kPosition)});
-    auto* ff = Param("ff", ty.bool_(), ast::AttributeList{Builtin(ast::Builtin::kFrontFacing)});
+    auto* ff = Param("ff", ty.bool_(), {Builtin(ast::Builtin::kFrontFacing)});
-    auto* si = Param("si", ty.u32(), ast::AttributeList{Builtin(ast::Builtin::kSampleIndex)});
+    auto* si = Param("si", ty.u32(), {Builtin(ast::Builtin::kSampleIndex)});
-    auto* sm = Param("sm", ty.u32(), ast::AttributeList{Builtin(ast::Builtin::kSampleMask)});
+    auto* sm = Param("sm", ty.u32(), {Builtin(ast::Builtin::kSampleMask)});
     auto* var_fd = Var("fd", ty.f32());
-    Func("fs_main", ast::VariableList{p, ff, si, sm}, ty.f32(), {Decl(var_fd), Return(var_fd)},
+    Func("fs_main", {p, ff, si, sm}, ty.f32(), {Decl(var_fd), Return(var_fd)},
-         ast::AttributeList{Stage(ast::PipelineStage::kFragment)},
+         {Stage(ast::PipelineStage::kFragment)}, {Builtin(ast::Builtin::kFragDepth)});
-         ast::AttributeList{Builtin(ast::Builtin::kFragDepth)});
     EXPECT_TRUE(r()->Resolve()) << r()->error();
 }
 
@@ -374,19 +443,16 @@ TEST_F(ResolverBuiltinsValidationTest, VertexBuiltin_Pass) {
     //   @builtin(vertex_index) vi : u32,
     //   @builtin(instance_index) ii : u32,
     // ) -> @builtin(position) vec4<f32> { var p :vec4<f32>; return p; }
-    auto* vi = Param("vi", ty.u32(),
+    auto* vi = Param("vi", ty.u32(), {Builtin(Source{{12, 34}}, ast::Builtin::kVertexIndex)});
-                     ast::AttributeList{Builtin(Source{{12, 34}}, ast::Builtin::kVertexIndex)});
 
-    auto* ii = Param("ii", ty.u32(),
+    auto* ii = Param("ii", ty.u32(), {Builtin(Source{{12, 34}}, ast::Builtin::kInstanceIndex)});
-                     ast::AttributeList{Builtin(Source{{12, 34}}, ast::Builtin::kInstanceIndex)});
     auto* p = Var("p", ty.vec4<f32>());
-    Func("main", ast::VariableList{vi, ii}, ty.vec4<f32>(),
+    Func("main", {vi, ii}, ty.vec4<f32>(),
          {
              Decl(p),
              Return(p),
          },
-         ast::AttributeList{Stage(ast::PipelineStage::kVertex)},
+         {Stage(ast::PipelineStage::kVertex)}, {Builtin(ast::Builtin::kPosition)});
-         ast::AttributeList{Builtin(ast::Builtin::kPosition)});
 
     EXPECT_TRUE(r()->Resolve()) << r()->error();
 }
@@ -401,29 +467,24 @@ TEST_F(ResolverBuiltinsValidationTest, ComputeBuiltin_Pass) {
     //   @builtin(num_workgroups) nwgs: vec3<u32>,
     // ) {}
 
-    auto* li_id = Param("li_id", ty.vec3<u32>(),
+    auto* li_id = Param("li_id", ty.vec3<u32>(), {Builtin(ast::Builtin::kLocalInvocationId)});
-                        ast::AttributeList{Builtin(ast::Builtin::kLocalInvocationId)});
+    auto* li_index = Param("li_index", ty.u32(), {Builtin(ast::Builtin::kLocalInvocationIndex)});
-    auto* li_index = Param("li_index", ty.u32(),
+    auto* gi = Param("gi", ty.vec3<u32>(), {Builtin(ast::Builtin::kGlobalInvocationId)});
-                           ast::AttributeList{Builtin(ast::Builtin::kLocalInvocationIndex)});
+    auto* wi = Param("wi", ty.vec3<u32>(), {Builtin(ast::Builtin::kWorkgroupId)});
-    auto* gi =
+    auto* nwgs = Param("nwgs", ty.vec3<u32>(), {Builtin(ast::Builtin::kNumWorkgroups)});
-        Param("gi", ty.vec3<u32>(), ast::AttributeList{Builtin(ast::Builtin::kGlobalInvocationId)});
-    auto* wi = Param("wi", ty.vec3<u32>(), ast::AttributeList{Builtin(ast::Builtin::kWorkgroupId)});
-    auto* nwgs =
-        Param("nwgs", ty.vec3<u32>(), ast::AttributeList{Builtin(ast::Builtin::kNumWorkgroups)});
 
-    Func("main", ast::VariableList{li_id, li_index, gi, wi, nwgs}, ty.void_(), {},
+    Func("main", {li_id, li_index, gi, wi, nwgs}, ty.void_(), {},
-         ast::AttributeList{Stage(ast::PipelineStage::kCompute),
+         {Stage(ast::PipelineStage::kCompute),
-                            WorkgroupSize(Expr(Source{Source::Location{12, 34}}, 2_i))});
+          WorkgroupSize(Expr(Source{Source::Location{12, 34}}, 2_i))});
 
     EXPECT_TRUE(r()->Resolve()) << r()->error();
 }
 
 TEST_F(ResolverBuiltinsValidationTest, ComputeBuiltin_WorkGroupIdNotVec3U32) {
-    auto* wi = Param("wi", ty.f32(),
+    auto* wi = Param("wi", ty.f32(), {Builtin(Source{{12, 34}}, ast::Builtin::kWorkgroupId)});
-                     ast::AttributeList{Builtin(Source{{12, 34}}, ast::Builtin::kWorkgroupId)});
+    Func("main", {wi}, ty.void_(), {},
-    Func("main", ast::VariableList{wi}, ty.void_(), {},
+         {Stage(ast::PipelineStage::kCompute),
-         ast::AttributeList{Stage(ast::PipelineStage::kCompute),
+          WorkgroupSize(Expr(Source{Source::Location{12, 34}}, 2_i))});
-                            WorkgroupSize(Expr(Source{Source::Location{12, 34}}, 2_i))});
 
     EXPECT_FALSE(r()->Resolve());
     EXPECT_EQ(r()->error(),
@@ -432,11 +493,10 @@ TEST_F(ResolverBuiltinsValidationTest, ComputeBuiltin_WorkGroupIdNotVec3U32) {
 }
 
 TEST_F(ResolverBuiltinsValidationTest, ComputeBuiltin_NumWorkgroupsNotVec3U32) {
-    auto* nwgs = Param("nwgs", ty.f32(),
+    auto* nwgs = Param("nwgs", ty.f32(), {Builtin(Source{{12, 34}}, ast::Builtin::kNumWorkgroups)});
-                       ast::AttributeList{Builtin(Source{{12, 34}}, ast::Builtin::kNumWorkgroups)});
+    Func("main", {nwgs}, ty.void_(), {},
-    Func("main", ast::VariableList{nwgs}, ty.void_(), {},
+         {Stage(ast::PipelineStage::kCompute),
-         ast::AttributeList{Stage(ast::PipelineStage::kCompute),
+          WorkgroupSize(Expr(Source{Source::Location{12, 34}}, 2_i))});
-                            WorkgroupSize(Expr(Source{Source::Location{12, 34}}, 2_i))});
 
     EXPECT_FALSE(r()->Resolve());
     EXPECT_EQ(r()->error(),
@@ -446,11 +506,10 @@ TEST_F(ResolverBuiltinsValidationTest, ComputeBuiltin_NumWorkgroupsNotVec3U32) {
 
 TEST_F(ResolverBuiltinsValidationTest, ComputeBuiltin_GlobalInvocationNotVec3U32) {
     auto* gi =
-        Param("gi", ty.vec3<i32>(),
+        Param("gi", ty.vec3<i32>(), {Builtin(Source{{12, 34}}, ast::Builtin::kGlobalInvocationId)});
-              ast::AttributeList{Builtin(Source{{12, 34}}, ast::Builtin::kGlobalInvocationId)});
+    Func("main", {gi}, ty.void_(), {},
-    Func("main", ast::VariableList{gi}, ty.void_(), {},
+         {Stage(ast::PipelineStage::kCompute),
-         ast::AttributeList{Stage(ast::PipelineStage::kCompute),
+          WorkgroupSize(Expr(Source{Source::Location{12, 34}}, 2_i))});
-                            WorkgroupSize(Expr(Source{Source::Location{12, 34}}, 2_i))});
 
     EXPECT_FALSE(r()->Resolve());
     EXPECT_EQ(r()->error(),
@@ -459,12 +518,11 @@ TEST_F(ResolverBuiltinsValidationTest, ComputeBuiltin_GlobalInvocationNotVec3U32
 }
 
 TEST_F(ResolverBuiltinsValidationTest, ComputeBuiltin_LocalInvocationIndexNotU32) {
-    auto* li_index =
+    auto* li_index = Param("li_index", ty.vec3<u32>(),
-        Param("li_index", ty.vec3<u32>(),
+                           {Builtin(Source{{12, 34}}, ast::Builtin::kLocalInvocationIndex)});
-              ast::AttributeList{Builtin(Source{{12, 34}}, ast::Builtin::kLocalInvocationIndex)});
+    Func("main", {li_index}, ty.void_(), {},
-    Func("main", ast::VariableList{li_index}, ty.void_(), {},
+         {Stage(ast::PipelineStage::kCompute),
-         ast::AttributeList{Stage(ast::PipelineStage::kCompute),
+          WorkgroupSize(Expr(Source{Source::Location{12, 34}}, 2_i))});
-                            WorkgroupSize(Expr(Source{Source::Location{12, 34}}, 2_i))});
 
     EXPECT_FALSE(r()->Resolve());
     EXPECT_EQ(r()->error(),
@@ -473,12 +531,11 @@ TEST_F(ResolverBuiltinsValidationTest, ComputeBuiltin_LocalInvocationIndexNotU32
 }
 
 TEST_F(ResolverBuiltinsValidationTest, ComputeBuiltin_LocalInvocationNotVec3U32) {
-    auto* li_id =
+    auto* li_id = Param("li_id", ty.vec2<u32>(),
-        Param("li_id", ty.vec2<u32>(),
+                        {Builtin(Source{{12, 34}}, ast::Builtin::kLocalInvocationId)});
-              ast::AttributeList{Builtin(Source{{12, 34}}, ast::Builtin::kLocalInvocationId)});
+    Func("main", {li_id}, ty.void_(), {},
-    Func("main", ast::VariableList{li_id}, ty.void_(), {},
+         {Stage(ast::PipelineStage::kCompute),
-         ast::AttributeList{Stage(ast::PipelineStage::kCompute),
+          WorkgroupSize(Expr(Source{Source::Location{12, 34}}, 2_i))});
-                            WorkgroupSize(Expr(Source{Source::Location{12, 34}}, 2_i))});
 
     EXPECT_FALSE(r()->Resolve());
     EXPECT_EQ(r()->error(),
@@ -496,13 +553,11 @@ TEST_F(ResolverBuiltinsValidationTest, FragmentBuiltinStruct_Pass) {
     // @fragment
     // fn fragShader(arg: MyInputs) -> @location(0) f32 { return 1.0; }
 
-    auto* s = Structure(
+    auto* s = Structure("MyInputs",
-        "MyInputs",
+                        {Member("position", ty.vec4<f32>(), {Builtin(ast::Builtin::kPosition)}),
-        {Member("position", ty.vec4<f32>(), ast::AttributeList{Builtin(ast::Builtin::kPosition)}),
+                         Member("front_facing", ty.bool_(), {Builtin(ast::Builtin::kFrontFacing)}),
-         Member("front_facing", ty.bool_(),
+                         Member("sample_index", ty.u32(), {Builtin(ast::Builtin::kSampleIndex)}),
-                ast::AttributeList{Builtin(ast::Builtin::kFrontFacing)}),
+                         Member("sample_mask", ty.u32(), {Builtin(ast::Builtin::kSampleMask)})});
-         Member("sample_index", ty.u32(), ast::AttributeList{Builtin(ast::Builtin::kSampleIndex)}),
-         Member("sample_mask", ty.u32(), ast::AttributeList{Builtin(ast::Builtin::kSampleMask)})});
     Func("fragShader", {Param("arg", ty.Of(s))}, ty.f32(), {Return(1_f)},
          {Stage(ast::PipelineStage::kFragment)}, {Location(0)});
     EXPECT_TRUE(r()->Resolve()) << r()->error();
@@ -515,10 +570,9 @@ TEST_F(ResolverBuiltinsValidationTest, FrontFacingParamIsNotBool_Fail) {
     // ) -> @location(0) f32 { return 1.0; }
 
     auto* is_front =
-        Param("is_front", ty.i32(),
+        Param("is_front", ty.i32(), {Builtin(Source{{12, 34}}, ast::Builtin::kFrontFacing)});
-              ast::AttributeList{Builtin(Source{{12, 34}}, ast::Builtin::kFrontFacing)});
+    Func("fs_main", {is_front}, ty.f32(), {Return(1_f)}, {Stage(ast::PipelineStage::kFragment)},
-    Func("fs_main", ast::VariableList{is_front}, ty.f32(), {Return(1_f)},
+         {Location(0)});
-         ast::AttributeList{Stage(ast::PipelineStage::kFragment)}, {Location(0)});
 
     EXPECT_FALSE(r()->Resolve());
     EXPECT_EQ(r()->error(), "12:34 error: store type of builtin(front_facing) must be 'bool'");
@@ -533,8 +587,7 @@ TEST_F(ResolverBuiltinsValidationTest, FrontFacingMemberIsNotBool_Fail) {
 
     auto* s = Structure(
         "MyInputs",
-        {Member("pos", ty.f32(),
+        {Member("pos", ty.f32(), {Builtin(Source{{12, 34}}, ast::Builtin::kFrontFacing)})});
-                ast::AttributeList{Builtin(Source{{12, 34}}, ast::Builtin::kFrontFacing)})});
     Func("fragShader", {Param("is_front", ty.Of(s))}, ty.f32(), {Return(1_f)},
          {Stage(ast::PipelineStage::kFragment)}, {Location(0)});
 

src/tint/resolver/call_validation_test.cc

@@ -171,7 +171,7 @@ TEST_F(ResolverCallValidationTest, PointerArgument_FunctionParamWithMain) {
     Func("foo", {Param("p", ty.pointer<i32>(ast::StorageClass::kFunction))}, ty.void_(), {});
     Func("bar", {Param("p", ty.pointer<i32>(ast::StorageClass::kFunction))}, ty.void_(),
          ast::StatementList{CallStmt(Call("foo", Expr("p")))});
-    Func("main", ast::VariableList{}, ty.void_(),
+    Func("main", {}, ty.void_(),
          {
              Decl(Var("v", ty.i32(), Expr(1_i))),
              CallStmt(Call("foo", AddressOf(Expr("v")))),
@@ -195,7 +195,7 @@ TEST_F(ResolverCallValidationTest, LetPointer) {
     auto* v = Var("v", ty.i32());
     auto* p = Let("p", ty.pointer(ty.i32(), ast::StorageClass::kFunction), AddressOf(v));
     auto* c = Var("c", ty.i32(), ast::StorageClass::kNone, Call("x", Expr(Source{{12, 34}}, p)));
-    Func("main", ast::VariableList{}, ty.void_(),
+    Func("main", {}, ty.void_(),
          {
              Decl(v),
              Decl(p),
@@ -222,7 +222,7 @@ TEST_F(ResolverCallValidationTest, LetPointerPrivate) {
     auto* v = Global("v", ty.i32(), ast::StorageClass::kPrivate);
     auto* p = Let("p", ty.pointer(ty.i32(), ast::StorageClass::kPrivate), AddressOf(v));
     auto* c = Var("c", ty.i32(), ast::StorageClass::kNone, Call("foo", Expr(Source{{12, 34}}, p)));
-    Func("main", ast::VariableList{}, ty.void_(),
+    Func("main", {}, ty.void_(),
          {
              Decl(p),
              Decl(c),

src/tint/resolver/function_validation_test.cc

@@ -394,7 +394,10 @@ TEST_F(ResolverFunctionValidationTest, FunctionVarInitWithParam) {
     auto* bar = Param("bar", ty.f32());
     auto* baz = Var("baz", ty.f32(), Expr("bar"));
 
-    Func("foo", ast::VariableList{bar}, ty.void_(), {Decl(baz)});
+    Func("foo", {bar}, ty.void_(),
+         {
+             Decl(baz),
+         });
 
     ASSERT_TRUE(r()->Resolve()) << r()->error();
 }
@@ -407,7 +410,10 @@ TEST_F(ResolverFunctionValidationTest, FunctionConstInitWithParam) {
     auto* bar = Param("bar", ty.f32());
     auto* baz = Let("baz", ty.f32(), Expr("bar"));
 
-    Func("foo", ast::VariableList{bar}, ty.void_(), {Decl(baz)});
+    Func("foo", {bar}, ty.void_(),
+         {
+             Decl(baz),
+         });
 
     ASSERT_TRUE(r()->Resolve()) << r()->error();
 }
@@ -709,7 +715,7 @@ TEST_F(ResolverFunctionValidationTest, ParameterStoreType_NonAtomicFree) {
     Structure("S", {Member("m", ty.atomic(ty.i32()))});
     auto* ret_type = ty.type_name(Source{{12, 34}}, "S");
     auto* bar = Param(Source{{12, 34}}, "bar", ret_type);
-    Func("f", ast::VariableList{bar}, ty.void_(), {});
+    Func("f", {bar}, ty.void_(), {});
 
     EXPECT_FALSE(r()->Resolve());
     EXPECT_EQ(r()->error(),
@@ -721,7 +727,7 @@ TEST_F(ResolverFunctionValidationTest, ParameterSotreType_AtomicFree) {
     Structure("S", {Member("m", ty.i32())});
     auto* ret_type = ty.type_name(Source{{12, 34}}, "S");
     auto* bar = Param(Source{{12, 34}}, "bar", ret_type);
-    Func("f", ast::VariableList{bar}, ty.void_(), {});
+    Func("f", {bar}, ty.void_(), {});
 
     ASSERT_TRUE(r()->Resolve()) << r()->error();
 }
@@ -779,7 +785,7 @@ TEST_P(ResolverFunctionParameterValidationTest, StorageClass) {
     auto& param = GetParam();
     auto* ptr_type = ty.pointer(Source{{12, 34}}, ty.i32(), param.storage_class);
     auto* arg = Param(Source{{12, 34}}, "p", ptr_type);
-    Func("f", ast::VariableList{arg}, ty.void_(), {});
+    Func("f", {arg}, ty.void_(), {});
 
     if (param.should_pass) {
         ASSERT_TRUE(r()->Resolve()) << r()->error();

src/tint/resolver/resolver_test.cc

@@ -270,8 +270,10 @@ TEST_F(ResolverTest, Stmt_Switch) {
 }
 
 TEST_F(ResolverTest, Stmt_Call) {
-    ast::VariableList params;
+    Func("my_func", {}, ty.void_(),
-    Func("my_func", params, ty.void_(), {Return()}, ast::AttributeList{});
+         {
+             Return(),
+         });
 
     auto* expr = Call("my_func");
 
@@ -333,8 +335,6 @@ TEST_F(ResolverTest, Stmt_VariableDecl_OuterScopeAfterInnerScope) {
     //   var bar : f32 = foo;
     // }
 
-    ast::VariableList params;
-
     // Declare i32 "foo" inside a block
     auto* foo_i32 = Var("foo", ty.i32(), ast::StorageClass::kNone, Expr(2_i));
     auto* foo_i32_init = foo_i32->constructor;
@@ -357,7 +357,7 @@ TEST_F(ResolverTest, Stmt_VariableDecl_OuterScopeAfterInnerScope) {
     auto* bar_f32_init = bar_f32->constructor;
     auto* bar_f32_decl = Decl(bar_f32);
 
-    Func("func", params, ty.void_(), {inner, foo_f32_decl, bar_f32_decl}, ast::AttributeList{});
+    Func("func", {}, ty.void_(), {inner, foo_f32_decl, bar_f32_decl});
 
     EXPECT_TRUE(r()->Resolve()) << r()->error();
     ASSERT_NE(TypeOf(foo_i32_init), nullptr);
@@ -389,13 +389,11 @@ TEST_F(ResolverTest, Stmt_VariableDecl_ModuleScopeAfterFunctionScope) {
     //   var bar : f32 = foo;
     // }
 
-    ast::VariableList params;
-
     // Declare i32 "foo" inside a function
     auto* fn_i32 = Var("foo", ty.i32(), ast::StorageClass::kNone, Expr(2_i));
     auto* fn_i32_init = fn_i32->constructor;
     auto* fn_i32_decl = Decl(fn_i32);
-    Func("func_i32", params, ty.void_(), {fn_i32_decl}, ast::AttributeList{});
+    Func("func_i32", {}, ty.void_(), {fn_i32_decl});
 
     // Declare f32 "foo" at module scope
     auto* mod_f32 = Var("foo", ty.f32(), ast::StorageClass::kPrivate, Expr(2_f));
@@ -406,7 +404,7 @@ TEST_F(ResolverTest, Stmt_VariableDecl_ModuleScopeAfterFunctionScope) {
     auto* fn_f32 = Var("bar", ty.f32(), ast::StorageClass::kNone, Expr("foo"));
     auto* fn_f32_init = fn_f32->constructor;
     auto* fn_f32_decl = Decl(fn_f32);
-    Func("func_f32", params, ty.void_(), {fn_f32_decl}, ast::AttributeList{});
+    Func("func_f32", {}, ty.void_(), {fn_f32_decl});
 
     EXPECT_TRUE(r()->Resolve()) << r()->error();
     ASSERT_NE(TypeOf(mod_init), nullptr);
@@ -493,8 +491,7 @@ TEST_F(ResolverTest, Expr_Bitcast) {
 }
 
 TEST_F(ResolverTest, Expr_Call) {
-    ast::VariableList params;
+    Func("my_func", {}, ty.f32(), {Return(0_f)});
-    Func("my_func", params, ty.f32(), {Return(0_f)}, ast::AttributeList{});
 
     auto* call = Call("my_func");
     WrapInFunction(call);
@@ -506,8 +503,7 @@ TEST_F(ResolverTest, Expr_Call) {
 }
 
 TEST_F(ResolverTest, Expr_Call_InBinaryOp) {
-    ast::VariableList params;
+    Func("func", {}, ty.f32(), {Return(0_f)});
-    Func("func", params, ty.f32(), {Return(0_f)}, ast::AttributeList{});
 
     auto* expr = Add(Call("func"), Call("func"));
     WrapInFunction(expr);
@@ -639,12 +635,11 @@ TEST_F(ResolverTest, Expr_Identifier_FunctionVariable_Const) {
     auto* var = Let("my_var", ty.f32(), Construct(ty.f32()));
     auto* decl = Decl(Var("b", ty.f32(), ast::StorageClass::kNone, my_var_a));
 
-    Func("my_func", ast::VariableList{}, ty.void_(),
+    Func("my_func", {}, ty.void_(),
          {
              Decl(var),
              decl,
-         },
+         });
-         ast::AttributeList{});
 
     EXPECT_TRUE(r()->Resolve()) << r()->error();
 
@@ -663,13 +658,12 @@ TEST_F(ResolverTest, IndexAccessor_Dynamic_Ref_F32) {
     auto* a = Var("a", ty.array<bool, 10>(), array<bool, 10>());
     auto* idx = Var("idx", ty.f32(), Construct(ty.f32()));
     auto* f = Var("f", ty.f32(), IndexAccessor("a", Expr(Source{{12, 34}}, idx)));
-    Func("my_func", ast::VariableList{}, ty.void_(),
+    Func("my_func", {}, ty.void_(),
          {
              Decl(a),
              Decl(idx),
              Decl(f),
-         },
+         });
-         ast::AttributeList{});
 
     EXPECT_FALSE(r()->Resolve());
     EXPECT_EQ(r()->error(), "12:34 error: index must be of type 'i32' or 'u32', found: 'f32'");
@@ -682,12 +676,11 @@ TEST_F(ResolverTest, Expr_Identifier_FunctionVariable) {
 
     auto* var = Var("my_var", ty.f32());
 
-    Func("my_func", ast::VariableList{}, ty.void_(),
+    Func("my_func", {}, ty.void_(),
          {
              Decl(var),
              assign,
-         },
+         });
-         ast::AttributeList{});
 
     EXPECT_TRUE(r()->Resolve()) << r()->error();
 
@@ -712,13 +705,12 @@ TEST_F(ResolverTest, Expr_Identifier_Function_Ptr) {
     auto* v_decl = Decl(Var("v", ty.f32()));
     auto* p_decl = Decl(Let("p", ty.pointer<f32>(ast::StorageClass::kFunction), AddressOf(v)));
     auto* assign = Assign(Deref(p), 1.23_f);
-    Func("my_func", ast::VariableList{}, ty.void_(),
+    Func("my_func", {}, ty.void_(),
          {
              v_decl,
              p_decl,
              assign,
-         },
+         });
-         ast::AttributeList{});
 
     EXPECT_TRUE(r()->Resolve()) << r()->error();
 
@@ -733,7 +725,10 @@ TEST_F(ResolverTest, Expr_Identifier_Function_Ptr) {
 }
 
 TEST_F(ResolverTest, Expr_Call_Function) {
-    Func("my_func", ast::VariableList{}, ty.f32(), {Return(0_f)}, ast::AttributeList{});
+    Func("my_func", {}, ty.f32(),
+         {
+             Return(0_f),
+         });
 
     auto* call = Call("my_func");
     WrapInFunction(call);
@@ -757,7 +752,7 @@ TEST_F(ResolverTest, Function_Parameters) {
     auto* param_c = Param("c", ty.u32());
 
     auto* func = Func("my_func",
-                      ast::VariableList{
+                      {
                           param_a,
                           param_b,
                           param_c,
@@ -789,7 +784,7 @@ TEST_F(ResolverTest, Function_RegisterInputOutputVariables) {
     auto* wg_var = Global("wg_var", ty.f32(), ast::StorageClass::kWorkgroup);
     auto* priv_var = Global("priv_var", ty.f32(), ast::StorageClass::kPrivate);
 
-    auto* func = Func("my_func", ast::VariableList{}, ty.void_(),
+    auto* func = Func("my_func", {}, ty.void_(),
                       {
                           Assign("wg_var", "wg_var"),
                           Assign("sb_var", "sb_var"),
@@ -821,12 +816,11 @@ TEST_F(ResolverTest, Function_RegisterInputOutputVariables_SubFunction) {
     auto* wg_var = Global("wg_var", ty.f32(), ast::StorageClass::kWorkgroup);
     auto* priv_var = Global("priv_var", ty.f32(), ast::StorageClass::kPrivate);
 
-    Func("my_func", ast::VariableList{}, ty.f32(),
+    Func("my_func", {}, ty.f32(),
          {Assign("wg_var", "wg_var"), Assign("sb_var", "sb_var"), Assign("priv_var", "priv_var"),
-          Return(0_f)},
+          Return(0_f)});
-         ast::AttributeList{});
 
-    auto* func2 = Func("func", ast::VariableList{}, ty.void_(),
+    auto* func2 = Func("func", {}, ty.void_(),
                        {
                            WrapInStatement(Call("my_func")),
                        },
@@ -846,7 +840,7 @@ TEST_F(ResolverTest, Function_RegisterInputOutputVariables_SubFunction) {
 }
 
 TEST_F(ResolverTest, Function_NotRegisterFunctionVariable) {
-    auto* func = Func("my_func", ast::VariableList{}, ty.void_(),
+    auto* func = Func("my_func", {}, ty.void_(),
                       {
                           Decl(Var("var", ty.f32())),
                           Assign("var", 1_f),
@@ -862,7 +856,7 @@ TEST_F(ResolverTest, Function_NotRegisterFunctionVariable) {
 }
 
 TEST_F(ResolverTest, Function_NotRegisterFunctionConstant) {
-    auto* func = Func("my_func", ast::VariableList{}, ty.void_(),
+    auto* func = Func("my_func", {}, ty.void_(),
                       {
                           Decl(Let("var", ty.f32(), Construct(ty.f32()))),
                       });
@@ -877,7 +871,7 @@ TEST_F(ResolverTest, Function_NotRegisterFunctionConstant) {
 }
 
 TEST_F(ResolverTest, Function_NotRegisterFunctionParams) {
-    auto* func = Func("my_func", {Let("var", ty.f32(), Construct(ty.f32()))}, ty.void_(), {});
+    auto* func = Func("my_func", {Param("var", ty.f32())}, ty.void_(), {});
     EXPECT_TRUE(r()->Resolve()) << r()->error();
 
     auto* func_sem = Sem().Get(func);
@@ -888,11 +882,11 @@ TEST_F(ResolverTest, Function_NotRegisterFunctionParams) {
 }
 
 TEST_F(ResolverTest, Function_CallSites) {
-    auto* foo = Func("foo", ast::VariableList{}, ty.void_(), {});
+    auto* foo = Func("foo", {}, ty.void_(), {});
 
     auto* call_1 = Call("foo");
     auto* call_2 = Call("foo");
-    auto* bar = Func("bar", ast::VariableList{}, ty.void_(),
+    auto* bar = Func("bar", {}, ty.void_(),
                      {
                          CallStmt(call_1),
                          CallStmt(call_2),
@@ -914,7 +908,7 @@ TEST_F(ResolverTest, Function_CallSites) {
 TEST_F(ResolverTest, Function_WorkgroupSize_NotSet) {
     // @compute @workgroup_size(1)
     // fn main() {}
-    auto* func = Func("main", ast::VariableList{}, ty.void_(), {}, {});
+    auto* func = Func("main", {}, ty.void_(), {});
 
     EXPECT_TRUE(r()->Resolve()) << r()->error();
 
@@ -932,8 +926,11 @@ TEST_F(ResolverTest, Function_WorkgroupSize_NotSet) {
 TEST_F(ResolverTest, Function_WorkgroupSize_Literals) {
     // @compute @workgroup_size(8, 2, 3)
     // fn main() {}
-    auto* func = Func("main", ast::VariableList{}, ty.void_(), {},
+    auto* func = Func("main", {}, ty.void_(), {},
-                      {Stage(ast::PipelineStage::kCompute), WorkgroupSize(8_i, 2_i, 3_i)});
+                      {
+                          Stage(ast::PipelineStage::kCompute),
+                          WorkgroupSize(8_i, 2_i, 3_i),
+                      });
 
     EXPECT_TRUE(r()->Resolve()) << r()->error();
 
@@ -957,9 +954,11 @@ TEST_F(ResolverTest, Function_WorkgroupSize_Consts) {
     GlobalConst("width", ty.i32(), Expr(16_i));
     GlobalConst("height", ty.i32(), Expr(8_i));
     GlobalConst("depth", ty.i32(), Expr(2_i));
-    auto* func =
+    auto* func = Func("main", {}, ty.void_(), {},
-        Func("main", ast::VariableList{}, ty.void_(), {},
+                      {
-             {Stage(ast::PipelineStage::kCompute), WorkgroupSize("width", "height", "depth")});
+                          Stage(ast::PipelineStage::kCompute),
+                          WorkgroupSize("width", "height", "depth"),
+                      });
 
     EXPECT_TRUE(r()->Resolve()) << r()->error();
 
@@ -983,8 +982,11 @@ TEST_F(ResolverTest, Function_WorkgroupSize_Consts_NestedInitializer) {
                 Construct(ty.i32(), Construct(ty.i32(), Construct(ty.i32(), 8_i))));
     GlobalConst("height", ty.i32(),
                 Construct(ty.i32(), Construct(ty.i32(), Construct(ty.i32(), 4_i))));
-    auto* func = Func("main", ast::VariableList{}, ty.void_(), {},
+    auto* func = Func("main", {}, ty.void_(), {},
-                      {Stage(ast::PipelineStage::kCompute), WorkgroupSize("width", "height")});
+                      {
+                          Stage(ast::PipelineStage::kCompute),
+                          WorkgroupSize("width", "height"),
+                      });
 
     EXPECT_TRUE(r()->Resolve()) << r()->error();
 
@@ -1008,9 +1010,11 @@ TEST_F(ResolverTest, Function_WorkgroupSize_OverridableConsts) {
     auto* width = Override("width", ty.i32(), Expr(16_i), {Id(0)});
     auto* height = Override("height", ty.i32(), Expr(8_i), {Id(1)});
     auto* depth = Override("depth", ty.i32(), Expr(2_i), {Id(2)});
-    auto* func =
+    auto* func = Func("main", {}, ty.void_(), {},
-        Func("main", ast::VariableList{}, ty.void_(), {},
+                      {
-             {Stage(ast::PipelineStage::kCompute), WorkgroupSize("width", "height", "depth")});
+                          Stage(ast::PipelineStage::kCompute),
+                          WorkgroupSize("width", "height", "depth"),
+                      });
 
     EXPECT_TRUE(r()->Resolve()) << r()->error();
 
@@ -1034,9 +1038,11 @@ TEST_F(ResolverTest, Function_WorkgroupSize_OverridableConsts_NoInit) {
     auto* width = Override("width", ty.i32(), nullptr, {Id(0)});
     auto* height = Override("height", ty.i32(), nullptr, {Id(1)});
     auto* depth = Override("depth", ty.i32(), nullptr, {Id(2)});
-    auto* func =
+    auto* func = Func("main", {}, ty.void_(), {},
-        Func("main", ast::VariableList{}, ty.void_(), {},
+                      {
-             {Stage(ast::PipelineStage::kCompute), WorkgroupSize("width", "height", "depth")});
+                          Stage(ast::PipelineStage::kCompute),
+                          WorkgroupSize("width", "height", "depth"),
+                      });
 
     EXPECT_TRUE(r()->Resolve()) << r()->error();
 
@@ -1058,8 +1064,11 @@ TEST_F(ResolverTest, Function_WorkgroupSize_Mixed) {
     // fn main() {}
     auto* height = Override("height", ty.i32(), Expr(2_i), {Id(0)});
     GlobalConst("depth", ty.i32(), Expr(3_i));
-    auto* func = Func("main", ast::VariableList{}, ty.void_(), {},
+    auto* func = Func("main", {}, ty.void_(), {},
-                      {Stage(ast::PipelineStage::kCompute), WorkgroupSize(8_i, "height", "depth")});
+                      {
+                          Stage(ast::PipelineStage::kCompute),
+                          WorkgroupSize(8_i, "height", "depth"),
+                      });
 
     EXPECT_TRUE(r()->Resolve()) << r()->error();
 
@@ -1709,7 +1718,7 @@ TEST_F(ResolverTest, StorageClass_SetsIfMissing) {
     auto* var = Var("var", ty.i32());
 
     auto* stmt = Decl(var);
-    Func("func", ast::VariableList{}, ty.void_(), {stmt}, ast::AttributeList{});
+    Func("func", {}, ty.void_(), {stmt});
 
     EXPECT_TRUE(r()->Resolve()) << r()->error();
 
@@ -1745,7 +1754,7 @@ TEST_F(ResolverTest, StorageClass_SetForTexture) {
 TEST_F(ResolverTest, StorageClass_DoesNotSetOnConst) {
     auto* var = Let("var", ty.i32(), Construct(ty.i32()));
     auto* stmt = Decl(var);
-    Func("func", ast::VariableList{}, ty.void_(), {stmt}, ast::AttributeList{});
+    Func("func", {}, ty.void_(), {stmt});
 
     EXPECT_TRUE(r()->Resolve()) << r()->error();
 
@@ -1802,26 +1811,40 @@ TEST_F(ResolverTest, Function_EntryPoints_StageAttribute) {
     Global("call_b", ty.f32(), ast::StorageClass::kPrivate);
     Global("call_c", ty.f32(), ast::StorageClass::kPrivate);
 
-    ast::VariableList params;
+    auto* func_b = Func("b", {}, ty.f32(),
-    auto* func_b = Func("b", params, ty.f32(), {Return(0_f)}, ast::AttributeList{});
+                        {
-    auto* func_c = Func("c", params, ty.f32(), {Assign("second", Call("b")), Return(0_f)},
+                            Return(0_f),
-                        ast::AttributeList{});
+                        });
+    auto* func_c = Func("c", {}, ty.f32(),
+                        {
+                            Assign("second", Call("b")),
+                            Return(0_f),
+                        });
 
-    auto* func_a = Func("a", params, ty.f32(), {Assign("first", Call("c")), Return(0_f)},
+    auto* func_a = Func("a", {}, ty.f32(),
-                        ast::AttributeList{});
+                        {
+                            Assign("first", Call("c")),
+                            Return(0_f),
+                        });
 
-    auto* ep_1 = Func("ep_1", params, ty.void_(),
+    auto* ep_1 = Func("ep_1", {}, ty.void_(),
                       {
                           Assign("call_a", Call("a")),
                           Assign("call_b", Call("b")),
                       },
-                      ast::AttributeList{Stage(ast::PipelineStage::kCompute), WorkgroupSize(1_i)});
+                      {
+                          Stage(ast::PipelineStage::kCompute),
+                          WorkgroupSize(1_i),
+                      });
 
-    auto* ep_2 = Func("ep_2", params, ty.void_(),
+    auto* ep_2 = Func("ep_2", {}, ty.void_(),
                       {
                           Assign("call_c", Call("c")),
                       },
-                      ast::AttributeList{Stage(ast::PipelineStage::kCompute), WorkgroupSize(1_i)});
+                      {
+                          Stage(ast::PipelineStage::kCompute),
+                          WorkgroupSize(1_i),
+                      });
 
     ASSERT_TRUE(r()->Resolve()) << r()->error();
 
@@ -1875,8 +1898,8 @@ TEST_F(ResolverTest, Function_EntryPoints_LinearTime) {
     auto fn_a = [](int level) { return "l" + std::to_string(level + 1) + "a"; };
     auto fn_b = [](int level) { return "l" + std::to_string(level + 1) + "b"; };
 
-    Func(fn_a(levels), {}, ty.void_(), {}, {});
+    Func(fn_a(levels), {}, ty.void_(), {});
-    Func(fn_b(levels), {}, ty.void_(), {}, {});
+    Func(fn_b(levels), {}, ty.void_(), {});
 
     for (int i = levels - 1; i >= 0; i--) {
         Func(fn_a(i), {}, ty.void_(),

src/tint/resolver/type_validation_test.cc

@@ -121,9 +121,10 @@ TEST_F(ResolverTypeValidationTest, GlobalVariableFunctionVariableNotUnique_Pass)
     // }
     // var a: f32 = 2.1;
 
-    auto* var = Var("a", ty.f32(), ast::StorageClass::kNone, Expr(2_f));
+    Func("my_func", {}, ty.void_(),
-
+         {
-    Func("my_func", ast::VariableList{}, ty.void_(), {Decl(var)});
+             Decl(Var("a", ty.f32(), ast::StorageClass::kNone, Expr(2_f))),
+         });
 
     Global("a", ty.f32(), ast::StorageClass::kPrivate, Expr(2.1_f));
 
@@ -172,15 +173,14 @@ TEST_F(ResolverTypeValidationTest, RedeclaredIdentifierDifferentFunctions_Pass)
 
     auto* var1 = Var("a", ty.f32(), ast::StorageClass::kNone, Expr(1_f));
 
-    Func("func0", ast::VariableList{}, ty.void_(),
+    Func("func0", {}, ty.void_(),
-         ast::StatementList{
+         {
              Decl(Source{{12, 34}}, var0),
              Return(),
-         },
+         });
-         ast::AttributeList{});
 
-    Func("func1", ast::VariableList{}, ty.void_(),
+    Func("func1", {}, ty.void_(),
-         ast::StatementList{
+         {
              Decl(Source{{13, 34}}, var1),
              Return(),
          });
@@ -374,11 +374,11 @@ TEST_F(ResolverTypeValidationTest, RuntimeArrayInFunction_Fail) {
 
     auto* var = Var(Source{{12, 34}}, "a", ty.array<i32>(), ast::StorageClass::kNone);
 
-    Func("func", ast::VariableList{}, ty.void_(),
+    Func("func", {}, ty.void_(),
-         ast::StatementList{
+         {
              Decl(var),
          },
-         ast::AttributeList{
+         {
              Stage(ast::PipelineStage::kVertex),
          });
 
@@ -556,17 +556,16 @@ TEST_F(ResolverTypeValidationTest, RuntimeArrayAsParameter_Fail) {
 
     auto* param = Param(Source{{12, 34}}, "a", ty.array<i32>());
 
-    Func("func", ast::VariableList{param}, ty.void_(),
+    Func("func", {param}, ty.void_(),
-         ast::StatementList{
+         {
              Return(),
-         },
+         });
-         ast::AttributeList{});
 
-    Func("main", ast::VariableList{}, ty.void_(),
+    Func("main", {}, ty.void_(),
-         ast::StatementList{
+         {
              Return(),
          },
-         ast::AttributeList{
+         {
              Stage(ast::PipelineStage::kVertex),
          });
 
@@ -582,11 +581,10 @@ TEST_F(ResolverTypeValidationTest, PtrToRuntimeArrayAsParameter_Fail) {
     auto* param =
         Param(Source{{12, 34}}, "a", ty.pointer(ty.array<i32>(), ast::StorageClass::kWorkgroup));
 
-    Func("func", ast::VariableList{param}, ty.void_(),
+    Func("func", {param}, ty.void_(),
-         ast::StatementList{
+         {
              Return(),
-         },
+         });
-         ast::AttributeList{});
 
     EXPECT_FALSE(r()->Resolve()) << r()->error();
     EXPECT_EQ(r()->error(),

src/tint/resolver/validation_test.cc

@@ -65,9 +65,17 @@ TEST_F(ResolverValidationTest, WorkgroupMemoryUsedInVertexStage) {
     Global("dst", ty.vec4<f32>(), ast::StorageClass::kPrivate);
     auto* stmt = Assign(Expr("dst"), Expr(Source{{3, 4}}, "wg"));
 
-    Func(Source{{9, 10}}, "f0", ast::VariableList{}, ty.vec4<f32>(), {stmt, Return(Expr("dst"))},
+    Func(Source{{9, 10}}, "f0", {}, ty.vec4<f32>(),
-         ast::AttributeList{Stage(ast::PipelineStage::kVertex)},
+         {
-         ast::AttributeList{Builtin(ast::Builtin::kPosition)});
+             stmt,
+             Return(Expr("dst")),
+         },
+         {
+             Stage(ast::PipelineStage::kVertex),
+         },
+         {
+             Builtin(ast::Builtin::kPosition),
+         });
 
     EXPECT_FALSE(r()->Resolve());
     EXPECT_EQ(r()->error(),
@@ -215,7 +223,7 @@ TEST_F(ResolverValidationTest, UsingUndefinedVariableGlobalVariable_Pass) {
 
     Global("global_var", ty.f32(), ast::StorageClass::kPrivate, Expr(2.1_f));
 
-    Func("my_func", ast::VariableList{}, ty.void_(),
+    Func("my_func", {}, ty.void_(),
          {
              Assign(Expr(Source{{12, 34}}, "global_var"), 3.14_f),
              Return(),
@@ -289,8 +297,10 @@ TEST_F(ResolverValidationTest, UsingUndefinedVariableDifferentScope_Fail) {
 TEST_F(ResolverValidationTest, StorageClass_FunctionVariableWorkgroupClass) {
     auto* var = Var("var", ty.i32(), ast::StorageClass::kWorkgroup);
 
-    auto* stmt = Decl(var);
+    Func("func", {}, ty.void_(),
-    Func("func", ast::VariableList{}, ty.void_(), {stmt}, ast::AttributeList{});
+         {
+             Decl(var),
+         });
 
     EXPECT_FALSE(r()->Resolve());
 
@@ -300,8 +310,10 @@ TEST_F(ResolverValidationTest, StorageClass_FunctionVariableWorkgroupClass) {
 TEST_F(ResolverValidationTest, StorageClass_FunctionVariableI32) {
     auto* var = Var("s", ty.i32(), ast::StorageClass::kPrivate);
 
-    auto* stmt = Decl(var);
+    Func("func", {}, ty.void_(),
-    Func("func", ast::VariableList{}, ty.void_(), {stmt}, ast::AttributeList{});
+         {
+             Decl(var),
+         });
 
     EXPECT_FALSE(r()->Resolve());
 

src/tint/transform/multiplanar_external_texture.cc

@@ -264,35 +264,38 @@ struct MultiplanarExternalTexture::State {
     /// Creates the gammaCorrection function if needed and returns a call
     /// expression to it.
     void createGammaCorrectionFn() {
-        ast::VariableList varList = {b.Param("v", b.ty.vec3<f32>()),
-                                     b.Param("params", b.ty.type_name(gamma_transfer_struct_sym))};
-
-        ast::StatementList statementList = {
-            // let cond = abs(v) < vec3(params.D);
-            b.Decl(b.Let(
-                "cond", nullptr,
-                b.LessThan(b.Call("abs", "v"), b.vec3<f32>(b.MemberAccessor("params", "D"))))),
-            // let t = sign(v) * ((params.C * abs(v)) + params.F);
-            b.Decl(b.Let("t", nullptr,
-                         b.Mul(b.Call("sign", "v"),
-                               b.Add(b.Mul(b.MemberAccessor("params", "C"), b.Call("abs", "v")),
-                                     b.MemberAccessor("params", "F"))))),
-            // let f = (sign(v) * pow(((params.A * abs(v)) + params.B),
-            // vec3(params.G))) + params.E;
-            b.Decl(b.Let(
-                "f", nullptr,
-                b.Mul(b.Call("sign", "v"),
-                      b.Add(b.Call("pow",
-                                   b.Add(b.Mul(b.MemberAccessor("params", "A"), b.Call("abs", "v")),
-                                         b.MemberAccessor("params", "B")),
-                                   b.vec3<f32>(b.MemberAccessor("params", "G"))),
-                            b.MemberAccessor("params", "E"))))),
-            // return select(f, t, cond);
-            b.Return(b.Call("select", "f", "t", "cond"))};
-
         gamma_correction_sym = b.Symbols().New("gammaCorrection");
 
-        b.Func(gamma_correction_sym, varList, b.ty.vec3<f32>(), statementList, {});
+        b.Func(
+            gamma_correction_sym,
+            {
+                b.Param("v", b.ty.vec3<f32>()),
+                b.Param("params", b.ty.type_name(gamma_transfer_struct_sym)),
+            },
+            b.ty.vec3<f32>(),
+            {
+                // let cond = abs(v) < vec3(params.D);
+                b.Decl(b.Let(
+                    "cond", nullptr,
+                    b.LessThan(b.Call("abs", "v"), b.vec3<f32>(b.MemberAccessor("params", "D"))))),
+                // let t = sign(v) * ((params.C * abs(v)) + params.F);
+                b.Decl(b.Let("t", nullptr,
+                             b.Mul(b.Call("sign", "v"),
+                                   b.Add(b.Mul(b.MemberAccessor("params", "C"), b.Call("abs", "v")),
+                                         b.MemberAccessor("params", "F"))))),
+                // let f = (sign(v) * pow(((params.A * abs(v)) + params.B),
+                // vec3(params.G))) + params.E;
+                b.Decl(b.Let("f", nullptr,
+                             b.Mul(b.Call("sign", "v"),
+                                   b.Add(b.Call("pow",
+                                                b.Add(b.Mul(b.MemberAccessor("params", "A"),
+                                                            b.Call("abs", "v")),
+                                                      b.MemberAccessor("params", "B")),
+                                                b.vec3<f32>(b.MemberAccessor("params", "G"))),
+                                         b.MemberAccessor("params", "E"))))),
+                // return select(f, t, cond);
+                b.Return(b.Call("select", "f", "t", "cond")),
+            });
     }
 
     /// Constructs a StatementList containing all the statements making up the
@@ -375,17 +378,19 @@ struct MultiplanarExternalTexture::State {
             texture_sample_external_sym = b.Symbols().New("textureSampleExternal");
 
             // Emit the textureSampleExternal function.
-            ast::VariableList varList = {
+            b.Func(
-                b.Param("plane0", b.ty.sampled_texture(ast::TextureDimension::k2d, b.ty.f32())),
+                texture_sample_external_sym,
-                b.Param("plane1", b.ty.sampled_texture(ast::TextureDimension::k2d, b.ty.f32())),
+                {
-                b.Param("smp", b.ty.sampler(ast::SamplerKind::kSampler)),
+                    b.Param("plane0", b.ty.sampled_texture(ast::TextureDimension::k2d, b.ty.f32())),
-                b.Param("coord", b.ty.vec2(b.ty.f32())),
+                    b.Param("plane1", b.ty.sampled_texture(ast::TextureDimension::k2d, b.ty.f32())),
-                b.Param("params", b.ty.type_name(params_struct_sym))};
+                    b.Param("smp", b.ty.sampler(ast::SamplerKind::kSampler)),
-
+                    b.Param("coord", b.ty.vec2(b.ty.f32())),
-            ast::StatementList statementList =
+                    b.Param("params", b.ty.type_name(params_struct_sym)),
-                createTexFnExtStatementList(sem::BuiltinType::kTextureSampleLevel);
+                },
-
+                b.ty.vec4(b.ty.f32()),
-            b.Func(texture_sample_external_sym, varList, b.ty.vec4(b.ty.f32()), statementList, {});
+                {
+                    createTexFnExtStatementList(sem::BuiltinType::kTextureSampleLevel),
+                });
         }
 
         const ast::IdentifierExpression* exp = b.Expr(texture_sample_external_sym);
@@ -421,22 +426,22 @@ struct MultiplanarExternalTexture::State {
             texture_load_external_sym = b.Symbols().New("textureLoadExternal");
 
             // Emit the textureLoadExternal function.
-            ast::VariableList var_list = {
+            b.Func(
-                b.Param("plane0", b.ty.sampled_texture(ast::TextureDimension::k2d, b.ty.f32())),
+                texture_load_external_sym,
-                b.Param("plane1", b.ty.sampled_texture(ast::TextureDimension::k2d, b.ty.f32())),
+                {
-                b.Param("coord", b.ty.vec2(b.ty.i32())),
+                    b.Param("plane0", b.ty.sampled_texture(ast::TextureDimension::k2d, b.ty.f32())),
-                b.Param("params", b.ty.type_name(params_struct_sym))};
+                    b.Param("plane1", b.ty.sampled_texture(ast::TextureDimension::k2d, b.ty.f32())),
-
+                    b.Param("coord", b.ty.vec2(b.ty.i32())),
-            ast::StatementList statement_list =
+                    b.Param("params", b.ty.type_name(params_struct_sym)),
-                createTexFnExtStatementList(sem::BuiltinType::kTextureLoad);
+                },
-
+                b.ty.vec4(b.ty.f32()),
-            b.Func(texture_load_external_sym, var_list, b.ty.vec4(b.ty.f32()), statement_list, {});
+                {
+                    createTexFnExtStatementList(sem::BuiltinType::kTextureLoad),
+                });
         }
 
-        const ast::IdentifierExpression* exp = b.Expr(texture_load_external_sym);
+        return b.Call(texture_load_external_sym, plane_0_binding_param, syms.plane_1,
-        params = {plane_0_binding_param, b.Expr(syms.plane_1), ctx.Clone(expr->args[1]),
+                      ctx.Clone(expr->args[1]), syms.params);
-                  b.Expr(syms.params)};
-        return b.Call(exp, params);
     }
 };
 

src/tint/writer/glsl/generator_impl_function_test.cc

@@ -28,7 +28,7 @@ namespace {
 using GlslGeneratorImplTest_Function = TestHelper;
 
 TEST_F(GlslGeneratorImplTest_Function, Emit_Function) {
-    Func("my_func", ast::VariableList{}, ty.void_(),
+    Func("my_func", {}, ty.void_(),
          {
              Return(),
          });
@@ -48,7 +48,7 @@ TEST_F(GlslGeneratorImplTest_Function, Emit_Function) {
 }
 
 TEST_F(GlslGeneratorImplTest_Function, Emit_Function_Name_Collision) {
-    Func("centroid", ast::VariableList{}, ty.void_(),
+    Func("centroid", {}, ty.void_(),
          {
              Return(),
          });
@@ -64,7 +64,12 @@ TEST_F(GlslGeneratorImplTest_Function, Emit_Function_Name_Collision) {
 }
 
 TEST_F(GlslGeneratorImplTest_Function, Emit_Function_WithParams) {
-    Func("my_func", ast::VariableList{Param("a", ty.f32()), Param("b", ty.i32())}, ty.void_(),
+    Func("my_func",
+         {
+             Param("a", ty.f32()),
+             Param("b", ty.i32()),
+         },
+         ty.void_(),
          {
              Return(),
          });
@@ -84,7 +89,7 @@ TEST_F(GlslGeneratorImplTest_Function, Emit_Function_WithParams) {
 }
 
 TEST_F(GlslGeneratorImplTest_Function, Emit_Attribute_EntryPoint_NoReturn_Void) {
-    Func("func", ast::VariableList{}, ty.void_(), {/* no explicit return */},
+    Func("func", {}, ty.void_(), {/* no explicit return */},
          {
              Stage(ast::PipelineStage::kFragment),
          });
@@ -121,9 +126,20 @@ TEST_F(GlslGeneratorImplTest_Function, Emit_Attribute_EntryPoint_WithInOutVars)
     // fn frag_main(@location(0) foo : f32) -> @location(1) f32 {
     //   return foo;
     // }
-    auto* foo_in = Param("foo", ty.f32(), {Location(0)});
+    Func("frag_main",
-    Func("frag_main", ast::VariableList{foo_in}, ty.f32(), {Return("foo")},
+         {
-         {Stage(ast::PipelineStage::kFragment)}, {Location(1)});
+             Param("foo", ty.f32(), {Location(0)}),
+         },
+         ty.f32(),
+         {
+             Return("foo"),
+         },
+         {
+             Stage(ast::PipelineStage::kFragment),
+         },
+         {
+             Location(1),
+         });
 
     GeneratorImpl& gen = SanitizeAndBuild();
 
@@ -150,8 +166,20 @@ TEST_F(GlslGeneratorImplTest_Function, Emit_Attribute_EntryPoint_WithInOut_Built
     //   return coord.x;
     // }
     auto* coord_in = Param("coord", ty.vec4<f32>(), {Builtin(ast::Builtin::kPosition)});
-    Func("frag_main", ast::VariableList{coord_in}, ty.f32(), {Return(MemberAccessor("coord", "x"))},
+    Func("frag_main",
-         {Stage(ast::PipelineStage::kFragment)}, {Builtin(ast::Builtin::kFragDepth)});
+         {
+             coord_in,
+         },
+         ty.f32(),
+         {
+             Return(MemberAccessor("coord", "x")),
+         },
+         {
+             Stage(ast::PipelineStage::kFragment),
+         },
+         {
+             Builtin(ast::Builtin::kFragDepth),
+         });
 
     GeneratorImpl& gen = SanitizeAndBuild();
 
@@ -384,7 +412,7 @@ TEST_F(GlslGeneratorImplTest_Function, Emit_Attribute_EntryPoint_With_UniformStr
     auto* var = Var("v", ty.f32(), ast::StorageClass::kNone,
                     MemberAccessor(MemberAccessor("uniforms", "coord"), "x"));
 
-    Func("frag_main", ast::VariableList{}, ty.void_(),
+    Func("frag_main", {}, ty.void_(),
          {
              Decl(var),
              Return(),
@@ -428,7 +456,7 @@ TEST_F(GlslGeneratorImplTest_Function, Emit_Attribute_EntryPoint_With_RW_Storage
 
     auto* var = Var("v", ty.f32(), ast::StorageClass::kNone, MemberAccessor("coord", "b"));
 
-    Func("frag_main", ast::VariableList{}, ty.void_(),
+    Func("frag_main", {}, ty.void_(),
          {
              Decl(var),
              Return(),
@@ -478,7 +506,7 @@ TEST_F(GlslGeneratorImplTest_Function, Emit_Attribute_EntryPoint_With_RO_Storage
 
     auto* var = Var("v", ty.f32(), ast::StorageClass::kNone, MemberAccessor("coord", "b"));
 
-    Func("frag_main", ast::VariableList{}, ty.void_(),
+    Func("frag_main", {}, ty.void_(),
          {
              Decl(var),
              Return(),
@@ -527,7 +555,7 @@ TEST_F(GlslGeneratorImplTest_Function, Emit_Attribute_EntryPoint_With_WO_Storage
                create<ast::GroupAttribute>(1),
            });
 
-    Func("frag_main", ast::VariableList{}, ty.void_(),
+    Func("frag_main", {}, ty.void_(),
          {
              Assign(MemberAccessor("coord", "b"), Expr(2_f)),
              Return(),
@@ -575,7 +603,7 @@ TEST_F(GlslGeneratorImplTest_Function, Emit_Attribute_EntryPoint_With_StorageBuf
                create<ast::GroupAttribute>(1),
            });
 
-    Func("frag_main", ast::VariableList{}, ty.void_(),
+    Func("frag_main", {}, ty.void_(),
          {
              Assign(MemberAccessor("coord", "b"), Expr(2_f)),
              Return(),
@@ -619,14 +647,14 @@ TEST_F(GlslGeneratorImplTest_Function, Emit_Attribute_Called_By_EntryPoint_With_
                create<ast::GroupAttribute>(1),
            });
 
-    Func("sub_func", ast::VariableList{Param("param", ty.f32())}, ty.f32(),
+    Func("sub_func", {Param("param", ty.f32())}, ty.f32(),
          {
              Return(MemberAccessor("coord", "x")),
          });
 
     auto* var = Var("v", ty.f32(), ast::StorageClass::kNone, Call("sub_func", 1_f));
 
-    Func("frag_main", ast::VariableList{}, ty.void_(),
+    Func("frag_main", {}, ty.void_(),
          {
              Decl(var),
              Return(),
@@ -668,14 +696,14 @@ TEST_F(GlslGeneratorImplTest_Function, Emit_Attribute_Called_By_EntryPoint_With_
                create<ast::GroupAttribute>(1),
            });
 
-    Func("sub_func", ast::VariableList{Param("param", ty.f32())}, ty.f32(),
+    Func("sub_func", {Param("param", ty.f32())}, ty.f32(),
          {
              Return(MemberAccessor("coord", "x")),
          });
 
     auto* var = Var("v", ty.f32(), ast::StorageClass::kNone, Call("sub_func", 1_f));
 
-    Func("frag_main", ast::VariableList{}, ty.void_(),
+    Func("frag_main", {}, ty.void_(),
          {
              Decl(var),
              Return(),
@@ -715,7 +743,7 @@ void main() {
 }
 
 TEST_F(GlslGeneratorImplTest_Function, Emit_Attribute_EntryPoint_WithNameCollision) {
-    Func("centroid", ast::VariableList{}, ty.void_(), {},
+    Func("centroid", {}, ty.void_(), {},
          {
              Stage(ast::PipelineStage::kFragment),
          });
@@ -737,11 +765,14 @@ void main() {
 }
 
 TEST_F(GlslGeneratorImplTest_Function, Emit_Attribute_EntryPoint_Compute) {
-    Func("main", ast::VariableList{}, ty.void_(),
+    Func("main", {}, ty.void_(),
          {
              Return(),
          },
-         {Stage(ast::PipelineStage::kCompute), WorkgroupSize(1_i)});
+         {
+             Stage(ast::PipelineStage::kCompute),
+             WorkgroupSize(1_i),
+         });
 
     GeneratorImpl& gen = Build();
 
@@ -756,7 +787,7 @@ void main() {
 }
 
 TEST_F(GlslGeneratorImplTest_Function, Emit_Attribute_EntryPoint_Compute_WithWorkgroup_Literal) {
-    Func("main", ast::VariableList{}, ty.void_(), {},
+    Func("main", {}, ty.void_(), {},
          {
              Stage(ast::PipelineStage::kCompute),
              WorkgroupSize(2_i, 4_i, 6_i),
@@ -778,7 +809,7 @@ TEST_F(GlslGeneratorImplTest_Function, Emit_Attribute_EntryPoint_Compute_WithWor
     GlobalConst("width", ty.i32(), Construct(ty.i32(), 2_i));
     GlobalConst("height", ty.i32(), Construct(ty.i32(), 3_i));
     GlobalConst("depth", ty.i32(), Construct(ty.i32(), 4_i));
-    Func("main", ast::VariableList{}, ty.void_(), {},
+    Func("main", {}, ty.void_(), {},
          {
              Stage(ast::PipelineStage::kCompute),
              WorkgroupSize("width", "height", "depth"),
@@ -804,7 +835,7 @@ TEST_F(GlslGeneratorImplTest_Function,
     Override("width", ty.i32(), Construct(ty.i32(), 2_i), {Id(7u)});
     Override("height", ty.i32(), Construct(ty.i32(), 3_i), {Id(8u)});
     Override("depth", ty.i32(), Construct(ty.i32(), 4_i), {Id(9u)});
-    Func("main", ast::VariableList{}, ty.void_(), {},
+    Func("main", {}, ty.void_(), {},
          {
              Stage(ast::PipelineStage::kCompute),
              WorkgroupSize("width", "height", "depth"),
@@ -835,7 +866,7 @@ void main() {
 }
 
 TEST_F(GlslGeneratorImplTest_Function, Emit_Function_WithArrayParams) {
-    Func("my_func", ast::VariableList{Param("a", ty.array<f32, 5>())}, ty.void_(),
+    Func("my_func", {Param("a", ty.array<f32, 5>())}, ty.void_(),
          {
              Return(),
          });
@@ -900,23 +931,29 @@ TEST_F(GlslGeneratorImplTest_Function, Emit_Multiple_EntryPoint_With_Same_Module
     {
         auto* var = Var("v", ty.f32(), ast::StorageClass::kNone, MemberAccessor("data", "d"));
 
-        Func("a", ast::VariableList{}, ty.void_(),
+        Func("a", {}, ty.void_(),
              {
                  Decl(var),
                  Return(),
              },
-             {Stage(ast::PipelineStage::kCompute), WorkgroupSize(1_i)});
+             {
+                 Stage(ast::PipelineStage::kCompute),
+                 WorkgroupSize(1_i),
+             });
     }
 
     {
         auto* var = Var("v", ty.f32(), ast::StorageClass::kNone, MemberAccessor("data", "d"));
 
-        Func("b", ast::VariableList{}, ty.void_(),
+        Func("b", {}, ty.void_(),
              {
                  Decl(var),
                  Return(),
              },
-             {Stage(ast::PipelineStage::kCompute), WorkgroupSize(1_i)});
+             {
+                 Stage(ast::PipelineStage::kCompute),
+                 WorkgroupSize(1_i),
+             });
     }
 
     GeneratorImpl& gen = SanitizeAndBuild();

src/tint/writer/glsl/generator_impl_member_accessor_test.cc

@@ -100,8 +100,8 @@ class GlslGeneratorImplTest_MemberAccessorBase : public BASE {
 
     void SetupFunction(ast::StatementList statements) {
         ProgramBuilder& b = *this;
-        b.Func("main", ast::VariableList{}, b.ty.void_(), statements,
+        b.Func("main", {}, b.ty.void_(), statements,
-               ast::AttributeList{
+               {
                    b.Stage(ast::PipelineStage::kFragment),
                });
     }

src/tint/writer/glsl/generator_impl_sanitizer_test.cc

@@ -32,12 +32,12 @@ TEST_F(GlslSanitizerTest, Call_ArrayLength) {
                create<ast::GroupAttribute>(2),
            });
 
-    Func("a_func", ast::VariableList{}, ty.void_(),
+    Func("a_func", {}, ty.void_(),
-         ast::StatementList{
+         {
              Decl(Var("len", ty.u32(), ast::StorageClass::kNone,
                       Call("arrayLength", AddressOf(MemberAccessor("b", "a"))))),
          },
-         ast::AttributeList{
+         {
              Stage(ast::PipelineStage::kFragment),
          });
 
@@ -75,12 +75,12 @@ TEST_F(GlslSanitizerTest, Call_ArrayLength_OtherMembersInStruct) {
                create<ast::GroupAttribute>(2),
            });
 
-    Func("a_func", ast::VariableList{}, ty.void_(),
+    Func("a_func", {}, ty.void_(),
-         ast::StatementList{
+         {
              Decl(Var("len", ty.u32(), ast::StorageClass::kNone,
                       Call("arrayLength", AddressOf(MemberAccessor("b", "a"))))),
          },
-         ast::AttributeList{
+         {
              Stage(ast::PipelineStage::kFragment),
          });
 
@@ -120,13 +120,13 @@ TEST_F(GlslSanitizerTest, Call_ArrayLength_ViaLets) {
     auto* p = Let("p", nullptr, AddressOf("b"));
     auto* p2 = Let("p2", nullptr, AddressOf(MemberAccessor(Deref(p), "a")));
 
-    Func("a_func", ast::VariableList{}, ty.void_(),
+    Func("a_func", {}, ty.void_(),
-         ast::StatementList{
+         {
              Decl(p),
              Decl(p2),
              Decl(Var("len", ty.u32(), ast::StorageClass::kNone, Call("arrayLength", p2))),
          },
-         ast::AttributeList{
+         {
              Stage(ast::PipelineStage::kFragment),
          });
 
@@ -159,7 +159,7 @@ TEST_F(GlslSanitizerTest, PromoteArrayInitializerToConstVar) {
     auto* array_index = IndexAccessor(array_init, 3_i);
     auto* pos = Var("pos", ty.i32(), ast::StorageClass::kNone, array_index);
 
-    Func("main", ast::VariableList{}, ty.void_(),
+    Func("main", {}, ty.void_(),
          {
              Decl(pos),
          },
@@ -198,7 +198,7 @@ TEST_F(GlslSanitizerTest, PromoteStructInitializerToConstVar) {
     auto* struct_access = MemberAccessor(struct_init, "b");
     auto* pos = Var("pos", ty.vec3<f32>(), ast::StorageClass::kNone, struct_access);
 
-    Func("main", ast::VariableList{}, ty.void_(),
+    Func("main", {}, ty.void_(),
          {
              Decl(pos),
          },
@@ -241,7 +241,7 @@ TEST_F(GlslSanitizerTest, InlinePtrLetsBasic) {
     auto* p = Let("p", ty.pointer<i32>(ast::StorageClass::kFunction), AddressOf(v));
     auto* x = Var("x", ty.i32(), ast::StorageClass::kNone, Deref(p));
 
-    Func("main", ast::VariableList{}, ty.void_(),
+    Func("main", {}, ty.void_(),
          {
              Decl(v),
              Decl(p),
@@ -287,7 +287,7 @@ TEST_F(GlslSanitizerTest, InlinePtrLetsComplexChain) {
                    AddressOf(IndexAccessor(Deref(mp), 2_i)));
     auto* v = Var("v", ty.vec4<f32>(), ast::StorageClass::kNone, Deref(vp));
 
-    Func("main", ast::VariableList{}, ty.void_(),
+    Func("main", {}, ty.void_(),
          {
              Decl(a),
              Decl(ap),

src/tint/writer/glsl/generator_impl_test.cc

@@ -29,7 +29,7 @@ TEST_F(GlslGeneratorImplTest, InvalidProgram) {
 }
 
 TEST_F(GlslGeneratorImplTest, Generate) {
-    Func("my_func", ast::VariableList{}, ty.void_(), ast::StatementList{}, ast::AttributeList{});
+    Func("my_func", {}, ty.void_(), {});
 
     GeneratorImpl& gen = Build();
 
@@ -43,7 +43,7 @@ void my_func() {
 }
 
 TEST_F(GlslGeneratorImplTest, GenerateDesktop) {
-    Func("my_func", ast::VariableList{}, ty.void_(), ast::StatementList{}, ast::AttributeList{});
+    Func("my_func", {}, ty.void_(), {});
 
     GeneratorImpl& gen = Build(Version(Version::Standard::kDesktop, 4, 4));
 
@@ -58,10 +58,15 @@ void my_func() {
 
 TEST_F(GlslGeneratorImplTest, GenerateSampleIndexES) {
     Global("gl_SampleID", ty.i32(),
-           ast::AttributeList{Builtin(ast::Builtin::kSampleIndex),
+           ast::AttributeList{
-                              Disable(ast::DisabledValidation::kIgnoreStorageClass)},
+               Builtin(ast::Builtin::kSampleIndex),
+               Disable(ast::DisabledValidation::kIgnoreStorageClass),
+           },
            ast::StorageClass::kInput);
-    Func("my_func", {}, ty.i32(), ast::StatementList{Return(Expr("gl_SampleID"))});
+    Func("my_func", {}, ty.i32(),
+         {
+             Return(Expr("gl_SampleID")),
+         });
 
     GeneratorImpl& gen = Build(Version(Version::Standard::kES, 3, 1));
 
@@ -78,10 +83,15 @@ int my_func() {
 
 TEST_F(GlslGeneratorImplTest, GenerateSampleIndexDesktop) {
     Global("gl_SampleID", ty.i32(),
-           ast::AttributeList{Builtin(ast::Builtin::kSampleIndex),
+           ast::AttributeList{
-                              Disable(ast::DisabledValidation::kIgnoreStorageClass)},
+               Builtin(ast::Builtin::kSampleIndex),
+               Disable(ast::DisabledValidation::kIgnoreStorageClass),
+           },
            ast::StorageClass::kInput);
-    Func("my_func", {}, ty.i32(), ast::StatementList{Return(Expr("gl_SampleID"))});
+    Func("my_func", {}, ty.i32(),
+         {
+             Return(Expr("gl_SampleID")),
+         });
 
     GeneratorImpl& gen = Build(Version(Version::Standard::kDesktop, 4, 4));
 

src/tint/writer/hlsl/generator_impl_function_test.cc

@@ -28,7 +28,7 @@ namespace {
 using HlslGeneratorImplTest_Function = TestHelper;
 
 TEST_F(HlslGeneratorImplTest_Function, Emit_Function) {
-    Func("my_func", ast::VariableList{}, ty.void_(),
+    Func("my_func", {}, ty.void_(),
          {
              Return(),
          });
@@ -45,7 +45,7 @@ TEST_F(HlslGeneratorImplTest_Function, Emit_Function) {
 }
 
 TEST_F(HlslGeneratorImplTest_Function, Emit_Function_Name_Collision) {
-    Func("GeometryShader", ast::VariableList{}, ty.void_(),
+    Func("GeometryShader", {}, ty.void_(),
          {
              Return(),
          });
@@ -61,7 +61,12 @@ TEST_F(HlslGeneratorImplTest_Function, Emit_Function_Name_Collision) {
 }
 
 TEST_F(HlslGeneratorImplTest_Function, Emit_Function_WithParams) {
-    Func("my_func", ast::VariableList{Param("a", ty.f32()), Param("b", ty.i32())}, ty.void_(),
+    Func("my_func",
+         {
+             Param("a", ty.f32()),
+             Param("b", ty.i32()),
+         },
+         ty.void_(),
          {
              Return(),
          });
@@ -78,7 +83,7 @@ TEST_F(HlslGeneratorImplTest_Function, Emit_Function_WithParams) {
 }
 
 TEST_F(HlslGeneratorImplTest_Function, Emit_Attribute_EntryPoint_NoReturn_Void) {
-    Func("main", ast::VariableList{}, ty.void_(), {/* no explicit return */},
+    Func("main", {}, ty.void_(), {/* no explicit return */},
          {
              Stage(ast::PipelineStage::kFragment),
          });
@@ -113,8 +118,16 @@ TEST_F(HlslGeneratorImplTest_Function, Emit_Attribute_EntryPoint_WithInOutVars)
     //   return foo;
     // }
     auto* foo_in = Param("foo", ty.f32(), {Location(0)});
-    Func("frag_main", ast::VariableList{foo_in}, ty.f32(), {Return("foo")},
+    Func("frag_main", {foo_in}, ty.f32(),
-         {Stage(ast::PipelineStage::kFragment)}, {Location(1)});
+         {
+             Return("foo"),
+         },
+         {
+             Stage(ast::PipelineStage::kFragment),
+         },
+         {
+             Location(1),
+         });
 
     GeneratorImpl& gen = SanitizeAndBuild();
 
@@ -144,8 +157,16 @@ TEST_F(HlslGeneratorImplTest_Function, Emit_Attribute_EntryPoint_WithInOut_Built
     //   return coord.x;
     // }
     auto* coord_in = Param("coord", ty.vec4<f32>(), {Builtin(ast::Builtin::kPosition)});
-    Func("frag_main", ast::VariableList{coord_in}, ty.f32(), {Return(MemberAccessor("coord", "x"))},
+    Func("frag_main", {coord_in}, ty.f32(),
-         {Stage(ast::PipelineStage::kFragment)}, {Builtin(ast::Builtin::kFragDepth)});
+         {
+             Return(MemberAccessor("coord", "x")),
+         },
+         {
+             Stage(ast::PipelineStage::kFragment),
+         },
+         {
+             Builtin(ast::Builtin::kFragDepth),
+         });
 
     GeneratorImpl& gen = SanitizeAndBuild();
 
@@ -381,7 +402,7 @@ TEST_F(HlslGeneratorImplTest_Function, Emit_Attribute_EntryPoint_With_UniformStr
     auto* var = Var("v", ty.f32(), ast::StorageClass::kNone,
                     MemberAccessor(MemberAccessor("uniforms", "coord"), "x"));
 
-    Func("frag_main", ast::VariableList{}, ty.void_(),
+    Func("frag_main", {}, ty.void_(),
          {
              Decl(var),
              Return(),
@@ -418,7 +439,7 @@ TEST_F(HlslGeneratorImplTest_Function, Emit_Attribute_EntryPoint_With_RW_Storage
 
     auto* var = Var("v", ty.f32(), ast::StorageClass::kNone, MemberAccessor("coord", "b"));
 
-    Func("frag_main", ast::VariableList{}, ty.void_(),
+    Func("frag_main", {}, ty.void_(),
          {
              Decl(var),
              Return(),
@@ -454,7 +475,7 @@ TEST_F(HlslGeneratorImplTest_Function, Emit_Attribute_EntryPoint_With_RO_Storage
 
     auto* var = Var("v", ty.f32(), ast::StorageClass::kNone, MemberAccessor("coord", "b"));
 
-    Func("frag_main", ast::VariableList{}, ty.void_(),
+    Func("frag_main", {}, ty.void_(),
          {
              Decl(var),
              Return(),
@@ -488,7 +509,7 @@ TEST_F(HlslGeneratorImplTest_Function, Emit_Attribute_EntryPoint_With_WO_Storage
                create<ast::GroupAttribute>(1),
            });
 
-    Func("frag_main", ast::VariableList{}, ty.void_(),
+    Func("frag_main", {}, ty.void_(),
          {
              Assign(MemberAccessor("coord", "b"), Expr(2_f)),
              Return(),
@@ -522,7 +543,7 @@ TEST_F(HlslGeneratorImplTest_Function, Emit_Attribute_EntryPoint_With_StorageBuf
                create<ast::GroupAttribute>(1),
            });
 
-    Func("frag_main", ast::VariableList{}, ty.void_(),
+    Func("frag_main", {}, ty.void_(),
          {
              Assign(MemberAccessor("coord", "b"), Expr(2_f)),
              Return(),
@@ -552,14 +573,18 @@ TEST_F(HlslGeneratorImplTest_Function, Emit_Attribute_Called_By_EntryPoint_With_
                create<ast::GroupAttribute>(1),
            });
 
-    Func("sub_func", ast::VariableList{Param("param", ty.f32())}, ty.f32(),
+    Func("sub_func",
+         {
+             Param("param", ty.f32()),
+         },
+         ty.f32(),
          {
              Return(MemberAccessor("coord", "x")),
          });
 
     auto* var = Var("v", ty.f32(), ast::StorageClass::kNone, Call("sub_func", 1_f));
 
-    Func("frag_main", ast::VariableList{}, ty.void_(),
+    Func("frag_main", {}, ty.void_(),
          {
              Decl(var),
              Return(),
@@ -594,14 +619,18 @@ TEST_F(HlslGeneratorImplTest_Function, Emit_Attribute_Called_By_EntryPoint_With_
                create<ast::GroupAttribute>(1),
            });
 
-    Func("sub_func", ast::VariableList{Param("param", ty.f32())}, ty.f32(),
+    Func("sub_func",
+         {
+             Param("param", ty.f32()),
+         },
+         ty.f32(),
          {
              Return(MemberAccessor("coord", "x")),
          });
 
     auto* var = Var("v", ty.f32(), ast::StorageClass::kNone, Call("sub_func", 1_f));
 
-    Func("frag_main", ast::VariableList{}, ty.void_(),
+    Func("frag_main", {}, ty.void_(),
          {
              Decl(var),
              Return(),
@@ -628,7 +657,7 @@ void frag_main() {
 }
 
 TEST_F(HlslGeneratorImplTest_Function, Emit_Attribute_EntryPoint_WithNameCollision) {
-    Func("GeometryShader", ast::VariableList{}, ty.void_(), {},
+    Func("GeometryShader", {}, ty.void_(), {},
          {
              Stage(ast::PipelineStage::kFragment),
          });
@@ -643,7 +672,7 @@ TEST_F(HlslGeneratorImplTest_Function, Emit_Attribute_EntryPoint_WithNameCollisi
 }
 
 TEST_F(HlslGeneratorImplTest_Function, Emit_Attribute_EntryPoint_Compute) {
-    Func("main", ast::VariableList{}, ty.void_(),
+    Func("main", {}, ty.void_(),
          {
              Return(),
          },
@@ -660,7 +689,7 @@ void main() {
 }
 
 TEST_F(HlslGeneratorImplTest_Function, Emit_Attribute_EntryPoint_Compute_WithWorkgroup_Literal) {
-    Func("main", ast::VariableList{}, ty.void_(), {},
+    Func("main", {}, ty.void_(), {},
          {
              Stage(ast::PipelineStage::kCompute),
              WorkgroupSize(2_i, 4_i, 6_i),
@@ -680,7 +709,7 @@ TEST_F(HlslGeneratorImplTest_Function, Emit_Attribute_EntryPoint_Compute_WithWor
     GlobalConst("width", ty.i32(), Construct(ty.i32(), 2_i));
     GlobalConst("height", ty.i32(), Construct(ty.i32(), 3_i));
     GlobalConst("depth", ty.i32(), Construct(ty.i32(), 4_i));
-    Func("main", ast::VariableList{}, ty.void_(), {},
+    Func("main", {}, ty.void_(), {},
          {
              Stage(ast::PipelineStage::kCompute),
              WorkgroupSize("width", "height", "depth"),
@@ -705,7 +734,7 @@ TEST_F(HlslGeneratorImplTest_Function,
     Override("width", ty.i32(), Construct(ty.i32(), 2_i), {Id(7u)});
     Override("height", ty.i32(), Construct(ty.i32(), 3_i), {Id(8u)});
     Override("depth", ty.i32(), Construct(ty.i32(), 4_i), {Id(9u)});
-    Func("main", ast::VariableList{}, ty.void_(), {},
+    Func("main", {}, ty.void_(), {},
          {
              Stage(ast::PipelineStage::kCompute),
              WorkgroupSize("width", "height", "depth"),
@@ -735,7 +764,11 @@ void main() {
 }
 
 TEST_F(HlslGeneratorImplTest_Function, Emit_Function_WithArrayParams) {
-    Func("my_func", ast::VariableList{Param("a", ty.array<f32, 5>())}, ty.void_(),
+    Func("my_func",
+         {
+             Param("a", ty.array<f32, 5>()),
+         },
+         ty.void_(),
          {
              Return(),
          });
@@ -839,23 +872,29 @@ TEST_F(HlslGeneratorImplTest_Function, Emit_Multiple_EntryPoint_With_Same_Module
     {
         auto* var = Var("v", ty.f32(), ast::StorageClass::kNone, MemberAccessor("data", "d"));
 
-        Func("a", ast::VariableList{}, ty.void_(),
+        Func("a", {}, ty.void_(),
              {
                  Decl(var),
                  Return(),
              },
-             {Stage(ast::PipelineStage::kCompute), WorkgroupSize(1_i)});
+             {
+                 Stage(ast::PipelineStage::kCompute),
+                 WorkgroupSize(1_i),
+             });
     }
 
     {
         auto* var = Var("v", ty.f32(), ast::StorageClass::kNone, MemberAccessor("data", "d"));
 
-        Func("b", ast::VariableList{}, ty.void_(),
+        Func("b", {}, ty.void_(),
              {
                  Decl(var),
                  Return(),
              },
-             {Stage(ast::PipelineStage::kCompute), WorkgroupSize(1_i)});
+             {
+                 Stage(ast::PipelineStage::kCompute),
+                 WorkgroupSize(1_i),
+             });
     }
 
     GeneratorImpl& gen = SanitizeAndBuild();

src/tint/writer/hlsl/generator_impl_member_accessor_test.cc

@@ -100,8 +100,8 @@ class HlslGeneratorImplTest_MemberAccessorBase : public BASE {
 
     void SetupFunction(ast::StatementList statements) {
         ProgramBuilder& b = *this;
-        b.Func("main", ast::VariableList{}, b.ty.void_(), statements,
+        b.Func("main", {}, b.ty.void_(), statements,
-               ast::AttributeList{
+               {
                    b.Stage(ast::PipelineStage::kFragment),
                });
     }

src/tint/writer/hlsl/generator_impl_sanitizer_test.cc

@@ -32,12 +32,12 @@ TEST_F(HlslSanitizerTest, Call_ArrayLength) {
                create<ast::GroupAttribute>(2),
            });
 
-    Func("a_func", ast::VariableList{}, ty.void_(),
+    Func("a_func", {}, ty.void_(),
-         ast::StatementList{
+         {
              Decl(Var("len", ty.u32(), ast::StorageClass::kNone,
                       Call("arrayLength", AddressOf(MemberAccessor("b", "a"))))),
          },
-         ast::AttributeList{
+         {
              Stage(ast::PipelineStage::kFragment),
          });
 
@@ -70,12 +70,12 @@ TEST_F(HlslSanitizerTest, Call_ArrayLength_OtherMembersInStruct) {
                create<ast::GroupAttribute>(2),
            });
 
-    Func("a_func", ast::VariableList{}, ty.void_(),
+    Func("a_func", {}, ty.void_(),
-         ast::StatementList{
+         {
              Decl(Var("len", ty.u32(), ast::StorageClass::kNone,
                       Call("arrayLength", AddressOf(MemberAccessor("b", "a"))))),
          },
-         ast::AttributeList{
+         {
              Stage(ast::PipelineStage::kFragment),
          });
 
@@ -109,13 +109,13 @@ TEST_F(HlslSanitizerTest, Call_ArrayLength_ViaLets) {
     auto* p = Let("p", nullptr, AddressOf("b"));
     auto* p2 = Let("p2", nullptr, AddressOf(MemberAccessor(Deref(p), "a")));
 
-    Func("a_func", ast::VariableList{}, ty.void_(),
+    Func("a_func", {}, ty.void_(),
-         ast::StatementList{
+         {
              Decl(p),
              Decl(p2),
              Decl(Var("len", ty.u32(), ast::StorageClass::kNone, Call("arrayLength", p2))),
          },
-         ast::AttributeList{
+         {
              Stage(ast::PipelineStage::kFragment),
          });
 
@@ -151,13 +151,13 @@ TEST_F(HlslSanitizerTest, Call_ArrayLength_ArrayLengthFromUniform) {
                create<ast::GroupAttribute>(2),
            });
 
-    Func("a_func", ast::VariableList{}, ty.void_(),
+    Func("a_func", {}, ty.void_(),
-         ast::StatementList{
+         {
              Decl(Var("len", ty.u32(), ast::StorageClass::kNone,
                       Add(Call("arrayLength", AddressOf(MemberAccessor("b", "a"))),
                           Call("arrayLength", AddressOf(MemberAccessor("c", "a")))))),
          },
-         ast::AttributeList{
+         {
              Stage(ast::PipelineStage::kFragment),
          });
 
@@ -191,7 +191,7 @@ TEST_F(HlslSanitizerTest, PromoteArrayInitializerToConstVar) {
     auto* array_index = IndexAccessor(array_init, 3_i);
     auto* pos = Var("pos", ty.i32(), ast::StorageClass::kNone, array_index);
 
-    Func("main", ast::VariableList{}, ty.void_(),
+    Func("main", {}, ty.void_(),
          {
              Decl(pos),
          },
@@ -223,7 +223,7 @@ TEST_F(HlslSanitizerTest, PromoteStructInitializerToConstVar) {
     auto* struct_access = MemberAccessor(struct_init, "b");
     auto* pos = Var("pos", ty.vec3<f32>(), ast::StorageClass::kNone, struct_access);
 
-    Func("main", ast::VariableList{}, ty.void_(),
+    Func("main", {}, ty.void_(),
          {
              Decl(pos),
          },
@@ -259,7 +259,7 @@ TEST_F(HlslSanitizerTest, InlinePtrLetsBasic) {
     auto* p = Let("p", ty.pointer<i32>(ast::StorageClass::kFunction), AddressOf(v));
     auto* x = Var("x", ty.i32(), ast::StorageClass::kNone, Deref(p));
 
-    Func("main", ast::VariableList{}, ty.void_(),
+    Func("main", {}, ty.void_(),
          {
              Decl(v),
              Decl(p),
@@ -298,7 +298,7 @@ TEST_F(HlslSanitizerTest, InlinePtrLetsComplexChain) {
                    AddressOf(IndexAccessor(Deref(mp), 2_i)));
     auto* v = Var("v", ty.vec4<f32>(), ast::StorageClass::kNone, Deref(vp));
 
-    Func("main", ast::VariableList{}, ty.void_(),
+    Func("main", {}, ty.void_(),
          {
              Decl(a),
              Decl(ap),

src/tint/writer/hlsl/generator_impl_test.cc

@@ -29,7 +29,7 @@ TEST_F(HlslGeneratorImplTest, InvalidProgram) {
 }
 
 TEST_F(HlslGeneratorImplTest, Generate) {
-    Func("my_func", ast::VariableList{}, ty.void_(), ast::StatementList{}, ast::AttributeList{});
+    Func("my_func", {}, ty.void_(), {});
 
     GeneratorImpl& gen = Build();
 

src/tint/writer/msl/generator_impl_function_test.cc

@@ -24,11 +24,10 @@ namespace {
 using MslGeneratorImplTest = TestHelper;
 
 TEST_F(MslGeneratorImplTest, Emit_Function) {
-    Func("my_func", ast::VariableList{}, ty.void_(),
+    Func("my_func", {}, ty.void_(),
-         ast::StatementList{
+         {
              Return(),
-         },
+         });
-         {});
 
     GeneratorImpl& gen = Build();
 
@@ -46,15 +45,15 @@ TEST_F(MslGeneratorImplTest, Emit_Function) {
 }
 
 TEST_F(MslGeneratorImplTest, Emit_Function_WithParams) {
-    ast::VariableList params;
+    Func("my_func",
-    params.push_back(Param("a", ty.f32()));
+         {
-    params.push_back(Param("b", ty.i32()));
+             Param("a", ty.f32()),
-
+             Param("b", ty.i32()),
-    Func("my_func", params, ty.void_(),
-         ast::StatementList{
-             Return(),
          },
-         {});
+         ty.void_(),
+         {
+             Return(),
+         });
 
     GeneratorImpl& gen = Build();
 
@@ -72,7 +71,7 @@ TEST_F(MslGeneratorImplTest, Emit_Function_WithParams) {
 }
 
 TEST_F(MslGeneratorImplTest, Emit_Attribute_EntryPoint_NoReturn_Void) {
-    Func("main", ast::VariableList{}, ty.void_(), ast::StatementList{/* no explicit return */},
+    Func("main", {}, ty.void_(), {/* no explicit return */},
          {Stage(ast::PipelineStage::kFragment)});
 
     GeneratorImpl& gen = Build();
@@ -93,8 +92,16 @@ TEST_F(MslGeneratorImplTest, Emit_Attribute_EntryPoint_WithInOutVars) {
     //   return foo;
     // }
     auto* foo_in = Param("foo", ty.f32(), {Location(0)});
-    Func("frag_main", ast::VariableList{foo_in}, ty.f32(), {Return("foo")},
+    Func("frag_main", {foo_in}, ty.f32(),
-         {Stage(ast::PipelineStage::kFragment)}, {Location(1)});
+         {
+             Return("foo"),
+         },
+         {
+             Stage(ast::PipelineStage::kFragment),
+         },
+         {
+             Location(1),
+         });
 
     GeneratorImpl& gen = SanitizeAndBuild();
 
@@ -129,8 +136,16 @@ TEST_F(MslGeneratorImplTest, Emit_Attribute_EntryPoint_WithInOut_Builtins) {
     //   return coord.x;
     // }
     auto* coord_in = Param("coord", ty.vec4<f32>(), {Builtin(ast::Builtin::kPosition)});
-    Func("frag_main", ast::VariableList{coord_in}, ty.f32(), {Return(MemberAccessor("coord", "x"))},
+    Func("frag_main", {coord_in}, ty.f32(),
-         {Stage(ast::PipelineStage::kFragment)}, {Builtin(ast::Builtin::kFragDepth)});
+         {
+             Return(MemberAccessor("coord", "x")),
+         },
+         {
+             Stage(ast::PipelineStage::kFragment),
+         },
+         {
+             Builtin(ast::Builtin::kFragDepth),
+         });
 
     GeneratorImpl& gen = SanitizeAndBuild();
 
@@ -256,10 +271,10 @@ TEST_F(MslGeneratorImplTest, Emit_Attribute_EntryPoint_SharedStruct_HelperFuncti
         "VertexOutput", {Member("pos", ty.vec4<f32>(), {Builtin(ast::Builtin::kPosition)})});
 
     Func("foo", {Param("x", ty.f32())}, ty.Of(vertex_output_struct),
-         {Return(Construct(ty.Of(vertex_output_struct),
+         {
-                           Construct(ty.vec4<f32>(), "x", "x", "x", Expr(1_f))))},
+             Return(Construct(ty.Of(vertex_output_struct),
-         {});
+                              Construct(ty.vec4<f32>(), "x", "x", "x", Expr(1_f)))),
-
+         });
     Func("vert_main1", {}, ty.Of(vertex_output_struct), {Return(Expr(Call("foo", Expr(0.5_f))))},
          {Stage(ast::PipelineStage::kVertex)});
 
@@ -328,8 +343,8 @@ TEST_F(MslGeneratorImplTest, Emit_FunctionAttribute_EntryPoint_With_RW_StorageBu
 
     auto* var = Var("v", ty.f32(), ast::StorageClass::kNone, MemberAccessor("coord", "b"));
 
-    Func("frag_main", ast::VariableList{}, ty.void_(),
+    Func("frag_main", {}, ty.void_(),
-         ast::StatementList{
+         {
              Decl(var),
              Return(),
          },
@@ -370,8 +385,8 @@ TEST_F(MslGeneratorImplTest, Emit_FunctionAttribute_EntryPoint_With_RO_StorageBu
 
     auto* var = Var("v", ty.f32(), ast::StorageClass::kNone, MemberAccessor("coord", "b"));
 
-    Func("frag_main", ast::VariableList{}, ty.void_(),
+    Func("frag_main", {}, ty.void_(),
-         ast::StatementList{
+         {
              Decl(var),
              Return(),
          },
@@ -460,17 +475,19 @@ TEST_F(MslGeneratorImplTest, Emit_FunctionAttribute_Called_By_EntryPoint_With_RW
                create<ast::GroupAttribute>(0),
            });
 
-    ast::VariableList params;
+    Func("sub_func",
-    params.push_back(Param("param", ty.f32()));
+         {
-
+             Param("param", ty.f32()),
-    auto body = ast::StatementList{Return(MemberAccessor("coord", "b"))};
+         },
-
+         ty.f32(),
-    Func("sub_func", params, ty.f32(), body, {});
+         {
+             Return(MemberAccessor("coord", "b")),
+         });
 
     auto* var = Var("v", ty.f32(), ast::StorageClass::kNone, Call("sub_func", 1_f));
 
-    Func("frag_main", ast::VariableList{}, ty.void_(),
+    Func("frag_main", {}, ty.void_(),
-         ast::StatementList{
+         {
              Decl(var),
              Return(),
          },
@@ -513,17 +530,19 @@ TEST_F(MslGeneratorImplTest, Emit_FunctionAttribute_Called_By_EntryPoint_With_RO
                create<ast::GroupAttribute>(0),
            });
 
-    ast::VariableList params;
+    Func("sub_func",
-    params.push_back(Param("param", ty.f32()));
+         {
-
+             Param("param", ty.f32()),
-    auto body = ast::StatementList{Return(MemberAccessor("coord", "b"))};
+         },
-
+         ty.f32(),
-    Func("sub_func", params, ty.f32(), body, {});
+         {
+             Return(MemberAccessor("coord", "b")),
+         });
 
     auto* var = Var("v", ty.f32(), ast::StorageClass::kNone, Call("sub_func", 1_f));
 
-    Func("frag_main", ast::VariableList{}, ty.void_(),
+    Func("frag_main", {}, ty.void_(),
-         ast::StatementList{
+         {
              Decl(var),
              Return(),
          },
@@ -555,10 +574,11 @@ fragment void frag_main(const device Data* tint_symbol_1 [[buffer(0)]]) {
 }
 
 TEST_F(MslGeneratorImplTest, Emit_Function_WithArrayParams) {
-    ast::VariableList params;
+    Func("my_func",
-    params.push_back(Param("a", ty.array<f32, 5>()));
+         {
-
+             Param("a", ty.array<f32, 5>()),
-    Func("my_func", params, ty.void_(),
+         },
+         ty.void_(),
          {
              Return(),
          });
@@ -636,8 +656,8 @@ TEST_F(MslGeneratorImplTest, Emit_Function_Multiple_EntryPoint_With_Same_ModuleV
     {
         auto* var = Var("v", ty.f32(), ast::StorageClass::kNone, MemberAccessor("data", "d"));
 
-        Func("a", ast::VariableList{}, ty.void_(),
+        Func("a", {}, ty.void_(),
-             ast::StatementList{
+             {
                  Decl(var),
                  Return(),
              },
@@ -650,7 +670,7 @@ TEST_F(MslGeneratorImplTest, Emit_Function_Multiple_EntryPoint_With_Same_ModuleV
     {
         auto* var = Var("v", ty.f32(), ast::StorageClass::kNone, MemberAccessor("data", "d"));
 
-        Func("b", ast::VariableList{}, ty.void_(), ast::StatementList{Decl(var), Return()},
+        Func("b", {}, ty.void_(), {Decl(var), Return()},
              {
                  Stage(ast::PipelineStage::kCompute),
                  WorkgroupSize(1_i),

src/tint/writer/msl/generator_impl_sanitizer_test.cc

@@ -33,12 +33,12 @@ TEST_F(MslSanitizerTest, Call_ArrayLength) {
                create<ast::GroupAttribute>(2),
            });
 
-    Func("a_func", ast::VariableList{}, ty.void_(),
+    Func("a_func", {}, ty.void_(),
-         ast::StatementList{
+         {
              Decl(Var("len", ty.u32(), ast::StorageClass::kNone,
                       Call("arrayLength", AddressOf(MemberAccessor("b", "a"))))),
          },
-         ast::AttributeList{
+         {
              Stage(ast::PipelineStage::kFragment),
          });
 
@@ -78,12 +78,12 @@ TEST_F(MslSanitizerTest, Call_ArrayLength_OtherMembersInStruct) {
                create<ast::GroupAttribute>(2),
            });
 
-    Func("a_func", ast::VariableList{}, ty.void_(),
+    Func("a_func", {}, ty.void_(),
-         ast::StatementList{
+         {
              Decl(Var("len", ty.u32(), ast::StorageClass::kNone,
                       Call("arrayLength", AddressOf(MemberAccessor("b", "a"))))),
          },
-         ast::AttributeList{
+         {
              Stage(ast::PipelineStage::kFragment),
          });
 
@@ -125,13 +125,13 @@ TEST_F(MslSanitizerTest, Call_ArrayLength_ViaLets) {
     auto* p = Let("p", nullptr, AddressOf("b"));
     auto* p2 = Let("p2", nullptr, AddressOf(MemberAccessor(Deref(p), "a")));
 
-    Func("a_func", ast::VariableList{}, ty.void_(),
+    Func("a_func", {}, ty.void_(),
-         ast::StatementList{
+         {
              Decl(p),
              Decl(p2),
              Decl(Var("len", ty.u32(), ast::StorageClass::kNone, Call("arrayLength", p2))),
          },
-         ast::AttributeList{
+         {
              Stage(ast::PipelineStage::kFragment),
          });
 
@@ -174,13 +174,13 @@ TEST_F(MslSanitizerTest, Call_ArrayLength_ArrayLengthFromUniform) {
                create<ast::GroupAttribute>(0),
            });
 
-    Func("a_func", ast::VariableList{}, ty.void_(),
+    Func("a_func", {}, ty.void_(),
-         ast::StatementList{
+         {
              Decl(Var("len", ty.u32(), ast::StorageClass::kNone,
                       Add(Call("arrayLength", AddressOf(MemberAccessor("b", "a"))),
                           Call("arrayLength", AddressOf(MemberAccessor("c", "a")))))),
          },
-         ast::AttributeList{
+         {
              Stage(ast::PipelineStage::kFragment),
          });
 
@@ -226,13 +226,13 @@ TEST_F(MslSanitizerTest, Call_ArrayLength_ArrayLengthFromUniformMissingBinding)
                create<ast::GroupAttribute>(0),
            });
 
-    Func("a_func", ast::VariableList{}, ty.void_(),
+    Func("a_func", {}, ty.void_(),
-         ast::StatementList{
+         {
              Decl(Var("len", ty.u32(), ast::StorageClass::kNone,
                       Add(Call("arrayLength", AddressOf(MemberAccessor("b", "a"))),
                           Call("arrayLength", AddressOf(MemberAccessor("c", "a")))))),
          },
-         ast::AttributeList{
+         {
              Stage(ast::PipelineStage::kFragment),
          });
 

src/tint/writer/msl/generator_impl_test.cc

@@ -32,8 +32,8 @@ TEST_F(MslGeneratorImplTest, InvalidProgram) {
 }
 
 TEST_F(MslGeneratorImplTest, Generate) {
-    Func("my_func", ast::VariableList{}, ty.void_(), ast::StatementList{},
+    Func("my_func", {}, ty.void_(), {},
-         ast::AttributeList{
+         {
              Stage(ast::PipelineStage::kCompute),
              WorkgroupSize(1_i),
          });
@@ -88,7 +88,7 @@ INSTANTIATE_TEST_SUITE_P(
 TEST_F(MslGeneratorImplTest, HasInvariantAttribute_True) {
     auto* out = Structure(
         "Out", {Member("pos", ty.vec4<f32>(), {Builtin(ast::Builtin::kPosition), Invariant()})});
-    Func("vert_main", ast::VariableList{}, ty.Of(out), {Return(Construct(ty.Of(out)))},
+    Func("vert_main", {}, ty.Of(out), {Return(Construct(ty.Of(out)))},
          {Stage(ast::PipelineStage::kVertex)});
 
     GeneratorImpl& gen = Build();
@@ -119,7 +119,7 @@ vertex Out vert_main() {
 TEST_F(MslGeneratorImplTest, HasInvariantAttribute_False) {
     auto* out =
         Structure("Out", {Member("pos", ty.vec4<f32>(), {Builtin(ast::Builtin::kPosition)})});
-    Func("vert_main", ast::VariableList{}, ty.Of(out), {Return(Construct(ty.Of(out)))},
+    Func("vert_main", {}, ty.Of(out), {Return(Construct(ty.Of(out)))},
          {Stage(ast::PipelineStage::kVertex)});
 
     GeneratorImpl& gen = Build();
@@ -142,7 +142,7 @@ vertex Out vert_main() {
 
 TEST_F(MslGeneratorImplTest, WorkgroupMatrix) {
     Global("m", ty.mat2x2<f32>(), ast::StorageClass::kWorkgroup);
-    Func("comp_main", ast::VariableList{}, ty.void_(), {Decl(Let("x", nullptr, Expr("m")))},
+    Func("comp_main", {}, ty.void_(), {Decl(Let("x", nullptr, Expr("m")))},
          {Stage(ast::PipelineStage::kCompute), WorkgroupSize(1_i)});
 
     GeneratorImpl& gen = SanitizeAndBuild();
@@ -179,7 +179,7 @@ kernel void comp_main(threadgroup tint_symbol_3* tint_symbol_2 [[threadgroup(0)]
 
 TEST_F(MslGeneratorImplTest, WorkgroupMatrixInArray) {
     Global("m", ty.array(ty.mat2x2<f32>(), 4_i), ast::StorageClass::kWorkgroup);
-    Func("comp_main", ast::VariableList{}, ty.void_(), {Decl(Let("x", nullptr, Expr("m")))},
+    Func("comp_main", {}, ty.void_(), {Decl(Let("x", nullptr, Expr("m")))},
          {Stage(ast::PipelineStage::kCompute), WorkgroupSize(1_i)});
 
     GeneratorImpl& gen = SanitizeAndBuild();
@@ -228,7 +228,7 @@ TEST_F(MslGeneratorImplTest, WorkgroupMatrixInStruct) {
                         Member("s", ty.type_name("S1")),
                     });
     Global("s", ty.type_name("S2"), ast::StorageClass::kWorkgroup);
-    Func("comp_main", ast::VariableList{}, ty.void_(), {Decl(Let("x", nullptr, Expr("s")))},
+    Func("comp_main", {}, ty.void_(), {Decl(Let("x", nullptr, Expr("s")))},
          {Stage(ast::PipelineStage::kCompute), WorkgroupSize(1_i)});
 
     GeneratorImpl& gen = SanitizeAndBuild();
@@ -283,28 +283,28 @@ TEST_F(MslGeneratorImplTest, WorkgroupMatrix_Multiples) {
     Global("m7", ty.mat4x2<f32>(), ast::StorageClass::kWorkgroup);
     Global("m8", ty.mat4x3<f32>(), ast::StorageClass::kWorkgroup);
     Global("m9", ty.mat4x4<f32>(), ast::StorageClass::kWorkgroup);
-    Func("main1", ast::VariableList{}, ty.void_(),
+    Func("main1", {}, ty.void_(),
          {
              Decl(Let("a1", nullptr, Expr("m1"))),
              Decl(Let("a2", nullptr, Expr("m2"))),
              Decl(Let("a3", nullptr, Expr("m3"))),
          },
          {Stage(ast::PipelineStage::kCompute), WorkgroupSize(1_i)});
-    Func("main2", ast::VariableList{}, ty.void_(),
+    Func("main2", {}, ty.void_(),
          {
              Decl(Let("a1", nullptr, Expr("m4"))),
              Decl(Let("a2", nullptr, Expr("m5"))),
              Decl(Let("a3", nullptr, Expr("m6"))),
          },
          {Stage(ast::PipelineStage::kCompute), WorkgroupSize(1_i)});
-    Func("main3", ast::VariableList{}, ty.void_(),
+    Func("main3", {}, ty.void_(),
          {
              Decl(Let("a1", nullptr, Expr("m7"))),
              Decl(Let("a2", nullptr, Expr("m8"))),
              Decl(Let("a3", nullptr, Expr("m9"))),
          },
          {Stage(ast::PipelineStage::kCompute), WorkgroupSize(1_i)});
-    Func("main4_no_usages", ast::VariableList{}, ty.void_(), {},
+    Func("main4_no_usages", {}, ty.void_(), {},
          {Stage(ast::PipelineStage::kCompute), WorkgroupSize(1_i)});
 
     GeneratorImpl& gen = SanitizeAndBuild();

src/tint/writer/spirv/builder_call_test.cc

@@ -25,11 +25,12 @@ namespace {
 using BuilderTest = TestHelper;
 
 TEST_F(BuilderTest, Expression_Call) {
-    ast::VariableList func_params;
+    auto* a_func = Func("a_func",
-    func_params.push_back(Param("a", ty.f32()));
+                        {
-    func_params.push_back(Param("b", ty.f32()));
+                            Param("a", ty.f32()),
-
+                            Param("b", ty.f32()),
-    auto* a_func = Func("a_func", func_params, ty.f32(), {Return(Add("a", "b"))});
+                        },
+                        ty.f32(), {Return(Add("a", "b"))});
     auto* func = Func("main", {}, ty.void_(), {Assign(Phony(), Call("a_func", 1_f, 1_f))});
 
     spirv::Builder& b = Build();
@@ -62,11 +63,12 @@ OpFunctionEnd
 }
 
 TEST_F(BuilderTest, Statement_Call) {
-    ast::VariableList func_params;
+    auto* a_func = Func("a_func",
-    func_params.push_back(Param("a", ty.f32()));
+                        {
-    func_params.push_back(Param("b", ty.f32()));
+                            Param("a", ty.f32()),
-
+                            Param("b", ty.f32()),
-    auto* a_func = Func("a_func", func_params, ty.f32(), {Return(Add("a", "b"))});
+                        },
+                        ty.f32(), {Return(Add("a", "b"))});
 
     auto* func = Func("main", {}, ty.void_(), {CallStmt(Call("a_func", 1_f, 1_f))});
 

src/tint/writer/spirv/builder_entry_point_test.cc

@@ -46,9 +46,8 @@ TEST_F(BuilderTest, EntryPoint_Parameters) {
     auto* loc1 = Param("loc1", ty.f32(), {Location(1u)});
     auto* mul = Mul(Expr(MemberAccessor("coord", "x")), Expr("loc1"));
     auto* col = Var("col", ty.f32(), ast::StorageClass::kNone, mul);
-    Func("frag_main", ast::VariableList{coord, loc1}, ty.void_(),
+    Func("frag_main", {coord, loc1}, ty.void_(), {WrapInStatement(col)},
-         ast::StatementList{WrapInStatement(col)},
+         {
-         ast::AttributeList{
              Stage(ast::PipelineStage::kFragment),
          });
 
@@ -116,15 +115,15 @@ TEST_F(BuilderTest, EntryPoint_ReturnValue) {
     auto* loc_in = Param("loc_in", ty.u32(), {Location(0), Flat()});
     auto* cond =
         create<ast::BinaryExpression>(ast::BinaryOp::kGreaterThan, Expr("loc_in"), Expr(10_u));
-    Func("frag_main", ast::VariableList{loc_in}, ty.f32(),
+    Func("frag_main", {loc_in}, ty.f32(),
-         ast::StatementList{
+         {
              If(cond, Block(Return(0.5_f))),
              Return(1_f),
          },
-         ast::AttributeList{
+         {
              Stage(ast::PipelineStage::kFragment),
          },
-         ast::AttributeList{Location(0)});
+         {Location(0)});
 
     spirv::Builder& b = SanitizeAndBuild();
 
@@ -198,20 +197,21 @@ TEST_F(BuilderTest, EntryPoint_SharedStruct) {
     // }
 
     auto* interface = Structure(
-        "Interface",
+        "Interface", {
-        {
+                         Member("value", ty.f32(), {Location(1u)}),
-            Member("value", ty.f32(), ast::AttributeList{Location(1u)}),
+                         Member("pos", ty.vec4<f32>(), {Builtin(ast::Builtin::kPosition)}),
-            Member("pos", ty.vec4<f32>(), ast::AttributeList{Builtin(ast::Builtin::kPosition)}),
+                     });
-        });
 
     auto* vert_retval = Construct(ty.Of(interface), 42_f, Construct(ty.vec4<f32>()));
-    Func("vert_main", ast::VariableList{}, ty.Of(interface), {Return(vert_retval)},
+    Func("vert_main", {}, ty.Of(interface), {Return(vert_retval)},
          {Stage(ast::PipelineStage::kVertex)});
 
     auto* frag_inputs = Param("inputs", ty.Of(interface));
-    Func("frag_main", ast::VariableList{frag_inputs}, ty.f32(),
+    Func("frag_main", {frag_inputs}, ty.f32(),
-         {Return(MemberAccessor(Expr("inputs"), "value"))}, {Stage(ast::PipelineStage::kFragment)},
+         {
-         {Builtin(ast::Builtin::kFragDepth)});
+             Return(MemberAccessor(Expr("inputs"), "value")),
+         },
+         {Stage(ast::PipelineStage::kFragment)}, {Builtin(ast::Builtin::kFragDepth)});
 
     spirv::Builder& b = SanitizeAndBuild();
 

src/tint/writer/spirv/builder_function_attribute_test.cc

@@ -25,8 +25,8 @@ namespace {
 using BuilderTest = TestHelper;
 
 TEST_F(BuilderTest, Attribute_Stage) {
-    auto* func = Func("main", {}, ty.void_(), ast::StatementList{},
+    auto* func = Func("main", {}, ty.void_(), {},
-                      ast::AttributeList{
+                      {
                           Stage(ast::PipelineStage::kFragment),
                       });
 
@@ -91,8 +91,8 @@ INSTANTIATE_TEST_SUITE_P(
                     FunctionStageData{ast::PipelineStage::kCompute, SpvExecutionModelGLCompute}));
 
 TEST_F(BuilderTest, Decoration_ExecutionMode_Fragment_OriginUpperLeft) {
-    auto* func = Func("main", {}, ty.void_(), ast::StatementList{},
+    auto* func = Func("main", {}, ty.void_(), {},
-                      ast::AttributeList{
+                      {
                           Stage(ast::PipelineStage::kFragment),
                       });
 
@@ -105,8 +105,8 @@ TEST_F(BuilderTest, Decoration_ExecutionMode_Fragment_OriginUpperLeft) {
 }
 
 TEST_F(BuilderTest, Decoration_ExecutionMode_WorkgroupSize_Default) {
-    auto* func = Func("main", {}, ty.void_(), ast::StatementList{},
+    auto* func =
-                      ast::AttributeList{Stage(ast::PipelineStage::kCompute), WorkgroupSize(1_i)});
+        Func("main", {}, ty.void_(), {}, {Stage(ast::PipelineStage::kCompute), WorkgroupSize(1_i)});
 
     spirv::Builder& b = Build();
 
@@ -117,8 +117,8 @@ TEST_F(BuilderTest, Decoration_ExecutionMode_WorkgroupSize_Default) {
 }
 
 TEST_F(BuilderTest, Decoration_ExecutionMode_WorkgroupSize_Literals) {
-    auto* func = Func("main", {}, ty.void_(), ast::StatementList{},
+    auto* func = Func("main", {}, ty.void_(), {},
-                      ast::AttributeList{
+                      {
                           WorkgroupSize(2_i, 4_i, 6_i),
                           Stage(ast::PipelineStage::kCompute),
                       });
@@ -135,8 +135,8 @@ TEST_F(BuilderTest, Decoration_ExecutionMode_WorkgroupSize_Const) {
     GlobalConst("width", ty.i32(), Construct(ty.i32(), 2_i));
     GlobalConst("height", ty.i32(), Construct(ty.i32(), 3_i));
     GlobalConst("depth", ty.i32(), Construct(ty.i32(), 4_i));
-    auto* func = Func("main", {}, ty.void_(), ast::StatementList{},
+    auto* func = Func("main", {}, ty.void_(), {},
-                      ast::AttributeList{
+                      {
                           WorkgroupSize("width", "height", "depth"),
                           Stage(ast::PipelineStage::kCompute),
                       });
@@ -153,8 +153,8 @@ TEST_F(BuilderTest, Decoration_ExecutionMode_WorkgroupSize_OverridableConst) {
     Override("width", ty.i32(), Construct(ty.i32(), 2_i), {Id(7u)});
     Override("height", ty.i32(), Construct(ty.i32(), 3_i), {Id(8u)});
     Override("depth", ty.i32(), Construct(ty.i32(), 4_i), {Id(9u)});
-    auto* func = Func("main", {}, ty.void_(), ast::StatementList{},
+    auto* func = Func("main", {}, ty.void_(), {},
-                      ast::AttributeList{
+                      {
                           WorkgroupSize("width", "height", "depth"),
                           Stage(ast::PipelineStage::kCompute),
                       });
@@ -182,8 +182,8 @@ OpDecorate %3 BuiltIn WorkgroupSize
 TEST_F(BuilderTest, Decoration_ExecutionMode_WorkgroupSize_LiteralAndConst) {
     Override("height", ty.i32(), Construct(ty.i32(), 2_i), {Id(7u)});
     GlobalConst("depth", ty.i32(), Construct(ty.i32(), 3_i));
-    auto* func = Func("main", {}, ty.void_(), ast::StatementList{},
+    auto* func = Func("main", {}, ty.void_(), {},
-                      ast::AttributeList{
+                      {
                           WorkgroupSize(4_i, "height", "depth"),
                           Stage(ast::PipelineStage::kCompute),
                       });
@@ -207,13 +207,13 @@ OpDecorate %3 BuiltIn WorkgroupSize
 }
 
 TEST_F(BuilderTest, Decoration_ExecutionMode_MultipleFragment) {
-    auto* func1 = Func("main1", {}, ty.void_(), ast::StatementList{},
+    auto* func1 = Func("main1", {}, ty.void_(), {},
-                       ast::AttributeList{
+                       {
                            Stage(ast::PipelineStage::kFragment),
                        });
 
-    auto* func2 = Func("main2", {}, ty.void_(), ast::StatementList{},
+    auto* func2 = Func("main2", {}, ty.void_(), {},
-                       ast::AttributeList{
+                       {
                            Stage(ast::PipelineStage::kFragment),
                        });
 
@@ -242,12 +242,14 @@ OpFunctionEnd
 }
 
 TEST_F(BuilderTest, Decoration_ExecutionMode_FragDepth) {
-    Func("main", ast::VariableList{}, ty.f32(),
+    Func("main", {}, ty.f32(),
-         ast::StatementList{
+         {
              Return(Expr(1_f)),
          },
-         ast::AttributeList{Stage(ast::PipelineStage::kFragment)},
+         {
-         ast::AttributeList{
+             Stage(ast::PipelineStage::kFragment),
+         },
+         {
              Builtin(ast::Builtin::kFragDepth),
          });
 

src/tint/writer/spirv/builder_function_test.cc

@@ -24,7 +24,7 @@ namespace {
 using BuilderTest = TestHelper;
 
 TEST_F(BuilderTest, Function_Empty) {
-    Func("a_func", {}, ty.void_(), ast::StatementList{}, ast::AttributeList{});
+    Func("a_func", {}, ty.void_(), {});
 
     spirv::Builder& b = Build();
 
@@ -42,10 +42,9 @@ OpFunctionEnd
 
 TEST_F(BuilderTest, Function_Terminator_Return) {
     Func("a_func", {}, ty.void_(),
-         ast::StatementList{
+         {
              Return(),
-         },
+         });
-         ast::AttributeList{});
 
     spirv::Builder& b = Build();
 
@@ -64,7 +63,7 @@ OpFunctionEnd
 TEST_F(BuilderTest, Function_Terminator_ReturnValue) {
     Global("a", ty.f32(), ast::StorageClass::kPrivate);
 
-    Func("a_func", {}, ty.f32(), ast::StatementList{Return("a")}, ast::AttributeList{});
+    Func("a_func", {}, ty.f32(), {Return("a")}, {});
 
     spirv::Builder& b = Build();
 
@@ -90,10 +89,9 @@ OpFunctionEnd
 
 TEST_F(BuilderTest, Function_Terminator_Discard) {
     Func("a_func", {}, ty.void_(),
-         ast::StatementList{
+         {
              create<ast::DiscardStatement>(),
-         },
+         });
-         ast::AttributeList{});
 
     spirv::Builder& b = Build();
 
@@ -110,9 +108,12 @@ OpFunctionEnd
 }
 
 TEST_F(BuilderTest, Function_WithParams) {
-    ast::VariableList params = {Param("a", ty.f32()), Param("b", ty.i32())};
+    Func("a_func",
-
+         {
-    Func("a_func", params, ty.f32(), ast::StatementList{Return("a")}, ast::AttributeList{});
+             Param("a", ty.f32()),
+             Param("b", ty.i32()),
+         },
+         ty.f32(), {Return("a")}, {});
 
     spirv::Builder& b = Build();
 
@@ -135,10 +136,9 @@ OpFunctionEnd
 
 TEST_F(BuilderTest, Function_WithBody) {
     Func("a_func", {}, ty.void_(),
-         ast::StatementList{
+         {
              Return(),
-         },
+         });
-         ast::AttributeList{});
 
     spirv::Builder& b = Build();
 
@@ -155,7 +155,7 @@ OpFunctionEnd
 }
 
 TEST_F(BuilderTest, FunctionType) {
-    Func("a_func", {}, ty.void_(), ast::StatementList{}, ast::AttributeList{});
+    Func("a_func", {}, ty.void_(), {}, {});
 
     spirv::Builder& b = Build();
 
@@ -167,8 +167,8 @@ TEST_F(BuilderTest, FunctionType) {
 }
 
 TEST_F(BuilderTest, FunctionType_DeDuplicate) {
-    auto* func1 = Func("a_func", {}, ty.void_(), ast::StatementList{}, ast::AttributeList{});
+    auto* func1 = Func("a_func", {}, ty.void_(), {}, {});
-    auto* func2 = Func("b_func", {}, ty.void_(), ast::StatementList{}, ast::AttributeList{});
+    auto* func2 = Func("b_func", {}, ty.void_(), {}, {});
 
     spirv::Builder& b = Build();
 
@@ -207,23 +207,23 @@ TEST_F(BuilderTest, Emit_Multiple_EntryPoint_With_Same_ModuleVar) {
     {
         auto* var = Var("v", ty.f32(), ast::StorageClass::kNone, MemberAccessor("data", "d"));
 
-        Func("a", ast::VariableList{}, ty.void_(),
+        Func("a", {}, ty.void_(),
-             ast::StatementList{
+             {
                  Decl(var),
                  Return(),
              },
-             ast::AttributeList{Stage(ast::PipelineStage::kCompute), WorkgroupSize(1_i)});
+             {Stage(ast::PipelineStage::kCompute), WorkgroupSize(1_i)});
     }
 
     {
         auto* var = Var("v", ty.f32(), ast::StorageClass::kNone, MemberAccessor("data", "d"));
 
-        Func("b", ast::VariableList{}, ty.void_(),
+        Func("b", {}, ty.void_(),
-             ast::StatementList{
+             {
                  Decl(var),
                  Return(),
              },
-             ast::AttributeList{Stage(ast::PipelineStage::kCompute), WorkgroupSize(1_i)});
+             {Stage(ast::PipelineStage::kCompute), WorkgroupSize(1_i)});
     }
 
     spirv::Builder& b = SanitizeAndBuild();

src/tint/writer/wgsl/generator_impl_function_test.cc

@@ -25,11 +25,10 @@ namespace {
 using WgslGeneratorImplTest = TestHelper;
 
 TEST_F(WgslGeneratorImplTest, Emit_Function) {
-    auto* func = Func("my_func", ast::VariableList{}, ty.void_(),
+    auto* func = Func("my_func", {}, ty.void_(),
-                      ast::StatementList{
+                      {
                           Return(),
-                      },
+                      });
-                      ast::AttributeList{});
 
     GeneratorImpl& gen = Build();
 
@@ -43,12 +42,10 @@ TEST_F(WgslGeneratorImplTest, Emit_Function) {
 }
 
 TEST_F(WgslGeneratorImplTest, Emit_Function_WithParams) {
-    auto* func =
+    auto* func = Func("my_func", {Param("a", ty.f32()), Param("b", ty.i32())}, ty.void_(),
-        Func("my_func", ast::VariableList{Param("a", ty.f32()), Param("b", ty.i32())}, ty.void_(),
+                      {
-             ast::StatementList{
+                          Return(),
-                 Return(),
+                      });
-             },
-             ast::AttributeList{});
 
     GeneratorImpl& gen = Build();
 
@@ -62,8 +59,8 @@ TEST_F(WgslGeneratorImplTest, Emit_Function_WithParams) {
 }
 
 TEST_F(WgslGeneratorImplTest, Emit_Function_WithAttribute_WorkgroupSize) {
-    auto* func = Func("my_func", ast::VariableList{}, ty.void_(), ast::StatementList{Return()},
+    auto* func = Func("my_func", {}, ty.void_(), {Return()},
-                      ast::AttributeList{
+                      {
                           Stage(ast::PipelineStage::kCompute),
                           WorkgroupSize(2_i, 4_i, 6_i),
                       });
@@ -82,8 +79,8 @@ TEST_F(WgslGeneratorImplTest, Emit_Function_WithAttribute_WorkgroupSize) {
 
 TEST_F(WgslGeneratorImplTest, Emit_Function_WithAttribute_WorkgroupSize_WithIdent) {
     GlobalConst("height", ty.i32(), Expr(2_i));
-    auto* func = Func("my_func", ast::VariableList{}, ty.void_(), ast::StatementList{Return()},
+    auto* func = Func("my_func", {}, ty.void_(), {Return()},
-                      ast::AttributeList{
+                      {
                           Stage(ast::PipelineStage::kCompute),
                           WorkgroupSize(2_i, "height"),
                       });
@@ -104,8 +101,8 @@ TEST_F(WgslGeneratorImplTest, Emit_Function_EntryPoint_Parameters) {
     auto* vec4 = ty.vec4<f32>();
     auto* coord = Param("coord", vec4, {Builtin(ast::Builtin::kPosition)});
     auto* loc1 = Param("loc1", ty.f32(), {Location(1u)});
-    auto* func = Func("frag_main", ast::VariableList{coord, loc1}, ty.void_(), ast::StatementList{},
+    auto* func = Func("frag_main", {coord, loc1}, ty.void_(), {},
-                      ast::AttributeList{
+                      {
                           Stage(ast::PipelineStage::kFragment),
                       });
 
@@ -121,14 +118,14 @@ TEST_F(WgslGeneratorImplTest, Emit_Function_EntryPoint_Parameters) {
 }
 
 TEST_F(WgslGeneratorImplTest, Emit_Function_EntryPoint_ReturnValue) {
-    auto* func = Func("frag_main", ast::VariableList{}, ty.f32(),
+    auto* func = Func("frag_main", {}, ty.f32(),
-                      ast::StatementList{
+                      {
                           Return(1_f),
                       },
-                      ast::AttributeList{
+                      {
                           Stage(ast::PipelineStage::kFragment),
                       },
-                      ast::AttributeList{
+                      {
                           Location(1u),
                       });
 
@@ -172,12 +169,12 @@ TEST_F(WgslGeneratorImplTest, Emit_Function_Multiple_EntryPoint_With_Same_Module
     {
         auto* var = Var("v", ty.f32(), ast::StorageClass::kNone, MemberAccessor("data", "d"));
 
-        Func("a", ast::VariableList{}, ty.void_(),
+        Func("a", {}, ty.void_(),
-             ast::StatementList{
+             {
                  Decl(var),
                  Return(),
              },
-             ast::AttributeList{
+             {
                  Stage(ast::PipelineStage::kCompute),
                  WorkgroupSize(1_i),
              });
@@ -186,12 +183,12 @@ TEST_F(WgslGeneratorImplTest, Emit_Function_Multiple_EntryPoint_With_Same_Module
     {
         auto* var = Var("v", ty.f32(), ast::StorageClass::kNone, MemberAccessor("data", "d"));
 
-        Func("b", ast::VariableList{}, ty.void_(),
+        Func("b", {}, ty.void_(),
-             ast::StatementList{
+             {
                  Decl(var),
                  Return(),
              },
-             ast::AttributeList{
+             {
                  Stage(ast::PipelineStage::kCompute),
                  WorkgroupSize(1_i),
              });

src/tint/writer/wgsl/generator_impl_global_decl_test.cc

@@ -49,23 +49,23 @@ TEST_F(WgslGeneratorImplTest, Emit_GlobalsInterleaved) {
 
     auto* s0 = Structure("S0", {Member("a", ty.i32())});
 
-    Func("func", ast::VariableList{}, ty.f32(),
+    Func("func", {}, ty.f32(),
-         ast::StatementList{
+         {
              Return("a0"),
          },
-         ast::AttributeList{});
+         {});
 
     Global("a1", ty.f32(), ast::StorageClass::kPrivate);
 
     auto* s1 = Structure("S1", {Member("a", ty.i32())});
 
-    Func("main", ast::VariableList{}, ty.void_(),
+    Func("main", {}, ty.void_(),
-         ast::StatementList{
+         {
              Decl(Var("s0", ty.Of(s0))),
              Decl(Var("s1", ty.Of(s1))),
              Assign("a1", Call("func")),
          },
-         ast::AttributeList{
+         {
              Stage(ast::PipelineStage::kCompute),
              WorkgroupSize(1_i),
          });

src/tint/writer/wgsl/generator_impl_test.cc

@@ -21,7 +21,7 @@ namespace {
 using WgslGeneratorImplTest = TestHelper;
 
 TEST_F(WgslGeneratorImplTest, Generate) {
-    Func("my_func", ast::VariableList{}, ty.void_(), ast::StatementList{}, ast::AttributeList{});
+    Func("my_func", {}, ty.void_(), {}, {});
 
     GeneratorImpl& gen = Build();