HLSL: work around FXC failures when dynamically indexing arrays in structs

FXC fails to compile code that assigns to dynamically-indexed fixed-size
arrays in structs on internal shader variables with:

error X3500: array reference cannot be used as an l-value; not natively
addressable

This CL detects this case, and transforms such assignments into copying
out the array to a local variable, assigning to that local, and then
copying the array back.

Also manually regenerate SKIPs for HLSL/FXC after this change, which
fixes 30 tests. Also exposes some "compilation aborted unexpectedly" now
that  "array reference cannot be used as an l-value" has been fixed. For
tests that fail for both DXC and FXC, updating SKIPs to the DXC one to
help distinguish actual FXC bugs from valid errors.

Bug: tint:998
Bug: tint:1206
Change-Id: I09204d8d81ab27d1c257538ad702414ccc386543
Reviewed-on: https://dawn-review.googlesource.com/c/tint/+/71620
Reviewed-by: Ben Clayton <bclayton@google.com>
Kokoro: Kokoro <noreply+kokoro@google.com>
Commit-Queue: Antonio Maiorano <amaiorano@google.com>

test/statements/assign/indexed_assign_to_array_in_struct/in_for_loop_body.wgsl

@@ -0,0 +1,22 @@
+struct Uniforms {
+  i : u32;
+};
+
+struct InnerS {
+  v : i32;
+};
+
+struct OuterS {
+  a1 : array<InnerS, 8>;
+};
+
+[[group(1), binding(4)]] var<uniform> uniforms : Uniforms;
+
+[[stage(compute), workgroup_size(1)]]
+fn main() {
+  var v : InnerS;
+  var s1 : OuterS;
+  for (var i: i32 = 0; i < 4; i = i + 1) {
+    s1.a1[uniforms.i] = v;
+  }
+}

test/statements/assign/indexed_assign_to_array_in_struct/in_for_loop_body.wgsl.expected.hlsl

@@ -0,0 +1,26 @@
+struct InnerS {
+  int v;
+};
+struct OuterS {
+  InnerS a1[8];
+};
+
+cbuffer cbuffer_uniforms : register(b4, space1) {
+  uint4 uniforms[1];
+};
+
+[numthreads(1, 1, 1)]
+void main() {
+  InnerS v = (InnerS)0;
+  OuterS s1 = (OuterS)0;
+  {
+    [loop] for(int i = 0; (i < 4); i = (i + 1)) {
+      {
+        InnerS tint_symbol_1[8] = s1.a1;
+        tint_symbol_1[uniforms[0].x] = v;
+        s1.a1 = tint_symbol_1;
+      }
+    }
+  }
+  return;
+}

test/statements/assign/indexed_assign_to_array_in_struct/in_for_loop_continuing.wgsl

@@ -0,0 +1,22 @@
+struct Uniforms {
+  i : u32;
+};
+
+struct InnerS {
+  v : i32;
+};
+
+struct OuterS {
+  a1 : array<InnerS, 8>;
+};
+
+[[group(1), binding(4)]] var<uniform> uniforms : Uniforms;
+
+[[stage(compute), workgroup_size(1)]]
+fn main() {
+  var v : InnerS;
+  var s1 : OuterS;
+  for (var i: i32 = 0; i < 4; s1.a1[uniforms.i] = v) {
+    i = i + 1;
+  }
+}

test/statements/assign/indexed_assign_to_array_in_struct/in_for_loop_continuing.wgsl.expected.hlsl

@@ -0,0 +1,29 @@
+struct InnerS {
+  int v;
+};
+struct OuterS {
+  InnerS a1[8];
+};
+
+cbuffer cbuffer_uniforms : register(b4, space1) {
+  uint4 uniforms[1];
+};
+
+[numthreads(1, 1, 1)]
+void main() {
+  InnerS v = (InnerS)0;
+  OuterS s1 = (OuterS)0;
+  {
+    int i = 0;
+    [loop] while (true) {
+      if (!((i < 4))) { break; }
+      i = (i + 1);
+      {
+        InnerS tint_symbol_1[8] = s1.a1;
+        tint_symbol_1[uniforms[0].x] = v;
+        s1.a1 = tint_symbol_1;
+      }
+    }
+  }
+  return;
+}

