Merge from shader-slang/slang master

build/visual-studio/gfx-unit-test-tool/gfx-unit-test-tool.vcxproj

@@ -303,6 +303,7 @@
     <ClCompile Include="..\..\..\tools\gfx-unit-test\gfx-test-texture-util.cpp" />
     <ClCompile Include="..\..\..\tools\gfx-unit-test\gfx-test-util.cpp" />
     <ClCompile Include="..\..\..\tools\gfx-unit-test\instanced-draw-tests.cpp" />
+    <ClCompile Include="..\..\..\tools\gfx-unit-test\link-time-constant.cpp" />
     <ClCompile Include="..\..\..\tools\gfx-unit-test\mutable-shader-object.cpp" />
     <ClCompile Include="..\..\..\tools\gfx-unit-test\nested-parameter-block.cpp" />
     <ClCompile Include="..\..\..\tools\gfx-unit-test\ray-tracing-tests.cpp" />
@@ -323,6 +324,7 @@
     <None Include="..\..\..\tools\gfx-unit-test\compute-trivial.slang" />
     <None Include="..\..\..\tools\gfx-unit-test\format-test-shaders.slang" />
     <None Include="..\..\..\tools\gfx-unit-test\graphics-smoke.slang" />
+    <None Include="..\..\..\tools\gfx-unit-test\link-time-constant.slang" />
     <None Include="..\..\..\tools\gfx-unit-test\mutable-shader-object.slang" />
     <None Include="..\..\..\tools\gfx-unit-test\nested-parameter-block.slang" />
     <None Include="..\..\..\tools\gfx-unit-test\ray-tracing-test-shaders.slang" />

build/visual-studio/gfx-unit-test-tool/gfx-unit-test-tool.vcxproj.filters

@@ -65,6 +65,9 @@
     <ClCompile Include="..\..\..\tools\gfx-unit-test\instanced-draw-tests.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
+    <ClCompile Include="..\..\..\tools\gfx-unit-test\link-time-constant.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
     <ClCompile Include="..\..\..\tools\gfx-unit-test\mutable-shader-object.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
@@ -121,6 +124,9 @@
     <None Include="..\..\..\tools\gfx-unit-test\graphics-smoke.slang">
       <Filter>Source Files</Filter>
     </None>
+    <None Include="..\..\..\tools\gfx-unit-test\link-time-constant.slang">
+      <Filter>Source Files</Filter>
+    </None>
     <None Include="..\..\..\tools\gfx-unit-test\mutable-shader-object.slang">
       <Filter>Source Files</Filter>
     </None>

source/slang/slang-ast-builder.cpp

@@ -338,6 +338,10 @@ ArrayExpressionType* ASTBuilder::getArrayType(Type* elementType, IntVal* element
         {
             elementCount = getIntVal(getIntType(), elementCountConstantInt->getValue());
         }
+        else
+        {
+            elementCount = getTypeCastIntVal(getIntType(), elementCount);
+        }
     }
     Val* args[] = {elementType, elementCount};
     return as<ArrayExpressionType>(getSpecializedBuiltinType(makeArrayView(args), "ArrayExpressionType"));

source/slang/slang-check-decl.cpp

@@ -1471,6 +1471,11 @@ namespace Slang
             }
             else
             {
+                if (varDecl->hasModifier<ExternModifier>())
+                {
+                    getSink()->diagnose(initExpr, Diagnostics::externValueCannotHaveInitializer);
+                }
+
                 initExpr = CheckExpr(initExpr);
 
                 // TODO: We might need some additional steps here to ensure
@@ -1484,7 +1489,7 @@ namespace Slang
 
                 _validateCircularVarDefinition(varDecl);
             }
-
+            
             // If we've gone down this path, then the variable
             // declaration is actually pretty far along in checking
             varDecl->setCheckState(DeclCheckState::DefinitionChecked);

source/slang/slang-check-expr.cpp

@@ -1659,6 +1659,9 @@ namespace Slang
             return nullptr;
         if(!decl->hasModifier<ConstModifier>())
             return nullptr;
