From 6b44630afe4ff180ba608142e9515abcd369775e Mon Sep 17 00:00:00 2001
From: Ronan <ro.cailleau@gmail.com>
Date: Thu, 3 Apr 2025 06:17:15 +0200
Subject: Fixed generic interface specialization crashes (#6601): (#6688)

* Fixed generic interface specialization crashes:

- Add an export decoration to specialized generic interfaces.

* Fixed generic interface specialization crashes:

- Add an export decoration to specialized generic interfaces.
- Use getTypeNameHint(...) instead of a manual mangler.

* In cloneInstDecorationsAndChildren: specialize all linkage decorations, not just the exports.

- If a linkage decoration is already present, it is not specialized and replaced by the specialized one.
- If a specialization uses the TypeNameHint, sanitize it to be used as an identifier.
- Use the identifier name sanitizer from slang-mangle.

* Added tests/generics/generic-interface-linkage.slang

- See #6601 and #6688
---
 source/slang/slang-ir-clone.cpp | 63 +++++++++++++++++++++++++++++++++++++++++
 1 file changed, 63 insertions(+)

(limited to 'source/slang/slang-ir-clone.cpp')

diff --git a/source/slang/slang-ir-clone.cpp b/source/slang/slang-ir-clone.cpp
index 66af405d6..5bb1c1210 100644
--- a/source/slang/slang-ir-clone.cpp
+++ b/source/slang/slang-ir-clone.cpp
@@ -2,7 +2,10 @@
 #include "slang-ir-clone.h"
 
 #include "slang-ir-insts.h"
+#include "slang-ir-util.h"
 #include "slang-ir.h"
+#include "slang-mangle.h"
+
 
 namespace Slang
 {
@@ -104,6 +107,61 @@ IRInst* cloneInstAndOperands(IRCloneEnv* env, IRBuilder* builder, IRInst* oldIns
     return newInst;
 }
 
+// Copy the linkage decoration of oldInst (if present) and specialize it for target.
+static void specializeLinkageDecoration(IRInst* target, IRSpecialize* oldInst, IRBuilder* builder)
+{
+    auto gen = as<IRGeneric>(oldInst->getBase());
+    if (gen)
+    {
+        auto genLinkage = gen->findDecoration<IRLinkageDecoration>();
+        if (genLinkage)
+        {
+            bool isExport = as<IRExportDecoration>(genLinkage);
+            StringBuilder sb;
+            sb.append(genLinkage->getMangledName());
+            sb.append("G");
+            IRSpecialize* specializationProvider = oldInst;
+            if (auto targetAsSpec = as<IRSpecialize>(target))
+            {
+                specializationProvider = targetAsSpec;
+            }
+            for (UInt i = 0; i < specializationProvider->getArgCount(); ++i)
+            {
+                auto arg = specializationProvider->getArg(i);
+                sb.append(i);
+                if (auto typeLinkage = arg->findDecoration<IRLinkageDecoration>())
+                {
+                    sb.append(typeLinkage->getMangledName());
+                }
+                else
+                {
+                    // getTypeNameHint may produce a name with characters that can't
+                    // be part of an identifier, so we need to filter it afterward.
+                    StringBuilder tmp;
+                    getTypeNameHint(tmp, arg);
+                    emitNameForLinkage(sb, tmp.getUnownedSlice());
+                }
+            }
+            if (auto previousLinkage = target->findDecoration<IRLinkageDecoration>())
+            {
+                // Overwrite the previous linkage decoration, since it was not specialized
+                previousLinkage->setOperand(0, builder->getStringValue(sb.getUnownedSlice()));
+            }
+            else
+            {
+                if (isExport)
+                {
+                    builder->addExportDecoration(target, sb.getUnownedSlice());
+                }
+                else
+                {
+                    builder->addImportDecoration(target, sb.getUnownedSlice());
+                }
+            }
+        }
+    }
+}
+
 // The complexity of the second phase of cloning (the
 // one that deals with decorations and children) comes
 // from the fact that it needs to sequence the two phases
@@ -226,6 +284,11 @@ static void _cloneInstDecorationsAndChildren(
         newParam->setFullType(newType);
         newParam->sourceLoc = oldParam->sourceLoc;
     }
+
+    if (auto oldAsSpec = as<IRSpecialize>(oldInst))
+    {
+        specializeLinkageDecoration(newInst, oldAsSpec, builder);
+    }
 }
 
 // The public version of `cloneInstDecorationsAndChildren` is then
-- 
cgit v1.2.3