test/statements/assign/indexed_assign_to_array_in_struct/in_for_loop_init.wgsl

@@ -0,0 +1,22 @@
+struct Uniforms {
+  i : u32;
+};
+
+struct InnerS {
+  v : i32;
+};
+
+struct OuterS {
+  a1 : array<InnerS, 8>;
+};
+
+[[group(1), binding(4)]] var<uniform> uniforms : Uniforms;
+
+[[stage(compute), workgroup_size(1)]]
+fn main() {
+  var v : InnerS;
+  var s1 : OuterS;
+  var i: i32 = 0;
+  for (s1.a1[uniforms.i] = v; i < 4; i = i + 1) {
+  }
+}

test/statements/assign/indexed_assign_to_array_in_struct/in_for_loop_init.wgsl.expected.hlsl

@@ -0,0 +1,27 @@
+struct InnerS {
+  int v;
+};
+struct OuterS {
+  InnerS a1[8];
+};
+
+cbuffer cbuffer_uniforms : register(b4, space1) {
+  uint4 uniforms[1];
+};
+
+[numthreads(1, 1, 1)]
+void main() {
+  InnerS v = (InnerS)0;
+  OuterS s1 = (OuterS)0;
+  int i = 0;
+  {
+    {
+      InnerS tint_symbol_1[8] = s1.a1;
+      tint_symbol_1[uniforms[0].x] = v;
+      s1.a1 = tint_symbol_1;
+    }
+    [loop] for(; (i < 4); i = (i + 1)) {
+    }
+  }
+  return;
+}

test/statements/assign/indexed_assign_to_array_in_struct/indexing_with_side_effect_func.wgsl

@@ -0,0 +1,31 @@
+struct Uniforms {
+  i : u32;
+  j : u32;
+};
+
+struct InnerS {
+  v : i32;
+};
+
+struct S1 {
+  a2 : array<InnerS, 8>;
+};
+
+struct OuterS {
+  a1 : array<S1, 8>;
+};
+
+var<private> nextIndex : u32;
+fn getNextIndex() -> u32 {
+  nextIndex = nextIndex + 1u;
+  return nextIndex;
+}
+
+[[group(1), binding(4)]] var<uniform> uniforms : Uniforms;
+
+[[stage(compute), workgroup_size(1)]]
+fn main() {
+  var v : InnerS;
+  var s : OuterS;
+  s.a1[getNextIndex()].a2[uniforms.j] = v;
+}

test/statements/assign/indexed_assign_to_array_in_struct/indexing_with_side_effect_func.wgsl.expected.hlsl

@@ -0,0 +1,35 @@
+struct InnerS {
+  int v;
+};
+struct S1 {
+  InnerS a2[8];
+};
+struct OuterS {
+  S1 a1[8];
+};
+
+static uint nextIndex = 0u;
+
+uint getNextIndex() {
+  nextIndex = (nextIndex + 1u);
+  return nextIndex;
+}
+
+cbuffer cbuffer_uniforms : register(b4, space1) {
+  uint4 uniforms[1];
+};
+
+[numthreads(1, 1, 1)]
+void main() {
+  InnerS v = (InnerS)0;
+  OuterS s = (OuterS)0;
+  {
+    S1 tint_symbol_1[8] = s.a1;
+    const uint tint_symbol_2_save = getNextIndex();
+    InnerS tint_symbol_3[8] = tint_symbol_1[tint_symbol_2_save].a2;
+    tint_symbol_3[uniforms[0].y] = v;
+    tint_symbol_1[tint_symbol_2_save].a2 = tint_symbol_3;
+    s.a1 = tint_symbol_1;
+  }
+  return;
+}

