glsl-in: Add tests for output parameters casts

tests/in/glsl/expressions.frag

@@ -151,6 +151,12 @@ void indexConstantNonConstantIndex(int i) {
     const uvec4 a = strct.array[i];
 }
 
+void testSwizzleWrites(vec3 a) {
+    a.zxy.xy = vec2(3.0, 4.0);
+    a.rg *= 5.0;
+    a.zy++;
+}
+
 out vec4 o_color;
 void main() {
     privatePointer(global);

tests/in/glsl/functions_call.frag

@@ -0,0 +1,21 @@
+#version 450
+
+void swizzleCallee(inout vec2 a) {}
+
+void swizzleCaller(vec3 a) {
+    swizzleCallee(a.xz);
+}
+
+void outImplicitCastCallee(out uint a) {}
+
+void outImplicitCastCaller(float a) {
+    outImplicitCastCallee(a);
+}
+
+void swizzleImplicitCastCallee(out uvec2 a) {}
+
+void swizzleImplicitCastCaller(vec3 a) {
+    swizzleImplicitCastCallee(a.xz);
+}
+
+void main() {}

tests/out/wgsl/expressions-frag.wgsl

@@ -413,6 +413,30 @@ fn indexConstantNonConstantIndex(i: i32) {
     return;
 }
 
+fn testSwizzleWrites(a_27: vec3<f32>) {
+    var a_28: vec3<f32>;
+
+    _ = (&global_1.a);
+    a_28 = a_27;
+    let _e6 = a_28;
+    _ = _e6.zxy;
+    _ = _e6.zx;
+    let _e11 = vec2<f32>(3.0, 4.0);
+    a_28.z = _e11.x;
+    a_28.x = _e11.y;
+    let _e16 = a_28;
+    _ = _e16.xy;
+    let _e18 = a_28;
+    let _e21 = (_e18.xy * 5.0);
+    a_28.x = _e21.x;
+    a_28.y = _e21.y;
+    let _e26 = a_28;
+    let _e30 = (_e26.zy + vec2<f32>(1.0));
+    a_28.z = _e30.x;
+    a_28.y = _e30.y;
+    return;
+}
+
 fn main_1() {
     var local_6: f32;
 

tests/out/wgsl/functions_call-frag.wgsl

@@ -0,0 +1,68 @@
+fn swizzleCallee(a: ptr<function, vec2<f32>>) {
+    return;
+}
+
+fn swizzleCaller(a_1: vec3<f32>) {
+    var a_2: vec3<f32>;
+    var local: vec2<f32>;
+
+    a_2 = a_1;
+    let _e2 = a_2;
+    _ = _e2.xz;
+    let _e4 = a_2;
+    local = _e4.xz;
+    swizzleCallee((&local));
+    let _e11 = local.x;
+    a_2.x = _e11;
+    let _e12 = local.y;
+    a_2.z = _e12;
+    return;
+}
+
+fn outImplicitCastCallee(a_3: ptr<function, u32>) {
+    return;
+}
+
+fn outImplicitCastCaller(a_4: f32) {
+    var a_5: f32;
+    var local_1: u32;
+
+    a_5 = a_4;
+    _ = a_5;
+    _ = a_5;
+    outImplicitCastCallee((&local_1));
+    let _e5 = local_1;
+    a_5 = f32(_e5);
+    return;
+}
+
+fn swizzleImplicitCastCallee(a_6: ptr<function, vec2<u32>>) {
+    return;
+}
+
+fn swizzleImplicitCastCaller(a_7: vec3<f32>) {
+    var a_8: vec3<f32>;
+    var local_2: vec2<u32>;
+
+    a_8 = a_7;
+    let _e2 = a_8;
+    _ = _e2.xz;
+    let _e4 = a_8;
+    _ = _e4.xz;
+    swizzleImplicitCastCallee((&local_2));
+    let _e11 = local_2.x;
+    a_8.x = f32(_e11);
+    let _e13 = local_2.y;
+    a_8.z = f32(_e13);
+    return;
+}
+
+fn main_1() {
+    return;
+}
+
+@fragment 
+fn main() {
+    main_1();
+    return;
+}