Allow interface types to be used inside of structs (shader-slang#966)

Previously, interface types were allowed to be used directly as function parameters, local variables, and global shader parameters.
Using an interface type as a field of a `struct` type or a `cbuffer` declaration was not implemented.
This change adds that support, and fixes several unrelated issues that caused problems in doing so.

* The most important work here was adding a case for `IRStructType` to `maybeSpecializeBindExistentialsType` that creates a specialized variant of a `struct` type on-demand based on specialization operands. This logic loops over the fields of the original struct, and creates new fields by binding the existentials/interfaces in the type of each field. Caching is used to ensure that the same `struct` type specialized to the same operands should yield the same result.

* To allow subsequent specialization to occur when a `struct` with interface-type fields is used, it was also necessary to specialize field-address and field-extract instructions in cases where the value that the field is being extracted from is a `wrapExistential`.

* Similarly, we neede to make sure that the logic for specializing called functions based on the concrete types for interfaces in the argument list would also take into account `struct` types with existential-type fields inside of them.

* Doing the above changes revealed some serious flaws in how the `ir-specialize.cpp` logic was tracking which instructions still needed to be processed. It had previously been assuming that it could assume any relevant instructions were on its work list, and when the work list went empty it could exit. This runs into two problems: (1) sometimes we create new instructions when specializing, and it may be impossible to ensure that all the new instructions (e.g., those created by utility routines in other files) get added to the work list, and (2) sometimes the instruction(s) that need to be re-visited when we specialize something aren't its direct users, but instead somethign that transitively depends on the instruction.

  These issues were fixed by two changes to the pass: (1) we now maintain a list of known "clean" instructions instead of implicitly using the work-list as a list of "dirty" instructions (so that implicitly any new instruction is dirty), and periodically iterating over all instructions to add the non-clean ones to the work list for processing, and (2) when an instruction is specialized/replaced we mark everything that transitively depends on it "dirty" (by removing it from the "clean" list).

* Added some logic to "fix up" the type of an IR function after changes that might modify its parameter list. Failing to have this logic meant that certain types were still live (because they were referenced by a function type) that couldn't actually be emitted as legal HLSL/GLSL.

* Added some special cases to IR instruction creation for `wrapExistential` and `BindExistentialsType` so that they act as no-ops when there are no "slots" providing specialization information. This helps avoid some special cases when specializing structure fields (since some fields specialization and others don't, so in general there are zero or more operands specific to each field).

* Added a test case that uses an interface type in a `cbuffer`, as well as an interface type in a `struct` passed as an entry-point `uniform` parameter.

* Fixed up some parts of the `.natvis` files to reflect naming changes from a previous PR and thus restore some of the useful Visual Studio debugging experience for Slang.

Author: Tim Foley

source/core/core.natvis

@@ -3,41 +3,41 @@
 <AutoVisualizer xmlns="http://schemas.microsoft.com/vstudio/debugger/natvis/2010">
 
 <Type Name="Slang::String">
-    <DisplayString>{((char*) (buffer.pointer+1)),s}</DisplayString>
-	<StringView>((char*) (buffer.pointer+1)),s</StringView>
+    <DisplayString>{((char*) (m_buffer.pointer+1)),s}</DisplayString>
+	<StringView>((char*) (m_buffer.pointer+1)),s</StringView>
 </Type>
 
 <Type Name="Slang::ArrayView&lt;*&gt;">
-  <DisplayString>{{ size={_count} }}</DisplayString>
+  <DisplayString>{{ size={m_count} }}</DisplayString>
   <Expand>
-    <Item Name="[size]">_count</Item>
+    <Item Name="[size]">m_count</Item>
     <ArrayItems>
-      <Size>_count</Size>
-      <ValuePointer>_buffer</ValuePointer>
+      <Size>m_count</Size>
+      <ValuePointer>m_buffer</ValuePointer>
     </ArrayItems>
   </Expand>
 </Type>
 
 <Type Name="Slang::List&lt;*&gt;">
-    <DisplayString>{{ size={_count} }}</DisplayString>
+    <DisplayString>{{ size={m_count} }}</DisplayString>
     <Expand>
-        <Item Name="[size]">_count</Item>
-        <Item Name="[capacity]">bufferSize</Item>
+        <Item Name="[size]">m_count</Item>
+        <Item Name="[capacity]">m_capacity</Item>
         <ArrayItems>
-            <Size>_count</Size>
-            <ValuePointer>buffer</ValuePointer>
+            <Size>m_count</Size>
+            <ValuePointer>m_buffer</ValuePointer>
         </ArrayItems>
     </Expand>
 </Type>
 
 
 <Type Name="Slang::Array&lt;*,*&gt;">
-  <DisplayString>{{ size={_count} }}</DisplayString>
+  <DisplayString>{{ size={m_count} }}</DisplayString>
   <Expand>
-    <Item Name="[size]">_count</Item>
+    <Item Name="[size]">m_count</Item>
     <ArrayItems>
-      <Size>_count</Size>
-      <ValuePointer>_buffer</ValuePointer>
+      <Size>m_count</Size>
+      <ValuePointer>m_buffer</ValuePointer>
     </ArrayItems>
   </Expand>
 </Type>

source/slang/ir-entry-point-uniforms.cpp

@@ -347,6 +347,8 @@ struct MoveEntryPointUniformParametersToGlobalScope
             //
             param->removeAndDeallocate();
         }
+
+        fixUpFuncType(func);
     }
 
     // We need to be able to determine if a parameter is logically

source/slang/ir-insts.h

@@ -919,6 +919,19 @@ struct IRBuilder
         UInt            slotArgCount,
         IRInst* const*  slotArgs);
 
+    IRInst* emitWrapExistential(
+        IRType*         type,
+        IRInst*         value,
+        UInt            slotArgCount,
+        IRUse const*    slotArgs)
+    {
+        List<IRInst*> slotArgVals;
+        for(UInt ii = 0; ii < slotArgCount; ++ii)
+            slotArgVals.add(slotArgs[ii].get());
+
+        return emitWrapExistential(type, value, slotArgCount, slotArgVals.getBuffer());
+    }
+
     IRUndefined* emitUndefined(IRType* type);