test/statements/assign/indexed_assign_to_array_in_struct/struct_array.wgsl

@@ -0,0 +1,21 @@
+struct Uniforms {
+  i : u32;
+};
+
+struct InnerS {
+  v : i32;
+};
+
+struct OuterS {
+  a1 : array<InnerS, 8>;
+};
+
+[[group(1), binding(4)]] var<uniform> uniforms : Uniforms;
+
+[[stage(compute), workgroup_size(1)]]
+fn main() {
+  var v : InnerS;
+  var s1 : OuterS;
+  s1.a1[uniforms.i] = v;
+  //s1.a1[0] = v;
+}

test/statements/assign/indexed_assign_to_array_in_struct/struct_array.wgsl.expected.hlsl

@@ -0,0 +1,22 @@
+struct InnerS {
+  int v;
+};
+struct OuterS {
+  InnerS a1[8];
+};
+
+cbuffer cbuffer_uniforms : register(b4, space1) {
+  uint4 uniforms[1];
+};
+
+[numthreads(1, 1, 1)]
+void main() {
+  InnerS v = (InnerS)0;
+  OuterS s1 = (OuterS)0;
+  {
+    InnerS tint_symbol_1[8] = s1.a1;
+    tint_symbol_1[uniforms[0].x] = v;
+    s1.a1 = tint_symbol_1;
+  }
+  return;
+}

test/statements/assign/indexed_assign_to_array_in_struct/struct_array_array.wgsl

@@ -0,0 +1,21 @@
+struct Uniforms {
+  i : u32;
+  j : u32;
+};
+
+struct InnerS {
+  v : i32;
+};
+
+struct OuterS {
+  a1 : array<array<InnerS, 8>, 8>;
+};
+
+[[group(1), binding(4)]] var<uniform> uniforms : Uniforms;
+
+[[stage(compute), workgroup_size(1)]]
+fn main() {
+  var v : InnerS;
+  var s1 : OuterS;
+  s1.a1[uniforms.i][uniforms.j] = v;
+}

test/statements/assign/indexed_assign_to_array_in_struct/struct_array_array.wgsl.expected.hlsl

@@ -0,0 +1,22 @@
+struct InnerS {
+  int v;
+};
+struct OuterS {
+  InnerS a1[8][8];
+};
+
+cbuffer cbuffer_uniforms : register(b4, space1) {
+  uint4 uniforms[1];
+};
+
+[numthreads(1, 1, 1)]
+void main() {
+  InnerS v = (InnerS)0;
+  OuterS s1 = (OuterS)0;
+  {
+    InnerS tint_symbol_1[8][8] = s1.a1;
+    tint_symbol_1[uniforms[0].x][uniforms[0].y] = v;
+    s1.a1 = tint_symbol_1;
+  }
+  return;
+}

test/statements/assign/indexed_assign_to_array_in_struct/struct_array_struct.wgsl

@@ -0,0 +1,24 @@
+struct Uniforms {
+  i : u32;
+};
+
+struct InnerS {
+  v : i32;
+};
+
+struct S1 {
+  s2 : InnerS;
+};
+
+struct OuterS {
+  a1 : array<S1, 8>;
+};
+
+[[group(1), binding(4)]] var<uniform> uniforms : Uniforms;
+
+[[stage(compute), workgroup_size(1)]]
+fn main() {
+  var v : InnerS;
+  var s1 : OuterS;
+  s1.a1[uniforms.i].s2 = v;
+}

test/statements/assign/indexed_assign_to_array_in_struct/struct_array_struct.wgsl.expected.hlsl

@@ -0,0 +1,25 @@
+struct InnerS {
+  int v;
+};
+struct S1 {
+  InnerS s2;
+};
+struct OuterS {
+  S1 a1[8];
+};
+
+cbuffer cbuffer_uniforms : register(b4, space1) {
+  uint4 uniforms[1];
+};
+
+[numthreads(1, 1, 1)]
+void main() {
+  InnerS v = (InnerS)0;
+  OuterS s1 = (OuterS)0;
+  {
+    S1 tint_symbol_1[8] = s1.a1;
+    tint_symbol_1[uniforms[0].x].s2 = v;
+    s1.a1 = tint_symbol_1;
+  }
+  return;
+}

