Add slangc flag to `-zero-initialize` all variables (#3987)

* Default (zero'd) values with `-zero-initialize` flag

Adds `-zero-initialize` flag to set values to a __default() expression if they are missing a initExpr.

* address review and ensure __default calls ctor + zero's fields.

1. We must keep zero-initialize in SemanticsDeclHeaderVisitor. This is done because else a ctor will be initialized before we can set struct fields to `__default`.
2. IRDefaultCtorDecoration was added to track default ctor's with parent struct.
3. ParentAggTypeModifier was added to track ChildOfStruct->IRType for sharing data such as with functions. This is required to ensure we associate a lowered function with a lowered struct type

* Removed decoration to track defaultCtor in favor of field.

This was done since decorations are checked for IR objects, storing auxillary info does not work here as a result if usable object.

* address some review comments

Since `IDefaultInitializable` is taking a considerabley larger amount of time than anticipated I am pushing some of the other fixes requested. I did not remove the "IRStruct storing a default Ctor" hack yet.

mostly renamed/adjusted tests to work as intended

added test to ensure we don't synthisize a junk `= 0` when not in `zero initialize` mode

removed member in favor of sharedContext+dictionary.

* a working but incorrect impl

* default init without any IR hacks (fully working aside from generic/containored-types)

* Finish zero init code

1. IDefaultInitializer interface was added. If conforming, your type may be zero-initialized. To Conform a `__init()` is required
2. `[OnlyAutoInitIfForced]` was added. This attribute states that a default initializer should only be implicitly called if forced by the compiler (`zero-initialize` for example). This allows types which implicitly/explicitly conform to IDefaultInitialize to have optional auto-init behavior (which is Slang's default for user structs) to be disabled.

* note about `[OnlyAutoInitIfForced]`. This is required for std-lib to not automatically resolve init-expressions for std-lib, but it has the added benifit of allowing user made structs/classes to control the default behavior of initializing

* fix ErrType assumption

* testing why dx12 fails local but passes CI

* push vector changes to generic test

* push syntax adjustment, still figuring out what is wrong with cuda.

* remove debug changes & adjust style

* fix field-init expressions with structs initializers

don't init a static in a ctor. This would be illegal code and wrong code (init list in lower-to-ir)

* minor adjustments temporarily while the rest of the issue is discussed

* fix

* implement IDefaultInitializable

* remove a unneeded whitespace change

* fix type checking error

should be checking if a valid type is `Type`, not `BasicExpressionType`

* needs to be DeclRefType, not Type

* fix langguage server error

* change findinheritance for correctness + cleanup

* remove return false

verified the issue was `findInheritance`

* push attempt at language server fix

* still trying to fix inheritance

* added extension support, remove redundant code

Did not address all review comments yet, want to see if CI also passes my changes

* undo a change which caused CI to fail

* change logic  + DefaultConstructExpr

setup code to use defaultConstructExpr when possible to construct a default without overhead of invoke/related

also changed code so parent's defaultInitializable propegates to derived member

* 1. fix error in `isSubtype` 2. add flag to isSubtype

`subtypeInheritanceIsNotFullyResolved` was added since we may not be done the lookup stage but still require `isSubtype` checking to verify usage of inheritance while working with inheritance. In This case we will just skip `ensureLookup` and "caching" (since we don't have a cache invalidation system, nor need)

* fix bug in logic + add test to better catch the bug

* address comment + isSubTypeOption + wrapper type test,

* fix wrong code adjustment

I checked on the CI and realized I caused a failure, mistake was made not negating some code

* syntax, class naming capital

* remove stdlib default initialize changes, replace with `__default()` for init

* remove redundant code + fix defaultConstruct emitting

previously defaultConstruct emitting was crashing due to having generics unresolved. By not resolving the default construct immediately, everything works.

* remove a coment

* add test to ensure static variables dont `init` inside a struct's `__init`

* fix Ptr members breaking struct use

* address review and add -zero-initialize test

`-zero-initialize` test was added to be sure debug pointers are not broken with default init values

---------

Co-authored-by: Yong He <yonghe@outlook.com>

14 files changed, 710 insertions, 0 deletions

diff --git a/tests/language-feature/zero-initialize/IDefaultExplicit-wrapper-type.slang b/tests/language-feature/zero-initialize/IDefaultExplicit-wrapper-type.slang
new file mode 100644
index 000000000..fd08b5bee
--- /dev/null
+++ b/tests/language-feature/zero-initialize/IDefaultExplicit-wrapper-type.slang
@@ -0,0 +1,52 @@
+//TEST:SIMPLE(filecheck=CHECK): -target glsl -stage compute -entry computeMain
+// CHECK: {{.* }}= 0;
+// CHECK-NOT: {{.* }}= 0;
+
+//TEST(compute, vulkan):COMPARE_COMPUTE_EX(filecheck-buffer=BUF):-vk -compute -entry computeMain -allow-glsl
+//TEST(compute, vulkan):COMPARE_COMPUTE_EX(filecheck-buffer=BUF):-vk -compute -entry computeMain -emit-spirv-directly -allow-glsl
+//TEST(compute, vulkan):COMPARE_COMPUTE_EX(filecheck-buffer=BUF):-cpu -compute -entry computeMain -allow-glsl
+//TEST(smoke,compute):COMPARE_COMPUTE_EX(filecheck-buffer=BUF):-dx12 -use-dxil -compute -entry computeMain -allow-glsl -profile sm_6_2 -xslang -DDX12
+
+//TEST_INPUT:ubuffer(data=[0], stride=4):out,name=outputBuffer
+RWStructuredBuffer<int> outputBuffer;
+
+struct Base : IDefaultInitializableType
+{
+    int data1;
+};
+
+struct idefault1_base : IDefaultInitializableType
+{
+};
+interface idefault2_base : IDefaultInitializableType
+{
+};
+
+struct idefault1 : idefault1_base = Base;
+
+struct idefault2 : idefault2_base = Base;
+
+idefault1 getDefault1()
+{
+    idefault1 default1;
+    return default1;
+}
+idefault2 getDefault2()
+{
+    idefault2 default2;
+    return default2;
+}
+
+[numthreads(1, 1, 1)]
+void computeMain(int3 dispatchThreadID: SV_DispatchThreadID)
+{
+    // BUF: 1
+    idefault1 default1 = getDefault1();
+    idefault2 default2 = getDefault2();
+
+    outputBuffer[0] = true
+        && default1.inner.data1 == 0
+        
+        && default2.inner.data1 == 0
+        ;
+}
diff --git a/tests/language-feature/zero-initialize/IDefaultExplicit.slang b/tests/language-feature/zero-initialize/IDefaultExplicit.slang
new file mode 100644
index 000000000..78c6b1596
--- /dev/null
+++ b/tests/language-feature/zero-initialize/IDefaultExplicit.slang
@@ -0,0 +1,103 @@
+//TEST:SIMPLE(filecheck=CHECK): -target glsl -stage compute -entry computeMain
+// CHECK-COUNT-6: {{.* }}= 0U;
+
+//TEST(compute, vulkan):COMPARE_COMPUTE_EX(filecheck-buffer=BUF):-vk -compute -entry computeMain -allow-glsl
+//TEST(compute, vulkan):COMPARE_COMPUTE_EX(filecheck-buffer=BUF):-vk -compute -entry computeMain -emit-spirv-directly -allow-glsl
+//TEST(compute, vulkan):COMPARE_COMPUTE_EX(filecheck-buffer=BUF):-cpu -compute -entry computeMain -allow-glsl
+//TEST(smoke,compute):COMPARE_COMPUTE_EX(filecheck-buffer=BUF):-dx12 -use-dxil -compute -entry computeMain -allow-glsl -profile sm_6_2 -xslang -DDX12
+
+//TEST_INPUT:ubuffer(data=[0], stride=4):out,name=outputBuffer
+RWStructuredBuffer<int> outputBuffer;
+
+struct idefault1 : IDefaultInitializableType
+{
+    uint data;
+};
+
+struct idefault2_base : IDefaultInitializableType
+{
+    uint data1;
+};
+struct idefault2 : idefault2_base
+{
+    uint data2 = 1;
+};
+
+interface idefault3_base : IDefaultInitializableType
+{
+};
+struct idefault3 : idefault3_base
+{
+    uint data;
+};
+
+struct idefault4
+{
+    uint data;
+};
+
+extension idefault4 : IDefaultInitializableType
+{
+}
+
+struct idefault5_base : IDefaultInitializableType
+{
+    uint data1;
+};
+
+struct idefault5 : idefault5_base
+{
+    uint data2;
+};
+
+idefault1 getDefault1()
+{
+    idefault1 default1;
+    return default1;
+}
+idefault2 getDefault2()
+{
+    idefault2 default2;
+    return default2;
+}
+idefault3 getDefault3()
+{
+    idefault3 default3;
+    return default3;
+}
+idefault4 getDefault4()
+{
+    idefault4 default4;
+    return default4;   
+}
+
+idefault5 getDefault5()
+{
+    idefault5 default5;
+    return default5;
+}
+
+[numthreads(1, 1, 1)]
+void computeMain(int3 dispatchThreadID: SV_DispatchThreadID)
+{
+    // BUF: 1
+    idefault1 default1 = getDefault1();
+    idefault2 default2 = getDefault2();
+    idefault3 default3 = getDefault3();
+    idefault4 default4 = getDefault4();
+    idefault5 default5 = getDefault5();
+
+    outputBuffer[0] = true
+        && default1.data == 0
+
+        && default2.data1 == 0
+        && default2.data2 == 1
+
+        && default3.data == 0
+
+        && default4.data == 0
+
+        && default5.data1 == 0
+        && default5.data2 == 0
+        ;
+}
diff --git a/tests/language-feature/zero-initialize/IDefaultExplicitGenerics.slang b/tests/language-feature/zero-initialize/IDefaultExplicitGenerics.slang
new file mode 100644
index 000000000..edb438c1c
--- /dev/null
+++ b/tests/language-feature/zero-initialize/IDefaultExplicitGenerics.slang
@@ -0,0 +1,30 @@
+//TEST:SIMPLE(filecheck=CHECK): -target glsl -stage compute -entry computeMain
+// CHECK: vec4(0.0
+
+//TEST(compute, vulkan):COMPARE_COMPUTE_EX(filecheck-buffer=BUF):-vk -compute -entry computeMain -allow-glsl
+//TEST(compute, vulkan):COMPARE_COMPUTE_EX(filecheck-buffer=BUF):-vk -compute -entry computeMain -emit-spirv-directly -allow-glsl
+//TEST(compute, vulkan):COMPARE_COMPUTE_EX(filecheck-buffer=BUF):-cpu -compute -entry computeMain -allow-glsl
+//TEST(smoke,compute):COMPARE_COMPUTE_EX(filecheck-buffer=BUF):-dx12 -use-dxil -compute -entry computeMain -allow-glsl -profile sm_6_2
+
+//TEST_INPUT:ubuffer(data=[0], stride=4):out,name=outputBuffer
+RWStructuredBuffer<int> outputBuffer;
+
+__generic<T>
+struct idefault1 : IDefaultInitializableType
+{
+    vector<T,4> data;
+};
+
+[numthreads(1, 1, 1)]
+void computeMain(int3 dispatchThreadID: SV_DispatchThreadID)
+{
+    // BUF: 1
+    idefault1<float> default1;
+
+    outputBuffer[0] = true
+        && default1.data[0] == 0
+        && default1.data[1] == 0
+        && default1.data[2] == 0
+        && default1.data[3] == 0
+    ;
+}
diff --git a/tests/language-feature/zero-initialize/generic.slang b/tests/language-feature/zero-initialize/generic.slang
new file mode 100644
index 000000000..25f52238c
--- /dev/null
+++ b/tests/language-feature/zero-initialize/generic.slang
@@ -0,0 +1,113 @@
+//TEST(compute, vulkan):COMPARE_COMPUTE_EX(filecheck-buffer=BUF):-vk -compute -entry computeMain -allow-glsl -xslang -zero-initialize
+//TEST(compute, vulkan):COMPARE_COMPUTE_EX(filecheck-buffer=BUF):-vk -compute -entry computeMain -emit-spirv-directly -allow-glsl -xslang -zero-initialize
+//TEST(compute, vulkan):COMPARE_COMPUTE_EX(filecheck-buffer=BUF):-cpu -compute -entry computeMain -allow-glsl -xslang -zero-initialize
+//TEST(smoke,compute):COMPARE_COMPUTE_EX(filecheck-buffer=BUF):-dx12 -use-dxil -compute -entry computeMain -allow-glsl -profile sm_6_2 -xslang -zero-initialize -xslang -DDX12
+
+//TEST_INPUT:ubuffer(data=[0], stride=4):out,name=outputBuffer
+RWStructuredBuffer<int> outputBuffer;
+
+__generic<T : __BuiltinArithmeticType>
+bool getValue()
+{
+    T genericOut;
+    return genericOut == T(0);
+}
+bool getValueBoolean()
+{
+    bool genericOut;
+    return genericOut == bool(0);
+}
+
+__generic<T : __BuiltinArithmeticType, let N : int>
+bool getValueVector()
+{
+    typealias gvec = vector<T, N>;
+
+    gvec genericOut;
+    for (int i = 0; i < N; ++i)
+        if (genericOut[i] != T(0))
+            return false;
+    return true;
+}
+__generic<let N : int>
+bool getValueVectorBoolean()
+{
+    typealias gvec = vector<bool, N>;
+
+    gvec genericOut;
+    for (int i = 0; i < N; ++i)
+        if (genericOut[i] != bool(0))
+            return false;
+    return true;
+}
+
+[numthreads(1, 1, 1)]
+void computeMain(int3 dispatchThreadID: SV_DispatchThreadID)
+{
+// BUF: 1
+    outputBuffer[0] = true
+    && getValue<int>()
+#ifndef DX12
+    && getValue<uint8_t>()
+    && getValue<int8_t>()
+#endif
+    && getValue<uint16_t>()
+    && getValue<int16_t>()
+    && getValue<uint32_t>()
+    && getValue<int32_t>()
+    && getValue<uint64_t>()
+    && getValue<int64_t>()
+    && getValue<half>()
+    && getValue<float>()
+    && getValue<double>()
+    && getValueBoolean()
+
+    && getValueVector<int, 2>()
+#ifndef DX12
+    && getValueVector<uint8_t, 2>()
+    && getValueVector<int8_t, 2>()
+#endif
+    && getValueVector<uint16_t, 2>()
+    && getValueVector<int16_t, 2>()
+    && getValueVector<uint32_t, 2>()
+    && getValueVector<int32_t, 2>()
+    && getValueVector<uint64_t, 2>()
+    && getValueVector<int64_t, 2>()
+    && getValueVector<half, 2>()
+    && getValueVector<float, 2>()
+    && getValueVector<double, 2>()
+    && getValueVectorBoolean<2>()
+
+    && getValueVector<int, 3>()
+#ifndef DX12
+    && getValueVector<uint8_t, 3>()
+    && getValueVector<int8_t, 3>()
+#endif
+    && getValueVector<uint16_t, 3>()
+    && getValueVector<int16_t, 3>()
+    && getValueVector<uint32_t, 3>()
+    && getValueVector<int32_t, 3>()
+    && getValueVector<uint64_t, 3>()
+    && getValueVector<int64_t, 3>()
+    && getValueVector<half, 3>()
+    && getValueVector<float, 3>()
+    && getValueVector<double, 3>()
+    && getValueVectorBoolean<3>()
+
+    && getValueVector<int, 4>()
+#ifndef DX12
+    && getValueVector<uint8_t, 4>()
+    && getValueVector<int8_t, 4>()
+#endif
+    && getValueVector<uint16_t, 4>()
+    && getValueVector<int16_t, 4>()
+    && getValueVector<uint32_t, 4>()
+    && getValueVector<int32_t, 4>()
+    && getValueVector<uint64_t, 4>()
+    && getValueVector<int64_t, 4>()
+    && getValueVector<half, 4>()
+    && getValueVector<float, 4>()
+    && getValueVector<double, 4>()
+    && getValueVectorBoolean<4>()
+    ;
+}
diff --git a/tests/language-feature/zero-initialize/missing-zero-init.slang b/tests/language-feature/zero-initialize/missing-zero-init.slang
new file mode 100644
index 000000000..f9d715e10
--- /dev/null
+++ b/tests/language-feature/zero-initialize/missing-zero-init.slang
@@ -0,0 +1,23 @@
+//TEST:SIMPLE(filecheck=CHECK): -target hlsl -stage compute -entry computeMain
+//TEST:SIMPLE(filecheck=CHECK): -target glsl -stage compute -entry computeMain
+
+// CHECK-NOT: {{.* }}= 0;
+// CHECK-NOT: return 0;
+
+RWStructuredBuffer<int> outputBuffer;
+
+[noinline]
+int returnInt()
+{
+    int myInt;
+    return myInt;
+}
+
+[numthreads(1, 1, 1)]
+void computeMain(int3 dispatchThreadID: SV_DispatchThreadID)
+{
+// BUF: 1
+    outputBuffer[0] = true
+        && returnInt() == 0
+        ;
+}
diff --git a/tests/language-feature/zero-initialize/regular.slang b/tests/language-feature/zero-initialize/regular.slang
new file mode 100644
index 000000000..5627762c3
--- /dev/null
+++ b/tests/language-feature/zero-initialize/regular.slang
@@ -0,0 +1,116 @@
+//TEST(compute, vulkan):COMPARE_COMPUTE_EX(filecheck-buffer=BUF):-vk -compute -entry computeMain -allow-glsl -xslang -zero-initialize
+//TEST(compute, vulkan):COMPARE_COMPUTE_EX(filecheck-buffer=BUF):-vk -compute -entry computeMain -emit-spirv-directly -allow-glsl -xslang -zero-initialize
+//TEST(compute, vulkan):COMPARE_COMPUTE_EX(filecheck-buffer=BUF):-cpu -compute -entry computeMain -allow-glsl -xslang -zero-initialize
+//TEST(smoke,compute):COMPARE_COMPUTE_EX(filecheck-buffer=BUF):-dx12 -use-dxil -compute -entry computeMain -allow-glsl -profile sm_6_2 -xslang -zero-initialize -xslang -DDX12
+
+//TEST_INPUT:ubuffer(data=[0], stride=4):out,name=outputBuffer
+RWStructuredBuffer<int> outputBuffer;
+
+enum MyFlags
+{
+    Zero = 0,
+    One,
+}
+MyFlags getMyFlagsUint_One()
+{
+    return MyFlags::One;
+}
+
+#ifndef DX12
+enum MyFlags_uint8 : uint8_t
+{
+    Zero = 0,
+    One,
+}
+MyFlags_uint8 getMyFlagsUint8_One()
+{
+    return MyFlags_uint8::One;
+}
+#endif
+
+enum MyFlags_uint16 : uint16_t
+{
+    Zero = 0,
+    One,
+}
+MyFlags_uint16 getMyFlagsUint16_One()
+{
+    return MyFlags_uint16::One;
+}
+
+enum MyFlags_uint32 : uint32_t
+{
+    Zero = 0,
+    One,
+}
+MyFlags_uint32 getMyFlagsUint32_One()
+{
+    return MyFlags_uint32::One;
+}
+
+enum MyFlags_uint64 : uint64_t
+{
+    Zero = 0,
+    One,
+}
+MyFlags_uint64 getMyFlagsUint64_One()
+{
+    return MyFlags_uint64::One;
+}
+
+int getDefaultInt()
+{
+    int val;
+    return val;
+}
+float getDefaultFloat()
+{
+    float val;
+    return val;
+}
+double getDefaultDouble()
+{
+    double val;
+    return val;
+}
+vector<int, 2> getDefaultIntVec2()
+{
+    vector<int, 2> val;
+    return val;
+}
+vector<int, 3> getDefaultIntVec3()
+{
+    vector<int, 3> val;
+    return val;
+}
+vector<int, 4> getDefaultIntVec4()
+{
+    vector<int, 4> val;
+    return val;
+}
+[numthreads(1, 1, 1)]
+void computeMain(int3 dispatchThreadID: SV_DispatchThreadID)
+{
+    int defaultInt = getDefaultInt();
+    float defaultFloat = getDefaultFloat();
+    double defaultDouble = getDefaultDouble();
+    vector<int, 2> vector2 = getDefaultIntVec2();
+    vector<int, 3> vector3 = getDefaultIntVec3();
+    vector<int, 4> vector4 = getDefaultIntVec4();
+// BUF: 1
+    outputBuffer[0] = true
+    && defaultInt == 0
+    && defaultFloat == 0
+    && defaultDouble == 0
+    && vector2 == vector<int, 2>(0)
+    && vector3 == vector<int, 3>(0)
+    && vector4 == vector<int, 4>(0)
+    && MyFlags::One == getMyFlagsUint_One()
+#ifndef DX12
+    && MyFlags_uint8::One == getMyFlagsUint8_One()
+#endif
+    && MyFlags_uint16::One == getMyFlagsUint16_One()
+    && MyFlags_uint32::One == getMyFlagsUint32_One()
+    && MyFlags_uint64::One == getMyFlagsUint64_One();
+    ;
+}
diff --git a/tests/language-feature/zero-initialize/static-struct-field-init-list.slang b/tests/language-feature/zero-initialize/static-struct-field-init-list.slang
new file mode 100644
index 000000000..e40ca7e56
--- /dev/null
+++ b/tests/language-feature/zero-initialize/static-struct-field-init-list.slang
@@ -0,0 +1,24 @@
+//TEST(compute, vulkan):COMPARE_COMPUTE_EX(filecheck-buffer=BUF):-vk -compute -entry computeMain -allow-glsl -xslang -zero-initialize
+
+//TEST_INPUT:ubuffer(data=[0], stride=4):out,name=outputBuffer
+RWStructuredBuffer<uint> outputBuffer;
+
+struct structData
+{
+    uint data;
+};
+
+struct structOuterData
+{
+    static structData data1 = { 1 };
+};
+
+[numthreads(1,1,1)]
+void computeMain()
+{
+    // BUF: 1
+    structOuterData mat;
+    outputBuffer[0] = true
+        && mat.data1.data == 1
+        ;
+}
\ No newline at end of file
diff --git a/tests/language-feature/zero-initialize/static-struct-field-init.slang b/tests/language-feature/zero-initialize/static-struct-field-init.slang
new file mode 100644
index 000000000..ad2db5027
--- /dev/null
+++ b/tests/language-feature/zero-initialize/static-struct-field-init.slang
@@ -0,0 +1,25 @@
+//TEST:SIMPLE(filecheck=CHECK): -target glsl -stage compute -entry computeMain -zero-initialize
+// CHECK: {{.* }}= 0U;
+
+//TEST(compute, vulkan):COMPARE_COMPUTE_EX(filecheck-buffer=BUF):-vk -compute -entry computeMain -allow-glsl -xslang -zero-initialize
+
+//TEST_INPUT:ubuffer(data=[0], stride=4):out,name=outputBuffer
+RWStructuredBuffer<uint> outputBuffer;
+
+struct structData
+{
+    uint data;
+};
+
+struct structOuterData
+{
+    static structData data;
+};
+
+[numthreads(1,1,1)]
+void computeMain()
+{
+    // BUF: 1
+    structOuterData mat;
+    outputBuffer[0] = mat.data.data == 0;
+}
\ No newline at end of file
diff --git a/tests/language-feature/zero-initialize/struct-array-some-member-missing-init.slang b/tests/language-feature/zero-initialize/struct-array-some-member-missing-init.slang
new file mode 100644
index 000000000..cdd3f703f
--- /dev/null
+++ b/tests/language-feature/zero-initialize/struct-array-some-member-missing-init.slang
@@ -0,0 +1,42 @@
+//TEST:SIMPLE(filecheck=CHECK): -target hlsl -stage compute -entry computeMain -xslang -zero-initialize
+//TEST:SIMPLE(filecheck=CHECK): -target glsl -stage compute -entry computeMain -xslang -zero-initialize
+
+// CHECK-NOT: {{.* }}= 0;
+
+RWStructuredBuffer<int> outputBuffer;
+
+struct MyStruct_base
+{
+    int a = 1;
+    int b;
+};
+struct MyStruct : MyStruct_base
+{
+    int c = 1;
+    int d;
+};
+
+Array<MyStruct,2> getStructs()
+{
+    Array<MyStruct, 2> outData;
+    return outData;
+}
+
+[numthreads(1, 1, 1)]
+void computeMain(int3 dispatchThreadID: SV_DispatchThreadID)
+{
+    Array<MyStruct,2> myStruct = getStructs();
+
+// BUF: 1
+    outputBuffer[0] = true
+        && myStruct[0].a == 1
+        && myStruct[0].b == 0
+        && myStruct[0].c == 1
+        && myStruct[0].d == 0
+
+        && myStruct[1].a == 1
+        && myStruct[1].b == 0
+        && myStruct[1].c == 1
+        && myStruct[1].d == 0
+        ;
+}
diff --git a/tests/language-feature/zero-initialize/struct-array.slang b/tests/language-feature/zero-initialize/struct-array.slang
new file mode 100644
index 000000000..1f1b8eede
--- /dev/null
+++ b/tests/language-feature/zero-initialize/struct-array.slang
@@ -0,0 +1,38 @@
+//TEST(compute, vulkan):COMPARE_COMPUTE_EX(filecheck-buffer=BUF):-vk -compute -entry computeMain -allow-glsl -xslang -zero-initialize
+//TEST(compute, vulkan):COMPARE_COMPUTE_EX(filecheck-buffer=BUF):-vk -compute -entry computeMain -emit-spirv-directly -allow-glsl -xslang -zero-initialize
+//TEST(compute):COMPARE_COMPUTE_EX(filecheck-buffer=BUF):-cpu -compute -entry computeMain -allow-glsl -xslang -zero-initialize
+//TEST(smoke,compute):COMPARE_COMPUTE_EX(filecheck-buffer=BUF):-dx12 -use-dxil -compute -entry computeMain -allow-glsl -xslang -zero-initialize
+
+//TEST_INPUT:ubuffer(data=[0], stride=4):out,name=outputBuffer
+RWStructuredBuffer<int> outputBuffer;
+
+struct MyStruct_base
+{
+    int a;
+};
+struct MyStruct : MyStruct_base
+{
+    int b;
+    int c;
+};
+[numthreads(1, 1, 1)]
+void computeMain(int3 dispatchThreadID: SV_DispatchThreadID)
+{
+    
+    Array<MyStruct, 3> myStructs;
+
+// BUF: 1
+    outputBuffer[0] = true
+        && myStructs[0].a == 0
+        && myStructs[0].b == 0
+        && myStructs[0].c == 0
+
+        && myStructs[1].a == 0
+        && myStructs[1].b == 0
+        && myStructs[1].c == 0
+
+        && myStructs[2].a == 0
+        && myStructs[2].b == 0
+        && myStructs[2].c == 0
+        ;
+}
diff --git a/tests/language-feature/zero-initialize/struct-no-zero-init.slang b/tests/language-feature/zero-initialize/struct-no-zero-init.slang
new file mode 100644
index 000000000..3a4a5f945
--- /dev/null
+++ b/tests/language-feature/zero-initialize/struct-no-zero-init.slang
@@ -0,0 +1,33 @@
+//TEST:SIMPLE(filecheck=CHECK): -target hlsl -stage compute -entry computeMain
+//TEST:SIMPLE(filecheck=CHECK): -target glsl -stage compute -entry computeMain
+
+// CHECK-NOT: {{.* }}= 0;
+
+RWStructuredBuffer<int> outputBuffer;
+
+struct MyStruct_base
+{
+    int a;
+};
+struct MyStruct : MyStruct_base
+{
+    int b;
+    int c;
+};
+MyStruct getStruct()
+{
+    MyStruct myStruct;
+    return myStruct;
+}
+[numthreads(1, 1, 1)]
+void computeMain(int3 dispatchThreadID: SV_DispatchThreadID)
+{
+    MyStruct myStruct = getStruct();
+
+// BUF: 1
+    outputBuffer[0] = true
+        && myStruct.a == 0
+        && myStruct.b == 0
+        && myStruct.c == 0
+        ;
+}
diff --git a/tests/language-feature/zero-initialize/struct-some-member-init-missing-zero-init.slang b/tests/language-feature/zero-initialize/struct-some-member-init-missing-zero-init.slang
new file mode 100644
index 000000000..2b584ad00
--- /dev/null
+++ b/tests/language-feature/zero-initialize/struct-some-member-init-missing-zero-init.slang
@@ -0,0 +1,35 @@
+//TEST:SIMPLE(filecheck=CHECK): -target hlsl -stage compute -entry computeMain
+//TEST:SIMPLE(filecheck=CHECK): -target glsl -stage compute -entry computeMain
+
+// CHECK-NOT: {{.* }}= 0;
+
+RWStructuredBuffer<int> outputBuffer;
+
+struct MyStruct_base
+{
+    int a = 1;
+    int b;
+};
+struct MyStruct : MyStruct_base
+{
+    int c = 1;
+    int d;
+};
+MyStruct getStruct()
+{
+    MyStruct myStruct;
+    return myStruct;
+}
+[numthreads(1, 1, 1)]
+void computeMain(int3 dispatchThreadID: SV_DispatchThreadID)
+{
+    MyStruct myStruct = getStruct();
+
+// BUF: 1
+    outputBuffer[0] = true
+        && myStruct.a == 1
+        && myStruct.b == 0
+        && myStruct.c == 1
+        && myStruct.d == 0
+        ;
+}
diff --git a/tests/language-feature/zero-initialize/struct-some-zero-init.slang b/tests/language-feature/zero-initialize/struct-some-zero-init.slang
new file mode 100644
index 000000000..9bbb1f49e
--- /dev/null
+++ b/tests/language-feature/zero-initialize/struct-some-zero-init.slang
@@ -0,0 +1,39 @@
+//TEST:SIMPLE(filecheck=CHECK): -target glsl -stage compute -entry computeMain -zero-initialize
+// CHECK-COUNT-2: {{.* }}= 0;
+
+//TEST(compute, vulkan):COMPARE_COMPUTE_EX(filecheck-buffer=BUF):-vk -compute -entry computeMain -allow-glsl -xslang -zero-initialize
+//TEST(compute, vulkan):COMPARE_COMPUTE_EX(filecheck-buffer=BUF):-vk -compute -entry computeMain -emit-spirv-directly -allow-glsl -xslang -zero-initialize
+//TEST(compute):COMPARE_COMPUTE_EX(filecheck-buffer=BUF):-cpu -compute -entry computeMain -allow-glsl -xslang -zero-initialize
+//TEST(smoke,compute):COMPARE_COMPUTE_EX(filecheck-buffer=BUF):-dx12 -use-dxil -compute -entry computeMain -allow-glsl -xslang -zero-initialize
+
+//TEST_INPUT:ubuffer(data=[0], stride=4):out,name=outputBuffer
+RWStructuredBuffer<int> outputBuffer;
+
+struct MyStruct_base
+{
+    int a = 1;
+    int b;
+};
+struct MyStruct : MyStruct_base
+{
+    int c = 1;
+    int d;
+};
+MyStruct getStruct()
+{
+    MyStruct myStruct;
+    return myStruct;
+}
+[numthreads(1, 1, 1)]
+void computeMain(int3 dispatchThreadID: SV_DispatchThreadID)
+{
+    MyStruct myStruct = getStruct();
+
+// BUF: 1
+    outputBuffer[0] = true
+        && myStruct.a == 1
+        && myStruct.b == 0
+        && myStruct.c == 1
+        && myStruct.d == 0
+        ;
+}
diff --git a/tests/language-feature/zero-initialize/struct.slang b/tests/language-feature/zero-initialize/struct.slang
new file mode 100644
index 000000000..62f403903
--- /dev/null
+++ b/tests/language-feature/zero-initialize/struct.slang
@@ -0,0 +1,37 @@
+//TEST:SIMPLE(filecheck=CHECK): -target glsl -stage compute -entry computeMain -zero-initialize
+// CHECK-COUNT-3: {{.* }}= 0;
+
+//TEST(compute, vulkan):COMPARE_COMPUTE_EX(filecheck-buffer=BUF):-vk -compute -entry computeMain -allow-glsl -xslang -zero-initialize
+//TEST(compute, vulkan):COMPARE_COMPUTE_EX(filecheck-buffer=BUF):-vk -compute -entry computeMain -emit-spirv-directly -allow-glsl -xslang -zero-initialize
+//TEST(compute):COMPARE_COMPUTE_EX(filecheck-buffer=BUF):-cpu -compute -entry computeMain -allow-glsl -xslang -zero-initialize
+//TEST(smoke,compute):COMPARE_COMPUTE_EX(filecheck-buffer=BUF):-dx12 -use-dxil -compute -entry computeMain -allow-glsl -xslang -zero-initialize
+
+//TEST_INPUT:ubuffer(data=[0], stride=4):out,name=outputBuffer
+RWStructuredBuffer<int> outputBuffer;
+
+struct MyStruct_base
+{
+    int a;
+};
+struct MyStruct : MyStruct_base
+{
+    int b;
+    int c;
+};
+MyStruct getStruct()
+{
+    MyStruct myStruct;
+    return myStruct;
+}
+[numthreads(1, 1, 1)]
+void computeMain(int3 dispatchThreadID: SV_DispatchThreadID)
+{
+    MyStruct myStruct = getStruct();
+
+// BUF: 1
+    outputBuffer[0] = true
+        && myStruct.a == 0
+        && myStruct.b == 0
+        && myStruct.c == 0
+        ;
+}