IR: add lowering for initializer list expressions (shader-slang#290)

* IR: add lowering for initializer list expressions

This is relatively straightforward in the easy cases, because the front-end will have already type-checked the elements of the initializer list, and attached an appropriate type to the overall expression.

Notes:

- We are assuming in this code that if the user provides a "flattened" initializer list when dealing with nested aggregates, then the front-end is responsible for grouping things up apprporiately (this is not actually implemented in the front-end today).

- I have only handled arrays and `struct` types here, so uses of initializer lists for anything else will fail.

- I have not tried to handle the common HLSL idiom of using `{0}` as a way to default-initialize things, even when their first field is not compatible with the expression `0`

- I have not implemented support for default-initializing fields/elements beyond those for which explicit initializers were provided. This can be addressed as a follow-on change.

This change is one clear place where the front-end lowering logic could potentially be made much cleaner using a "destination-driven" code generation strategy. For example, given the following code

```hlsl
struct A { int a0; a1; };
struct B { A b0; A b1; };
struct C { B c0; B c1; };
// ...
C c = { { { 0, 1 }, {2, 3}, }, /* ... */ };
```

Our current code generator will end up allocating local variables for 1 instance of `C`, two instances of `B`, and four instances of `C`, for over 3x the allocation that would be done by a good destination-driven code generator. Yes, later optimization passes should be able to clean up the waste, but avoiding the waste from the start should result in faster compiles and also easier debugging (since intermediate IR won't be as messy in general).

* Fixup: try to appease clang compiler

Author: Tim Foley

source/slang/lower-to-ir.cpp

@@ -1107,9 +1107,87 @@ struct ExprLoweringVisitorBase : ExprVisitor<Derived, LoweredValInfo>
         return lowerSubExpr(expr->base);
     }
 
-    LoweredValInfo visitInitializerListExpr(InitializerListExpr* /*expr*/)
+    LoweredValInfo visitInitializerListExpr(InitializerListExpr* expr)
     {
-        SLANG_UNIMPLEMENTED_X("codegen for initializer list expression");
+        // Allocate a temporary of the given type
+        RefPtr<Type> type = lowerSimpleType(context, expr->type);
+        LoweredValInfo val = createVar(context, type);
+
+        UInt argCount = expr->args.Count();
+
+        // Now for each argument in the initializer list,
+        // fill in the appropriate field of the result
+        if (auto arrayType = type->As<ArrayExpressionType>())
+        {
+            UInt elementCount = (UInt) GetIntVal(arrayType->ArrayLength);
+            auto elementType = lowerType(context, arrayType->baseType);
+            for (UInt ee = 0; ee < elementCount; ++ee)
+            {
+                IRValue* indexVal = context->irBuilder->getIntValue(
+                        getIntType(context),
+                        ee);
+                LoweredValInfo elemVal = subscriptValue(
+                    elementType,
+                    val,
+                    indexVal);
+
+                if (ee < argCount)
+                {
+                    auto argExpr = expr->args[ee];
+                    LoweredValInfo argVal = lowerRValueExpr(context, argExpr);
+
+                    assign(context, elemVal, argVal);
+                }
+                else
+                {
+                    SLANG_UNEXPECTED("need to default-initialize array elements");
+                }
+            }
+        }
+        else if (auto declRefType = type->As<DeclRefType>())
+        {
+            DeclRef<Decl> declRef = declRefType->declRef;
+            if (auto aggTypeDeclRef = declRef.As<AggTypeDecl>())
+            {
+                UInt argCounter = 0;
+                for (auto ff : getMembersOfType<StructField>(aggTypeDeclRef))
+                {
+                    if (ff.getDecl()->HasModifier<HLSLStaticModifier>())
+                        continue;
+
+                    auto loweredFieldType = lowerType(
+                        context,
+                        GetType(ff));
+                    LoweredValInfo fieldVal = extractField(
+                        loweredFieldType,
+                        val,
+                        ff);
+
+                    UInt argIndex = argCounter++;
+                    if (argIndex < argCount)
+                    {
+                        auto argExpr = expr->args[argIndex];
+                        LoweredValInfo argVal = lowerRValueExpr(context, argExpr);
+                        assign(context, fieldVal, argVal);
+                    }
+                    else
+                    {
+                        SLANG_UNEXPECTED("need to default-initialize struct fields");
+                    }
+                }
+            }
+            else
+            {
+                SLANG_UNEXPECTED("not sure how to initialize this type");
+            }
+        }
+        else
+        {
+            SLANG_UNEXPECTED("not sure how to initialize this type");
+        }
+
+
+        return val;
     }
 
     LoweredValInfo visitConstantExpr(ConstantExpr* expr)

tests/compute/initializer-list.slang

@@ -0,0 +1,30 @@
+//TEST(compute):COMPARE_COMPUTE:-xslang -use-ir
+
+//TEST_INPUT: ubuffer(data=[0 0 0 0], stride=4):dxbinding(0),glbinding(0),out
+
+struct Test
+{
+	float4 	a;
+	uint 	b;
+	float 	c;	
+};
+
+
+uint test(uint val)
+{
+	Test t = { float4(1.0f), 16, 99.0f };
+	return val + t.b;
+}
+
+RWStructuredBuffer<uint> outputBuffer;
+
+[numthreads(4, 1, 1)]
+void computeMain(uint3 dispatchThreadID : SV_DispatchThreadID)
+{
+	uint tid = dispatchThreadID.x;
+
+	uint inVal = tid;
+	uint outVal = test(inVal);
+
+	outputBuffer[tid] = outVal;
+}

tests/compute/initializer-list.slang.expected.txt

@@ -0,0 +1,4 @@
+10
+11
+12
+13