test/statements/assign/indexed_assign_to_array_in_struct/struct_array_struct_array.wgsl

@@ -0,0 +1,25 @@
+struct Uniforms {
+  i : u32;
+  j : u32;
+};
+
+struct InnerS {
+  v : i32;
+};
+
+struct S1 {
+  a2 : array<InnerS, 8>;
+};
+
+struct OuterS {
+  a1 : array<S1, 8>;
+};
+
+[[group(1), binding(4)]] var<uniform> uniforms : Uniforms;
+
+[[stage(compute), workgroup_size(1)]]
+fn main() {
+  var v : InnerS;
+  var s : OuterS;
+  s.a1[uniforms.i].a2[uniforms.j] = v;
+}

test/statements/assign/indexed_assign_to_array_in_struct/struct_array_struct_array.wgsl.expected.hlsl

@@ -0,0 +1,28 @@
+struct InnerS {
+  int v;
+};
+struct S1 {
+  InnerS a2[8];
+};
+struct OuterS {
+  S1 a1[8];
+};
+
+cbuffer cbuffer_uniforms : register(b4, space1) {
+  uint4 uniforms[1];
+};
+
+[numthreads(1, 1, 1)]
+void main() {
+  InnerS v = (InnerS)0;
+  OuterS s = (OuterS)0;
+  {
+    S1 tint_symbol_1[8] = s.a1;
+    const uint tint_symbol_2_save = uniforms[0].x;
+    InnerS tint_symbol_3[8] = tint_symbol_1[tint_symbol_2_save].a2;
+    tint_symbol_3[uniforms[0].y] = v;
+    tint_symbol_1[tint_symbol_2_save].a2 = tint_symbol_3;
+    s.a1 = tint_symbol_1;
+  }
+  return;
+}

test/statements/assign/indexed_assign_to_array_in_struct/struct_dynamic_array.wgsl

@@ -0,0 +1,20 @@
+struct Uniforms {
+  i : u32;
+};
+
+struct InnerS {
+  v : i32;
+};
+
+struct OuterS {
+  a1 : array<InnerS>;
+};
+
+[[group(1), binding(4)]] var<uniform> uniforms : Uniforms;
+[[binding(0), group(0)]] var<storage, read_write> s1 : OuterS;
+
+[[stage(compute), workgroup_size(1)]]
+fn main() {
+  var v : InnerS;
+  s1.a1[uniforms.i] = v;
+}

test/statements/assign/indexed_assign_to_array_in_struct/struct_dynamic_array.wgsl.expected.hlsl

@@ -0,0 +1,19 @@
+struct InnerS {
+  int v;
+};
+
+cbuffer cbuffer_uniforms : register(b4, space1) {
+  uint4 uniforms[1];
+};
+RWByteAddressBuffer s1 : register(u0, space0);
+
+void tint_symbol_1(RWByteAddressBuffer buffer, uint offset, InnerS value) {
+  buffer.Store((offset + 0u), asuint(value.v));
+}
+
+[numthreads(1, 1, 1)]
+void main() {
+  InnerS v = (InnerS)0;
+  tint_symbol_1(s1, (4u * uniforms[0].x), v);
+  return;
+}

test/statements/assign/indexed_assign_to_array_in_struct/struct_dynamic_array_struct_array.wgsl

@@ -0,0 +1,25 @@
+struct Uniforms {
+  i : u32;
+  j : u32;
+};
+
+struct InnerS {
+  v : i32;
+};
+
+struct S1 {
+  a2 : array<InnerS, 8>;
+};
+
+struct OuterS {
+  a1 : array<S1>;
+};
+
+[[group(1), binding(4)]] var<uniform> uniforms : Uniforms;
+[[binding(0), group(0)]] var<storage, read_write> s : OuterS;
+
+[[stage(compute), workgroup_size(1)]]
+fn main() {
+  var v : InnerS;
+  s.a1[uniforms.i].a2[uniforms.j] = v;
+}

