src/transform/spirv_test.cc - dawn - Git at Google

 // Copyright 2021 The Tint Authors.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
 //
 //     http://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing, software
 // distributed under the License is distributed on an "AS IS" BASIS,
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.

 #include "src/transform/spirv.h"

 #include "src/transform/test_helper.h"

 namespace tint {
 namespace transform {
 namespace {

 using SpirvTest = TransformTest;

 TEST_F(SpirvTest, HandleEntryPointIOTypes_Parameters) {
   auto* src = R"(
 [[stage(fragment)]]
 fn frag_main([[builtin(frag_coord)]] coord : vec4<f32>,
              [[location(1)]] loc1 : f32) -> void {
   var col : f32 = (coord.x * loc1);
 }

 [[stage(compute)]]
 fn compute_main([[builtin(local_invocation_id)]] local_id : vec3<u32>,
                 [[builtin(local_invocation_index)]] local_index : u32) -> void {
   var id_x : u32 = local_id.x;
 }
 )";

   auto* expect = R"(
 [[builtin(frag_coord)]] var<in> tint_symbol_1 : vec4<f32>;

 [[location(1)]] var<in> tint_symbol_2 : f32;

 [[stage(fragment)]]
 fn frag_main() -> void {
   var col : f32 = (tint_symbol_1.x * tint_symbol_2);
 }

 [[builtin(local_invocation_id)]] var<in> tint_symbol_6 : vec3<u32>;

 [[builtin(local_invocation_index)]] var<in> tint_symbol_7 : u32;

 [[stage(compute)]]
 fn compute_main() -> void {
   var id_x : u32 = tint_symbol_6.x;
 }
 )";

   auto got = Run<Spirv>(src);

   EXPECT_EQ(expect, str(got));
 }

 TEST_F(SpirvTest, HandleEntryPointIOTypes_Parameter_TypeAlias) {
   auto* src = R"(
 type myf32 = f32;

 [[stage(fragment)]]
 fn frag_main([[location(1)]] loc1 : myf32) -> void {
 }
 )";

   auto* expect = R"(
 type myf32 = f32;

 [[location(1)]] var<in> tint_symbol_1 : myf32;

 [[stage(fragment)]]
 fn frag_main() -> void {
 }
 )";

   auto got = Run<Spirv>(src);

   EXPECT_EQ(expect, str(got));
 }

 TEST_F(SpirvTest, HandleEntryPointIOTypes_ReturnBuiltin) {
   auto* src = R"(
 [[stage(vertex)]]
 fn vert_main() -> [[builtin(position)]] vec4<f32> {
   return vec4<f32>(1.0, 2.0, 3.0, 0.0);
 }
 )";

   auto* expect = R"(
 [[builtin(position)]] var<out> tint_symbol_2 : vec4<f32>;

 fn tint_symbol_3(tint_symbol_1 : vec4<f32>) -> void {
   tint_symbol_2 = tint_symbol_1;
 }

 [[stage(vertex)]]
 fn vert_main() -> void {
   tint_symbol_3(vec4<f32>(1.0, 2.0, 3.0, 0.0));
   return;
 }
 )";

   auto got = Run<Spirv>(src);

   EXPECT_EQ(expect, str(got));
 }

 TEST_F(SpirvTest, HandleEntryPointIOTypes_ReturnLocation) {
   auto* src = R"(
 [[stage(fragment)]]
 fn frag_main([[location(0)]] loc_in : u32) -> [[location(0)]] f32 {
   if (loc_in > 10u) {
     return 0.5;
   }
   return 1.0;
 }
 )";

   auto* expect = R"(
 [[location(0)]] var<in> tint_symbol_1 : u32;

 [[location(0)]] var<out> tint_symbol_3 : f32;

 fn tint_symbol_4(tint_symbol_2 : f32) -> void {
   tint_symbol_3 = tint_symbol_2;
 }

 [[stage(fragment)]]
 fn frag_main() -> void {
   if ((tint_symbol_1 > 10u)) {
     tint_symbol_4(0.5);
     return;
   }
   tint_symbol_4(1.0);
   return;
 }
 )";

   auto got = Run<Spirv>(src);

   EXPECT_EQ(expect, str(got));
 }

 TEST_F(SpirvTest, HandleEntryPointIOTypes_ReturnLocation_TypeAlias) {
   auto* src = R"(
 type myf32 = f32;

 [[stage(fragment)]]
 fn frag_main([[location(0)]] loc_in : u32) -> [[location(0)]] myf32 {
   if (loc_in > 10u) {
     return 0.5;
   }
   return 1.0;
 }
 )";

   auto* expect = R"(
 type myf32 = f32;

 [[location(0)]] var<in> tint_symbol_1 : u32;

 [[location(0)]] var<out> tint_symbol_3 : myf32;

 fn tint_symbol_5(tint_symbol_2 : myf32) -> void {
   tint_symbol_3 = tint_symbol_2;
 }

 [[stage(fragment)]]
 fn frag_main() -> void {
   if ((tint_symbol_1 > 10u)) {
     tint_symbol_5(0.5);
     return;
   }
   tint_symbol_5(1.0);
   return;
 }
 )";

   auto got = Run<Spirv>(src);

   EXPECT_EQ(expect, str(got));
 }

 TEST_F(SpirvTest, HandleEntryPointIOTypes_StructParameters) {
   auto* src = R"(
 struct FragmentInput {
   [[builtin(frag_coord)]] coord : vec4<f32>;
   [[location(1)]] value : f32;
 };

 [[stage(fragment)]]
 fn frag_main(inputs : FragmentInput) -> void {
   var col : f32 = inputs.coord.x * inputs.value;
 }
 )";

   auto* expect = R"(
 struct FragmentInput {
   coord : vec4<f32>;
   value : f32;
 };

 [[builtin(frag_coord)]] var<in> tint_symbol_4 : vec4<f32>;

 [[location(1)]] var<in> tint_symbol_5 : f32;

 [[stage(fragment)]]
 fn frag_main() -> void {
   const tint_symbol_6 : FragmentInput = FragmentInput(tint_symbol_4, tint_symbol_5);
   var col : f32 = (tint_symbol_6.coord.x * tint_symbol_6.value);
 }
 )";

   auto got = Run<Spirv>(src);

   EXPECT_EQ(expect, str(got));
 }

 TEST_F(SpirvTest, HandleEntryPointIOTypes_StructParameters_Nested) {
   auto* src = R"(
 struct Builtins {
   [[builtin(frag_coord)]] coord : vec4<f32>;
 };

 struct Locations {
   [[location(2)]] l2 : f32;
   [[location(3)]] l3 : f32;
 };

 struct Other {
   l : Locations;
 };

 struct FragmentInput {
   b : Builtins;
   o : Other;
   [[location(1)]] value : f32;
 };

 [[stage(fragment)]]
 fn frag_main(inputs : FragmentInput) -> void {
   var col : f32 = inputs.b.coord.x * inputs.value;
   var l : f32 = inputs.o.l.l2 + inputs.o.l.l3;
 }
 )";

   auto* expect = R"(
 struct Builtins {
   coord : vec4<f32>;
 };

 struct Locations {
   l2 : f32;
   l3 : f32;
 };

 struct Other {
   l : Locations;
 };

 struct FragmentInput {
   b : Builtins;
   o : Other;
   value : f32;
 };

 [[builtin(frag_coord)]] var<in> tint_symbol_12 : vec4<f32>;

 [[location(2)]] var<in> tint_symbol_14 : f32;

 [[location(3)]] var<in> tint_symbol_15 : f32;

 [[location(1)]] var<in> tint_symbol_18 : f32;

 [[stage(fragment)]]
 fn frag_main() -> void {
   const tint_symbol_13 : Builtins = Builtins(tint_symbol_12);
   const tint_symbol_16 : Locations = Locations(tint_symbol_14, tint_symbol_15);
   const tint_symbol_17 : Other = Other(tint_symbol_16);
   const tint_symbol_19 : FragmentInput = FragmentInput(tint_symbol_13, tint_symbol_17, tint_symbol_18);
   var col : f32 = (tint_symbol_19.b.coord.x * tint_symbol_19.value);
   var l : f32 = (tint_symbol_19.o.l.l2 + tint_symbol_19.o.l.l3);
 }
 )";

   auto got = Run<Spirv>(src);

   EXPECT_EQ(expect, str(got));
 }

 TEST_F(SpirvTest, HandleEntryPointIOTypes_StructParameters_EmptyBody) {
   auto* src = R"(
 struct Locations {
   [[location(1)]] value : f32;
 };

 struct FragmentInput {
   locations : Locations;
 };

 [[stage(fragment)]]
 fn frag_main(inputs : FragmentInput) -> void {
 }
 )";

   auto* expect = R"(
 struct Locations {
   value : f32;
 };

 struct FragmentInput {
   locations : Locations;
 };

 [[location(1)]] var<in> tint_symbol_5 : f32;

 [[stage(fragment)]]
 fn frag_main() -> void {
 }
 )";

   auto got = Run<Spirv>(src);

   EXPECT_EQ(expect, str(got));
 }

 TEST_F(SpirvTest, HandleEntryPointIOTypes_ReturnStruct) {
   auto* src = R"(
 struct VertexOutput {
   [[builtin(position)]] pos : vec4<f32>;
   [[location(1)]] value : f32;
 };

 [[stage(vertex)]]
 fn vert_main() -> VertexOutput {
   if (false) {
     return VertexOutput();
   }
   var pos : vec4<f32> = vec4<f32>(1.0, 2.0, 3.0, 0.0);
   return VertexOutput(pos, 2.0);
 }
 )";

   auto* expect = R"(
 struct VertexOutput {
   pos : vec4<f32>;
   value : f32;
 };

 [[builtin(position)]] var<out> tint_symbol_5 : vec4<f32>;

 [[location(1)]] var<out> tint_symbol_6 : f32;

 fn tint_symbol_7(tint_symbol_4 : VertexOutput) -> void {
   tint_symbol_5 = tint_symbol_4.pos;
   tint_symbol_6 = tint_symbol_4.value;
 }

 [[stage(vertex)]]
 fn vert_main() -> void {
   if (false) {
     tint_symbol_7(VertexOutput());
     return;
   }
   var pos : vec4<f32> = vec4<f32>(1.0, 2.0, 3.0, 0.0);
   tint_symbol_7(VertexOutput(pos, 2.0));
   return;
 }
 )";

   auto got = Run<Spirv>(src);

   EXPECT_EQ(expect, str(got));
 }

 TEST_F(SpirvTest, HandleEntryPointIOTypes_ReturnStruct_Nested) {
   auto* src = R"(
 struct Builtins {
   [[builtin(position)]] pos : vec4<f32>;
 };

 struct Locations {
   [[location(2)]] l2 : f32;
   [[location(3)]] l3 : f32;
 };

 struct Other {
   l : Locations;
 };

 struct VertexOutput {
   b : Builtins;
   o : Other;
   [[location(1)]] value : f32;
 };

 [[stage(vertex)]]
 fn vert_main() -> VertexOutput {
   if (false) {
     return VertexOutput();
   }
   var output : VertexOutput = VertexOutput();
   output.b.pos = vec4<f32>(1.0, 2.0, 3.0, 0.0);
   output.o.l.l2 = 4.0;
   output.o.l.l3 = 5.0;
   output.value = 6.0;
   return output;
 }
 )";

   auto* expect = R"(
 struct Builtins {
   pos : vec4<f32>;
 };

 struct Locations {
   l2 : f32;
   l3 : f32;
 };

 struct Other {
   l : Locations;
 };

 struct VertexOutput {
   b : Builtins;
   o : Other;
   value : f32;
 };

 [[builtin(position)]] var<out> tint_symbol_13 : vec4<f32>;

 [[location(2)]] var<out> tint_symbol_14 : f32;

 [[location(3)]] var<out> tint_symbol_15 : f32;

 [[location(1)]] var<out> tint_symbol_16 : f32;

 fn tint_symbol_17(tint_symbol_12 : VertexOutput) -> void {
   tint_symbol_13 = tint_symbol_12.b.pos;
   tint_symbol_14 = tint_symbol_12.o.l.l2;
   tint_symbol_15 = tint_symbol_12.o.l.l3;
   tint_symbol_16 = tint_symbol_12.value;
 }

 [[stage(vertex)]]
 fn vert_main() -> void {
   if (false) {
     tint_symbol_17(VertexOutput());
     return;
   }
   var output : VertexOutput = VertexOutput();
   output.b.pos = vec4<f32>(1.0, 2.0, 3.0, 0.0);
   output.o.l.l2 = 4.0;
   output.o.l.l3 = 5.0;
   output.value = 6.0;
   tint_symbol_17(output);
   return;
 }
 )";

   auto got = Run<Spirv>(src);

   EXPECT_EQ(expect, str(got));
 }

 TEST_F(SpirvTest, HandleEntryPointIOTypes_SharedStruct_SameShader) {
   auto* src = R"(
 struct Interface {
   [[location(1)]] value : f32;
 };

 [[stage(vertex)]]
 fn vert_main(inputs : Interface) -> Interface {
   return inputs;
 }
 )";

   auto* expect = R"(
 struct Interface {
   value : f32;
 };

 [[location(1)]] var<in> tint_symbol_3 : f32;

 [[location(1)]] var<out> tint_symbol_6 : f32;

 fn tint_symbol_7(tint_symbol_5 : Interface) -> void {
   tint_symbol_6 = tint_symbol_5.value;
 }

 [[stage(vertex)]]
 fn vert_main() -> void {
   const tint_symbol_4 : Interface = Interface(tint_symbol_3);
   tint_symbol_7(tint_symbol_4);
   return;
 }
 )";

   auto got = Run<Spirv>(src);

   EXPECT_EQ(expect, str(got));
 }

 TEST_F(SpirvTest, HandleEntryPointIOTypes_SharedStruct_DifferentShaders) {
   auto* src = R"(
 struct Interface {
   [[location(1)]] value : f32;
 };

 [[stage(vertex)]]
 fn vert_main() -> Interface {
   return Interface(42.0);
 }

 [[stage(fragment)]]
 fn frag_main(inputs : Interface) -> void {
   var x : f32 = inputs.value;
 }
 )";

   auto* expect = R"(
 struct Interface {
   value : f32;
 };

 [[location(1)]] var<out> tint_symbol_4 : f32;

 fn tint_symbol_5(tint_symbol_3 : Interface) -> void {
   tint_symbol_4 = tint_symbol_3.value;
 }

 [[stage(vertex)]]
 fn vert_main() -> void {
   tint_symbol_5(Interface(42.0));
   return;
 }

 [[location(1)]] var<in> tint_symbol_7 : f32;

 [[stage(fragment)]]
 fn frag_main() -> void {
   const tint_symbol_8 : Interface = Interface(tint_symbol_7);
   var x : f32 = tint_symbol_8.value;
 }
 )";

   auto got = Run<Spirv>(src);

   EXPECT_EQ(expect, str(got));
 }

 TEST_F(SpirvTest, HandleEntryPointIOTypes_SharedSubStruct) {
   auto* src = R"(
 struct Interface {
   [[location(1)]] value : f32;
 };

 struct VertexOutput {
   [[builtin(position)]] pos : vec4<f32>;
   interface : Interface;
 };

 struct FragmentInput {
   [[builtin(sample_index)]] index : u32;
   interface : Interface;
 };

 [[stage(vertex)]]
 fn vert_main() -> VertexOutput {
   return VertexOutput(vec4<f32>(), Interface(42.0));
 }

 [[stage(fragment)]]
 fn frag_main(inputs : FragmentInput) -> void {
   var x : f32 = inputs.interface.value;
 }
 )";

   auto* expect = R"(
 struct Interface {
   value : f32;
 };

 struct VertexOutput {
   pos : vec4<f32>;
   interface : Interface;
 };

 struct FragmentInput {
   index : u32;
   interface : Interface;
 };

 [[builtin(position)]] var<out> tint_symbol_9 : vec4<f32>;

 [[location(1)]] var<out> tint_symbol_10 : f32;

 fn tint_symbol_11(tint_symbol_8 : VertexOutput) -> void {
   tint_symbol_9 = tint_symbol_8.pos;
   tint_symbol_10 = tint_symbol_8.interface.value;
 }

 [[stage(vertex)]]
 fn vert_main() -> void {
   tint_symbol_11(VertexOutput(vec4<f32>(), Interface(42.0)));
   return;
 }

 [[builtin(sample_index)]] var<in> tint_symbol_13 : u32;

 [[location(1)]] var<in> tint_symbol_14 : f32;

 [[stage(fragment)]]
 fn frag_main() -> void {
   const tint_symbol_15 : Interface = Interface(tint_symbol_14);
   const tint_symbol_16 : FragmentInput = FragmentInput(tint_symbol_13, tint_symbol_15);
   var x : f32 = tint_symbol_16.interface.value;
 }
 )";

   auto got = Run<Spirv>(src);

   EXPECT_EQ(expect, str(got));
 }

 TEST_F(SpirvTest, HandleEntryPointIOTypes_NestedStruct_TypeAlias) {
   auto* src = R"(
 type myf32 = f32;

 struct Location {
   [[location(2)]] l2 : myf32;
 };

 type MyLocation = Location;

 struct VertexIO {
   l : MyLocation;
   [[location(1)]] value : myf32;
 };

 type MyVertexInput = VertexIO;

 type MyVertexOutput = VertexIO;

 [[stage(vertex)]]
 fn vert_main(inputs : MyVertexInput) -> MyVertexOutput {
   return inputs;
 }
 )";

   auto* expect = R"(
 type myf32 = f32;

 struct Location {
   l2 : myf32;
 };

 type MyLocation = Location;

 struct VertexIO {
   l : MyLocation;
   value : myf32;
 };

 type MyVertexInput = VertexIO;

 type MyVertexOutput = VertexIO;

 [[location(2)]] var<in> tint_symbol_8 : myf32;

 [[location(1)]] var<in> tint_symbol_10 : myf32;

 [[location(2)]] var<out> tint_symbol_14 : myf32;

 [[location(1)]] var<out> tint_symbol_15 : myf32;

 fn tint_symbol_17(tint_symbol_13 : MyVertexOutput) -> void {
   tint_symbol_14 = tint_symbol_13.l.l2;
   tint_symbol_15 = tint_symbol_13.value;
 }

 [[stage(vertex)]]
 fn vert_main() -> void {
   const tint_symbol_9 : MyLocation = MyLocation(tint_symbol_8);
   const tint_symbol_11 : MyVertexInput = MyVertexInput(tint_symbol_9, tint_symbol_10);
   tint_symbol_17(tint_symbol_11);
   return;
 }
 )";

   auto got = Run<Spirv>(src);

   EXPECT_EQ(expect, str(got));
 }

 TEST_F(SpirvTest, HandleEntryPointIOTypes_StructLayoutDecorations) {
   auto* src = R"(
 [[block]]
 struct FragmentInput {
   [[size(16), location(1)]] value : f32;
   [[builtin(frag_coord)]] [[align(32)]] coord : vec4<f32>;
 };

 struct FragmentOutput {
   [[size(16), location(1)]] value : f32;
 };

 [[stage(fragment)]]
 fn frag_main(inputs : FragmentInput) -> FragmentOutput {
   return FragmentOutput(inputs.coord.x * inputs.value);
 }
 )";

   auto* expect = R"(
 [[block]]
 struct FragmentInput {
   [[size(16)]]
   value : f32;
   [[align(32)]]
   coord : vec4<f32>;
 };

 struct FragmentOutput {
   [[size(16)]]
   value : f32;
 };

 [[location(1)]] var<in> tint_symbol_5 : f32;

 [[builtin(frag_coord)]] var<in> tint_symbol_6 : vec4<f32>;

 [[location(1)]] var<out> tint_symbol_9 : f32;

 fn tint_symbol_10(tint_symbol_8 : FragmentOutput) -> void {
   tint_symbol_9 = tint_symbol_8.value;
 }

 [[stage(fragment)]]
 fn frag_main() -> void {
   const tint_symbol_7 : FragmentInput = FragmentInput(tint_symbol_5, tint_symbol_6);
   tint_symbol_10(FragmentOutput((tint_symbol_7.coord.x * tint_symbol_7.value)));
   return;
 }
 )";

   auto got = Run<Spirv>(src);

   EXPECT_EQ(expect, str(got));
 }

 TEST_F(SpirvTest, HandleSampleMaskBuiltins_Basic) {
   auto* src = R"(
 [[builtin(sample_index)]] var<in> sample_index : u32;

 [[builtin(sample_mask_in)]] var<in> mask_in : u32;

 [[builtin(sample_mask_out)]] var<out> mask_out : u32;

 [[stage(fragment)]]
 fn main() -> void {
   mask_out = mask_in;
 }
 )";

   auto* expect = R"(
 [[builtin(sample_index)]] var<in> sample_index : u32;

 [[builtin(sample_mask_in)]] var<in> mask_in : array<u32, 1>;

 [[builtin(sample_mask_out)]] var<out> mask_out : array<u32, 1>;

 [[stage(fragment)]]
 fn main() -> void {
   mask_out[0] = mask_in[0];
 }
 )";

   auto got = Run<Spirv>(src);

   EXPECT_EQ(expect, str(got));
 }

 TEST_F(SpirvTest, HandleSampleMaskBuiltins_FunctionArg) {
   auto* src = R"(
 [[builtin(sample_mask_in)]] var<in> mask_in : u32;

 [[builtin(sample_mask_out)]] var<out> mask_out : u32;

 fn filter(mask: u32) -> u32 {
   return (mask & 3u);
 }

 fn set_mask(input : u32) -> void {
   mask_out = input;
 }

 [[stage(fragment)]]
 fn main() -> void {
   set_mask(filter(mask_in));
 }
 )";

   auto* expect = R"(
 [[builtin(sample_mask_in)]] var<in> mask_in : array<u32, 1>;

 [[builtin(sample_mask_out)]] var<out> mask_out : array<u32, 1>;

 fn filter(mask : u32) -> u32 {
   return (mask & 3u);
 }

 fn set_mask(input : u32) -> void {
   mask_out[0] = input;
 }

 [[stage(fragment)]]
 fn main() -> void {
   set_mask(filter(mask_in[0]));
 }
 )";

   auto got = Run<Spirv>(src);

   EXPECT_EQ(expect, str(got));
 }

 // Test that different transforms within the sanitizer interact correctly.
 TEST_F(SpirvTest, MultipleTransforms) {
   auto* src = R"(
 [[stage(fragment)]]
 fn main([[builtin(sample_index)]] sample_index : u32,
         [[builtin(sample_mask_in)]] mask_in : u32)
         -> [[builtin(sample_mask_out)]] u32 {
   return mask_in;
 }
 )";

   auto* expect = R"(
 [[builtin(sample_index)]] var<in> tint_symbol_1 : u32;

 [[builtin(sample_mask_in)]] var<in> tint_symbol_2 : array<u32, 1>;

 [[builtin(sample_mask_out)]] var<out> tint_symbol_4 : array<u32, 1>;

 fn tint_symbol_5(tint_symbol_3 : u32) -> void {
   tint_symbol_4[0] = tint_symbol_3;
 }

 [[stage(fragment)]]
 fn main() -> void {
   tint_symbol_5(tint_symbol_2[0]);
   return;
 }
 )";

   auto got = Run<Spirv>(src);

   EXPECT_EQ(expect, str(got));
 }

 }  // namespace
 }  // namespace transform
 }  // namespace tint
	// Copyright 2021 The Tint Authors.
	//
	// Licensed under the Apache License, Version 2.0 (the "License");
	// you may not use this file except in compliance with the License.
	// You may obtain a copy of the License at
	//
	// http://www.apache.org/licenses/LICENSE-2.0
	//
	// Unless required by applicable law or agreed to in writing, software
	// distributed under the License is distributed on an "AS IS" BASIS,
	// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	// See the License for the specific language governing permissions and
	// limitations under the License.

	#include "src/transform/spirv.h"

	#include "src/transform/test_helper.h"

	namespace tint {
	namespace transform {
	namespace {

	using SpirvTest = TransformTest;

	TEST_F(SpirvTest, HandleEntryPointIOTypes_Parameters) {
	auto* src = R"(
	[[stage(fragment)]]
	fn frag_main([[builtin(frag_coord)]] coord : vec4<f32>,
	[[location(1)]] loc1 : f32) -> void {
	var col : f32 = (coord.x * loc1);
	}

	[[stage(compute)]]
	fn compute_main([[builtin(local_invocation_id)]] local_id : vec3<u32>,
	[[builtin(local_invocation_index)]] local_index : u32) -> void {
	var id_x : u32 = local_id.x;
	}
	)";

	auto* expect = R"(
	[[builtin(frag_coord)]] var<in> tint_symbol_1 : vec4<f32>;

	[[location(1)]] var<in> tint_symbol_2 : f32;

	[[stage(fragment)]]
	fn frag_main() -> void {
	var col : f32 = (tint_symbol_1.x * tint_symbol_2);
	}

	[[builtin(local_invocation_id)]] var<in> tint_symbol_6 : vec3<u32>;

	[[builtin(local_invocation_index)]] var<in> tint_symbol_7 : u32;

	[[stage(compute)]]
	fn compute_main() -> void {
	var id_x : u32 = tint_symbol_6.x;
	}
	)";

	auto got = Run<Spirv>(src);

	EXPECT_EQ(expect, str(got));
	}

	TEST_F(SpirvTest, HandleEntryPointIOTypes_Parameter_TypeAlias) {
	auto* src = R"(
	type myf32 = f32;

	[[stage(fragment)]]
	fn frag_main([[location(1)]] loc1 : myf32) -> void {
	}
	)";

	auto* expect = R"(
	type myf32 = f32;

	[[location(1)]] var<in> tint_symbol_1 : myf32;

	[[stage(fragment)]]
	fn frag_main() -> void {
	}
	)";

	auto got = Run<Spirv>(src);

	EXPECT_EQ(expect, str(got));
	}

	TEST_F(SpirvTest, HandleEntryPointIOTypes_ReturnBuiltin) {
	auto* src = R"(
	[[stage(vertex)]]
	fn vert_main() -> [[builtin(position)]] vec4<f32> {
	return vec4<f32>(1.0, 2.0, 3.0, 0.0);
	}
	)";

	auto* expect = R"(
	[[builtin(position)]] var<out> tint_symbol_2 : vec4<f32>;

	fn tint_symbol_3(tint_symbol_1 : vec4<f32>) -> void {
	tint_symbol_2 = tint_symbol_1;
	}

	[[stage(vertex)]]
	fn vert_main() -> void {
	tint_symbol_3(vec4<f32>(1.0, 2.0, 3.0, 0.0));
	return;
	}
	)";

	auto got = Run<Spirv>(src);

	EXPECT_EQ(expect, str(got));
	}

	TEST_F(SpirvTest, HandleEntryPointIOTypes_ReturnLocation) {
	auto* src = R"(
	[[stage(fragment)]]
	fn frag_main([[location(0)]] loc_in : u32) -> [[location(0)]] f32 {
	if (loc_in > 10u) {
	return 0.5;
	}
	return 1.0;
	}
	)";

	auto* expect = R"(
	[[location(0)]] var<in> tint_symbol_1 : u32;

	[[location(0)]] var<out> tint_symbol_3 : f32;

	fn tint_symbol_4(tint_symbol_2 : f32) -> void {
	tint_symbol_3 = tint_symbol_2;
	}

	[[stage(fragment)]]
	fn frag_main() -> void {
	if ((tint_symbol_1 > 10u)) {
	tint_symbol_4(0.5);
	return;
	}
	tint_symbol_4(1.0);
	return;
	}
	)";

	auto got = Run<Spirv>(src);

	EXPECT_EQ(expect, str(got));
	}

	TEST_F(SpirvTest, HandleEntryPointIOTypes_ReturnLocation_TypeAlias) {
	auto* src = R"(
	type myf32 = f32;

	[[stage(fragment)]]
	fn frag_main([[location(0)]] loc_in : u32) -> [[location(0)]] myf32 {
	if (loc_in > 10u) {
	return 0.5;
	}
	return 1.0;
	}
	)";

	auto* expect = R"(
	type myf32 = f32;

	[[location(0)]] var<in> tint_symbol_1 : u32;

	[[location(0)]] var<out> tint_symbol_3 : myf32;

	fn tint_symbol_5(tint_symbol_2 : myf32) -> void {
	tint_symbol_3 = tint_symbol_2;
	}

	[[stage(fragment)]]
	fn frag_main() -> void {
	if ((tint_symbol_1 > 10u)) {
	tint_symbol_5(0.5);
	return;
	}
	tint_symbol_5(1.0);
	return;
	}
	)";

	auto got = Run<Spirv>(src);

	EXPECT_EQ(expect, str(got));
	}

	TEST_F(SpirvTest, HandleEntryPointIOTypes_StructParameters) {
	auto* src = R"(
	struct FragmentInput {
	[[builtin(frag_coord)]] coord : vec4<f32>;
	[[location(1)]] value : f32;
	};

	[[stage(fragment)]]
	fn frag_main(inputs : FragmentInput) -> void {
	var col : f32 = inputs.coord.x * inputs.value;
	}
	)";

	auto* expect = R"(
	struct FragmentInput {
	coord : vec4<f32>;
	value : f32;
	};

	[[builtin(frag_coord)]] var<in> tint_symbol_4 : vec4<f32>;

	[[location(1)]] var<in> tint_symbol_5 : f32;

	[[stage(fragment)]]
	fn frag_main() -> void {
	const tint_symbol_6 : FragmentInput = FragmentInput(tint_symbol_4, tint_symbol_5);
	var col : f32 = (tint_symbol_6.coord.x * tint_symbol_6.value);
	}
	)";

	auto got = Run<Spirv>(src);

	EXPECT_EQ(expect, str(got));
	}

	TEST_F(SpirvTest, HandleEntryPointIOTypes_StructParameters_Nested) {
	auto* src = R"(
	struct Builtins {
	[[builtin(frag_coord)]] coord : vec4<f32>;
	};

	struct Locations {
	[[location(2)]] l2 : f32;
	[[location(3)]] l3 : f32;
	};

	struct Other {
	l : Locations;
	};

	struct FragmentInput {
	b : Builtins;
	o : Other;
	[[location(1)]] value : f32;
	};

	[[stage(fragment)]]
	fn frag_main(inputs : FragmentInput) -> void {
	var col : f32 = inputs.b.coord.x * inputs.value;
	var l : f32 = inputs.o.l.l2 + inputs.o.l.l3;
	}
	)";

	auto* expect = R"(
	struct Builtins {
	coord : vec4<f32>;
	};

	struct Locations {
	l2 : f32;
	l3 : f32;
	};

	struct Other {
	l : Locations;
	};

	struct FragmentInput {
	b : Builtins;
	o : Other;
	value : f32;
	};

	[[builtin(frag_coord)]] var<in> tint_symbol_12 : vec4<f32>;

	[[location(2)]] var<in> tint_symbol_14 : f32;

	[[location(3)]] var<in> tint_symbol_15 : f32;

	[[location(1)]] var<in> tint_symbol_18 : f32;

	[[stage(fragment)]]
	fn frag_main() -> void {
	const tint_symbol_13 : Builtins = Builtins(tint_symbol_12);
	const tint_symbol_16 : Locations = Locations(tint_symbol_14, tint_symbol_15);
	const tint_symbol_17 : Other = Other(tint_symbol_16);
	const tint_symbol_19 : FragmentInput = FragmentInput(tint_symbol_13, tint_symbol_17, tint_symbol_18);
	var col : f32 = (tint_symbol_19.b.coord.x * tint_symbol_19.value);
	var l : f32 = (tint_symbol_19.o.l.l2 + tint_symbol_19.o.l.l3);
	}
	)";

	auto got = Run<Spirv>(src);

	EXPECT_EQ(expect, str(got));
	}

	TEST_F(SpirvTest, HandleEntryPointIOTypes_StructParameters_EmptyBody) {
	auto* src = R"(
	struct Locations {
	[[location(1)]] value : f32;
	};

	struct FragmentInput {
	locations : Locations;
	};

	[[stage(fragment)]]
	fn frag_main(inputs : FragmentInput) -> void {
	}
	)";

	auto* expect = R"(
	struct Locations {
	value : f32;
	};

	struct FragmentInput {
	locations : Locations;
	};

	[[location(1)]] var<in> tint_symbol_5 : f32;

	[[stage(fragment)]]
	fn frag_main() -> void {
	}
	)";

	auto got = Run<Spirv>(src);

	EXPECT_EQ(expect, str(got));
	}

	TEST_F(SpirvTest, HandleEntryPointIOTypes_ReturnStruct) {
	auto* src = R"(
	struct VertexOutput {
	[[builtin(position)]] pos : vec4<f32>;
	[[location(1)]] value : f32;
	};

	[[stage(vertex)]]
	fn vert_main() -> VertexOutput {
	if (false) {
	return VertexOutput();
	}
	var pos : vec4<f32> = vec4<f32>(1.0, 2.0, 3.0, 0.0);
	return VertexOutput(pos, 2.0);
	}
	)";

	auto* expect = R"(
	struct VertexOutput {
	pos : vec4<f32>;
	value : f32;
	};

	[[builtin(position)]] var<out> tint_symbol_5 : vec4<f32>;

	[[location(1)]] var<out> tint_symbol_6 : f32;

	fn tint_symbol_7(tint_symbol_4 : VertexOutput) -> void {
	tint_symbol_5 = tint_symbol_4.pos;
	tint_symbol_6 = tint_symbol_4.value;
	}

	[[stage(vertex)]]
	fn vert_main() -> void {
	if (false) {
	tint_symbol_7(VertexOutput());
	return;
	}
	var pos : vec4<f32> = vec4<f32>(1.0, 2.0, 3.0, 0.0);
	tint_symbol_7(VertexOutput(pos, 2.0));
	return;
	}
	)";

	auto got = Run<Spirv>(src);

	EXPECT_EQ(expect, str(got));
	}

	TEST_F(SpirvTest, HandleEntryPointIOTypes_ReturnStruct_Nested) {
	auto* src = R"(
	struct Builtins {
	[[builtin(position)]] pos : vec4<f32>;
	};

	struct Locations {
	[[location(2)]] l2 : f32;
	[[location(3)]] l3 : f32;
	};

	struct Other {
	l : Locations;
	};

	struct VertexOutput {
	b : Builtins;
	o : Other;
	[[location(1)]] value : f32;
	};

	[[stage(vertex)]]
	fn vert_main() -> VertexOutput {
	if (false) {
	return VertexOutput();
	}
	var output : VertexOutput = VertexOutput();
	output.b.pos = vec4<f32>(1.0, 2.0, 3.0, 0.0);
	output.o.l.l2 = 4.0;
	output.o.l.l3 = 5.0;
	output.value = 6.0;
	return output;
	}
	)";

	auto* expect = R"(
	struct Builtins {
	pos : vec4<f32>;
	};

	struct Locations {
	l2 : f32;
	l3 : f32;
	};

	struct Other {
	l : Locations;
	};

	struct VertexOutput {
	b : Builtins;
	o : Other;
	value : f32;
	};

	[[builtin(position)]] var<out> tint_symbol_13 : vec4<f32>;

	[[location(2)]] var<out> tint_symbol_14 : f32;

	[[location(3)]] var<out> tint_symbol_15 : f32;

	[[location(1)]] var<out> tint_symbol_16 : f32;

	fn tint_symbol_17(tint_symbol_12 : VertexOutput) -> void {
	tint_symbol_13 = tint_symbol_12.b.pos;
	tint_symbol_14 = tint_symbol_12.o.l.l2;
	tint_symbol_15 = tint_symbol_12.o.l.l3;
	tint_symbol_16 = tint_symbol_12.value;
	}

	[[stage(vertex)]]
	fn vert_main() -> void {
	if (false) {
	tint_symbol_17(VertexOutput());
	return;
	}
	var output : VertexOutput = VertexOutput();
	output.b.pos = vec4<f32>(1.0, 2.0, 3.0, 0.0);
	output.o.l.l2 = 4.0;
	output.o.l.l3 = 5.0;
	output.value = 6.0;
	tint_symbol_17(output);
	return;
	}
	)";

	auto got = Run<Spirv>(src);

	EXPECT_EQ(expect, str(got));
	}

	TEST_F(SpirvTest, HandleEntryPointIOTypes_SharedStruct_SameShader) {
	auto* src = R"(
	struct Interface {
	[[location(1)]] value : f32;
	};

	[[stage(vertex)]]
	fn vert_main(inputs : Interface) -> Interface {
	return inputs;
	}
	)";

	auto* expect = R"(
	struct Interface {
	value : f32;
	};

	[[location(1)]] var<in> tint_symbol_3 : f32;

	[[location(1)]] var<out> tint_symbol_6 : f32;

	fn tint_symbol_7(tint_symbol_5 : Interface) -> void {
	tint_symbol_6 = tint_symbol_5.value;
	}

	[[stage(vertex)]]
	fn vert_main() -> void {
	const tint_symbol_4 : Interface = Interface(tint_symbol_3);
	tint_symbol_7(tint_symbol_4);
	return;
	}
	)";

	auto got = Run<Spirv>(src);

	EXPECT_EQ(expect, str(got));
	}

	TEST_F(SpirvTest, HandleEntryPointIOTypes_SharedStruct_DifferentShaders) {
	auto* src = R"(
	struct Interface {
	[[location(1)]] value : f32;
	};

	[[stage(vertex)]]
	fn vert_main() -> Interface {
	return Interface(42.0);
	}

	[[stage(fragment)]]
	fn frag_main(inputs : Interface) -> void {
	var x : f32 = inputs.value;
	}
	)";

	auto* expect = R"(
	struct Interface {
	value : f32;
	};

	[[location(1)]] var<out> tint_symbol_4 : f32;

	fn tint_symbol_5(tint_symbol_3 : Interface) -> void {
	tint_symbol_4 = tint_symbol_3.value;
	}

	[[stage(vertex)]]
	fn vert_main() -> void {
	tint_symbol_5(Interface(42.0));
	return;
	}

	[[location(1)]] var<in> tint_symbol_7 : f32;

	[[stage(fragment)]]
	fn frag_main() -> void {
	const tint_symbol_8 : Interface = Interface(tint_symbol_7);
	var x : f32 = tint_symbol_8.value;
	}
	)";

	auto got = Run<Spirv>(src);

	EXPECT_EQ(expect, str(got));
	}

	TEST_F(SpirvTest, HandleEntryPointIOTypes_SharedSubStruct) {
	auto* src = R"(
	struct Interface {
	[[location(1)]] value : f32;
	};

	struct VertexOutput {
	[[builtin(position)]] pos : vec4<f32>;
	interface : Interface;
	};

	struct FragmentInput {
	[[builtin(sample_index)]] index : u32;
	interface : Interface;
	};

	[[stage(vertex)]]
	fn vert_main() -> VertexOutput {
	return VertexOutput(vec4<f32>(), Interface(42.0));
	}

	[[stage(fragment)]]
	fn frag_main(inputs : FragmentInput) -> void {
	var x : f32 = inputs.interface.value;
	}
	)";

	auto* expect = R"(
	struct Interface {
	value : f32;
	};

	struct VertexOutput {
	pos : vec4<f32>;
	interface : Interface;
	};

	struct FragmentInput {
	index : u32;
	interface : Interface;
	};

	[[builtin(position)]] var<out> tint_symbol_9 : vec4<f32>;

	[[location(1)]] var<out> tint_symbol_10 : f32;

	fn tint_symbol_11(tint_symbol_8 : VertexOutput) -> void {
	tint_symbol_9 = tint_symbol_8.pos;
	tint_symbol_10 = tint_symbol_8.interface.value;
	}

	[[stage(vertex)]]
	fn vert_main() -> void {
	tint_symbol_11(VertexOutput(vec4<f32>(), Interface(42.0)));
	return;
	}

	[[builtin(sample_index)]] var<in> tint_symbol_13 : u32;

	[[location(1)]] var<in> tint_symbol_14 : f32;

	[[stage(fragment)]]
	fn frag_main() -> void {
	const tint_symbol_15 : Interface = Interface(tint_symbol_14);
	const tint_symbol_16 : FragmentInput = FragmentInput(tint_symbol_13, tint_symbol_15);
	var x : f32 = tint_symbol_16.interface.value;
	}
	)";

	auto got = Run<Spirv>(src);

	EXPECT_EQ(expect, str(got));
	}

	TEST_F(SpirvTest, HandleEntryPointIOTypes_NestedStruct_TypeAlias) {
	auto* src = R"(
	type myf32 = f32;

	struct Location {
	[[location(2)]] l2 : myf32;
	};

	type MyLocation = Location;

	struct VertexIO {
	l : MyLocation;
	[[location(1)]] value : myf32;
	};

	type MyVertexInput = VertexIO;

	type MyVertexOutput = VertexIO;

	[[stage(vertex)]]
	fn vert_main(inputs : MyVertexInput) -> MyVertexOutput {
	return inputs;
	}
	)";

	auto* expect = R"(
	type myf32 = f32;

	struct Location {
	l2 : myf32;
	};

	type MyLocation = Location;

	struct VertexIO {
	l : MyLocation;
	value : myf32;
	};

	type MyVertexInput = VertexIO;

	type MyVertexOutput = VertexIO;

	[[location(2)]] var<in> tint_symbol_8 : myf32;

	[[location(1)]] var<in> tint_symbol_10 : myf32;

	[[location(2)]] var<out> tint_symbol_14 : myf32;

	[[location(1)]] var<out> tint_symbol_15 : myf32;

	fn tint_symbol_17(tint_symbol_13 : MyVertexOutput) -> void {
	tint_symbol_14 = tint_symbol_13.l.l2;
	tint_symbol_15 = tint_symbol_13.value;
	}

	[[stage(vertex)]]
	fn vert_main() -> void {
	const tint_symbol_9 : MyLocation = MyLocation(tint_symbol_8);
	const tint_symbol_11 : MyVertexInput = MyVertexInput(tint_symbol_9, tint_symbol_10);
	tint_symbol_17(tint_symbol_11);
	return;
	}
	)";

	auto got = Run<Spirv>(src);

	EXPECT_EQ(expect, str(got));
	}

	TEST_F(SpirvTest, HandleEntryPointIOTypes_StructLayoutDecorations) {
	auto* src = R"(
	[[block]]
	struct FragmentInput {
	[[size(16), location(1)]] value : f32;
	[[builtin(frag_coord)]] [[align(32)]] coord : vec4<f32>;
	};

	struct FragmentOutput {
	[[size(16), location(1)]] value : f32;
	};

	[[stage(fragment)]]
	fn frag_main(inputs : FragmentInput) -> FragmentOutput {
	return FragmentOutput(inputs.coord.x * inputs.value);
	}
	)";

	auto* expect = R"(
	[[block]]
	struct FragmentInput {
	[[size(16)]]
	value : f32;
	[[align(32)]]
	coord : vec4<f32>;
	};

	struct FragmentOutput {
	[[size(16)]]
	value : f32;
	};

	[[location(1)]] var<in> tint_symbol_5 : f32;

	[[builtin(frag_coord)]] var<in> tint_symbol_6 : vec4<f32>;

	[[location(1)]] var<out> tint_symbol_9 : f32;

	fn tint_symbol_10(tint_symbol_8 : FragmentOutput) -> void {
	tint_symbol_9 = tint_symbol_8.value;
	}

	[[stage(fragment)]]
	fn frag_main() -> void {
	const tint_symbol_7 : FragmentInput = FragmentInput(tint_symbol_5, tint_symbol_6);
	tint_symbol_10(FragmentOutput((tint_symbol_7.coord.x * tint_symbol_7.value)));
	return;
	}
	)";

	auto got = Run<Spirv>(src);

	EXPECT_EQ(expect, str(got));
	}

	TEST_F(SpirvTest, HandleSampleMaskBuiltins_Basic) {
	auto* src = R"(
	[[builtin(sample_index)]] var<in> sample_index : u32;

	[[builtin(sample_mask_in)]] var<in> mask_in : u32;

	[[builtin(sample_mask_out)]] var<out> mask_out : u32;

	[[stage(fragment)]]
	fn main() -> void {
	mask_out = mask_in;
	}
	)";

	auto* expect = R"(
	[[builtin(sample_index)]] var<in> sample_index : u32;

	[[builtin(sample_mask_in)]] var<in> mask_in : array<u32, 1>;

	[[builtin(sample_mask_out)]] var<out> mask_out : array<u32, 1>;

	[[stage(fragment)]]
	fn main() -> void {
	mask_out[0] = mask_in[0];
	}
	)";

	auto got = Run<Spirv>(src);

	EXPECT_EQ(expect, str(got));
	}

	TEST_F(SpirvTest, HandleSampleMaskBuiltins_FunctionArg) {
	auto* src = R"(
	[[builtin(sample_mask_in)]] var<in> mask_in : u32;

	[[builtin(sample_mask_out)]] var<out> mask_out : u32;

	fn filter(mask: u32) -> u32 {
	return (mask & 3u);
	}

	fn set_mask(input : u32) -> void {
	mask_out = input;
	}

	[[stage(fragment)]]
	fn main() -> void {
	set_mask(filter(mask_in));
	}
	)";

	auto* expect = R"(
	[[builtin(sample_mask_in)]] var<in> mask_in : array<u32, 1>;

	[[builtin(sample_mask_out)]] var<out> mask_out : array<u32, 1>;

	fn filter(mask : u32) -> u32 {
	return (mask & 3u);
	}

	fn set_mask(input : u32) -> void {
	mask_out[0] = input;
	}

	[[stage(fragment)]]
	fn main() -> void {
	set_mask(filter(mask_in[0]));
	}
	)";

	auto got = Run<Spirv>(src);

	EXPECT_EQ(expect, str(got));
	}

	// Test that different transforms within the sanitizer interact correctly.
	TEST_F(SpirvTest, MultipleTransforms) {
	auto* src = R"(
	[[stage(fragment)]]
	fn main([[builtin(sample_index)]] sample_index : u32,
	[[builtin(sample_mask_in)]] mask_in : u32)
	-> [[builtin(sample_mask_out)]] u32 {
	return mask_in;
	}
	)";

	auto* expect = R"(
	[[builtin(sample_index)]] var<in> tint_symbol_1 : u32;

	[[builtin(sample_mask_in)]] var<in> tint_symbol_2 : array<u32, 1>;

	[[builtin(sample_mask_out)]] var<out> tint_symbol_4 : array<u32, 1>;

	fn tint_symbol_5(tint_symbol_3 : u32) -> void {
	tint_symbol_4[0] = tint_symbol_3;
	}

	[[stage(fragment)]]
	fn main() -> void {
	tint_symbol_5(tint_symbol_2[0]);
	return;
	}
	)";

	auto got = Run<Spirv>(src);

	EXPECT_EQ(expect, str(got));
	}

	} // namespace
	} // namespace transform
	} // namespace tint