tint/test-runner: Split expectations for FXC and DXC

Change tint's `--fxc` flag to take the path of the FXC compiler DLL.
Have tint attempt to validate with both FXC and DXC if `--validate` is
passed.

Fix the 'dirsWithNoPassExpectations' logic which looks like it got
broken with the tint -> dawn merge. It also incorrectly applied
filepath.FromSlash() on windows.

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

test/tint/shader_io/compute_input_builtins.wgsl.expected.fxc.hlsl

@@ -0,0 +1,20 @@
+cbuffer cbuffer_tint_symbol_3 : register(b0, space0) {
+  uint4 tint_symbol_3[1];
+};
+
+struct tint_symbol_1 {
+  uint3 local_invocation_id : SV_GroupThreadID;
+  uint local_invocation_index : SV_GroupIndex;
+  uint3 global_invocation_id : SV_DispatchThreadID;
+  uint3 workgroup_id : SV_GroupID;
+};
+
+void main_inner(uint3 local_invocation_id, uint local_invocation_index, uint3 global_invocation_id, uint3 workgroup_id, uint3 num_workgroups) {
+  const uint foo = ((((local_invocation_id.x + local_invocation_index) + global_invocation_id.x) + workgroup_id.x) + num_workgroups.x);
+}
+
+[numthreads(1, 1, 1)]
+void main(tint_symbol_1 tint_symbol) {
+  main_inner(tint_symbol.local_invocation_id, tint_symbol.local_invocation_index, tint_symbol.global_invocation_id, tint_symbol.workgroup_id, tint_symbol_3[0].xyz);
+  return;
+}

test/tint/shader_io/compute_input_builtins_struct.wgsl.expected.fxc.hlsl

@@ -0,0 +1,28 @@
+cbuffer cbuffer_tint_symbol_3 : register(b0, space0) {
+  uint4 tint_symbol_3[1];
+};
+
+struct ComputeInputs {
+  uint3 local_invocation_id;
+  uint local_invocation_index;
+  uint3 global_invocation_id;
+  uint3 workgroup_id;
+  uint3 num_workgroups;
+};
+struct tint_symbol_1 {
+  uint3 local_invocation_id : SV_GroupThreadID;
+  uint local_invocation_index : SV_GroupIndex;
+  uint3 global_invocation_id : SV_DispatchThreadID;
+  uint3 workgroup_id : SV_GroupID;
+};
+
+void main_inner(ComputeInputs inputs) {
+  const uint foo = ((((inputs.local_invocation_id.x + inputs.local_invocation_index) + inputs.global_invocation_id.x) + inputs.workgroup_id.x) + inputs.num_workgroups.x);
+}
+
+[numthreads(1, 1, 1)]
+void main(tint_symbol_1 tint_symbol) {
+  const ComputeInputs tint_symbol_5 = {tint_symbol.local_invocation_id, tint_symbol.local_invocation_index, tint_symbol.global_invocation_id, tint_symbol.workgroup_id, tint_symbol_3[0].xyz};
+  main_inner(tint_symbol_5);
+  return;
+}

test/tint/shader_io/compute_input_mixed.wgsl.expected.fxc.hlsl

@@ -0,0 +1,24 @@
+struct ComputeInputs0 {
+  uint3 local_invocation_id;
+};
+struct ComputeInputs1 {
+  uint3 workgroup_id;
+};
+struct tint_symbol_1 {
+  uint3 local_invocation_id : SV_GroupThreadID;
+  uint local_invocation_index : SV_GroupIndex;
+  uint3 global_invocation_id : SV_DispatchThreadID;
+  uint3 workgroup_id : SV_GroupID;
+};
+
+void main_inner(ComputeInputs0 inputs0, uint local_invocation_index, uint3 global_invocation_id, ComputeInputs1 inputs1) {
+  const uint foo = (((inputs0.local_invocation_id.x + local_invocation_index) + global_invocation_id.x) + inputs1.workgroup_id.x);
+}
+
+[numthreads(1, 1, 1)]
+void main(tint_symbol_1 tint_symbol) {
+  const ComputeInputs0 tint_symbol_2 = {tint_symbol.local_invocation_id};
+  const ComputeInputs1 tint_symbol_3 = {tint_symbol.workgroup_id};
+  main_inner(tint_symbol_2, tint_symbol.local_invocation_index, tint_symbol.global_invocation_id, tint_symbol_3);
+  return;
+}

test/tint/shader_io/fragment_input_builtins.wgsl.expected.fxc.hlsl