test/statements/assign/indexed_assign_to_array_in_struct/struct_dynamic_array_struct_array.wgsl.expected.hlsl

@@ -0,0 +1,19 @@
+struct InnerS {
+  int v;
+};
+
+cbuffer cbuffer_uniforms : register(b4, space1) {
+  uint4 uniforms[1];
+};
+RWByteAddressBuffer s : register(u0, space0);
+
+void tint_symbol_1(RWByteAddressBuffer buffer, uint offset, InnerS value) {
+  buffer.Store((offset + 0u), asuint(value.v));
+}
+
+[numthreads(1, 1, 1)]
+void main() {
+  InnerS v = (InnerS)0;
+  tint_symbol_1(s, ((32u * uniforms[0].x) + (4u * uniforms[0].y)), v);
+  return;
+}

test/statements/assign/indexed_assign_to_array_in_struct/struct_matrix.wgsl

@@ -0,0 +1,16 @@
+struct Uniforms {
+  i : u32;
+};
+
+struct OuterS {
+  m1 : mat2x4<f32>;
+};
+
+[[group(1), binding(4)]] var<uniform> uniforms : Uniforms;
+
+[[stage(compute), workgroup_size(1)]]
+fn main() {
+  var s1 : OuterS;
+  s1.m1[uniforms.i] = vec4<f32>(1.0);
+  s1.m1[uniforms.i][uniforms.i] = 1.0;
+}

test/statements/assign/indexed_assign_to_array_in_struct/struct_matrix.wgsl.expected.hlsl

@@ -0,0 +1,33 @@
+void set_vector_float2x4(inout float2x4 mat, int col, float4 val) {
+  switch (col) {
+    case 0: mat[0] = val; break;
+    case 1: mat[1] = val; break;
+  }
+}
+
+void set_scalar_float2x4(inout float2x4 mat, int col, int row, float val) {
+  switch (col) {
+    case 0:
+      mat[0] = (row.xxxx == int4(0, 1, 2, 3)) ? val.xxxx : mat[0];
+      break;
+    case 1:
+      mat[1] = (row.xxxx == int4(0, 1, 2, 3)) ? val.xxxx : mat[1];
+      break;
+  }
+}
+
+struct OuterS {
+  float2x4 m1;
+};
+
+cbuffer cbuffer_uniforms : register(b4, space1) {
+  uint4 uniforms[1];
+};
+
+[numthreads(1, 1, 1)]
+void main() {
+  OuterS s1 = (OuterS)0;
+  set_vector_float2x4(s1.m1, uniforms[0].x, float4((1.0f).xxxx));
+  set_scalar_float2x4(s1.m1, uniforms[0].x, uniforms[0].x, 1.0f);
+  return;
+}

test/statements/assign/indexed_assign_to_array_in_struct/struct_multiple_arrays.wgsl

@@ -0,0 +1,22 @@
+struct Uniforms {
+  i : u32;
+};
+
+struct InnerS {
+  v : i32;
+};
+
+struct OuterS {
+  a1 : array<InnerS, 8>;
+  a2 : array<InnerS, 8>;
+};
+
+[[group(1), binding(4)]] var<uniform> uniforms : Uniforms;
+
+[[stage(compute), workgroup_size(1)]]
+fn main() {
+  var v : InnerS;
+  var s1 : OuterS;
+  s1.a1[uniforms.i] = v;
+  s1.a2[uniforms.i] = v;
+}

test/statements/assign/indexed_assign_to_array_in_struct/struct_multiple_arrays.wgsl.expected.hlsl