+        // Extern static const is not considered compile-time constant by the front-end.
+        if (decl->hasModifier<ExternModifier>())
+            return nullptr;
 
         if (isInterfaceRequirement(decl))
         {

source/slang/slang-diagnostic-defs.h

@@ -478,10 +478,10 @@ DIAGNOSTIC(30502, Error, cannotUseInitializerListForVectorOfUnknownSize, "cannot
 DIAGNOSTIC(30503, Error, cannotUseInitializerListForMatrixOfUnknownSize, "cannot use initializer list for matrix of statically unknown size '$0' rows")
 DIAGNOSTIC(30504, Error, cannotUseInitializerListForType, "cannot use initializer list for type '$0'")
 
-// 306xx: variables
-DIAGNOSTIC(30600, Error, varWithoutTypeMustHaveInitializer, "a variable declaration without an initial-value expression must be given an explicit type")
-
-DIAGNOSTIC(30610, Error, ambiguousDefaultInitializerForType, "more than one default initializer was found for type '$0'")
+// 3062x: variables
+DIAGNOSTIC(30620, Error, varWithoutTypeMustHaveInitializer, "a variable declaration without an initial-value expression must be given an explicit type")
+DIAGNOSTIC(30621, Error, externValueCannotHaveInitializer, "an 'extern' variable declaration cannot have a value.")
+DIAGNOSTIC(30622, Error, ambiguousDefaultInitializerForType, "more than one default initializer was found for type '$0'")
 
 // 307xx: parameters
 DIAGNOSTIC(30700, Error, outputParameterCannotHaveDefaultValue, "an 'out' or 'inout' parameter cannot have a default-value expression")

source/slang/slang-ir-specialize.cpp

@@ -1323,13 +1323,24 @@ struct SpecializationContext
         // their replacements.
         //
         IRCloneEnv cloneEnv;
+        cloneEnv.squashChildrenMapping = true;
 
         // We also need some IR building state, for any
         // new instructions we will emit.
         //
         IRBuilder builderStorage(module);
         auto builder = &builderStorage;
 
+        // To get started, we will create the skeleton of the new
+        // specialized function, so newly created insts
+        // will be placed in a proper parent.
+        //
+
+        IRFunc* newFunc = builder->createFunc();
+
+        builder->setInsertInto(newFunc);
+        IRBlock* tempHeaderBlock = builder->emitBlock();
+
         // We will start out by determining what the parameters
         // of the specialized function should be, based on
         // the parameters of the original, and the concrete
@@ -1343,7 +1354,6 @@ struct SpecializationContext
         // block, or even a function, to insert them into.
         //
         List<IRParam*> newParams;
-        List<IRInst*> newBodyInsts;
         UInt argCounter = 0;
         for (auto oldParam : oldFunc->getParams())
         {
@@ -1387,7 +1397,6 @@ struct SpecializationContext
                 // correct existential type, and stores the right witness table).
                 //
                 auto newMakeExistential = builder->emitMakeExistential(oldParam->getFullType(), newParam, witnessTable);
-                newBodyInsts.add(newMakeExistential);
                 replacementVal = newMakeExistential;
             }
             else if (auto oldWrapExistential = as<IRWrapExistential>(arg))
@@ -1412,7 +1421,6 @@ struct SpecializationContext
                     newParam,
                     oldWrapExistential->getSlotOperandCount(),
                     oldWrapExistential->getSlotOperands());
-                newBodyInsts.add(newWrapExistential);
                 replacementVal = newWrapExistential;
             }
             else
@@ -1433,8 +1441,20 @@ struct SpecializationContext
             cloneEnv.mapOldValToNew.add(oldParam, replacementVal);
         }
 
-        // Next we will create the skeleton of the new
-        // specialized function, including its type.
+        // The above steps have accomplished the "first phase"
+        // of cloning the function (since `IRFunc`s have no
+        // operands).
+        //
+        // We can now use the shared IR cloning infrastructure
+        // to perform the second phase of cloning, which will recursively
+        // clone any nested decorations, blocks, and instructions.
+        //
+        cloneInstDecorationsAndChildren(
+            &cloneEnv,
+            builder->getModule(),
+            oldFunc,
+            newFunc);
+
         //
         // In order to construct the type of the new function, we
         // need to extract the types of all its parameters.
@@ -1448,24 +1468,9 @@ struct SpecializationContext
             newParamTypes.getCount(),
             newParamTypes.getBuffer(),
             oldFunc->getResultType());