@@ -0,0 +1,18 @@
+struct tint_symbol_1 {
+  float4 position : SV_Position;
+  bool front_facing : SV_IsFrontFace;
+  uint sample_index : SV_SampleIndex;
+  uint sample_mask : SV_Coverage;
+};
+
+void main_inner(float4 position, bool front_facing, uint sample_index, uint sample_mask) {
+  if (front_facing) {
+    const float4 foo = position;
+    const uint bar = (sample_index + sample_mask);
+  }
+}
+
+void main(tint_symbol_1 tint_symbol) {
+  main_inner(tint_symbol.position, tint_symbol.front_facing, tint_symbol.sample_index, tint_symbol.sample_mask);
+  return;
+}

test/tint/shader_io/fragment_input_builtins_struct.wgsl.expected.fxc.hlsl

@@ -0,0 +1,25 @@
+struct FragmentInputs {
+  float4 position;
+  bool front_facing;
+  uint sample_index;
+  uint sample_mask;
+};
+struct tint_symbol_1 {
+  float4 position : SV_Position;
+  bool front_facing : SV_IsFrontFace;
+  uint sample_index : SV_SampleIndex;
+  uint sample_mask : SV_Coverage;
+};
+
+void main_inner(FragmentInputs inputs) {
+  if (inputs.front_facing) {
+    const float4 foo = inputs.position;
+    const uint bar = (inputs.sample_index + inputs.sample_mask);
+  }
+}
+
+void main(tint_symbol_1 tint_symbol) {
+  const FragmentInputs tint_symbol_2 = {tint_symbol.position, tint_symbol.front_facing, tint_symbol.sample_index, tint_symbol.sample_mask};
+  main_inner(tint_symbol_2);
+  return;
+}

test/tint/shader_io/fragment_input_locations.wgsl.expected.fxc.hlsl

@@ -0,0 +1,18 @@
+struct tint_symbol_1 {
+  nointerpolation int loc0 : TEXCOORD0;
+  nointerpolation uint loc1 : TEXCOORD1;
+  float loc2 : TEXCOORD2;
+  float4 loc3 : TEXCOORD3;
+};
+
+void main_inner(int loc0, uint loc1, float loc2, float4 loc3) {
+  const int i = loc0;
+  const uint u = loc1;
+  const float f = loc2;
+  const float4 v = loc3;
+}
+
+void main(tint_symbol_1 tint_symbol) {
+  main_inner(tint_symbol.loc0, tint_symbol.loc1, tint_symbol.loc2, tint_symbol.loc3);
+  return;
+}

test/tint/shader_io/fragment_input_locations_struct.wgsl.expected.fxc.hlsl

@@ -0,0 +1,25 @@
+struct FragmentInputs {
+  int loc0;
+  uint loc1;
+  float loc2;
+  float4 loc3;
+};
+struct tint_symbol_1 {
+  nointerpolation int loc0 : TEXCOORD0;
+  nointerpolation uint loc1 : TEXCOORD1;
+  float loc2 : TEXCOORD2;
+  float4 loc3 : TEXCOORD3;
+};
+
+void main_inner(FragmentInputs inputs) {
+  const int i = inputs.loc0;
+  const uint u = inputs.loc1;
+  const float f = inputs.loc2;
+  const float4 v = inputs.loc3;
+}
+
+void main(tint_symbol_1 tint_symbol) {
+  const FragmentInputs tint_symbol_2 = {tint_symbol.loc0, tint_symbol.loc1, tint_symbol.loc2, tint_symbol.loc3};
+  main_inner(tint_symbol_2);
+  return;
+}

test/tint/shader_io/fragment_input_mixed.wgsl.expected.fxc.hlsl

@@ -0,0 +1,36 @@
+struct FragmentInputs0 {
+  float4 position;
+  int loc0;
+};
+struct FragmentInputs1 {
+  float4 loc3;
+  uint sample_mask;
+};
+struct tint_symbol_1 {
+  nointerpolation int loc0 : TEXCOORD0;
+  nointerpolation uint loc1 : TEXCOORD1;
+  float loc2 : TEXCOORD2;
+  float4 loc3 : TEXCOORD3;
+  float4 position : SV_Position;
+  bool front_facing : SV_IsFrontFace;
+  uint sample_index : SV_SampleIndex;
+  uint sample_mask : SV_Coverage;
+};
+
+void main_inner(FragmentInputs0 inputs0, bool front_facing, uint loc1, uint sample_index, FragmentInputs1 inputs1, float loc2) {
+  if (front_facing) {
+    const float4 foo = inputs0.position;
+    const uint bar = (sample_index + inputs1.sample_mask);
+    const int i = inputs0.loc0;
+    const uint u = loc1;
+    const float f = loc2;
+    const float4 v = inputs1.loc3;
+  }
+}
+
+void main(tint_symbol_1 tint_symbol) {
+  const FragmentInputs0 tint_symbol_2 = {tint_symbol.position, tint_symbol.loc0};
+  const FragmentInputs1 tint_symbol_3 = {tint_symbol.loc3, tint_symbol.sample_mask};
+  main_inner(tint_symbol_2, tint_symbol.front_facing, tint_symbol.loc1, tint_symbol.sample_index, tint_symbol_3, tint_symbol.loc2);
+  return;
+}