@@ -0,0 +1,28 @@
+struct InnerS {
+  int v;
+};
+struct OuterS {
+  InnerS a1[8];
+  InnerS a2[8];
+};
+
+cbuffer cbuffer_uniforms : register(b4, space1) {
+  uint4 uniforms[1];
+};
+
+[numthreads(1, 1, 1)]
+void main() {
+  InnerS v = (InnerS)0;
+  OuterS s1 = (OuterS)0;
+  {
+    InnerS tint_symbol_1[8] = s1.a1;
+    tint_symbol_1[uniforms[0].x] = v;
+    s1.a1 = tint_symbol_1;
+  }
+  {
+    InnerS tint_symbol_3[8] = s1.a2;
+    tint_symbol_3[uniforms[0].x] = v;
+    s1.a2 = tint_symbol_3;
+  }
+  return;
+}

test/statements/assign/indexed_assign_to_array_in_struct/struct_struct_array.wgsl

@@ -0,0 +1,24 @@
+struct Uniforms {
+  i : u32;
+};
+
+struct InnerS {
+  v : i32;
+};
+
+struct S1 {
+  a : array<InnerS, 8>;
+};
+
+struct OuterS {
+  s2 : S1;
+};
+
+[[group(1), binding(4)]] var<uniform> uniforms : Uniforms;
+
+[[stage(compute), workgroup_size(1)]]
+fn main() {
+  var v : InnerS;
+  var s1 : OuterS;
+  s1.s2.a[uniforms.i] = v;
+}

test/statements/assign/indexed_assign_to_array_in_struct/struct_struct_array.wgsl.expected.hlsl

@@ -0,0 +1,25 @@
+struct InnerS {
+  int v;
+};
+struct S1 {
+  InnerS a[8];
+};
+struct OuterS {
+  S1 s2;
+};
+
+cbuffer cbuffer_uniforms : register(b4, space1) {
+  uint4 uniforms[1];
+};
+
+[numthreads(1, 1, 1)]
+void main() {
+  InnerS v = (InnerS)0;
+  OuterS s1 = (OuterS)0;
+  {
+    InnerS tint_symbol_1[8] = s1.s2.a;
+    tint_symbol_1[uniforms[0].x] = v;
+    s1.s2.a = tint_symbol_1;
+  }
+  return;
+}

test/statements/assign/indexed_assign_to_array_in_struct/struct_vector.wgsl

@@ -0,0 +1,15 @@
+struct Uniforms {
+  i : u32;
+};
+
+struct OuterS {
+  v1 : vec3<f32>;
+};
+
+[[group(1), binding(4)]] var<uniform> uniforms : Uniforms;
+
+[[stage(compute), workgroup_size(1)]]
+fn main() {
+  var s1 : OuterS;
+  s1.v1[uniforms.i] = 1.0;
+}

test/statements/assign/indexed_assign_to_array_in_struct/struct_vector.wgsl.expected.hlsl

@@ -0,0 +1,18 @@
+void set_float3(inout float3 vec, int idx, float val) {
+  vec = (idx.xxx == int3(0, 1, 2)) ? val.xxx : vec;
+}
+
+struct OuterS {
+  float3 v1;
+};
+
+cbuffer cbuffer_uniforms : register(b4, space1) {
+  uint4 uniforms[1];
+};
+
+[numthreads(1, 1, 1)]
+void main() {
+  OuterS s1 = (OuterS)0;
+  set_float3(s1.v1, uniforms[0].x, 1.0f);
+  return;
+}

test/statements/assign/indexed_assign_to_array_in_struct/vector_assign.wgsl

@@ -0,0 +1,21 @@
+struct Uniforms {
+  i : u32;
+};
+
+struct OuterS {
+  a1 : array<u32, 8>;
+};
+
+[[group(1), binding(4)]] var<uniform> uniforms : Uniforms;
+
+fn f(i: u32) -> u32 {
+  return i + 1u;
+}
+
+[[stage(compute), workgroup_size(1)]]
+fn main() {
+  var s1 : OuterS;
+  var v : vec3<f32>;
+  v[s1.a1[uniforms.i]] = 1.0;
+  v[f(s1.a1[uniforms.i])] = 1.0;
+}

