Add a diagnostic check to warn when special types leak from param groups

As part of type legalization, certain special types may be removed from
parameter group types. For example, in the following structure:

    [vk::push_constants]
    cbuffer PushConstants {
        int i;
        RaytracingAccelerationStructure rtas;
    }

`rtas` cannot be included in this structure, and will leak out to a
different binding. Warn the user when this happens.

Fixes #8818

Author: zangold-nv

source/slang/slang-diagnostic-defs.h

@@ -1183,6 +1183,17 @@ DIAGNOSTIC(
     imageFormatUnsupportedByBackend,
     "Image format '$0' is not explicitly supported by the $1 backend, using supported format '$2' "
     "instead.")
+DIAGNOSTIC(
+    31106,
+    Warning,
+    specialTypeLeaksFromParameterGroup,
+    "Parameter group type includes some members with types which cannot be included in the same "
+    "binding. These types will be moved into another parameter binding slot.")
+DIAGNOSTIC(
+    31107,
+    Warning,
+    specialTypeLeaksFromParameterGroupElement,
+    "Structure member will leak into separate binding.")
 
 DIAGNOSTIC(31120, Error, invalidAttributeTarget, "invalid syntax target for user defined attribute")
 DIAGNOSTIC(

source/slang/slang-legalize-types.cpp

@@ -1225,6 +1225,29 @@ LegalType legalizeTypeImpl(TypeLegalizationContext* context, IRType* type)
         else
         {
             legalElementType = legalizeType(context, originalElementType);
+
+            // When special types leak out of a parameter group, they need to
+            // be bound differently. Warn the user when this happens.
+            if (legalElementType.flavor == LegalType::Flavor::pair)
+            {
+                context->m_sink->diagnose(
+                    findFirstUseLoc(type),
+                    Diagnostics::specialTypeLeaksFromParameterGroup);
+
+                // indicate which elements cannot be part of the parameter group
+                auto &specialType = legalElementType.getPair()->specialType;
+                if (specialType.flavor == LegalType::Flavor::tuple)
+                {
+                    auto specialTuple = specialType.getTuple();
+                    for (auto specialElement : specialTuple->elements)
+                    {
+                        context->m_sink->diagnose(
+                            specialElement.key,
+                            Diagnostics::specialTypeLeaksFromParameterGroupElement);
+                    }
+                }
+            }
+
             // As a bit of a corner case, if the user requested something
             // like `ConstantBuffer<Texture2D>` the element type would
             // legalize to a "simple" type, and that would be interpreted

tests/diagnostics/rtas-cbuff-leak.slang

@@ -0,0 +1,16 @@
+//DIAGNOSTIC_TEST:SIMPLE(filecheck=CHECK): -entry computeMain -target spirv -stage compute -preserve-params
+
+// CHECK:rtas-cbuff-leak.slang(8): warning 31106
+// CHECK:rtas-cbuff-leak.slang(10): warning 31107
+
+// RTAS can't be a part of this binding, and will leak to a different binding.
+[vk::push_constant]
+cbuffer PushConstants {
+    int i;
+    RaytracingAccelerationStructure rtas;
+};
+
+[numthreads(1,1,1)]
+void computeMain()
+{
+}