test/tint/shader_io/fragment_output_builtins.wgsl.expected.fxc.hlsl

@@ -0,0 +1,29 @@
+struct tint_symbol {
+  float value : SV_Depth;
+};
+
+float main1_inner() {
+  return 1.0f;
+}
+
+tint_symbol main1() {
+  const float inner_result = main1_inner();
+  tint_symbol wrapper_result = (tint_symbol)0;
+  wrapper_result.value = inner_result;
+  return wrapper_result;
+}
+
+struct tint_symbol_1 {
+  uint value : SV_Coverage;
+};
+
+uint main2_inner() {
+  return 1u;
+}
+
+tint_symbol_1 main2() {
+  const uint inner_result_1 = main2_inner();
+  tint_symbol_1 wrapper_result_1 = (tint_symbol_1)0;
+  wrapper_result_1.value = inner_result_1;
+  return wrapper_result_1;
+}

test/tint/shader_io/fragment_output_builtins_struct.wgsl.expected.fxc.hlsl

@@ -0,0 +1,21 @@
+struct FragmentOutputs {
+  float frag_depth;
+  uint sample_mask;
+};
+struct tint_symbol {
+  float frag_depth : SV_Depth;
+  uint sample_mask : SV_Coverage;
+};
+
+FragmentOutputs main_inner() {
+  const FragmentOutputs tint_symbol_1 = {1.0f, 1u};
+  return tint_symbol_1;
+}
+
+tint_symbol main() {
+  const FragmentOutputs inner_result = main_inner();
+  tint_symbol wrapper_result = (tint_symbol)0;
+  wrapper_result.frag_depth = inner_result.frag_depth;
+  wrapper_result.sample_mask = inner_result.sample_mask;
+  return wrapper_result;
+}

test/tint/shader_io/fragment_output_locations.wgsl.expected.fxc.hlsl

@@ -0,0 +1,59 @@
+struct tint_symbol {
+  int value : SV_Target0;
+};
+
+int main0_inner() {
+  return 1;
+}
+
+tint_symbol main0() {
+  const int inner_result = main0_inner();
+  tint_symbol wrapper_result = (tint_symbol)0;
+  wrapper_result.value = inner_result;
+  return wrapper_result;
+}
+
+struct tint_symbol_1 {
+  uint value : SV_Target1;
+};
+
+uint main1_inner() {
+  return 1u;
+}
+
+tint_symbol_1 main1() {
+  const uint inner_result_1 = main1_inner();
+  tint_symbol_1 wrapper_result_1 = (tint_symbol_1)0;
+  wrapper_result_1.value = inner_result_1;
+  return wrapper_result_1;
+}
+
+struct tint_symbol_2 {
+  float value : SV_Target2;
+};
+
+float main2_inner() {
+  return 1.0f;
+}
+
+tint_symbol_2 main2() {
+  const float inner_result_2 = main2_inner();
+  tint_symbol_2 wrapper_result_2 = (tint_symbol_2)0;
+  wrapper_result_2.value = inner_result_2;
+  return wrapper_result_2;
+}
+
+struct tint_symbol_3 {
+  float4 value : SV_Target3;
+};
+
+float4 main3_inner() {
+  return float4(1.0f, 2.0f, 3.0f, 4.0f);
+}
+
+tint_symbol_3 main3() {
+  const float4 inner_result_3 = main3_inner();
+  tint_symbol_3 wrapper_result_3 = (tint_symbol_3)0;
+  wrapper_result_3.value = inner_result_3;
+  return wrapper_result_3;
+}

test/tint/shader_io/fragment_output_locations_struct.wgsl.expected.fxc.hlsl

