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-diagnostics.lua

@@ -2163,6 +2163,20 @@ warning(
     span { loc = "location" }  -- No span message: this diagnostic has no meaningful source location
 )
 
+warning(
+    "special-type-leaks-from-parameter-group",
+    31106,
+    "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.",
+    span { loc = "location" }
+)
+
+warning(
+    "special-type-member-leaks-from-parameter-group",
+    31107,
+    "",
+    span { loc = "member:IRInst", message = "This member will leak into a separate binding slot." }
+)
+
 err(
     "invalid-attribute-target",
     31120,

source/slang/slang-legalize-types.cpp

@@ -1225,6 +1225,27 @@ 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(
+                    Diagnostics::SpecialTypeLeaksFromParameterGroup{.location = findFirstUseLoc(type)});
+
+                // 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(
+                            Diagnostics::SpecialTypeMemberLeaksFromParameterGroup{.member = specialElement.key});
+                    }
+                }
+            }
+
             // 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,18 @@
+//DIAGNOSTIC_TEST:SIMPLE(filecheck=CHECK): -entry computeMain -target spirv -stage compute -preserve-params
+
+// RTAS can't be a part of this binding, and will leak to a different binding.
+//
+// CHECK: warning[E31106]
+// CHECK:rtas-cbuff-leak.slang:[[# @LINE+2]]:
+[vk::push_constant]
+cbuffer PushConstants {
+    int i;
+    // CHECK: warning[E31107]
+    // CHECK:rtas-cbuff-leak.slang:[[# @LINE+1]]
+    RaytracingAccelerationStructure rtas;
+};
+
+[numthreads(1,1,1)]
+void computeMain()
+{
+}