Feature/initialize list side branch

.github/workflows/falcor-compiler-perf-test.yml

@@ -76,12 +76,11 @@ jobs:
 
           # A flag to set the download target as latest release
           # The default value is 'false'
-          latest: true
-
+          tag: "v0.0.2"
           # The name of the file to download.
           # Use this field only to specify filenames other than tarball or zipball, if any.
           # Supports wildcard pattern (eg: '*', '*.deb', '*.zip' etc..)
-          fileName: "falcor_perf_test-*-win-64.zip"
+          fileName: "falcor_perf_test-v0.0.2-win-64-beta.zip"
 
           # Download the attached zipball (*.zip)
           zipBall: true

.github/workflows/falcor-test.yml

@@ -59,12 +59,12 @@ jobs:
         run: |
           mkdir FalcorBin
           cd FalcorBin
-          Copy-Item -Path 'C:\Falcor\build\windows-vs2022\bin' -Destination '.\build\windows-vs2022\bin' -Recurse -Exclude ("*.pdb")
-          Copy-Item -Path 'C:\Falcor\tests' -Destination '.\' -Recurse
-          Copy-Item -Path 'C:\Falcor\tools' -Destination '.\' -Recurse
-          Copy-Item -Path 'C:\Falcor\media' -Destination '.\' -Recurse
-          Copy-Item -Path 'C:\Falcor\media_internal' -Destination '.\' -Recurse
-          Copy-Item -Path 'C:\Falcor\scripts' -Destination '.\' -Recurse
+          Copy-Item -Path 'C:\Falcor-new\build\windows-vs2022\bin' -Destination '.\build\windows-vs2022\bin' -Recurse -Exclude ("*.pdb")
+          Copy-Item -Path 'C:\Falcor-new\tests' -Destination '.\' -Recurse
+          Copy-Item -Path 'C:\Falcor-new\tools' -Destination '.\' -Recurse
+          Copy-Item -Path 'C:\Falcor-new\media' -Destination '.\' -Recurse
+          Copy-Item -Path 'C:\Falcor-new\media_internal' -Destination '.\' -Recurse
+          Copy-Item -Path 'C:\Falcor-new\scripts' -Destination '.\' -Recurse
           cd ..\
       - name: Build Slang
         run: |
@@ -78,18 +78,18 @@ jobs:
           cmake --workflow --preset "${{matrix.config}}"
       - name: Copy Slang to Falcor
         run: |