@@ -0,0 +1,27 @@
+struct FragmentOutputs {
+  int loc0;
+  uint loc1;
+  float loc2;
+  float4 loc3;
+};
+struct tint_symbol {
+  int loc0 : SV_Target0;
+  uint loc1 : SV_Target1;
+  float loc2 : SV_Target2;
+  float4 loc3 : SV_Target3;
+};
+
+FragmentOutputs main_inner() {
+  const FragmentOutputs tint_symbol_1 = {1, 1u, 1.0f, float4(1.0f, 2.0f, 3.0f, 4.0f)};
+  return tint_symbol_1;
+}
+
+tint_symbol main() {
+  const FragmentOutputs inner_result = main_inner();
+  tint_symbol wrapper_result = (tint_symbol)0;
+  wrapper_result.loc0 = inner_result.loc0;
+  wrapper_result.loc1 = inner_result.loc1;
+  wrapper_result.loc2 = inner_result.loc2;
+  wrapper_result.loc3 = inner_result.loc3;
+  return wrapper_result;
+}

test/tint/shader_io/fragment_output_mixed.wgsl.expected.fxc.hlsl

@@ -0,0 +1,33 @@
+struct FragmentOutputs {
+  int loc0;
+  float frag_depth;
+  uint loc1;
+  float loc2;
+  uint sample_mask;
+  float4 loc3;
+};
+struct tint_symbol {
+  int loc0 : SV_Target0;
+  uint loc1 : SV_Target1;
+  float loc2 : SV_Target2;
+  float4 loc3 : SV_Target3;
+  float frag_depth : SV_Depth;
+  uint sample_mask : SV_Coverage;
+};
+
+FragmentOutputs main_inner() {
+  const FragmentOutputs tint_symbol_1 = {1, 2.0f, 1u, 1.0f, 2u, float4(1.0f, 2.0f, 3.0f, 4.0f)};
+  return tint_symbol_1;
+}
+
+tint_symbol main() {
+  const FragmentOutputs inner_result = main_inner();
+  tint_symbol wrapper_result = (tint_symbol)0;
+  wrapper_result.loc0 = inner_result.loc0;
+  wrapper_result.frag_depth = inner_result.frag_depth;
+  wrapper_result.loc1 = inner_result.loc1;
+  wrapper_result.loc2 = inner_result.loc2;
+  wrapper_result.sample_mask = inner_result.sample_mask;
+  wrapper_result.loc3 = inner_result.loc3;
+  return wrapper_result;
+}

test/tint/shader_io/interpolate_input_parameters.wgsl.expected.fxc.hlsl

@@ -0,0 +1,18 @@
+struct tint_symbol_1 {
+  float none : TEXCOORD0;
+  nointerpolation float flat : TEXCOORD1;
+  linear float perspective_center : TEXCOORD2;
+  linear centroid float perspective_centroid : TEXCOORD3;
+  linear sample float perspective_sample : TEXCOORD4;
+  noperspective float linear_center : TEXCOORD5;
+  noperspective centroid float linear_centroid : TEXCOORD6;
+  noperspective sample float linear_sample : TEXCOORD7;
+};
+
+void main_inner(float none, float flat, float perspective_center, float perspective_centroid, float perspective_sample, float linear_center, float linear_centroid, float linear_sample) {
+}
+
+void main(tint_symbol_1 tint_symbol) {
+  main_inner(tint_symbol.none, tint_symbol.flat, tint_symbol.perspective_center, tint_symbol.perspective_centroid, tint_symbol.perspective_sample, tint_symbol.linear_center, tint_symbol.linear_centroid, tint_symbol.linear_sample);
+  return;
+}

test/tint/shader_io/interpolate_input_struct.wgsl.expected.fxc.hlsl

@@ -0,0 +1,29 @@
+struct In {
+  float none;
+  float flat;
+  float perspective_center;
+  float perspective_centroid;
+  float perspective_sample;
+  float linear_center;
+  float linear_centroid;
+  float linear_sample;
+};
+struct tint_symbol_2 {
+  float none : TEXCOORD0;
+  nointerpolation float flat : TEXCOORD1;
+  linear float perspective_center : TEXCOORD2;
+  linear centroid float perspective_centroid : TEXCOORD3;
+  linear sample float perspective_sample : TEXCOORD4;
+  noperspective float linear_center : TEXCOORD5;
+  noperspective centroid float linear_centroid : TEXCOORD6;
+  noperspective sample float linear_sample : TEXCOORD7;
+};
+
+void main_inner(In tint_symbol) {
+}
+
+void main(tint_symbol_2 tint_symbol_1) {
+  const In tint_symbol_3 = {tint_symbol_1.none, tint_symbol_1.flat, tint_symbol_1.perspective_center, tint_symbol_1.perspective_centroid, tint_symbol_1.perspective_sample, tint_symbol_1.linear_center, tint_symbol_1.linear_centroid, tint_symbol_1.linear_sample};
+  main_inner(tint_symbol_3);
+  return;
+}

