Support generic `struct` types during IR-based emit

Fixes #318

Most of the required support was actually in place, so this is just a bunch of fixes:

- Detect when we are in "full IR" mode, so that we can always emit `struct` declarations with their mangled named (which will produce different names for different specializations, since we emit decl-refs)

  - Carefully exclude builtin types from this for now. We'll need a more complete solution for mapping HLSL/Slang builtin types to their GLSL equivalents soon.

- Skip emitting types referenced by generic IR functions, since they might not be usable.

  - Also fix things up so that we emit types used in the initializer for any global variables.

- Fix bug in generic specialization where we specialize the same function more than once, with different type arguments. We were crashing on a `Dictionary::Add` call where the key already exists from a previous specialization attempt.

- Fix name-mangling logic so that when outputting a possibly-specialized generic it looks for the outer-most `GenericSubstitution` rather than just the first one in the list. This is to handle the way that we insert other substitutions willy-nilly in places where they realistically don't belong. :(

All of these changes together allow us to pass a slightly modified (more advanced) version of the test case posted to #318.

1 files changed, 13 insertions, 1 deletions

diff --git a/source/slang/mangle.cpp b/source/slang/mangle.cpp
index 721072b82..0625a6f73 100644
--- a/source/slang/mangle.cpp
+++ b/source/slang/mangle.cpp
@@ -184,6 +184,18 @@ namespace Slang
         }
     }
 
+    // TODO: this needs to be centralized
+    RefPtr<GenericSubstitution> getOutermostGenericSubst(
+        RefPtr<Substitutions> inSubst)
+    {
+        for (auto subst = inSubst; subst; subst = subst->outer)
+        {
+            if (auto genericSubst = subst.As<GenericSubstitution>())
+                return genericSubst;
+        }
+        return nullptr;
+    }
+
     void emitQualifiedName(
         ManglingContext*    context,
         DeclRef<Decl>       declRef)
@@ -221,7 +233,7 @@ namespace Slang
             // There are two cases here: either we have specializations
             // in place for the parent generic declaration, or we don't.
 
-            auto subst = declRef.substitutions.As<GenericSubstitution>();
+            auto subst = getOutermostGenericSubst(declRef.substitutions);
             if( subst && subst->genericDecl == parentGenericDeclRef.getDecl() )
             {
                 // This is the case where we *do* have substitutions.