-          cp --verbose --recursive --target-directory ./FalcorBin/build/windows-vs2022/bin/Release build/Release/bin/*
+          cp --verbose --recursive --target-directory ./FalcorBin/build/windows-vs2022/bin/Debug build/Release/bin/*
       - name: falcor-unit-test
         shell: pwsh
         run: |
           $ErrorActionPreference = "SilentlyContinue"
           cd .\FalcorBin\tests
-          python ./testing/run_unit_tests.py --config windows-vs2022-Release -t "-slow"
+          python ./testing/run_unit_tests.py --config windows-vs2022-Debug -t "-slow"
           cd ../../
       - name: falcor-image-test
         shell: pwsh
         run: |
           $ErrorActionPreference = "SilentlyContinue"
           cd .\FalcorBin\tests
-          python ./testing/run_image_tests.py --config windows-vs2022-Release --run-only
+          python ./testing/run_unit_tests.py --config windows-vs2022-Debug -t "-slow"
           cd ../../

CMakeLists.txt

@@ -33,6 +33,9 @@ cmake_policy(SET CMP0091 NEW)
 # tree relocatable
 set(CMAKE_BUILD_RPATH_USE_ORIGIN TRUE)
 
+# Export the compile datebase as a json file, this can be used by VIM language server
+set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
+
 # Enable placing targets into a hierarchy for IDE generators
 set_property(GLOBAL PROPERTY USE_FOLDERS ON)
 

docs/proposals/004-initialization.md

@@ -129,6 +129,39 @@ MyType x = MyType(y); // equivalent to `x = y`.
 
 The compiler will attempt to resolve all type casts using type coercion rules, if that failed, will fall back to resolve it as a constructor call.
 
+### Inheritance Initialization
+For derived struct, slang will synthesized the constructor by bring the parameters from the base struct's constructor if the base struct also has a synthesized constructor. For example:
+```csharp
+struct Base
+{
+  int x;
+  // compiler synthesizes:
+  // __init(int x) { ... }
+}
+struct Derived : Base
+{
+  int y;
+  // compiler synthesizes:
+  // __init(int x, int y) { ... }
+}
+```
+
+However, if the base struct has explicit ctors, the compiler will not synthesize a constructor for the derived struct.
+For example, given
+```csharp
+struct Base { int x; __init(int x) { this.x = x; } }
+struct Derived : Base { int y;}
+```
+The compiler will not synthesize a constructor for `Derived`, and the following code will fail to compile:
+```csharp
+
+Derived d = {1};            // error, no matching ctor.
+Derived d = {1, 2};         // error, no matching ctor.
+Derived d = Derived(1);     // error, no matching ctor.
+Derived d = Derived(1, 2);  // error, no matching ctor.
+```
+
+
 ### Initialization List
 
 Slang allows initialization of a variable by assigning it with an initialization list. 
@@ -167,7 +200,8 @@ If the above code passes type check, then it will be used as the way to initiali
 
 If the above code does not pass type check, and if there is only one constructor for`MyType` that is synthesized as described in the previous section (and therefore marked as `[Synthesized]`, Slang continues to check if `S` meets the standard of a "legacy C-style struct` type.
 A type is a "legacy C-Style struct" if all of the following conditions are met:
-- It is a user-defined struct type or a basic scalar, vector or matrix type, e.g. `int`, `float4x4`.
+- It is a user-defined struct type or an enum, a basic scalar, vector or matrix type, e.g. `int`, `float4x4`.
+- It does not inherit from any other types.
 - It does not contain any explicit constructors defined by the user.
 - All its members have the same visibility as the type itself.
 - All its members are legacy C-Style structs or arrays of legacy C-style structs.
@@ -405,4 +439,4 @@ Alternatives Considered
 
 One important decision point is whether or not Slang should allow variables to be left in uninitialized state after its declaration as it is allowed in C++. In contrast, C# forces everything to be default initialized at its declaration site, which come at the cost of incurring the burden to developers to come up with a way to define the default value for each type.
 Our opinion is we want to allow things as uninitialized, and to have the compiler validation checks to inform
-the developer something is wrong if they try to use a variable in uninitialized state. We believe it is desirable to tell the developer what's wrong instead of using a heavyweight mechanism to ensure everything is initialized at declaration sites, which can have non-trivial performance consequences for GPU programs, especially when the variable is declared in groupshared memory.
+the developer something is wrong if they try to use a variable in uninitialized state. We believe it is desirable to tell the developer what's wrong instead of using a heavyweight mechanism to ensure everything is initialized at declaration sites, which can have non-trivial performance consequences for GPU programs, especially when the variable is declared in groupshared memory.

source/slang/slang-ast-decl.h

@@ -165,6 +165,12 @@ class AggTypeDecl : public AggTypeDeclBase
 class StructDecl : public AggTypeDecl
 {
     SLANG_AST_CLASS(StructDecl);
+
+    SLANG_UNREFLECTED
+    // We will use these auxiliary to help in synthesizing the member initialize constructor.
+    Slang::HashSet<VarDeclBase*> m_membersVisibleInCtor;
+    Dictionary<int, ConstructorDecl*> m_synthesizedCtorMap;
+    bool m_hasExplicitCtorInExtension = false;
 };
 
 class ClassDecl : public AggTypeDecl
@@ -372,9 +378,20 @@ class ConstructorDecl : public FunctionDeclBase
 {
     SLANG_AST_CLASS(ConstructorDecl)
 
-    // Indicates whether the declaration was synthesized by
-    // slang and not actually provided by the user
-    bool isSynthesized = false;
+    enum class ConstructorTags : int
+    {
+        None = 0x00,
+        // Indicates whether the declaration was synthesized by
+        // Slang and not explicitly provided by the user
+        Synthesized = 0x01,
+        // Member initialize constructor is a synthesized ctor,
+        // but it takes parameters.
+        MemberInitCtor = 0x02
+    };
+
+    int m_tags = (int)ConstructorTags::None;
+    void addTag(ConstructorTags tag) { m_tags |= (int)tag; }
+    bool containsTag(ConstructorTags tag) { return m_tags & (int)tag; }
 };
 
 // A subscript operation used to index instances of a type