test/tint/shader_io/interpolate_integers.wgsl.expected.fxc.hlsl

@@ -0,0 +1,53 @@
+struct Interface {
+  int i;
+  uint u;
+  int4 vi;
+  uint4 vu;
+  float4 pos;
+};
+struct tint_symbol {
+  nointerpolation int i : TEXCOORD0;
+  nointerpolation uint u : TEXCOORD1;
+  nointerpolation int4 vi : TEXCOORD2;
+  nointerpolation uint4 vu : TEXCOORD3;
+  float4 pos : SV_Position;
+};
+
+Interface vert_main_inner() {
+  const Interface tint_symbol_4 = (Interface)0;
+  return tint_symbol_4;
+}
+
+tint_symbol vert_main() {
+  const Interface inner_result = vert_main_inner();
+  tint_symbol wrapper_result = (tint_symbol)0;
+  wrapper_result.i = inner_result.i;
+  wrapper_result.u = inner_result.u;
+  wrapper_result.vi = inner_result.vi;
+  wrapper_result.vu = inner_result.vu;
+  wrapper_result.pos = inner_result.pos;
+  return wrapper_result;
+}
+
+struct tint_symbol_2 {
+  nointerpolation int i : TEXCOORD0;
+  nointerpolation uint u : TEXCOORD1;
+  nointerpolation int4 vi : TEXCOORD2;
+  nointerpolation uint4 vu : TEXCOORD3;
+  float4 pos : SV_Position;
+};
+struct tint_symbol_3 {
+  int value : SV_Target0;
+};
+
+int frag_main_inner(Interface inputs) {
+  return inputs.i;
+}
+
+tint_symbol_3 frag_main(tint_symbol_2 tint_symbol_1) {
+  const Interface tint_symbol_5 = {tint_symbol_1.i, tint_symbol_1.u, tint_symbol_1.vi, tint_symbol_1.vu, tint_symbol_1.pos};
+  const int inner_result_1 = frag_main_inner(tint_symbol_5);
+  tint_symbol_3 wrapper_result_1 = (tint_symbol_3)0;
+  wrapper_result_1.value = inner_result_1;
+  return wrapper_result_1;
+}

test/tint/shader_io/interpolate_return_struct.wgsl.expected.fxc.hlsl

@@ -0,0 +1,42 @@
+struct Out {
+  float4 pos;
+  float none;
+  float flat;
+  float perspective_center;
+  float perspective_centroid;
+  float perspective_sample;
+  float linear_center;
+  float linear_centroid;
+  float linear_sample;
+};
+struct tint_symbol {
+  float none : TEXCOORD0;
+  nointerpolation float flat : TEXCOORD1;
+  linear float perspective_center : TEXCOORD2;
+  linear centroid float perspective_centroid : TEXCOORD3;
+  linear sample float perspective_sample : TEXCOORD4;
+  noperspective float linear_center : TEXCOORD5;
+  noperspective centroid float linear_centroid : TEXCOORD6;
+  noperspective sample float linear_sample : TEXCOORD7;
+  float4 pos : SV_Position;
+};
+
+Out main_inner() {
+  const Out tint_symbol_1 = (Out)0;
+  return tint_symbol_1;
+}
+
+tint_symbol main() {
+  const Out inner_result = main_inner();
+  tint_symbol wrapper_result = (tint_symbol)0;
+  wrapper_result.pos = inner_result.pos;
+  wrapper_result.none = inner_result.none;
+  wrapper_result.flat = inner_result.flat;
+  wrapper_result.perspective_center = inner_result.perspective_center;
+  wrapper_result.perspective_centroid = inner_result.perspective_centroid;
+  wrapper_result.perspective_sample = inner_result.perspective_sample;
+  wrapper_result.linear_center = inner_result.linear_center;
+  wrapper_result.linear_centroid = inner_result.linear_centroid;
+  wrapper_result.linear_sample = inner_result.linear_sample;
+  return wrapper_result;
+}

test/tint/shader_io/invariant.wgsl.expected.fxc.hlsl

@@ -0,0 +1,14 @@
+struct tint_symbol {
+  precise float4 value : SV_Position;
+};
+
+float4 main_inner() {
+  return (0.0f).xxxx;
+}
+
+tint_symbol main() {
+  const float4 inner_result = main_inner();
+  tint_symbol wrapper_result = (tint_symbol)0;
+  wrapper_result.value = inner_result;
+  return wrapper_result;
+}