-        IRFunc* newFunc = builder->createFunc();
         newFunc->setFullType(newFuncType);
 
-        // The above steps have accomplished the "first phase"
-        // of cloning the function (since `IRFunc`s have no
-        // operands).
-        //
-        // We can now use the shared IR cloning infrastructure
-        // to perform the second phase of cloning, which will recursively
-        // clone any nested decorations, blocks, and instructions.
-        //
-        cloneInstDecorationsAndChildren(
-            &cloneEnv,
-            builder->getModule(),
-            oldFunc,
-            newFunc);
-
-        // Now that the main body of existing isntructions have
+        // Now that the main body of existing instructions have
         // been cloned into the new function, we can go ahead
         // and insert all the parameters and body instructions
         // we built up into the function at the right place.
@@ -1474,7 +1479,7 @@ struct SpecializationContext
         // block (this was an invariant established before
         // we decided to specialize).
         //
-        auto newEntryBlock = newFunc->getFirstBlock();
+        auto newEntryBlock = as<IRBlock>(cloneEnv.mapOldValToNew[oldFunc->getFirstBlock()]);
         SLANG_ASSERT(newEntryBlock);
 
         // We expect every valid block to have at least one
@@ -1497,11 +1502,17 @@ struct SpecializationContext
         // before the first ordinary instruction (but will come
         // *after* the parameters by the order of these two loops).
         //
-        for (auto newBodyInst : newBodyInsts)
+        for (auto newBodyInst = tempHeaderBlock->getFirstChild(); newBodyInst;)
         {
+            auto next = newBodyInst->next;
             newBodyInst->insertBefore(newFirstOrdinary);
+            newBodyInst = next;
         }
 
+        // After moving all param and existential insts in tempHeaderBlock
+        // it should be empty now and we can remove it.
+        tempHeaderBlock->removeAndDeallocate();
+
         // After all this work we have a valid `newFunc` that has been
         // specialized to match the types at the call site.
         //

source/slang/slang-ir-spirv-legalize.cpp

@@ -258,8 +258,7 @@ struct SPIRVLegalizationContext : public SourceEmitterBase
         }
 
         for (auto i : instsToRemove)
-            if (!i->hasUses())
-                i->removeAndDeallocate();
+            i->removeAndDeallocate();
     }
 
     // Returns true if the given type that should be decorated as in `UniformConstant` address space.

source/slang/slang-mangle.cpp

@@ -132,7 +132,8 @@ namespace Slang
 
     void emitQualifiedName(
         ManglingContext*    context,
-        DeclRef<Decl>       declRef);
+        DeclRef<Decl>       declRef,
+        bool includeModuleName);
 
     void emitSimpleIntVal(
         ManglingContext*    context,
@@ -211,7 +212,7 @@ namespace Slang
         }
         else if( auto declRefType = dynamicCast<DeclRefType>(type) )
         {
-            emitQualifiedName(context, declRefType->getDeclRef());
+            emitQualifiedName(context, declRefType->getDeclRef(), true);
         }
         else if (auto arrType = dynamicCast<ArrayExpressionType>(type))
         {
@@ -222,7 +223,7 @@ namespace Slang
         else if( auto thisType = dynamicCast<ThisType>(type) )
         {
             emitRaw(context, "t");
-            emitQualifiedName(context, thisType->getInterfaceDeclRef());
+            emitQualifiedName(context, thisType->getInterfaceDeclRef(), true);
         }
         else if (const auto errorType = dynamicCast<ErrorType>(type))
         {
@@ -356,16 +357,34 @@ namespace Slang
 
     void emitQualifiedName(
         ManglingContext*    context,
-        DeclRef<Decl>       declRef)
+        DeclRef<Decl>       declRef,
+        bool includeModuleName)
     {
+        if (!includeModuleName)
+        {
+            if (as<ModuleDecl>(declRef))
+                return;
+        }
+        else
+        {
+            for (auto modifier : declRef.getDecl()->modifiers)
+            {
+                if (as<ExternModifier>(modifier) || as<HLSLExportModifier>(modifier))
+                {
+                    includeModuleName = false;
+                    break;
+                }
+            }
+        }
+
         auto parentDeclRef = declRef.getParent();
         if (as<FileDecl>(parentDeclRef))
             parentDeclRef = parentDeclRef.getParent();
 
         auto parentGenericDeclRef = parentDeclRef.as<GenericDecl>();
         if( parentDeclRef )
         {
-            emitQualifiedName(context, parentDeclRef);
+            emitQualifiedName(context, parentDeclRef, includeModuleName);
         }
 
         // A generic declaration is kind of a pseudo-declaration
@@ -490,7 +509,7 @@ namespace Slang
                     for (auto type : constraint.value)
                     {
                         emitRaw(context, "C");
-                        emitQualifiedName(context, makeDeclRef(constraint.key));
+                        emitQualifiedName(context, makeDeclRef(constraint.key), true);
                             emitType(context, type);
                     }
                 }
@@ -579,7 +598,7 @@ namespace Slang
 
             auto innerDecl = getInner(genericDecl);
 
-            emitQualifiedName(context, makeDeclRef(innerDecl));
+            emitQualifiedName(context, makeDeclRef(innerDecl), true);
             return;
         }
         else if (as<ForwardDerivativeRequirementDecl>(decl))
