wgsl: signedness mismatch fixes

source/slang/slang-ir-wgsl-legalize.cpp

@@ -1429,6 +1429,30 @@ struct LegalizeWGSLEntryPointContext
         }
     }
 
+    void legalizeFunc(IRFunc* func)
+    {
+        // Insert casts to convert integer return types
+        auto funcReturnType = func->getResultType();
+        if (isIntegralType(funcReturnType))
+        {
+            for (auto block : func->getBlocks())
+            {
+                if (auto returnInst = as<IRReturn>(block->getTerminator()))
+                {
+                    auto returnedValue = returnInst->getOperand(0);
+                    auto returnedValueType = returnedValue->getDataType();
+                    if (isIntegralType(returnedValueType))
+                    {
+                        IRBuilder builder(returnInst);
+                        builder.setInsertBefore(returnInst);
+                        auto newOp = builder.emitCast(funcReturnType, returnedValue);
+                        builder.replaceOperand(returnInst->getOperands(), newOp);
+                    }
+                }
+            }
+        }
+    }
+
     void legalizeSwitch(IRSwitch* switchInst)
     {
         // WGSL Requires all switch statements to contain a default case.
@@ -1491,6 +1515,28 @@ struct LegalizeWGSLEntryPointContext
                 inst->getOperand(0));
             builder.replaceOperand(inst->getOperands(), newLhs);
         }
+        else if (
+            isIntegralType(inst->getOperand(0)->getDataType()) &&
+            isIntegralType(inst->getOperand(1)->getDataType()))
+        {
+            // If integer operands differ in signedness, convert the signed one to unsigned.
+            // We're assuming that the cases where this is bad have already been caught by
+            // common validation checks.
+            IntInfo opIntInfo[2] = {
+                getIntTypeInfo(inst->getOperand(0)->getDataType()),
+                getIntTypeInfo(inst->getOperand(1)->getDataType())};
+            if (opIntInfo[0].isSigned != opIntInfo[1].isSigned)
+            {
+                int signedOpIndex = (int)opIntInfo[1].isSigned;
+                opIntInfo[signedOpIndex].isSigned = false;
+                IRBuilder builder(inst);
+                builder.setInsertBefore(inst);
+                auto newOp = builder.emitCast(
+                    builder.getType(getIntTypeOpFromInfo(opIntInfo[signedOpIndex])),
+                    inst->getOperand(signedOpIndex));
+                builder.replaceOperand(inst->getOperands() + signedOpIndex, newOp);
+            }
+        }
     }
 
     void processInst(IRInst* inst)
@@ -1529,6 +1575,9 @@ struct LegalizeWGSLEntryPointContext
             legalizeBinaryOp(inst);
             break;
 
+        case kIROp_Func:
+            legalizeFunc(static_cast<IRFunc*>(inst));
+            [[fallthrough]];
         default:
             for (auto child : inst->getModifiableChildren())
             {

tests/expected-failure-github.txt

@@ -13,5 +13,4 @@ tests/bugs/buffer-swizzle-store.slang.3 syn (wgpu)
 tests/compute/interface-shader-param-in-struct.slang.4 syn (wgpu)
 tests/compute/interface-shader-param.slang.5 syn (wgpu)
 tests/language-feature/constants/static-const-in-generic-interface.slang.1 syn (wgpu)
-tests/language-feature/enums/strongly-typed-id.slang.1 syn (wgpu)
 tests/language-feature/shader-params/interface-shader-param-ordinary.slang.4 syn (wgpu)

tests/language-feature/enums/strongly-typed-id.slang

@@ -1,6 +1,4 @@
 //TEST(compute):COMPARE_COMPUTE(filecheck-buffer=CHECK): -shaderobj
-// WGSL: No matching overload for operator... #5606
-//DISABLE_TEST(compute):COMPARE_COMPUTE_EX:-wgpu
 
 enum MyId : uint {}
 extension MyId { uint get() { return (uint)this; } }