test/tint/shader_io/invariant_struct_member.wgsl.expected.fxc.hlsl

@@ -0,0 +1,18 @@
+struct Out {
+  float4 pos;
+};
+struct tint_symbol {
+  precise float4 pos : SV_Position;
+};
+
+Out main_inner() {
+  const Out tint_symbol_1 = (Out)0;
+  return tint_symbol_1;
+}
+
+tint_symbol main() {
+  const Out inner_result = main_inner();
+  tint_symbol wrapper_result = (tint_symbol)0;
+  wrapper_result.pos = inner_result.pos;
+  return wrapper_result;
+}

test/tint/shader_io/shared_struct_different_stages.wgsl.expected.fxc.hlsl

@@ -0,0 +1,41 @@
+struct Interface {
+  float col1;
+  float col2;
+  float4 pos;
+};
+struct tint_symbol {
+  float col1 : TEXCOORD1;
+  float col2 : TEXCOORD2;
+  float4 pos : SV_Position;
+};
+
+Interface vert_main_inner() {
+  const Interface tint_symbol_3 = {0.400000006f, 0.600000024f, (0.0f).xxxx};
+  return tint_symbol_3;
+}
+
+tint_symbol vert_main() {
+  const Interface inner_result = vert_main_inner();
+  tint_symbol wrapper_result = (tint_symbol)0;
+  wrapper_result.col1 = inner_result.col1;
+  wrapper_result.col2 = inner_result.col2;
+  wrapper_result.pos = inner_result.pos;
+  return wrapper_result;
+}
+
+struct tint_symbol_2 {
+  float col1 : TEXCOORD1;
+  float col2 : TEXCOORD2;
+  float4 pos : SV_Position;
+};
+
+void frag_main_inner(Interface colors) {
+  const float r = colors.col1;
+  const float g = colors.col2;
+}
+
+void frag_main(tint_symbol_2 tint_symbol_1) {
+  const Interface tint_symbol_4 = {tint_symbol_1.col1, tint_symbol_1.col2, tint_symbol_1.pos};
+  frag_main_inner(tint_symbol_4);
+  return;
+}

test/tint/shader_io/shared_struct_helper_function.wgsl.expected.fxc.hlsl

@@ -0,0 +1,43 @@
+struct VertexOutput {
+  float4 pos;
+  int loc0;
+};
+
+VertexOutput foo(float x) {
+  const VertexOutput tint_symbol_2 = {float4(x, x, x, 1.0f), 42};
+  return tint_symbol_2;
+}
+
+struct tint_symbol {
+  nointerpolation int loc0 : TEXCOORD0;
+  float4 pos : SV_Position;
+};
+
+VertexOutput vert_main1_inner() {
+  return foo(0.5f);
+}
+
+tint_symbol vert_main1() {
+  const VertexOutput inner_result = vert_main1_inner();
+  tint_symbol wrapper_result = (tint_symbol)0;
+  wrapper_result.pos = inner_result.pos;
+  wrapper_result.loc0 = inner_result.loc0;
+  return wrapper_result;
+}
+
+struct tint_symbol_1 {
+  nointerpolation int loc0 : TEXCOORD0;
+  float4 pos : SV_Position;
+};
+
+VertexOutput vert_main2_inner() {
+  return foo(0.25f);
+}
+
+tint_symbol_1 vert_main2() {
+  const VertexOutput inner_result_1 = vert_main2_inner();
+  tint_symbol_1 wrapper_result_1 = (tint_symbol_1)0;
+  wrapper_result_1.pos = inner_result_1.pos;
+  wrapper_result_1.loc0 = inner_result_1.loc0;
+  return wrapper_result_1;
+}

test/tint/shader_io/shared_struct_storage_buffer.wgsl.expected.fxc.hlsl

@@ -0,0 +1,32 @@
+struct S {
+  float f;
+  uint u;
+  float4 v;
+};
+
+RWByteAddressBuffer output : register(u0, space0);
+
+struct tint_symbol_1 {
+  float f : TEXCOORD0;
+  nointerpolation uint u : TEXCOORD1;
+  float4 v : SV_Position;
+};
+
+void tint_symbol_2(RWByteAddressBuffer buffer, uint offset, S value) {
+  buffer.Store((offset + 0u), asuint(value.f));
+  buffer.Store((offset + 4u), asuint(value.u));
+  buffer.Store4((offset + 128u), asuint(value.v));
+}
+
+void frag_main_inner(S input) {
+  const float f = input.f;
+  const uint u = input.u;
+  const float4 v = input.v;
+  tint_symbol_2(output, 0u, input);
+}
+
+void frag_main(tint_symbol_1 tint_symbol) {
+  const S tint_symbol_6 = {tint_symbol.f, tint_symbol.u, tint_symbol.v};
+  frag_main_inner(tint_symbol_6);
+  return;
+}

