Diagnose if extension declares new interface requirements (#9276)

## Summary

This PR adds a diagnostic for missing symbol definitions during the IR
linking phase. When `cloneGlobalValueWithLinkage` selects the "best
value" for a symbol, it now validates that the value is actually
usable—meaning it must either:

- Have a function body (a concrete definition)
- Be marked as a target intrinsic (via appropriate decoration)
- Be marked as an imported symbol (e.g., `DLLImport` decoration)
- Have SPIRV instruction or autodiff decorations

If none of these conditions are met, the compiler now emits a linker
error indicating the symbol lacks a definition, along with note
diagnostics listing all candidate values that were considered.

## Background

Previously, declaring a method signature in an extension without
providing a body would silently proceed through compilation until
hitting an internal error during code emission ("unexpected IR opcode").
This made it difficult to diagnose issues where users accidentally
declared interface-like requirements in extensions—something that isn't
semantically valid since extensions cannot add new requirements to
existing types.

## Changes

- **`source/slang/slang-ir-link.cpp`**: Added validation in
`cloneGlobalValueWithLinkage` to check that the selected best value has
a valid definition. Added helper function `isFunctionDefinedOrImported`
to perform the check. Emits a clear diagnostic when a symbol is
referenced but has no definition.

- **`tests/diagnostics/extension-interface-requirement.slang`**: Added
test case covering the scenario where an extension declares a method
without a body.


Closes #9198

Author: gtong-nv

source/slang/slang-ir-link.cpp

@@ -60,9 +60,13 @@ struct IRSharedSpecContext
 
     // The "global" specialization environment.
     IRSpecEnv globalEnv;
+
+    // Diagnostic sink for reporting errors during linking.
+    DiagnosticSink* sink = nullptr;
 };
 
 void insertGlobalValueSymbol(IRSharedSpecContext* sharedContext, IRInst* gv);
+static bool isFunctionDefinedOrImported(IRInst* inst);
 
 struct WitnessTableCloneInfo : RefObject
 {
@@ -1553,6 +1557,27 @@ IRInst* cloneGlobalValueWithLinkage(
         return nullptr;
     }
 
+    // Check that the best value we found is valid: if it's a function,
+    // it should either have a body, be an intrinsic, or be imported.
+    // This catches cases like extension methods declared without a body,
+    // which are not valid (extensions cannot define new requirements).
+    if (!isFunctionDefinedOrImported(bestVal))
+    {
+        if (auto sink = context->shared->sink)
+        {
+            sink->diagnose(bestVal->sourceLoc, Diagnostics::unresolvedSymbol, bestVal);
+
+            // Emit notes for all available declarations of this symbol
+            for (IRSpecSymbol* ss = sym; ss; ss = ss->nextWithSameName)
+            {
+                sink->diagnose(
+                    ss->irGlobalValue->sourceLoc,
+                    Diagnostics::seeDeclarationOf,
+                    ss->irGlobalValue);
+            }
+        }
+    }
+
     // Check if we've already cloned this value, for the case where
     // we didn't have an original value (just a name), but we've
     // now found a representative value.
@@ -1697,6 +1722,60 @@ static bool doesFuncHaveDefinition(IRFunc* func)
     return false;
 }
 
+/// Check if a function (or generic containing a function) is properly defined or imported.
+/// Returns true if the value is not a function, or if it has a definition, is an intrinsic,
+/// or is marked as imported.
+static bool isFunctionDefinedOrImported(IRInst* inst)
+{
+    IRFunc* func = nullptr;
+
+    // Handle generic case - unwrap the generic to get the function
+    if (auto generic = as<IRGeneric>(inst))
+    {
+        func = as<IRFunc>(findGenericReturnVal(generic));
+    }
+    else
+    {
+        func = as<IRFunc>(inst);
+    }
+
+    // Not a function, no check needed
+    if (!func)
+        return true;
+
+    // Check if it has a function body
+    if (func->getFirstBlock() != nullptr)
+        return true;
+
+    // Check for decorations that indicate the function has an external/special implementation
+    for (auto decor : func->getDecorations())
+    {
+        switch (decor->getOp())
+        {
+        // Intrinsic decorations
+        case kIROp_IntrinsicOpDecoration:
+        case kIROp_TargetIntrinsicDecoration:
+        case kIROp_SPIRVOpDecoration:
+        // Autodiff decorations - the function's implementation is provided by the derivative
+        // function
+        case kIROp_ForwardDerivativeDecoration:
+        case kIROp_BackwardDerivativeDecoration:
+        case kIROp_UserDefinedBackwardDerivativeDecoration:
+        case kIROp_PrimalSubstituteDecoration:
+            return true;
+        default:
+            continue;
+        }
+    }
+
+    // Check for import decorations on the original inst (for generics)
+    if (inst->findDecoration<IRImportDecoration>() || inst->findDecoration<IRDllImportDecoration>())
+        return true;
+
+
+    return false;
+}
+
 static bool doesWitnessTableHaveDefinition(IRWitnessTable* wt)
 {
     auto interfaceType = as<IRInterfaceType>(wt->getConformanceType());
@@ -2065,6 +2144,7 @@ LinkedIR linkIR(CodeGenContext* codeGenContext)
 
     auto sharedContext = state->getSharedContext();
     initializeSharedSpecContext(sharedContext, session, nullptr, targetReq);
+    sharedContext->sink = codeGenContext->getSink();
 
     state->irModule = sharedContext->module;
 

tests/diagnostics/extension-interface-requirement.slang

@@ -0,0 +1,60 @@
+// extension-interface-requirement.slang
+
+// Test that extension method declarations without bodies are properly diagnosed.
+// Extensions cannot declare new interface requirements - they must provide implementations.
+// See https://github.com/shader-slang/slang/issues/9198
+
+//DIAGNOSTIC_TEST:SIMPLE(filecheck=CHECK):-target spirv
+
+// Simple interface
+public interface IROTensor<T, let D : int>
+{
+    T read_buffer(int idx);
+}
+
+// Concrete type implementing the interface
+public struct ROTensor<T, let D : int> : IROTensor<T, D>
+{
+    public StructuredBuffer<T> _data;
+    public uint[D] _strides;
+    public uint _offset;
+
+    public T read_buffer(int idx)
+    {
+        return _data[idx];
+    }
+}
+
+// Helper function
+int _idx(int i0, uint stride[1], uint offset)
+{
+    return i0 * stride[0] + offset;
+}
+
+// This concrete extension works fine - it has a function body
+public extension<T> ROTensor<T, 1>
+{
+    public T load(int i0)
+    {
+        int idx = _idx(i0, this._strides, this._offset);
+        return this.read_buffer(idx);
+    }
+}
+
+// ERROR: Extension with generic type parameter that declares a method without a body.
+// Extensions cannot declare new interface requirements.
+public extension<T, TensorType : IROTensor<T, 1>> TensorType
+{
+    // CHECK: ([[# @LINE+1]]): error 45001
+    public T loadGeneric(int i0);  // Error: function declaration without definition
+}
+
+// Test entry point
+[shader("compute")]
+[numthreads(1, 1, 1)]
+void main()
+{
+    ROTensor<float, 1> tensor;
+    float value = tensor.load(0);
+    float value2 = tensor.loadGeneric(0);  // Uses the extension method
+}