Merge branch 'master' into ci-add-sascha-willems

jvepsalainen-nv · web-flow · commit 9ce8512f912f · 2026-03-10T12:19:22.000+02:00
diff --git a/prelude/slang-torch-prelude.h b/prelude/slang-torch-prelude.h
@@ -158,20 +158,19 @@ TensorView make_tensor_view(
                                      .append(")")
                                      .c_str());
 
-    bool isEmpty = true;
+    // A tensor can have zero elements even if some dimensions are non-zero
+    // (e.g. shape (10, 0)). Emptiness must be based on numel().
+    bool isEmpty = (val.numel() == 0);
     for (int i = 0; i < val.dim(); ++i)
     {
+        res.sizes[i] = val.size(i);
         res.strides[i] = val.stride(i) * elementSize;
-        if (res.strides[i] == 0)
+        if (!isEmpty && res.strides[i] == 0)
             throw std::runtime_error(
                 std::string(name)
                     .append(": tensors with broadcasted dimensions are not supported (use "
                             "tensor.contiguous() to make tensor whole)")
                     .c_str());
-
-        res.sizes[i] = val.size(i);
-        if (res.sizes[i] > 0)
-            isEmpty = false;
     }
 
     if (!res.data && !isEmpty)
diff --git a/source/compiler-core/slang-rich-diagnostics-render.cpp b/source/compiler-core/slang-rich-diagnostics-render.cpp
@@ -134,6 +134,7 @@ struct DiagnosticRenderer
         Int64 number = 0;
         UnownedStringSlice content;
         List<LineHighlight> spans;
+        bool sourceAvailable = false;
     };
 
     // A collection of nearby HighlightedLines