@@ -592,7 +611,8 @@ namespace Slang
         }
 
         // Now we encode the qualified name of the decl.
-        emitQualifiedName(context, declRef);
+
+        emitQualifiedName(context, declRef, true);
     }
 
     static String getMangledName(ASTBuilder* astBuilder, DeclRef<Decl> const& declRef)
@@ -625,8 +645,8 @@ namespace Slang
         SLANG_AST_BUILDER_RAII(astBuilder);
         ManglingContext context(astBuilder);
         emitRaw(&context, "_SW");
-        emitQualifiedName(&context, sub);
-        emitQualifiedName(&context, sup);
+        emitQualifiedName(&context, sub, true);
+        emitQualifiedName(&context, sup, true);
         return context.sb.produceString();
     }
 
@@ -643,7 +663,7 @@ namespace Slang
         //
         ManglingContext context(astBuilder);
         emitRaw(&context, "_SW");
-        emitQualifiedName(&context, sub);
+        emitQualifiedName(&context, sub, true);
         emitType(&context, sup);
         return context.sb.produceString();
     }

tests/language-feature/generics/generic-interface-2.slang

@@ -0,0 +1,42 @@
+//TEST(compute):COMPARE_COMPUTE(filecheck-buffer=CHECK): -shaderobj -output-using-type
+//TEST(compute):COMPARE_COMPUTE(filecheck-buffer=CHECK): -vk -shaderobj -output-using-type
+
+interface IFoo<let n: uint>
+{
+    static int sum(int arr[n]);
+}
+
+struct MyType<let n:uint> : IFoo<n>
+{
+    static int sum(int arr[n])
+    {
+        int rs = 0;
+        for (int i = 0; i < n; i++)
+            rs += arr[i];
+        return rs;
+    }
+}
+
+int test<let n:uint>(IFoo<n> foo)
+{
+    int arr[n];
+    for (int i =0; i < n; i++)
+        arr[i] = i;
+    return foo.sum(arr);
+}
+
+//TEST_INPUT:ubuffer(data=[0 0 0 0], stride=4):out,name=outputBuffer
+RWStructuredBuffer<int> outputBuffer;
+
+[numthreads(1, 1, 1)]
+void computeMain(int3 dispatchThreadID : SV_DispatchThreadID)
+{
+    MyType<3> t;
+    test(t);
+    // CHECK: 3
+    outputBuffer[0] = test(t);
+
+    int arr[3] = {1,2,3};
+    // CHECK: 3
+    outputBuffer[1] = MyType<3>.sum(arr);
+}

tests/spirv/array-of-array.slang

@@ -0,0 +1,12 @@
+//TEST:SIMPLE(filecheck=CHECK):-target spirv -entry main -stage compute -emit-spirv-directly -skip-spirv-validation
+
+Texture2D texArray[3][4][5];
+RWStructuredBuffer<float4> outputBuffer;
+
+// CHECK: OpEntryPoint
+
+[shader("compute")]
+void main(uint3 tid : SV_DispatchThreadID)
+{
+    outputBuffer[0] = texArray[tid.x][tid.y][tid.z].Load(int3(1,2,3));
+}