test/tint/shader_io/vertex_input_builtins.wgsl.expected.fxc.hlsl

@@ -0,0 +1,19 @@
+struct tint_symbol_1 {
+  uint vertex_index : SV_VertexID;
+  uint instance_index : SV_InstanceID;
+};
+struct tint_symbol_2 {
+  float4 value : SV_Position;
+};
+
+float4 main_inner(uint vertex_index, uint instance_index) {
+  const uint foo = (vertex_index + instance_index);
+  return (0.0f).xxxx;
+}
+
+tint_symbol_2 main(tint_symbol_1 tint_symbol) {
+  const float4 inner_result = main_inner(tint_symbol.vertex_index, tint_symbol.instance_index);
+  tint_symbol_2 wrapper_result = (tint_symbol_2)0;
+  wrapper_result.value = inner_result;
+  return wrapper_result;
+}

test/tint/shader_io/vertex_input_builtins_struct.wgsl.expected.fxc.hlsl

@@ -0,0 +1,24 @@
+struct VertexInputs {
+  uint vertex_index;
+  uint instance_index;
+};
+struct tint_symbol_1 {
+  uint vertex_index : SV_VertexID;
+  uint instance_index : SV_InstanceID;
+};
+struct tint_symbol_2 {
+  float4 value : SV_Position;
+};
+
+float4 main_inner(VertexInputs inputs) {
+  const uint foo = (inputs.vertex_index + inputs.instance_index);
+  return (0.0f).xxxx;
+}
+
+tint_symbol_2 main(tint_symbol_1 tint_symbol) {
+  const VertexInputs tint_symbol_3 = {tint_symbol.vertex_index, tint_symbol.instance_index};
+  const float4 inner_result = main_inner(tint_symbol_3);
+  tint_symbol_2 wrapper_result = (tint_symbol_2)0;
+  wrapper_result.value = inner_result;
+  return wrapper_result;
+}

test/tint/shader_io/vertex_input_locations.wgsl.expected.fxc.hlsl

@@ -0,0 +1,24 @@
+struct tint_symbol_1 {
+  int loc0 : TEXCOORD0;
+  uint loc1 : TEXCOORD1;
+  float loc2 : TEXCOORD2;
+  float4 loc3 : TEXCOORD3;
+};
+struct tint_symbol_2 {
+  float4 value : SV_Position;
+};
+
+float4 main_inner(int loc0, uint loc1, float loc2, float4 loc3) {
+  const int i = loc0;
+  const uint u = loc1;
+  const float f = loc2;
+  const float4 v = loc3;
+  return (0.0f).xxxx;
+}
+
+tint_symbol_2 main(tint_symbol_1 tint_symbol) {
+  const float4 inner_result = main_inner(tint_symbol.loc0, tint_symbol.loc1, tint_symbol.loc2, tint_symbol.loc3);
+  tint_symbol_2 wrapper_result = (tint_symbol_2)0;
+  wrapper_result.value = inner_result;
+  return wrapper_result;
+}

test/tint/shader_io/vertex_input_locations_struct.wgsl.expected.fxc.hlsl

@@ -0,0 +1,31 @@
+struct VertexInputs {
+  int loc0;
+  uint loc1;
+  float loc2;
+  float4 loc3;
+};
+struct tint_symbol_1 {
+  int loc0 : TEXCOORD0;
+  uint loc1 : TEXCOORD1;
+  float loc2 : TEXCOORD2;
+  float4 loc3 : TEXCOORD3;
+};
+struct tint_symbol_2 {
+  float4 value : SV_Position;
+};
+
+float4 main_inner(VertexInputs inputs) {
+  const int i = inputs.loc0;
+  const uint u = inputs.loc1;
+  const float f = inputs.loc2;
+  const float4 v = inputs.loc3;
+  return (0.0f).xxxx;
+}
+
+tint_symbol_2 main(tint_symbol_1 tint_symbol) {
+  const VertexInputs tint_symbol_3 = {tint_symbol.loc0, tint_symbol.loc1, tint_symbol.loc2, tint_symbol.loc3};
+  const float4 inner_result = main_inner(tint_symbol_3);
+  tint_symbol_2 wrapper_result = (tint_symbol_2)0;
+  wrapper_result.value = inner_result;
+  return wrapper_result;
+}