@@ -303,12 +304,13 @@ struct DiagnosticRenderer
         {
             HighlightedLine& line = grouped[span.line];
             line.number = span.line;
-            if (line.content.getLength() == 0)
+            if (line.content.getLength() == 0 && !line.sourceAvailable)
             {
                 SourceView* view =
                     m_sourceManager ? m_sourceManager->findSourceView(span.startLoc) : nullptr;
                 if (view)
                 {
+                    line.sourceAvailable = true;
                     // Get the line content and trim end-of-line characters and trailing whitespace
                     UnownedStringSlice rawLine = StringUtil::trimEndOfLine(
                         view->getSourceFile()->getLineAtIndex(span.line - 1));
@@ -347,6 +349,18 @@ struct DiagnosticRenderer
         return section;
     }
 
+    // Returns true if any line in the section has source text available.
+    // When source is unavailable (e.g. built-in modules), we skip rendering
+    // the section body to avoid showing empty source lines with underlines.
+    bool sectionHasSourceAvailable(const SectionLayout& section) const
+    {
+        for (const auto& block : section.blocks)
+            for (const auto& line : block.lines)
+                if (line.sourceAvailable)
+                    return true;
+        return false;
+    }
+
     Int64 findCommonIndent(const List<LayoutBlock>& blocks)
     {
         Index minIndent = std::numeric_limits<Index>::max();
@@ -504,6 +518,24 @@ struct DiagnosticRenderer
         return rows;
     }
 
+    // When source text is unavailable (e.g. built-in modules), render span
+    // labels with a compact gutter structure (pipe + closing corner), using a
+    // minimal gutter width since there are no line numbers to display.
+    void renderOrphanedLabels(StringBuilder& ss, const SectionLayout& section, Int64 gutterWidth)
+    {
+        String gutter =
+            repeat(' ', gutterWidth + 1) + color(TerminalColor::Cyan, m_glyphs.vertical);
+        for (const auto& block : section.blocks)
+            for (const auto& line : block.lines)
+                for (const auto& span : line.spans)
+                    if (span.label.getLength() > 0)
+                        ss << gutter << " " << color(TerminalColor::BoldRed, span.label) << "\n";
+        ss << color(
+                  TerminalColor::Cyan,
+                  repeat(m_glyphs.secondaryUnderline, gutterWidth + 1) + m_glyphs.gutterCorner)
+           << "\n";
+    }
+
     void renderSectionBody(StringBuilder& ss, const SectionLayout& section)
     {
         for (const auto& block : section.blocks)
@@ -643,36 +675,61 @@ struct DiagnosticRenderer
             layout.primaryLoc.line > 0 || layout.primaryLoc.fileName.getLength() > 0;
         if (hasValidLocation)
         {
-            renderLocation(ss, layout.primaryLoc);
-
-            if (layout.primarySection.blocks.getCount() > 0)
+            bool primaryHasSource = sectionHasSourceAvailable(layout.primarySection);
+            if (primaryHasSource)
+            {
+                renderLocation(ss, layout.primaryLoc);
+                if (layout.primarySection.blocks.getCount() > 0)
+                {
+                    ss << repeat(' ', layout.primarySection.maxGutterWidth + 1)
+                       << color(TerminalColor::Cyan, m_glyphs.vertical) << "\n";
+                    renderSectionBody(ss, layout.primarySection);
+                    ss << color(
+                              TerminalColor::Cyan,
+                              repeat(
+                                  m_glyphs.secondaryUnderline,
+                                  layout.primarySection.maxGutterWidth + 1) +
+                                  m_glyphs.gutterCorner)
+                       << "\n";
+                }
+            }
+            else
             {
-                ss << repeat(' ', layout.primarySection.maxGutterWidth + 1)
-                   << color(TerminalColor::Cyan, m_glyphs.vertical) << "\n";
-                renderSectionBody(ss, layout.primarySection);
-                ss << color(
-                          TerminalColor::Cyan,
-                          repeat(
-                              m_glyphs.secondaryUnderline,
-                              layout.primarySection.maxGutterWidth + 1) +
-                              m_glyphs.gutterCorner)
-                   << "\n";
+                constexpr Int64 kOrphanGutterWidth = 0;
+                DiagnosticLayout::Location loc = layout.primaryLoc;
+                loc.gutterIndent = kOrphanGutterWidth;
+                renderLocation(ss, loc);
+                if (layout.primarySection.blocks.getCount() > 0)
+                    renderOrphanedLabels(ss, layout.primarySection, kOrphanGutterWidth);
             }
         }
         for (const auto& note : layout.notes)
         {
             ss << "\n" << color(TerminalColor::Cyan, "note") << ": " << note.message << "\n";
-            renderNoteLocation(ss, note.loc);
-            if (note.section.blocks.getCount() > 0)
+            bool noteHasSource = sectionHasSourceAvailable(note.section);
+            if (noteHasSource)
+            {
+                renderNoteLocation(ss, note.loc);
+                if (note.section.blocks.getCount() > 0)
+                {
+                    ss << repeat(' ', note.section.maxGutterWidth + 1)
+                       << color(TerminalColor::Cyan, m_glyphs.vertical) << "\n";
+                    renderSectionBody(ss, note.section);
+                    ss << color(
+                              TerminalColor::Cyan,
+                              repeat(m_glyphs.secondaryUnderline, note.section.maxGutterWidth + 1) +
+                                  m_glyphs.gutterCorner)
+                       << "\n";
+                }
+            }
+            else
             {
-                ss << repeat(' ', note.section.maxGutterWidth + 1)
-                   << color(TerminalColor::Cyan, m_glyphs.vertical) << "\n";
-                renderSectionBody(ss, note.section);
-                ss << color(
-                          TerminalColor::Cyan,
-                          repeat(m_glyphs.secondaryUnderline, note.section.maxGutterWidth + 1) +
-                              m_glyphs.gutterCorner)
-                   << "\n";
+                constexpr Int64 kOrphanGutterWidth = 0;
+                DiagnosticLayout::Location noteLoc = note.loc;
+                noteLoc.gutterIndent = kOrphanGutterWidth;
+                renderNoteLocation(ss, noteLoc);
+                if (note.section.blocks.getCount() > 0)
+                    renderOrphanedLabels(ss, note.section, kOrphanGutterWidth);
             }
         }
         return ss.produceString();
diff --git a/tests/diagnostics/rich-diag-no-source.slang b/tests/diagnostics/rich-diag-no-source.slang
@@ -0,0 +1,23 @@
+//TEST:SIMPLE(diag=CHK):-target hlsl -stage compute -entry computeMain
+//TEST:SIMPLE(filecheck=FC):-target hlsl -stage compute -entry computeMain
+
+// Test that diagnostics pointing to built-in modules (where source text is
+// unavailable) don't render empty source sections.
+
+Texture2D<int4> t2D;
+SamplerState s;
+
+RWStructuredBuffer<int4> outputBuffer;
+
+void computeMain()
+{
+    outputBuffer[0] = t2D.Sample(s, float2(0.0, 0.0));
+//CHK: static assertion failed
+//CHK: HLSL supports only float and half type textures
+//CHK: see call to 'Sample'
+}
+
+// FC: error[E41400]: static assertion failed
+// FC-NEXT: --> hlsl.meta.slang:{{[0-9]+}}:{{[0-9]+}}
+// FC-NEXT:  | static assertion failed, HLSL supports only float and half type textures
+// FC-NEXT: -'
diff --git a/tests/language-feature/dynamic-dispatch/diagnose-explicit-specialize-with-interface.slang b/tests/language-feature/dynamic-dispatch/diagnose-explicit-specialize-with-interface.slang
@@ -0,0 +1,56 @@
+// Explicitly specializing a constrained generic function with an
+// interface type should be rejected with the same diagnostic as
+// implicit inference (error 33180). Currently crashes with an
+// internal compiler error (99999) on a different code path than
+// the implicit case in diagnose-generic-func-with-interface.slang.
+
+// Disabled: ICE -- should emit error 33180 but crashes with error 99999
+//DISABLE_TEST:SIMPLE(filecheck=CHECK): -target spirv
+//DISABLE_TEST:SIMPLE(filecheck=CHECK): -target hlsl -stage compute -entry computeMain
+//DISABLE_TEST:SIMPLE(filecheck=CHECK): -target glsl -stage compute -entry computeMain
+//DISABLE_TEST:SIMPLE(filecheck=CHECK): -target metal -stage compute -entry computeMain
+
+#lang slang 2025
+
+interface IFoo
+{
+    float calc(float x);
+}
+
+struct A : IFoo
+{
+    float calc(float x) { return x * x; }
+}
+
+struct B : IFoo
+{
+    float calc(float x) { return x * 2; }
+}
+
+float genericFunc<T : IFoo>(T obj, float x)
+{
+    return obj.calc(x);
+}
+
+IFoo makeInterface(uint id)
+{
+    if (id == 0)
+        return A();
+    else
+        return B();
+}
+
+RWStructuredBuffer<float> outputBuffer;
+
+[numthreads(1, 1, 1)]
+void computeMain(uint3 dispatchThreadID : SV_DispatchThreadID)
+{
+    IFoo obj = makeInterface(dispatchThreadID.x);
+
+    // Explicit specialization with an interface type should be rejected
+    // the same way implicit inference is (error 33180).
+    // CHECK: ([[# @LINE+1]]): error[E33180]
+    float result = genericFunc<IFoo>(obj, 3.0);
+
+    outputBuffer[0] = result;
+}
diff --git a/tests/language-feature/dynamic-dispatch/generic-method-with-interface-arg.slang b/tests/language-feature/dynamic-dispatch/generic-method-with-interface-arg.slang
@@ -0,0 +1,73 @@
+// A generic method in a struct, constrained with T : IFoo, correctly
+// dispatches when called with an interface-typed argument. This works
+// even though free generic functions with the same constraint produce
+// error 33180.
+
+//TEST(compute):COMPARE_COMPUTE_EX(filecheck-buffer=CHECK):-slang -compute -shaderobj -output-using-type
+//TEST(compute,vulkan):COMPARE_COMPUTE_EX(filecheck-buffer=CHECK):-vk -compute -shaderobj -output-using-type
+//TEST(compute):COMPARE_COMPUTE_EX(filecheck-buffer=CHECK):-cuda -compute -shaderobj -output-using-type
+//TEST(compute):COMPARE_COMPUTE_EX(filecheck-buffer=CHECK):-cpu -compute -shaderobj -output-using-type
+//TEST:SIMPLE(filecheck=REPORT):-target hlsl -stage compute -entry computeMain -report-dynamic-dispatch-sites
+
+interface IFoo
+{
+    float calc(float x);
+}
+
+struct FooA : IFoo
+{
+    float calc(float x) { return x * 2.0; }
+}
+
+struct FooB : IFoo
+{
+    float calc(float x) { return x + 10.0; }
+}
+
+struct Processor
+{
+    float scale;
+
+    float apply<T : IFoo>(T obj, float x)
+    {
+        return obj.calc(x) * scale;
+        // REPORT-DAG: note[E50102]: generated {{.*}} dispatch code{{.*}} 2 possible types:
+    }
+}
+
+IFoo makeObj(int id)
+{
+    if (id == 0) return FooA();
+    else return FooB();
+}
+
+float testGenericMethod(int id, float x, float scale)
+{
+    IFoo obj = makeObj(id);
+    Processor p;
+    p.scale = scale;
+    return p.apply(obj, x);
+}
+
+//TEST_INPUT:ubuffer(data=[0 0 0 0], stride=4):out,name=outputBuffer
+RWStructuredBuffer<float> outputBuffer;
+
+[numthreads(1, 1, 1)]
+void computeMain(int id : SV_DispatchThreadID)
+{
+    // FooA: calc(5.0) * 2.0 = 10.0 * 2.0 = 20.0
+    outputBuffer[0] = testGenericMethod(id, 5.0, 2.0);
+    // CHECK: 20.0
+
+    // FooB: calc(5.0) * 2.0 = 15.0 * 2.0 = 30.0
+    outputBuffer[1] = testGenericMethod(id + 1, 5.0, 2.0);
+    // CHECK: 30.0
+
+    // FooA: calc(3.0) * 0.5 = 6.0 * 0.5 = 3.0
+    outputBuffer[2] = testGenericMethod(id, 3.0, 0.5);
+    // CHECK: 3.0
+
+    // FooB: calc(3.0) * 0.5 = 13.0 * 0.5 = 6.5
+    outputBuffer[3] = testGenericMethod(id + 1, 3.0, 0.5);
+    // CHECK: 6.5
+}
diff --git a/tests/language-feature/dynamic-dispatch/generic-struct-with-interface-field.slang b/tests/language-feature/dynamic-dispatch/generic-struct-with-interface-field.slang
