Replace DownstreamCompileResult with Artifact (#2369)

* #include an absolute path didn't work - because paths were taken to always be relative.

* WIP replacing DownstreamCompileResult.

* First attempt at replacing DownstreamCompileResult with IArtifact and associated types.

* Small renaming around CharSlice.

* ICastable -> ISlangCastable
Added IClonable
Fix issue with cloning in ArtifactDiagnostics.

* Only add the blob if one is defined in DXC.

* Guard adding blob representation.

* Make cloneInterface available across code base.
Set enums backing type for ArtifactDiagnostic.

* Added ::create for ArtifactDiagnostics.

3 files changed, 72 insertions, 62 deletions

diff --git a/tools/slang-test/parse-diagnostic-util.cpp b/tools/slang-test/parse-diagnostic-util.cpp
index 552a0924b..c2cc1f010 100644
--- a/tools/slang-test/parse-diagnostic-util.cpp
+++ b/tools/slang-test/parse-diagnostic-util.cpp
@@ -11,13 +11,13 @@
 #include "../../source/core/slang-byte-encode-util.h"
 #include "../../source/core/slang-char-util.h"
 
+#include "../../source/compiler-core/slang-artifact-diagnostic-util.h"
+#include "../../source/compiler-core/slang-artifact-associated-impl.h"
 #include "../../source/compiler-core/slang-downstream-compiler.h"
 
 using namespace Slang;
 
-
-
-/* static */SlangResult ParseDiagnosticUtil::parseGenericLine(const UnownedStringSlice& line, List<UnownedStringSlice>& lineSlices, DownstreamDiagnostic& outDiagnostic)
+/* static */SlangResult ParseDiagnosticUtil::parseGenericLine(CharSliceAllocator& allocator, const UnownedStringSlice& line, List<UnownedStringSlice>& lineSlices, ArtifactDiagnostic& outDiagnostic)
 {
     /* e:\git\somewhere\tests\diagnostics\syntax-error-intrinsic.slang(13): error C2018:  unknown character '0x40' */
     if (lineSlices.getCount() < 3)
@@ -28,29 +28,29 @@ using namespace Slang;
     {
         const UnownedStringSlice severityAndCodeSlice = lineSlices[1].trim();
         // Get the code
-        outDiagnostic.code = StringUtil::getAtInSplit(severityAndCodeSlice, ' ', 1).trim();
+        outDiagnostic.code = allocator.allocate(StringUtil::getAtInSplit(severityAndCodeSlice, ' ', 1).trim());
 
         const UnownedStringSlice severitySlice = StringUtil::getAtInSplit(severityAndCodeSlice, ' ', 0);
 
-        outDiagnostic.severity = DownstreamDiagnostic::Severity::Error;
+        outDiagnostic.severity = ArtifactDiagnostic::Severity::Error;
         if (severitySlice == UnownedStringSlice::fromLiteral("warning"))
         {
-            outDiagnostic.severity = DownstreamDiagnostic::Severity::Warning;
+            outDiagnostic.severity = ArtifactDiagnostic::Severity::Warning;
         }
         else if (severitySlice == UnownedStringSlice::fromLiteral("info"))
         {
-            outDiagnostic.severity = DownstreamDiagnostic::Severity::Info;
+            outDiagnostic.severity = ArtifactDiagnostic::Severity::Info;
         }
     }
 
     // Get the location info
-    SLANG_RETURN_ON_FAIL(DownstreamDiagnostic::splitPathLocation(lineSlices[0], outDiagnostic));
+    SLANG_RETURN_ON_FAIL(ArtifactDiagnosticUtil::splitPathLocation(allocator, lineSlices[0], outDiagnostic));
 
-    outDiagnostic.text = UnownedStringSlice(lineSlices[2].begin(), line.end());
+    outDiagnostic.text = allocator.allocate(lineSlices[2].begin(), line.end());
     return SLANG_OK;
 }
 
-static SlangResult _getSlangDiagnosticSeverity(const UnownedStringSlice& inText, DownstreamDiagnostic::Severity& outSeverity, Int& outCode)
+static SlangResult _getSlangDiagnosticSeverity(const UnownedStringSlice& inText, ArtifactDiagnostic::Severity& outSeverity, Int& outCode)
 {
     UnownedStringSlice text(inText.trim());
 
@@ -79,9 +79,9 @@ static SlangResult _getSlangDiagnosticSeverity(const UnownedStringSlice& inText,
     switch (index)
     {
         case -1:    return SLANG_FAIL;
-        case 0:     outSeverity = DownstreamDiagnostic::Severity::Info; break;
-        case 1:     outSeverity = DownstreamDiagnostic::Severity::Warning; break;
-        default:    outSeverity = DownstreamDiagnostic::Severity::Error; break;
+        case 0:     outSeverity = ArtifactDiagnostic::Severity::Info; break;
+        case 1:     outSeverity = ArtifactDiagnostic::Severity::Warning; break;
+        default:    outSeverity = ArtifactDiagnostic::Severity::Error; break;
     }
 
     outCode = 0;
@@ -108,12 +108,12 @@ static bool _isSlangDiagnostic(const UnownedStringSlice& line)
     // Extract the type/code slice
     UnownedStringSlice typeSlice = StringUtil::getAtInSplit(line, ':', typeIndex);
 
-    DownstreamDiagnostic::Severity type;
+    ArtifactDiagnostic::Severity type;
     Int code;
     return SLANG_SUCCEEDED(_getSlangDiagnosticSeverity(typeSlice, type, code));
 }
 
-/* static */SlangResult ParseDiagnosticUtil::parseSlangLine(const UnownedStringSlice& line, List<UnownedStringSlice>& lineSlices, DownstreamDiagnostic& outDiagnostic)
+/* static */SlangResult ParseDiagnosticUtil::parseSlangLine(CharSliceAllocator& allocator, const UnownedStringSlice& line, List<UnownedStringSlice>& lineSlices, ArtifactDiagnostic& outDiagnostic)
 {
     /*
     tests/diagnostics/accessors.slang(11): error 31101: accessors other than 'set' must not have parameters
@@ -125,7 +125,7 @@ static bool _isSlangDiagnostic(const UnownedStringSlice& line)
         return SLANG_FAIL;
     }
 
-    SLANG_RETURN_ON_FAIL(DownstreamDiagnostic::splitPathLocation(lineSlices[0], outDiagnostic));
+    SLANG_RETURN_ON_FAIL(ArtifactDiagnosticUtil::splitPathLocation(allocator, lineSlices[0], outDiagnostic));
     Int code;
     SLANG_RETURN_ON_FAIL(_getSlangDiagnosticSeverity(lineSlices[1], outDiagnostic.severity, code));
 
@@ -133,10 +133,10 @@ static bool _isSlangDiagnostic(const UnownedStringSlice& line)
     {
         StringBuilder buf;
         buf << code;
-        outDiagnostic.code = buf.ProduceString();
+        outDiagnostic.code = allocator.allocate(buf);
     }
 
-    outDiagnostic.text = UnownedStringSlice(lineSlices[2].begin(), line.end());
+    outDiagnostic.text = allocator.allocate(lineSlices[2].begin(), line.end());
     return SLANG_OK;
 }
 
@@ -251,12 +251,11 @@ static bool _isWhitespace(const UnownedStringSlice& slice)
     return true;
 }
 
-/* static */SlangResult ParseDiagnosticUtil::parseDiagnostics(const UnownedStringSlice& inText, List<DownstreamDiagnostic>& outDiagnostics)
+/* static */SlangResult ParseDiagnosticUtil::parseDiagnostics(const UnownedStringSlice& inText, IArtifactDiagnostics* diagnostics)
 {
     if (_isWhitespace(inText))
     {
         // If it's empty, then there are no diagnostics to add.
-        outDiagnostics.clear();
         return SLANG_OK;
     }
 
@@ -274,10 +273,10 @@ static bool _isWhitespace(const UnownedStringSlice& slice)
         // For now we assume no prefix.
     }
 
-    return parseDiagnostics(inText, compilerIdentity, linePrefix, outDiagnostics);
+    return parseDiagnostics(inText, compilerIdentity, linePrefix, diagnostics);
 }
 
-/* static */SlangResult ParseDiagnosticUtil::parseDiagnostics(const UnownedStringSlice& inText, const CompilerIdentity& compilerIdentity, const UnownedStringSlice& linePrefix, List<DownstreamDiagnostic>& outDiagnostics)
+/* static */SlangResult ParseDiagnosticUtil::parseDiagnostics(const UnownedStringSlice& inText, const CompilerIdentity& compilerIdentity, const UnownedStringSlice& linePrefix, IArtifactDiagnostics* diagnostics)
 {
     auto lineParser = getLineParser(compilerIdentity);
     if (!lineParser)
@@ -287,6 +286,8 @@ static bool _isWhitespace(const UnownedStringSlice& slice)
 
     List<UnownedStringSlice> splitLine;
 
+    CharSliceAllocator allocator;
+
     UnownedStringSlice text(inText), line;
     while (StringUtil::extractLine(text, line))
     {
@@ -307,23 +308,23 @@ static bool _isWhitespace(const UnownedStringSlice& slice)
         // If we don't have a valid split then just assume it's a note
         if (!isValidSplit)
         {
-            DownstreamDiagnostics::addNote(line, outDiagnostics);
+            diagnostics->maybeAddNote(asCharSlice(line));
             continue;
         }
 
-        DownstreamDiagnostic diagnostic;
-        diagnostic.severity = DownstreamDiagnostic::Severity::Error;
-        diagnostic.stage = DownstreamDiagnostic::Stage::Compile;
-        diagnostic.fileLine = 0;
+        ArtifactDiagnostic diagnostic;
+        diagnostic.severity = ArtifactDiagnostic::Severity::Error;
+        diagnostic.stage = ArtifactDiagnostic::Stage::Compile;
+        diagnostic.location.line = 0;
         
-        if (SLANG_SUCCEEDED(lineParser(line, splitLine, diagnostic)))
+        if (SLANG_SUCCEEDED(lineParser(allocator, line, splitLine, diagnostic)))
         {
-            outDiagnostics.add(diagnostic);   
+            diagnostics->add(diagnostic);
         }
         else
         {
             // If couldn't parse, just add as a note
-             DownstreamDiagnostics::addNote(line, outDiagnostics);
+             ArtifactDiagnosticUtil::maybeAddNote(line, diagnostics);
         }
     }
 
@@ -427,7 +428,9 @@ static UnownedStringSlice _getEquals(const UnownedStringSlice& in)
 
 /* static */bool ParseDiagnosticUtil::areEqual(const UnownedStringSlice& a, const UnownedStringSlice& b, EqualityFlags flags)
 {
-    List<DownstreamDiagnostic> diagsA, diagsB;
+    auto diagsA = ArtifactDiagnostics::create();
+    auto diagsB = ArtifactDiagnostics::create();
+
     SlangResult resA = ParseDiagnosticUtil::parseDiagnostics(a, diagsA);
     SlangResult resB = ParseDiagnosticUtil::parseDiagnostics(b, diagsB);
 
@@ -448,18 +451,21 @@ static UnownedStringSlice _getEquals(const UnownedStringSlice& in)
 
     // Must have both succeeded, and have the same amount of lines
     if (SLANG_SUCCEEDED(resA) && SLANG_SUCCEEDED(resB) &&
-        diagsA.getCount() == diagsB.getCount())
+        diagsA->getCount() == diagsB->getCount())
     {
-        for (Index i = 0; i < diagsA.getCount(); ++i)
+        const auto count = diagsA->getCount();
+        for (Index i = 0; i < count; ++i)
         {
-            DownstreamDiagnostic diagA = diagsA[i];
-            DownstreamDiagnostic diagB = diagsB[i];
+            ArtifactDiagnostic diagA = *diagsA->getAt(i);
+            ArtifactDiagnostic diagB = *diagsB->getAt(i);
 
             // Check if we need to ignore line numbers
             if (flags & EqualityFlag::IgnoreLineNos)
             {
-                diagA.fileLine = 0;
-                diagB.fileLine = 0;
+                const ArtifactDiagnostic::Location loc;
+
+                diagA.location = loc;
+                diagB.location = loc;
             }
 
             if (diagA != diagB)
diff --git a/tools/slang-test/parse-diagnostic-util.h b/tools/slang-test/parse-diagnostic-util.h
index b9f81bfe8..eb631f1fa 100644
--- a/tools/slang-test/parse-diagnostic-util.h
+++ b/tools/slang-test/parse-diagnostic-util.h
@@ -8,6 +8,8 @@
 
 #include "../../source/compiler-core/slang-downstream-compiler.h"
 
+#include "../../source/compiler-core/slang-artifact-diagnostic-util.h"
+
 #include "../../slang-com-ptr.h"
 
 struct ParseDiagnosticUtil
@@ -55,23 +57,23 @@ struct ParseDiagnosticUtil
         };
     };
 
-    typedef SlangResult (*LineParser)(const Slang::UnownedStringSlice& line, Slang::List<Slang::UnownedStringSlice>& lineSlices, Slang::DownstreamDiagnostic& outDiagnostic);
+    typedef SlangResult (*LineParser)(Slang::CharSliceAllocator& allocator, const Slang::UnownedStringSlice& line, Slang::List<Slang::UnownedStringSlice>& lineSlices, Slang::ArtifactDiagnostic& outDiagnostic);
 
         /// Given a compiler identity returns a line parsing function.
     static LineParser getLineParser(const CompilerIdentity& compilerIdentity);
 
         /// For a 'generic' (as in uses DownstreamCompiler mechanism) line parsing
-    static SlangResult parseGenericLine(const Slang::UnownedStringSlice& line, Slang::List<Slang::UnownedStringSlice>& lineSlices, Slang::DownstreamDiagnostic& outDiagnostic);
+    static SlangResult parseGenericLine(Slang::CharSliceAllocator& allocator, const Slang::UnownedStringSlice& line, Slang::List<Slang::UnownedStringSlice>& lineSlices, Slang::ArtifactDiagnostic& outDiagnostic);
 
         /// For parsing diagnostics from Slang
-    static SlangResult parseSlangLine(const Slang::UnownedStringSlice& line, Slang::List<Slang::UnownedStringSlice>& lineSlices, Slang::DownstreamDiagnostic& outDiagnostic);
+    static SlangResult parseSlangLine(Slang::CharSliceAllocator& allocator, const Slang::UnownedStringSlice& line, Slang::List<Slang::UnownedStringSlice>& lineSlices, Slang::ArtifactDiagnostic& outDiagnostic);
 
         /// Parse diagnostics into output text
-    static SlangResult parseDiagnostics(const Slang::UnownedStringSlice& inText, Slang::List<Slang::DownstreamDiagnostic>& outDiagnostics);
+    static SlangResult parseDiagnostics(const Slang::UnownedStringSlice& inText, Slang::IArtifactDiagnostics* diagnostics);
 
         /// Parse diagnostics with known compiler identity.
         /// If the prefix is empty, it is assumed there is no prefix and it won't be checked.
-    static SlangResult parseDiagnostics(const Slang::UnownedStringSlice& inText, const CompilerIdentity& identity, const Slang::UnownedStringSlice& prefix, Slang::List<Slang::DownstreamDiagnostic>& outDiagnostics);
+    static SlangResult parseDiagnostics(const Slang::UnownedStringSlice& inText, const CompilerIdentity& identity, const Slang::UnownedStringSlice& prefix, Slang::IArtifactDiagnostics* diagnostics);
 
         /// Given the file output style used by tests, get components of the output into Diagnostic
     static SlangResult parseOutputInfo(const Slang::UnownedStringSlice& in, OutputInfo& out);
diff --git a/tools/slang-test/slang-test-main.cpp b/tools/slang-test/slang-test-main.cpp
index 8e6e6f3e1..af7ca1f83 100644
--- a/tools/slang-test/slang-test-main.cpp
+++ b/tools/slang-test/slang-test-main.cpp
@@ -33,6 +33,8 @@
 #include "../../source/compiler-core/slang-nvrtc-compiler.h"
 #include "../../source/compiler-core/slang-language-server-protocol.h"
 
+#include "../../source/compiler-core/slang-artifact-associated-impl.h"
+
 #define STB_IMAGE_IMPLEMENTATION
 #include "external/stb/stb_image.h"
 
@@ -1904,8 +1906,8 @@ TestResult runSimpleLineTest(TestContext* context, TestInput& input)
     }
 
     // Parse all the diagnostics so we can extract line numbers
-    List<DownstreamDiagnostic> diagnostics;
-    if (SLANG_FAILED(ParseDiagnosticUtil::parseDiagnostics(exeRes.standardError.getUnownedSlice(), diagnostics)) || diagnostics.getCount() <= 0)
+    auto diagnostics = ArtifactDiagnostics::create();
+    if (SLANG_FAILED(ParseDiagnosticUtil::parseDiagnostics(exeRes.standardError.getUnownedSlice(), diagnostics)) || diagnostics->getCount() <= 0)
     {
         // Write out the diagnostics which couldn't be parsed.
 
@@ -1917,9 +1919,9 @@ TestResult runSimpleLineTest(TestContext* context, TestInput& input)
 
     StringBuilder actualOutput;
 
-    if (diagnostics.getCount() > 0)
+    if (diagnostics->getCount() > 0)
     {
-        actualOutput << diagnostics[0].fileLine << "\n";
+        actualOutput << diagnostics->getAt(0)->location.line << "\n";
     }
     else
     {
@@ -2136,18 +2138,18 @@ String getExpectedOutput(String const& outputStem)
     return expectedOutput;
 }
 
-static String _calcSummary(const DownstreamDiagnostics& inOutput)
+static String _calcSummary(IArtifactDiagnostics* inDiagnostics)
 {
-    DownstreamDiagnostics output(inOutput);
-
+    auto diagnostics = cloneInterface(inDiagnostics);
+    
     // We only want to analyze errors for now
-    output.removeBySeverity(DownstreamDiagnostic::Severity::Info);
-    output.removeBySeverity(DownstreamDiagnostic::Severity::Warning);
+    diagnostics->removeBySeverity(ArtifactDiagnostic::Severity::Info);
+    diagnostics->removeBySeverity(ArtifactDiagnostic::Severity::Warning);
 
-    StringBuilder builder;
+    ComPtr<ISlangBlob> summary;
+    diagnostics->calcSimplifiedSummary(summary.writeRef());
 
-    output.appendSimplifiedSummary(builder);
-    return builder;
+    return StringUtil::getString(summary);
 }
 
 static TestResult runCPPCompilerCompile(TestContext* context, TestInput& input)
@@ -2236,15 +2238,15 @@ static TestResult runCPPCompilerSharedLibrary(TestContext* context, TestInput& i
 
     options.includePaths.add(".");
 
-    RefPtr<DownstreamCompileResult> compileResult;
-    if (SLANG_FAILED(compiler->compile(options, compileResult)))
+    ComPtr<IArtifact> artifact;
+    if (SLANG_FAILED(compiler->compile(options, artifact.writeRef())))
     {
         return TestResult::Fail;
     }
 
-    const auto& diagnostics = compileResult->getDiagnostics();
+    auto diagnostics = findAssociated<IArtifactDiagnostics>(artifact);
 
-    if (SLANG_FAILED(diagnostics.result))
+    if (diagnostics && SLANG_FAILED(diagnostics->getResult()))
     {
         // Compilation failed
         String actualOutput = _calcSummary(diagnostics);
@@ -2353,18 +2355,18 @@ static TestResult runCPPCompilerExecute(TestContext* context, TestInput& input)
     options.sourceFiles.add(filePath);
     options.modulePath = modulePath;
 
-    RefPtr<DownstreamCompileResult> compileResult;
-    if (SLANG_FAILED(compiler->compile(options, compileResult)))
+    ComPtr<IArtifact> artifact;
+    if (SLANG_FAILED(compiler->compile(options, artifact.writeRef())))
     {
         return TestResult::Fail;
     }
 
     String actualOutput;
 
-    const auto& diagnostics = compileResult->getDiagnostics();
+    auto diagnostics = findAssociated<IArtifactDiagnostics>(artifact);
 
     // If the actual compilation failed, then the output will be the summary
-    if (SLANG_FAILED(diagnostics.result))
+    if (diagnostics && SLANG_FAILED(diagnostics->getResult()))
     {
         actualOutput = _calcSummary(diagnostics);
     }