test/tint/shader_io/vertex_input_mixed.wgsl.expected.fxc.hlsl

@@ -0,0 +1,37 @@
+struct VertexInputs0 {
+  uint vertex_index;
+  int loc0;
+};
+struct VertexInputs1 {
+  float loc2;
+  float4 loc3;
+};
+struct tint_symbol_1 {
+  int loc0 : TEXCOORD0;
+  uint loc1 : TEXCOORD1;
+  float loc2 : TEXCOORD2;
+  float4 loc3 : TEXCOORD3;
+  uint vertex_index : SV_VertexID;
+  uint instance_index : SV_InstanceID;
+};
+struct tint_symbol_2 {
+  float4 value : SV_Position;
+};
+
+float4 main_inner(VertexInputs0 inputs0, uint loc1, uint instance_index, VertexInputs1 inputs1) {
+  const uint foo = (inputs0.vertex_index + instance_index);
+  const int i = inputs0.loc0;
+  const uint u = loc1;
+  const float f = inputs1.loc2;
+  const float4 v = inputs1.loc3;
+  return (0.0f).xxxx;
+}
+
+tint_symbol_2 main(tint_symbol_1 tint_symbol) {
+  const VertexInputs0 tint_symbol_3 = {tint_symbol.vertex_index, tint_symbol.loc0};
+  const VertexInputs1 tint_symbol_4 = {tint_symbol.loc2, tint_symbol.loc3};
+  const float4 inner_result = main_inner(tint_symbol_3, tint_symbol.loc1, tint_symbol.instance_index, tint_symbol_4);
+  tint_symbol_2 wrapper_result = (tint_symbol_2)0;
+  wrapper_result.value = inner_result;
+  return wrapper_result;
+}

test/tint/shader_io/vertex_output_builtins.wgsl.expected.fxc.hlsl

@@ -0,0 +1,14 @@
+struct tint_symbol {
+  float4 value : SV_Position;
+};
+
+float4 main_inner() {
+  return float4(1.0f, 2.0f, 3.0f, 4.0f);
+}
+
+tint_symbol main() {
+  const float4 inner_result = main_inner();
+  tint_symbol wrapper_result = (tint_symbol)0;
+  wrapper_result.value = inner_result;
+  return wrapper_result;
+}

test/tint/shader_io/vertex_output_builtins_struct.wgsl.expected.fxc.hlsl

@@ -0,0 +1,18 @@
+struct VertexOutputs {
+  float4 position;
+};
+struct tint_symbol {
+  float4 position : SV_Position;
+};
+
+VertexOutputs main_inner() {
+  const VertexOutputs tint_symbol_1 = {float4(1.0f, 2.0f, 3.0f, 4.0f)};
+  return tint_symbol_1;
+}
+
+tint_symbol main() {
+  const VertexOutputs inner_result = main_inner();
+  tint_symbol wrapper_result = (tint_symbol)0;
+  wrapper_result.position = inner_result.position;
+  return wrapper_result;
+}

test/tint/shader_io/vertex_output_locations_struct.wgsl.expected.fxc.hlsl

@@ -0,0 +1,30 @@
+struct VertexOutputs {
+  int loc0;
+  uint loc1;
+  float loc2;
+  float4 loc3;
+  float4 position;
+};
+struct tint_symbol {
+  nointerpolation int loc0 : TEXCOORD0;
+  nointerpolation uint loc1 : TEXCOORD1;
+  float loc2 : TEXCOORD2;
+  float4 loc3 : TEXCOORD3;
+  float4 position : SV_Position;
+};
+
+VertexOutputs main_inner() {
+  const VertexOutputs tint_symbol_1 = {1, 1u, 1.0f, float4(1.0f, 2.0f, 3.0f, 4.0f), (0.0f).xxxx};
+  return tint_symbol_1;
+}
+
+tint_symbol main() {
+  const VertexOutputs inner_result = main_inner();
+  tint_symbol wrapper_result = (tint_symbol)0;
+  wrapper_result.loc0 = inner_result.loc0;
+  wrapper_result.loc1 = inner_result.loc1;
+  wrapper_result.loc2 = inner_result.loc2;
+  wrapper_result.loc3 = inner_result.loc3;
+  wrapper_result.position = inner_result.position;
+  return wrapper_result;
+}