test/statements/assign/indexed_assign_to_array_in_struct/vector_assign.wgsl.expected.hlsl

@@ -0,0 +1,24 @@
+void set_float3(inout float3 vec, int idx, float val) {
+  vec = (idx.xxx == int3(0, 1, 2)) ? val.xxx : vec;
+}
+
+struct OuterS {
+  uint a1[8];
+};
+
+cbuffer cbuffer_uniforms : register(b4, space1) {
+  uint4 uniforms[1];
+};
+
+uint f(uint i) {
+  return (i + 1u);
+}
+
+[numthreads(1, 1, 1)]
+void main() {
+  OuterS s1 = (OuterS)0;
+  float3 v = float3(0.0f, 0.0f, 0.0f);
+  set_float3(v, s1.a1[uniforms[0].x], 1.0f);
+  set_float3(v, f(s1.a1[uniforms[0].x]), 1.0f);
+  return;
+}

test/statements/assign/indexed_assign_to_array_in_struct/via_pointer.wgsl

@@ -0,0 +1,21 @@
+struct Uniforms {
+  i : u32;
+};
+
+struct InnerS {
+  v : i32;
+};
+
+struct OuterS {
+  a1 : array<InnerS, 8>;
+};
+
+[[group(1), binding(4)]] var<uniform> uniforms : Uniforms;
+
+[[stage(compute), workgroup_size(1)]]
+fn main() {
+  var v : InnerS;
+  var s1 : OuterS;
+  let p = &(s1.a1[uniforms.i]);
+  *p = v;
+}

test/statements/assign/indexed_assign_to_array_in_struct/via_pointer.wgsl.expected.hlsl

@@ -0,0 +1,23 @@
+struct InnerS {
+  int v;
+};
+struct OuterS {
+  InnerS a1[8];
+};
+
+cbuffer cbuffer_uniforms : register(b4, space1) {
+  uint4 uniforms[1];
+};
+
+[numthreads(1, 1, 1)]
+void main() {
+  InnerS v = (InnerS)0;
+  OuterS s1 = (OuterS)0;
+  const uint p_save = uniforms[0].x;
+  {
+    InnerS tint_symbol_1[8] = s1.a1;
+    tint_symbol_1[p_save] = v;
+    s1.a1 = tint_symbol_1;
+  }
+  return;
+}

test/statements/assign/indexed_assign_to_array_in_struct/via_pointer_arg.wgsl

@@ -0,0 +1,21 @@
+struct Uniforms {
+  i : u32;
+};
+struct InnerS {
+  v : i32;
+};
+struct OuterS {
+  a1 : array<InnerS, 8>;
+};
+[[group(1), binding(4)]] var<uniform> uniforms : Uniforms;
+
+fn f(p : ptr<function, OuterS>) {
+  var v : InnerS;
+  (*p).a1[uniforms.i] = v;
+}
+
+[[stage(compute), workgroup_size(1)]]
+fn main() {
+  var s1 : OuterS;
+  f(&s1);
+}

test/statements/assign/indexed_assign_to_array_in_struct/via_pointer_arg.wgsl.expected.hlsl

@@ -0,0 +1,26 @@
+struct InnerS {
+  int v;
+};
+struct OuterS {
+  InnerS a1[8];
+};
+
+cbuffer cbuffer_uniforms : register(b4, space1) {
+  uint4 uniforms[1];
+};
+
+void f(inout OuterS p) {
+  InnerS v = (InnerS)0;
+  {
+    InnerS tint_symbol_1[8] = p.a1;
+    tint_symbol_1[uniforms[0].x] = v;
+    p.a1 = tint_symbol_1;
+  }
+}
+
+[numthreads(1, 1, 1)]
+void main() {
+  OuterS s1 = (OuterS)0;
+  f(s1);
+  return;
+}