DownstreamCompiler abstraction (#1149)

* CPPCompiler -> DownstreamCompiler

* Added DownstreamCompileResult to start abstraction such that we don't need files.

* * Split out slang-blob.cpp
* Made CompileResult hold a DownstreamCompileResult - for access to binary or ISlangSharedLibrary

* Keep temporary files in scope.

* Add a hash to the hex dump stream.

* Move all file tracking into DownstreamCompiler.

20 files changed, 1275 insertions, 920 deletions

diff --git a/source/core/core.vcxproj b/source/core/core.vcxproj
index e0cc33569..b0f33f2a2 100644
--- a/source/core/core.vcxproj
+++ b/source/core/core.vcxproj
@@ -174,10 +174,11 @@
     <ClInclude Include="slang-array-view.h" />
     <ClInclude Include="slang-array.h" />
     <ClInclude Include="slang-basic.h" />
+    <ClInclude Include="slang-blob.h" />
     <ClInclude Include="slang-byte-encode-util.h" />
     <ClInclude Include="slang-common.h" />
-    <ClInclude Include="slang-cpp-compiler.h" />
     <ClInclude Include="slang-dictionary.h" />
+    <ClInclude Include="slang-downstream-compiler.h" />
     <ClInclude Include="slang-exception.h" />
     <ClInclude Include="slang-free-list.h" />
     <ClInclude Include="slang-gcc-compiler-util.h" />
@@ -212,8 +213,9 @@
     <ClInclude Include="windows\slang-win-visual-studio-util.h" />
   </ItemGroup>
   <ItemGroup>
+    <ClCompile Include="slang-blob.cpp" />
     <ClCompile Include="slang-byte-encode-util.cpp" />
-    <ClCompile Include="slang-cpp-compiler.cpp" />
+    <ClCompile Include="slang-downstream-compiler.cpp" />
     <ClCompile Include="slang-free-list.cpp" />
     <ClCompile Include="slang-gcc-compiler-util.cpp" />
     <ClCompile Include="slang-hex-dump-util.cpp" />
diff --git a/source/core/core.vcxproj.filters b/source/core/core.vcxproj.filters
index 6042a1c22..44d199771 100644
--- a/source/core/core.vcxproj.filters
+++ b/source/core/core.vcxproj.filters
@@ -21,16 +21,19 @@
     <ClInclude Include="slang-basic.h">
       <Filter>Header Files</Filter>
     </ClInclude>
+    <ClInclude Include="slang-blob.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
     <ClInclude Include="slang-byte-encode-util.h">
       <Filter>Header Files</Filter>
     </ClInclude>
     <ClInclude Include="slang-common.h">
       <Filter>Header Files</Filter>
     </ClInclude>
-    <ClInclude Include="slang-cpp-compiler.h">
+    <ClInclude Include="slang-dictionary.h">
       <Filter>Header Files</Filter>
     </ClInclude>
-    <ClInclude Include="slang-dictionary.h">
+    <ClInclude Include="slang-downstream-compiler.h">
       <Filter>Header Files</Filter>
     </ClInclude>
     <ClInclude Include="slang-exception.h">
@@ -131,10 +134,13 @@
     </ClInclude>
   </ItemGroup>
   <ItemGroup>
+    <ClCompile Include="slang-blob.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
     <ClCompile Include="slang-byte-encode-util.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
-    <ClCompile Include="slang-cpp-compiler.cpp">
+    <ClCompile Include="slang-downstream-compiler.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
     <ClCompile Include="slang-free-list.cpp">
diff --git a/source/core/slang-blob.cpp b/source/core/slang-blob.cpp
new file mode 100644
index 000000000..4421db09a
--- /dev/null
+++ b/source/core/slang-blob.cpp
@@ -0,0 +1,14 @@
+#include "slang-blob.h"
+
+namespace Slang {
+
+// Allocate static const storage for the various interface IDs that the Slang API needs to expose
+static const Guid IID_ISlangUnknown = SLANG_UUID_ISlangUnknown;
+static const Guid IID_ISlangBlob = SLANG_UUID_ISlangBlob;
+
+ISlangUnknown* BlobBase::getInterface(const Guid& guid)
+{
+    return (guid == IID_ISlangUnknown || guid == IID_ISlangBlob) ? static_cast<ISlangBlob*>(this) : nullptr;
+}
+
+} // namespace Slang
diff --git a/source/core/slang-blob.h b/source/core/slang-blob.h
new file mode 100644
index 000000000..aab131a36
--- /dev/null
+++ b/source/core/slang-blob.h
@@ -0,0 +1,126 @@
+#ifndef SLANG_CORE_BLOB_H
+#define SLANG_CORE_BLOB_H
+
+#include "../../slang.h"
+
+#include "slang-string.h"
+#include "slang-list.h"
+
+#include <stdarg.h>
+
+#include "../../slang-com-helper.h"
+#include "../../slang-com-ptr.h"
+
+namespace Slang {
+
+/** Base class for simple blobs.
+*/
+class BlobBase : public ISlangBlob, public RefObject
+{
+public:
+    // ISlangUnknown
+    SLANG_REF_OBJECT_IUNKNOWN_ALL
+
+protected:
+    ISlangUnknown* getInterface(const Guid& guid);
+};
+
+/** A blob that uses a `String` for its storage.
+*/
+class StringBlob : public BlobBase
+{
+public:
+        // ISlangBlob
+    SLANG_NO_THROW void const* SLANG_MCALL getBufferPointer() SLANG_OVERRIDE { return m_string.getBuffer(); }
+    SLANG_NO_THROW size_t SLANG_MCALL getBufferSize() SLANG_OVERRIDE { return m_string.getLength(); }
+
+        /// Get the contained string
+    SLANG_FORCE_INLINE const String& getString() const { return m_string; }
+
+    explicit StringBlob(String const& string)
+        : m_string(string)
+    {}
+
+protected:
+    String m_string;
+};
+
+class ListBlob : public BlobBase
+{
+public:
+    typedef BlobBase Super;
+    typedef ListBlob ThisType;
+
+    // ISlangBlob
+    SLANG_NO_THROW void const* SLANG_MCALL getBufferPointer() SLANG_OVERRIDE { return m_data.getBuffer(); }
+    SLANG_NO_THROW size_t SLANG_MCALL getBufferSize() SLANG_OVERRIDE { return m_data.getCount(); }
+
+    ListBlob() {}
+
+    ListBlob(const List<uint8_t>& data): m_data(data) {}
+        // Move ctor
+    ListBlob(List<uint8_t>&& data): m_data(data) {}
+
+    static RefPtr<ListBlob> moveCreate(List<uint8_t>& data) { return new ListBlob(_Move(data)); } 
+
+    List<uint8_t> m_data;
+
+protected:
+    void operator=(const ThisType& rhs) = delete;
+};
+
+/** A blob that manages some raw data that it owns.
+*/
+class RawBlob : public BlobBase
+{
+public:
+    // ISlangBlob
+    SLANG_NO_THROW void const* SLANG_MCALL getBufferPointer() SLANG_OVERRIDE { return m_data; }
+    SLANG_NO_THROW size_t SLANG_MCALL getBufferSize() SLANG_OVERRIDE { return m_size; }
+
+    // Ctor
+    RawBlob(const void* data, size_t size) :
+        m_size(size)
+    {
+        m_data = malloc(size);
+        memcpy(m_data, data, size);
+    }
+    ~RawBlob()
+    {
+        free(m_data);
+    }
+
+protected:
+    void* m_data;
+    size_t m_size;
+};
+
+/// Create a blob that will retain (a copy of) raw data.
+///
+inline ComPtr<ISlangBlob> createRawBlob(void const* inData, size_t size)
+{
+    return ComPtr<ISlangBlob>(new RawBlob(inData, size));
+}
+
+class ScopeRefObjectBlob : public BlobBase
+{
+public:
+    // ISlangBlob
+    SLANG_NO_THROW void const* SLANG_MCALL getBufferPointer() SLANG_OVERRIDE { return m_blob->getBufferPointer(); }
+    SLANG_NO_THROW size_t SLANG_MCALL getBufferSize() SLANG_OVERRIDE { return m_blob->getBufferSize(); }
+
+    // Ctor
+    ScopeRefObjectBlob(ISlangBlob* blob, RefObject* scope) :
+        m_blob(blob),
+        m_scope(scope)
+    {
+    }
+
+protected:
+    RefPtr<RefObject> m_scope;
+    ComPtr<ISlangBlob> m_blob;
+};
+
+} // namespace Slang
+
+#endif // SLANG_CORE_BLOB_H
diff --git a/source/core/slang-cpp-compiler.cpp b/source/core/slang-cpp-compiler.cpp
deleted file mode 100644
index 7ae474fe7..000000000
--- a/source/core/slang-cpp-compiler.cpp
+++ /dev/null
@@ -1,436 +0,0 @@
-// slang-cpp-compiler.cpp
-#include "slang-cpp-compiler.h"
-
-#include "slang-common.h"
-#include "../../slang-com-helper.h"
-#include "slang-string-util.h"
-
-#include "slang-io.h"
-#include "slang-shared-library.h"
-
-// if Visual Studio import the visual studio platform specific header
-#if SLANG_VC
-#   include "windows/slang-win-visual-studio-util.h"
-#endif
-
-#include "slang-visual-studio-compiler-util.h"
-#include "slang-gcc-compiler-util.h"
-
-namespace Slang
-{
-
-/* !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! CPPCompiler::Desc !!!!!!!!!!!!!!!!!!!!!!*/
-
-void CPPCompiler::Desc::appendAsText(StringBuilder& out) const
-{
-    out << getCompilerTypeAsText(type);
-    out << " ";
-    out << majorVersion;
-    out << ".";
-    out << minorVersion;
-}
-
-/* !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! CPPCompiler::OutputMessage !!!!!!!!!!!!!!!!!!!!!!*/
-
-/* static */UnownedStringSlice CPPCompiler::Diagnostic::getTypeText(Diagnostic::Type type)
-{
-    typedef Diagnostic::Type Type;
-    switch (type)
-    {
-        default:            return UnownedStringSlice::fromLiteral("Unknown");
-        case Type::Info:    return UnownedStringSlice::fromLiteral("Info");
-        case Type::Warning: return UnownedStringSlice::fromLiteral("Warning");
-        case Type::Error:   return UnownedStringSlice::fromLiteral("Error");
-    }
-}
-
-/* !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! CPPCompiler !!!!!!!!!!!!!!!!!!!!!!!!!!!!!*/
-
-/* static */UnownedStringSlice CPPCompiler::getCompilerTypeAsText(CompilerType type)
-{
-    switch (type)
-    {
-        default:
-        case CompilerType::Unknown:     return UnownedStringSlice::fromLiteral("Unknown");
-        case CompilerType::VisualStudio:return UnownedStringSlice::fromLiteral("Visual Studio");
-        case CompilerType::GCC:         return UnownedStringSlice::fromLiteral("GCC");
-        case CompilerType::Clang:       return UnownedStringSlice::fromLiteral("Clang");
-        case CompilerType::SNC:         return UnownedStringSlice::fromLiteral("SNC");
-        case CompilerType::GHS:         return UnownedStringSlice::fromLiteral("GHS");
-    }
-}
-
-/* !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! CPPCompiler::Output !!!!!!!!!!!!!!!!!!!!!!*/
-
-Index CPPCompiler::Output::getCountByType(Diagnostic::Type type) const
-{
-    Index count = 0;
-    for (const auto& msg : diagnostics)
-    {
-        count += Index(msg.type == type);
-    }
-    return count;
-}
-
-Int CPPCompiler::Output::countByStage(Diagnostic::Stage stage, Index counts[Int(Diagnostic::Type::CountOf)]) const
-{
-    Int count = 0;
-    ::memset(counts, 0, sizeof(Index) * Int(Diagnostic::Type::CountOf));
-    for (const auto& diagnostic : diagnostics)
-    {
-        if (diagnostic.stage == stage)
-        {
-            count++;
-            counts[Index(diagnostic.type)]++;
-        }
-    }
-    return count++;
-}
-
-static void _appendCounts(const Index counts[Int(CPPCompiler::Diagnostic::Type::CountOf)], StringBuilder& out)
-{
-    typedef CPPCompiler::Diagnostic::Type Type;
-
-    for (Index i = 0; i < Int(Type::CountOf); i++)
-    {
-        if (counts[i] > 0)
-        {
-            out << CPPCompiler::Diagnostic::getTypeText(Type(i)) << "(" << counts[i] << ") ";
-        }
-    }
-}
-
-static void _appendSimplified(const Index counts[Int(CPPCompiler::Diagnostic::Type::CountOf)], StringBuilder& out)
-{
-    typedef CPPCompiler::Diagnostic::Type Type;
-    for (Index i = 0; i < Int(Type::CountOf); i++)
-    {
-        if (counts[i] > 0)
-        {
-            out << CPPCompiler::Diagnostic::getTypeText(Type(i)) << " ";
-        }
-    }
-}
-
-void CPPCompiler::Output::appendSummary(StringBuilder& out) const
-{
-    Index counts[Int(Diagnostic::Type::CountOf)];
-    if (countByStage(Diagnostic::Stage::Compile, counts) > 0)
-    {
-        out << "Compile: ";
-        _appendCounts(counts, out);
-        out << "\n";
-    }
-    if (countByStage(Diagnostic::Stage::Link, counts) > 0)
-    {
-        out << "Link: ";
-        _appendCounts(counts, out);
-        out << "\n";
-    }
-}
-
-void CPPCompiler::Output::appendSimplifiedSummary(StringBuilder& out) const
-{
-    Index counts[Int(Diagnostic::Type::CountOf)];
-    if (countByStage(Diagnostic::Stage::Compile, counts) > 0)
-    {
-        out << "Compile: ";
-        _appendSimplified(counts, out);
-        out << "\n";
-    }
-    if (countByStage(Diagnostic::Stage::Link, counts) > 0)
-    {
-        out << "Link: ";
-        _appendSimplified(counts, out);
-        out << "\n";
-    }
-}
-
-void CPPCompiler::Output::removeByType(Diagnostic::Type type)
-{
-    Index count = diagnostics.getCount();
-    for (Index i = 0; i < count; ++i)
-    {
-        if (diagnostics[i].type == type)
-        {
-            diagnostics.removeAt(i);
-            i--;
-            count--;
-        }
-    }
-}
-
-/* !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! CommandLineCPPCompiler !!!!!!!!!!!!!!!!!!!!!!*/
-
-SlangResult CommandLineCPPCompiler::compile(const CompileOptions& options, Output& outOutput)
-{
-    outOutput.reset();
-
-    // Copy the command line options
-    CommandLine cmdLine(m_cmdLine);
-
-    // Append command line args to the end of cmdLine using the target specific function for the specified options
-    SLANG_RETURN_ON_FAIL(calcArgs(options, cmdLine));
-
-    ExecuteResult exeRes;
-
-#if 0
-    // Test
-    {
-        String line = ProcessUtil::getCommandLineString(cmdLine);
-        printf("%s", line.getBuffer());
-    }
-#endif
-
-    SLANG_RETURN_ON_FAIL(ProcessUtil::execute(cmdLine, exeRes));
-
-#if 0
-    {
-        printf("stdout=\"%s\"\nstderr=\"%s\"\nret=%d\n", exeRes.standardOutput.getBuffer(), exeRes.standardError.getBuffer(), int(exeRes.resultCode));
-    }
-#endif
-
-    return parseOutput(exeRes, outOutput);
-}
-
-/* !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! CPPCompilerUtil !!!!!!!!!!!!!!!!!!!!!!*/
-
-static CPPCompiler::Desc _calcCompiledWithDesc()
-{
-    CPPCompiler::Desc desc = {};
-
-#if SLANG_VC
-    desc = WinVisualStudioUtil::getDesc(WinVisualStudioUtil::getCompiledVersion());
-#elif SLANG_CLANG
-    desc.type = CPPCompiler::CompilerType::Clang;
-    desc.majorVersion = Int(__clang_major__);
-    desc.minorVersion = Int(__clang_minor__);
-#elif SLANG_SNC
-    desc.type = CPPCompiler::CompilerType::SNC;
-#elif SLANG_GHS
-    desc.type = CPPCompiler::CompilerType::GHS;
-#elif SLANG_GCC
-    desc.type = CPPCompiler::CompilerType::GCC;
-    desc.majorVersion = Int(__GNUC__);
-    desc.minorVersion = Int(__GNUC_MINOR__);
-#else
-    desc.type = CPPCompiler::CompilerType::Unknown;
-#endif
-
-    return desc;
-}
-
-const CPPCompiler::Desc& CPPCompilerUtil::getCompiledWithDesc()
-{
-    static CPPCompiler::Desc s_desc = _calcCompiledWithDesc();
-    return s_desc;
-}
-
-/* static */CPPCompiler* CPPCompilerUtil::findCompiler(const CPPCompilerSet* set, MatchType matchType, const CPPCompiler::Desc& desc)
-{
-    List<CPPCompiler*> compilers;
-    set->getCompilers(compilers);
-    return findCompiler(compilers, matchType, desc);
-}
-
-/* static */CPPCompiler* CPPCompilerUtil::findCompiler(const List<CPPCompiler*>& compilers, MatchType matchType, const CPPCompiler::Desc& desc)
-{
-    Int bestIndex = -1;
-
-    const CPPCompiler::CompilerType type = desc.type;
-
-    Int maxVersionValue = 0;
-    Int minVersionDiff = 0x7fffffff;
-
-    const auto descVersionValue = desc.getVersionValue();
-
-    for (Index i = 0; i < compilers.getCount(); ++i)
-    {
-        CPPCompiler* compiler = compilers[i];
-        auto compilerDesc = compiler->getDesc();
-
-        if (type == compilerDesc.type)
-        {
-            const Int versionValue = compilerDesc.getVersionValue();
-            switch (matchType)
-            {
-                case MatchType::MinGreaterEqual:
-                {
-                    auto diff = descVersionValue - versionValue;
-                    if (diff >= 0 && diff < minVersionDiff)
-                    {
-                        bestIndex = i;
-                        minVersionDiff = diff;
-                    }
-                    break;
-                }
-                case MatchType::MinAbsolute:
-                {
-                    auto diff = descVersionValue - versionValue;
-                    diff = (diff >= 0) ? diff : -diff;
-                    if (diff < minVersionDiff)
-                    {
-                        bestIndex = i;
-                        minVersionDiff = diff;
-                    }
-                    break;
-                }
-                case MatchType::Newest:
-                {
-                    if (versionValue > maxVersionValue)
-                    {
-                        maxVersionValue = versionValue;
-                        bestIndex = i;
-                    }
-                    break;
-                }
-            }
-        }
-    }
-
-    return (bestIndex >= 0) ? compilers[bestIndex] : nullptr;
-}
-
-/* static */CPPCompiler* CPPCompilerUtil::findClosestCompiler(const List<CPPCompiler*>& compilers, const CPPCompiler::Desc& desc)
-{
-    CPPCompiler* compiler;
-
-    compiler = findCompiler(compilers, MatchType::MinGreaterEqual, desc);
-    if (compiler)
-    {
-        return compiler;
-    }
-    compiler = findCompiler(compilers, MatchType::MinAbsolute, desc);
-    if (compiler)
-    {
-        return compiler;
-    }
-
-    // If we are gcc, we can try clang and vice versa
-    if (desc.type == CPPCompiler::CompilerType::GCC || desc.type == CPPCompiler::CompilerType::Clang)
-    {
-        CPPCompiler::Desc compatible = desc;
-        compatible.type = (compatible.type == CPPCompiler::CompilerType::Clang) ? CPPCompiler::CompilerType::GCC : CPPCompiler::CompilerType::Clang;
-
-        compiler = findCompiler(compilers, MatchType::MinGreaterEqual, compatible);
-        if (compiler)
-        {
-            return compiler;
-        }
-        compiler = findCompiler(compilers, MatchType::MinAbsolute, compatible);
-        if (compiler)
-        {
-            return compiler;
-        }
-    }
-
-    return nullptr;
-}
-
-static void _addGCCFamilyCompiler(const String& path, const String& inExeName, CPPCompilerSet* compilerSet)
-{
-    String exeName(inExeName);
-    if (path.getLength() > 0)
-    {
-        exeName = Path::combine(path, inExeName);
-    }
-
-    CPPCompiler::Desc desc;
-    if (SLANG_SUCCEEDED(GCCCompilerUtil::calcVersion(exeName, desc)))
-    {
-        RefPtr<CommandLineCPPCompiler> compiler(new GCCCPPCompiler(desc));
-        compiler->m_cmdLine.setExecutableFilename(exeName);
-        compilerSet->addCompiler(compiler);
-    }
-}
-
-/* static */CPPCompiler* CPPCompilerUtil::findClosestCompiler(const CPPCompilerSet* set, const CPPCompiler::Desc& desc)
-{
-    CPPCompiler* compiler = set->getCompiler(desc);
-    if (compiler)
-    {
-        return compiler;
-    }
-    List<CPPCompiler*> compilers;
-    set->getCompilers(compilers);
-    return findClosestCompiler(compilers, desc);
-}
-
-/* static */SlangResult CPPCompilerUtil::initializeSet(const InitializeSetDesc& desc, CPPCompilerSet* set)
-{
-#if SLANG_WINDOWS_FAMILY
-    WinVisualStudioUtil::find(set);
-#endif
-
-    _addGCCFamilyCompiler(desc.getPath(CompilerType::Clang), "clang", set);
-    _addGCCFamilyCompiler(desc.getPath(CompilerType::GCC), "g++", set);
-
-    // Set the default to the compiler closest to how this source was compiled
-    set->setDefaultCompiler(findClosestCompiler(set, getCompiledWithDesc()));
-    return SLANG_OK;
-}
-
-/* !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! CPPCompilerFactory !!!!!!!!!!!!!!!!!!!!!!*/
-
-
-void CPPCompilerSet::getCompilerDescs(List<CPPCompiler::Desc>& outCompilerDescs) const
-{
-    outCompilerDescs.clear();
-    for (CPPCompiler* compiler : m_compilers)
-    {
-        outCompilerDescs.add(compiler->getDesc());
-    }
-}
-
-Index CPPCompilerSet::_findIndex(const CPPCompiler::Desc& desc) const
-{
-    const Index count = m_compilers.getCount();
-    for (Index i = 0; i < count; ++i)
-    { 
-        if (m_compilers[i]->getDesc() == desc)
-        {
-            return i;
-        }
-    }
-    return -1;
-}
-
-CPPCompiler* CPPCompilerSet::getCompiler(const CPPCompiler::Desc& compilerDesc) const
-{
-    const Index index = _findIndex(compilerDesc);
-    return index >= 0 ? m_compilers[index] : nullptr;
-}
-
-void CPPCompilerSet::getCompilers(List<CPPCompiler*>& outCompilers) const
-{
-    outCompilers.clear();
-    outCompilers.addRange((CPPCompiler*const*)m_compilers.begin(), m_compilers.getCount());
-}
-
-bool CPPCompilerSet::hasCompiler(CPPCompiler::CompilerType compilerType) const
-{
-    for (CPPCompiler* compiler : m_compilers)
-    {
-        const auto& desc = compiler->getDesc();
-        if (desc.type == compilerType)
-        {
-            return true;
-        }
-    }
-    return false;
-}
-
-void CPPCompilerSet::addCompiler(CPPCompiler* compiler)
-{
-    const Index index = _findIndex(compiler->getDesc());
-    if (index >= 0)
-    {
-        m_compilers[index] = compiler;
-    }
-    else
-    {
-        m_compilers.add(compiler);
-    }
-}
-
-}
diff --git a/source/core/slang-cpp-compiler.h b/source/core/slang-cpp-compiler.h
deleted file mode 100644
index f1592d240..000000000
--- a/source/core/slang-cpp-compiler.h
+++ /dev/null
@@ -1,343 +0,0 @@
-#ifndef SLANG_CPP_COMPILER_H
-#define SLANG_CPP_COMPILER_H
-
-#include "slang-common.h"
-#include "slang-string.h"
-
-#include "slang-process-util.h"
-
-#include "slang-platform.h"
-
-namespace Slang
-{
-
-class CPPCompiler: public RefObject
-{
-public:
-    typedef RefObject Super;
-    enum class CompilerType
-    {
-        Unknown,
-        VisualStudio,
-        GCC,
-        Clang,
-        SNC,
-        GHS,
-        CountOf,
-    };
-    enum class SourceType
-    {
-        C,              ///< C source
-        CPP,            ///< C++ source
-    };
-
-    struct Desc
-    {
-        typedef Desc ThisType;
-
-        UInt GetHashCode() const { return combineHash(int(type), combineHash(int(majorVersion), int(minorVersion))); }
-        bool operator==(const ThisType& rhs) const { return type == rhs.type && majorVersion == rhs.majorVersion && minorVersion == rhs.minorVersion;  }
-        bool operator!=(const ThisType& rhs) const { return !(*this == rhs); }
-
-            /// Get the version as a value
-        Int getVersionValue() const { return majorVersion * 100 + minorVersion;  }
-
-        void appendAsText(StringBuilder& out) const;
-
-            /// Ctor
-        Desc(CompilerType inType = CompilerType::Unknown, Int inMajorVersion = 0, Int inMinorVersion = 0):type(inType), majorVersion(inMajorVersion), minorVersion(inMinorVersion) {}
-
-        CompilerType type;                      ///< The type of the compiler
-        Int majorVersion;               ///< Major version (interpretation is type specific)
-        Int minorVersion;               ///< Minor version
-    };
-
-    enum class OptimizationLevel
-    {
-        None,           ///< Don't optimize at all. 
-        Default,        ///< Default optimization level: balance code quality and compilation time. 
-        High,           ///< Optimize aggressively. 
-        Maximal,        ///< Include optimizations that may take a very long time, or may involve severe space-vs-speed tradeoffs 
-    };
-
-    enum class DebugInfoType
-    {
-        None,       ///< Don't emit debug information at all. 
-        Minimal,    ///< Emit as little debug information as possible, while still supporting stack traces. 
-        Standard,   ///< Emit whatever is the standard level of debug information for each target. 
-        Maximal,    ///< Emit as much debug information as possible for each target. 
-    };
-    enum class FloatingPointMode
-    {
-        Default, 
-        Fast,
-        Precise,
-    };
-
-    enum TargetType
-    {
-        Executable,         ///< Produce an executable
-        SharedLibrary,      ///< Produce a shared library object/dll 
-        Object,             ///< Produce an object file
-    };
-
-    struct Define
-    {
-        String nameWithSig;             ///< If macro takes parameters include in brackets
-        String value;
-    };
-
-    struct CompileOptions
-    {
-        typedef uint32_t Flags;
-        struct Flag 
-        {
-            enum Enum : Flags
-            {
-                EnableExceptionHandling = 0x01,
-                Verbose                 = 0x02,
-                EnableSecurityChecks    = 0x04,
-            };
-        };
-
-        OptimizationLevel optimizationLevel = OptimizationLevel::Default;
-        DebugInfoType debugInfoType = DebugInfoType::Standard;
-        TargetType targetType = TargetType::Executable;
-        SourceType sourceType = SourceType::CPP;
-        FloatingPointMode floatingPointMode = FloatingPointMode::Default;
-
-        Flags flags = Flag::EnableExceptionHandling;
-
-        PlatformKind platform = PlatformKind::Unknown;
-
-        String modulePath;      ///< The path/name of the output module. Should not have the extension, as that will be added for each of the target types
-
-        List<Define> defines;
-
-        List<String> sourceFiles;
-
-        List<String> includePaths;
-        List<String> libraryPaths;
-    };
-
-    struct Diagnostic
-    {
-        enum class Type
-        {
-            Unknown,
-            Info,
-            Warning,
-            Error,
-            CountOf,
-        };
-        enum class Stage
-        {
-            Compile,
-            Link,
-        };
-
-        void reset()
-        {
-            type = Type::Unknown;
-            stage = Stage::Compile;
-            fileLine = 0;
-        }
-        static UnownedStringSlice getTypeText(Diagnostic::Type type);
-
-
-        Type type;                      ///< The type of error
-        Stage stage;                    ///< The stage the error came from
-        String text;                    ///< The text of the error
-        String code;                    ///< The compiler specific error code
-        String filePath;                ///< The path the error originated from
-        Int fileLine;                   ///< The line number the error came from
-    };
-
-    typedef uint32_t ProductFlags;
-    struct ProductFlag
-    {
-        enum Enum : ProductFlags
-        {
-            Debug               = 0x1,                ///< Used by debugger during execution
-            Execution           = 0x2,                ///< Required for execution
-            Compile             = 0x4,                ///< A product *required* for compilation
-            Miscellaneous       = 0x8,                ///< Anything else    
-        };
-        enum Mask : ProductFlags
-        {
-            All                 = 0xf,                ///< All the flags
-        };
-    };
-
-    enum class Product
-    {
-        DebugRun,
-        Run,
-        CompileTemporary,
-        All,
-    };
-
-    struct Output
-    {
-            /// Reset to an initial empty state
-        void reset() { diagnostics.clear(); rawDiagnostics = String(); result = SLANG_OK; }
-        
-            /// Get the number of diagnostics by type
-        Index getCountByType(Diagnostic::Type type) const;
-            /// True if there are any diagnostics  of the type
-        bool has(Diagnostic::Type type) const { return getCountByType(type) > 0; }
-
-            /// Stores in outCounts, the amount of diagnostics for the stage of each type
-        Int countByStage(Diagnostic::Stage stage, Index outCounts[Int(Diagnostic::Type::CountOf)]) const;
-
-            /// Append a summary to out
-        void appendSummary(StringBuilder& out) const;
-            /// Appends a summary that just identifies if there is an error of a type (not a count)
-        void appendSimplifiedSummary(StringBuilder& out) const;
-        
-            /// Remove all diagnostics of the type
-        void removeByType(Diagnostic::Type type);
-
-        String rawDiagnostics;
-
-        SlangResult result;
-        List<Diagnostic> diagnostics;
-    };
-
-        /// Get the desc of this compiler
-    const Desc& getDesc() const { return m_desc;  }
-        /// Compile using the specified options. The result is in resOut
-    virtual SlangResult compile(const CompileOptions& options, Output& outOutput) = 0;
-        /// Given the compilation options and the module name, determines the actual file name used for output
-    virtual SlangResult calcModuleFilePath(const CompileOptions& options, StringBuilder& outPath) = 0;
-        /// Given options determines the paths to products produced (including the 'moduleFilePath').
-        /// Note that does *not* guarentee all products were or should be produced. Just aims to include all that could
-        /// be produced, such that can be removed on completion.
-    virtual SlangResult calcCompileProducts(const CompileOptions& options, ProductFlags flags, List<String>& outPaths) = 0;
-
-        /// Return the compiler type as name
-    static UnownedStringSlice getCompilerTypeAsText(CompilerType type);
-
-protected:
-
-    CPPCompiler(const Desc& desc) :
-        m_desc(desc)
-    {}
-
-    Desc m_desc;
-};
-
-class CommandLineCPPCompiler : public CPPCompiler
-{
-public:
-    typedef CPPCompiler Super;
-
-    // CPPCompiler
-    virtual SlangResult compile(const CompileOptions& options, Output& outOutput) SLANG_OVERRIDE;
-    
-    // Functions to be implemented for a specific CommandLine    
-    virtual SlangResult calcArgs(const CompileOptions& options, CommandLine& cmdLine) = 0;
-    virtual SlangResult parseOutput(const ExecuteResult& exeResult, Output& output) = 0;
-
-    CommandLineCPPCompiler(const Desc& desc, const String& exeName) :
-        Super(desc)
-    {
-        m_cmdLine.setExecutableFilename(exeName);
-    }
-
-    CommandLineCPPCompiler(const Desc& desc, const CommandLine& cmdLine) :
-        Super(desc),
-        m_cmdLine(cmdLine)
-    {}
-
-    CommandLineCPPCompiler(const Desc& desc):Super(desc) {}
-
-    CommandLine m_cmdLine;
-};
-
-class CPPCompilerSet : public RefObject
-{
-public:
-    typedef RefObject Super;
-
-    
-        /// Find all the available compilers
-    void getCompilerDescs(List<CPPCompiler::Desc>& outCompilerDescs) const;
-        /// Returns list of all compilers
-    void getCompilers(List<CPPCompiler*>& outCompilers) const;
-
-        /// Get a compiler
-    CPPCompiler* getCompiler(const CPPCompiler::Desc& compilerDesc) const;
-  
-        /// Will replace if there is one with same desc
-    void addCompiler(CPPCompiler* compiler);
-
-        /// Get a default compiler
-    CPPCompiler* getDefaultCompiler() const { return m_defaultCompiler;  }
-        /// Set the default compiler
-    void setDefaultCompiler(CPPCompiler* compiler) { m_defaultCompiler = compiler;  }
-
-        /// True if has a compiler of the specified type
-    bool hasCompiler(CPPCompiler::CompilerType compilerType) const;
-
-protected:
-
-    Index _findIndex(const CPPCompiler::Desc& desc) const;
-
-    RefPtr<CPPCompiler> m_defaultCompiler;
-    // This could be a dictionary/map - but doing a linear search is going to be fine and it makes
-    // somethings easier.
-    List<RefPtr<CPPCompiler>> m_compilers;
-};
-
-/* Only purpose of having base-class here is to make all the CPPCompiler types available directly in derived Utils */
-struct CPPCompilerBaseUtil
-{
-    typedef CPPCompiler::CompileOptions CompileOptions;
-    typedef CPPCompiler::OptimizationLevel OptimizationLevel;
-    typedef CPPCompiler::TargetType TargetType;
-    typedef CPPCompiler::DebugInfoType DebugInfoType;
-    typedef CPPCompiler::SourceType SourceType;
-    typedef CPPCompiler::CompilerType CompilerType;
-
-    typedef CPPCompiler::Diagnostic Diagnostic;
-    typedef CPPCompiler::FloatingPointMode FloatingPointMode;
-    typedef CPPCompiler::ProductFlag ProductFlag;
-    typedef CPPCompiler::ProductFlags ProductFlags;
-};
-
-struct CPPCompilerUtil: public CPPCompilerBaseUtil
-{
-    enum class MatchType
-    {
-        MinGreaterEqual,
-        MinAbsolute,
-        Newest,
-    };
-
-    struct InitializeSetDesc
-    {
-        const String& getPath(CompilerType type) const { return paths[int(type)]; }
-        void setPath(CompilerType type, const String& path) { paths[int(type)] = path; }
-
-        String paths[int(CPPCompiler::CompilerType::CountOf)];
-    };
-
-        /// Find a compiler
-    static CPPCompiler* findCompiler(const CPPCompilerSet* set, MatchType matchType, const CPPCompiler::Desc& desc);
-    static CPPCompiler* findCompiler(const List<CPPCompiler*>& compilers, MatchType matchType, const CPPCompiler::Desc& desc);
-
-        /// Find the compiler closest to the desc 
-    static CPPCompiler* findClosestCompiler(const List<CPPCompiler*>& compilers, const CPPCompiler::Desc& desc);
-    static CPPCompiler* findClosestCompiler(const CPPCompilerSet* set, const CPPCompiler::Desc& desc);
-
-        /// Get the information on the compiler used to compile this source
-    static const CPPCompiler::Desc& getCompiledWithDesc();
-
-        /// Given a set, registers compilers found through standard means and determines a reasonable default compiler if possible
-    static SlangResult initializeSet(const InitializeSetDesc& desc, CPPCompilerSet* set);    
-};
-
-}
-
-#endif
diff --git a/source/core/slang-downstream-compiler.cpp b/source/core/slang-downstream-compiler.cpp
new file mode 100644
index 000000000..52ec2fcd7
--- /dev/null
+++ b/source/core/slang-downstream-compiler.cpp
@@ -0,0 +1,558 @@
+// slang-downstream-compiler.cpp
+#include "slang-downstream-compiler.h"
+
+#include "slang-common.h"
+#include "../../slang-com-helper.h"
+#include "slang-string-util.h"
+
+#include "slang-io.h"
+#include "slang-shared-library.h"
+#include "slang-blob.h"
+
+// if Visual Studio import the visual studio platform specific header
+#if SLANG_VC
+#   include "windows/slang-win-visual-studio-util.h"
+#endif
+
+#include "slang-visual-studio-compiler-util.h"
+#include "slang-gcc-compiler-util.h"
+
+namespace Slang
+{
+
+/* !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! DownstreamCompiler::Desc !!!!!!!!!!!!!!!!!!!!!!*/
+
+void DownstreamCompiler::Desc::appendAsText(StringBuilder& out) const
+{
+    out << getCompilerTypeAsText(type);
+    out << " ";
+    out << majorVersion;
+    out << ".";
+    out << minorVersion;
+}
+
+/* !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! DownstreamDiagnostic !!!!!!!!!!!!!!!!!!!!!!!!*/
+
+/* static */UnownedStringSlice DownstreamDiagnostic::getTypeText(Type type)
+{
+    switch (type)
+    {
+        default:            return UnownedStringSlice::fromLiteral("Unknown");
+        case Type::Info:    return UnownedStringSlice::fromLiteral("Info");
+        case Type::Warning: return UnownedStringSlice::fromLiteral("Warning");
+        case Type::Error:   return UnownedStringSlice::fromLiteral("Error");
+    }
+}
+
+/* !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! DownstreamCompiler !!!!!!!!!!!!!!!!!!!!!!!!!!!!!*/
+
+/* static */UnownedStringSlice DownstreamCompiler::getCompilerTypeAsText(CompilerType type)
+{
+    switch (type)
+    {
+        default:
+        case CompilerType::Unknown:     return UnownedStringSlice::fromLiteral("Unknown");
+        case CompilerType::VisualStudio:return UnownedStringSlice::fromLiteral("Visual Studio");
+        case CompilerType::GCC:         return UnownedStringSlice::fromLiteral("GCC");
+        case CompilerType::Clang:       return UnownedStringSlice::fromLiteral("Clang");
+        case CompilerType::SNC:         return UnownedStringSlice::fromLiteral("SNC");
+        case CompilerType::GHS:         return UnownedStringSlice::fromLiteral("GHS");
+    }
+}
+
+/* !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! DownstreamDiagnostics !!!!!!!!!!!!!!!!!!!!!!*/
+
+Index DownstreamDiagnostics::getCountByType(Diagnostic::Type type) const
+{
+    Index count = 0;
+    for (const auto& msg : diagnostics)
+    {
+        count += Index(msg.type == type);
+    }
+    return count;
+}
+
+Int DownstreamDiagnostics::countByStage(Diagnostic::Stage stage, Index counts[Int(Diagnostic::Type::CountOf)]) const
+{
+    Int count = 0;
+    ::memset(counts, 0, sizeof(Index) * Int(Diagnostic::Type::CountOf));
+    for (const auto& diagnostic : diagnostics)
+    {
+        if (diagnostic.stage == stage)
+        {
+            count++;
+            counts[Index(diagnostic.type)]++;
+        }
+    }
+    return count++;
+}
+
+static void _appendCounts(const Index counts[Int(DownstreamDiagnostic::Type::CountOf)], StringBuilder& out)
+{
+    typedef DownstreamDiagnostic::Type Type;
+
+    for (Index i = 0; i < Int(Type::CountOf); i++)
+    {
+        if (counts[i] > 0)
+        {
+            out << DownstreamDiagnostic::getTypeText(Type(i)) << "(" << counts[i] << ") ";
+        }
+    }
+}
+
+static void _appendSimplified(const Index counts[Int(DownstreamDiagnostic::Type::CountOf)], StringBuilder& out)
+{
+    typedef DownstreamDiagnostic::Type Type;
+    for (Index i = 0; i < Int(Type::CountOf); i++)
+    {
+        if (counts[i] > 0)
+        {
+            out << DownstreamDiagnostic::getTypeText(Type(i)) << " ";
+        }
+    }
+}
+
+void DownstreamDiagnostics::appendSummary(StringBuilder& out) const
+{
+    Index counts[Int(Diagnostic::Type::CountOf)];
+    if (countByStage(Diagnostic::Stage::Compile, counts) > 0)
+    {
+        out << "Compile: ";
+        _appendCounts(counts, out);
+        out << "\n";
+    }
+    if (countByStage(Diagnostic::Stage::Link, counts) > 0)
+    {
+        out << "Link: ";
+        _appendCounts(counts, out);
+        out << "\n";
+    }
+}
+
+void DownstreamDiagnostics::appendSimplifiedSummary(StringBuilder& out) const
+{
+    Index counts[Int(Diagnostic::Type::CountOf)];
+    if (countByStage(Diagnostic::Stage::Compile, counts) > 0)
+    {
+        out << "Compile: ";
+        _appendSimplified(counts, out);
+        out << "\n";
+    }
+    if (countByStage(Diagnostic::Stage::Link, counts) > 0)
+    {
+        out << "Link: ";
+        _appendSimplified(counts, out);
+        out << "\n";
+    }
+}
+
+void DownstreamDiagnostics::removeByType(Diagnostic::Type type)
+{
+    Index count = diagnostics.getCount();
+    for (Index i = 0; i < count; ++i)
+    {
+        if (diagnostics[i].type == type)
+        {
+            diagnostics.removeAt(i);
+            i--;
+            count--;
+        }
+    }
+}
+
+/* !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! CommandLineDownstreamCompileResult !!!!!!!!!!!!!!!!!!!!!!*/
+
+SlangResult CommandLineDownstreamCompileResult::getHostCallableSharedLibrary(ComPtr<ISlangSharedLibrary>& outLibrary)
+{
+    if (m_hostCallableSharedLibrary)
+    {
+        outLibrary = m_hostCallableSharedLibrary;
+        return SLANG_OK;
+    }
+
+    // Okay we want to load
+    // Try loading the shared library
+    SharedLibrary::Handle handle;
+    if (SLANG_FAILED(SharedLibrary::loadWithPlatformPath(m_moduleFilePath.getBuffer(), handle)))
+    {
+        return SLANG_FAIL;
+    }
+    // The shared library needs to keep temp files in scope
+    RefPtr<TemporarySharedLibrary> sharedLib(new TemporarySharedLibrary(handle, m_moduleFilePath));
+    sharedLib->m_temporaryFileSet = m_temporaryFiles;
+
+    m_hostCallableSharedLibrary = sharedLib;
+    outLibrary = m_hostCallableSharedLibrary;
+    return SLANG_OK;
+}
+
+SlangResult CommandLineDownstreamCompileResult::getBinary(ComPtr<ISlangBlob>& outBlob)
+{
+    if (m_binaryBlob)
+    {
+        outBlob = m_binaryBlob;
+        return SLANG_OK;
+    }
+
+    // Read the binary
+    try
+    {
+        // Read the contents of the binary
+        List<uint8_t> contents = File::readAllBytes(m_moduleFilePath);
+
+        m_binaryBlob = new ScopeRefObjectBlob(ListBlob::moveCreate(contents), m_temporaryFiles);
+        outBlob = m_binaryBlob;
+        return SLANG_OK;
+    }
+    catch (const Slang::IOException&)
+    {
+        return SLANG_FAIL;
+    }
+}
+
+/* !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! CommandLineDownstreamCompiler !!!!!!!!!!!!!!!!!!!!!!*/
+
+SlangResult CommandLineDownstreamCompiler::compile(const CompileOptions& inOptions, RefPtr<DownstreamCompileResult>& out)
+{
+    // Copy the command line options
+    CommandLine cmdLine(m_cmdLine);
+
+    CompileOptions options(inOptions);
+
+    // Find all the files that will be produced
+    RefPtr<TemporaryFileSet> productFileSet(new TemporaryFileSet);
+    
+    if (options.modulePath.getLength() == 0 || options.sourceContents.getLength() != 0)
+    {
+        String modulePath = options.modulePath;
+
+        // If there is no module path, generate one.
+        if (modulePath.getLength() == 0)
+        {
+            SLANG_RETURN_ON_FAIL(File::generateTemporary(UnownedStringSlice::fromLiteral("slang-generated"), modulePath));
+            options.modulePath = modulePath;
+        }
+        
+        if (options.sourceContents.getLength() != 0)
+        {
+            String compileSourcePath = modulePath;
+
+            // NOTE: Strictly speaking producing filenames by modifying the generateTemporary path that may introduce a temp filename clash, but in practice is extraordinary unlikely
+            compileSourcePath.append("-src");
+
+            // Make the temporary filename have the appropriate extension.
+            if (options.sourceType == DownstreamCompiler::SourceType::C)
+            {
+                compileSourcePath.append(".c");
+            }
+            else
+            {
+                compileSourcePath.append(".cpp");
+            }
+
+            // Write it out
+            try
+            {
+                productFileSet->add(compileSourcePath);
+
+                File::writeAllText(compileSourcePath, options.sourceContents);
+            }
+            catch (...)
+            {
+                return SLANG_FAIL;
+            }
+
+            // Add it as a source file
+            options.sourceFiles.add(compileSourcePath);
+
+            // There is no source contents
+            options.sourceContents = String();
+        }
+    }
+
+    // Append command line args to the end of cmdLine using the target specific function for the specified options
+    SLANG_RETURN_ON_FAIL(calcArgs(options, cmdLine));
+
+    String moduleFilePath;
+
+    {
+        StringBuilder builder;
+        SLANG_RETURN_ON_FAIL(calcModuleFilePath(options, builder));
+        moduleFilePath = builder.ProduceString();
+    }
+
+    {
+        List<String> paths;
+        SLANG_RETURN_ON_FAIL(calcCompileProducts(options, DownstreamCompiler::ProductFlag::All, paths));
+        productFileSet->add(paths);
+    }
+
+    ExecuteResult exeRes;
+
+#if 0
+    // Test
+    {
+        String line = ProcessUtil::getCommandLineString(cmdLine);
+        printf("%s", line.getBuffer());
+    }
+#endif
+
+    SLANG_RETURN_ON_FAIL(ProcessUtil::execute(cmdLine, exeRes));
+
+#if 0
+    {
+        printf("stdout=\"%s\"\nstderr=\"%s\"\nret=%d\n", exeRes.standardOutput.getBuffer(), exeRes.standardError.getBuffer(), int(exeRes.resultCode));
+    }
+#endif
+
+    DownstreamDiagnostics diagnostics;
+    SLANG_RETURN_ON_FAIL(parseOutput(exeRes, diagnostics));
+
+    
+    out = new CommandLineDownstreamCompileResult(diagnostics, moduleFilePath, productFileSet);
+    
+    return SLANG_OK;
+}
+
+/* !!!!!!!!!!!!!!!!!!!!!!!!! DownstreamCompiler::Desc !!!!!!!!!!!!!!!!!!!!!!*/
+
+static DownstreamCompiler::Desc _calcCompiledWithDesc()
+{
+    DownstreamCompiler::Desc desc = {};
+
+#if SLANG_VC
+    desc = WinVisualStudioUtil::getDesc(WinVisualStudioUtil::getCompiledVersion());
+#elif SLANG_CLANG
+    desc.type = DownstreamCompiler::CompilerType::Clang;
+    desc.majorVersion = Int(__clang_major__);
+    desc.minorVersion = Int(__clang_minor__);
+#elif SLANG_SNC
+    desc.type = DownstreamCompiler::CompilerType::SNC;
+#elif SLANG_GHS
+    desc.type = DownstreamCompiler::CompilerType::GHS;
+#elif SLANG_GCC
+    desc.type = DownstreamCompiler::CompilerType::GCC;
+    desc.majorVersion = Int(__GNUC__);
+    desc.minorVersion = Int(__GNUC_MINOR__);
+#else
+    desc.type = DownstreamCompiler::CompilerType::Unknown;
+#endif
+
+    return desc;
+}
+
+/* !!!!!!!!!!!!!!!!!!!!!!!!! DownstreamCompilerUtil !!!!!!!!!!!!!!!!!!!!!!*/
+
+const DownstreamCompiler::Desc& DownstreamCompilerUtil::getCompiledWithDesc()
+{
+    static DownstreamCompiler::Desc s_desc = _calcCompiledWithDesc();
+    return s_desc;
+}
+
+/* static */DownstreamCompiler* DownstreamCompilerUtil::findCompiler(const DownstreamCompilerSet* set, MatchType matchType, const DownstreamCompiler::Desc& desc)
+{
+    List<DownstreamCompiler*> compilers;
+    set->getCompilers(compilers);
+    return findCompiler(compilers, matchType, desc);
+}
+
+/* static */DownstreamCompiler* DownstreamCompilerUtil::findCompiler(const List<DownstreamCompiler*>& compilers, MatchType matchType, const DownstreamCompiler::Desc& desc)
+{
+    Int bestIndex = -1;
+
+    const DownstreamCompiler::CompilerType type = desc.type;
+
+    Int maxVersionValue = 0;
+    Int minVersionDiff = 0x7fffffff;
+
+    const auto descVersionValue = desc.getVersionValue();
+
+    for (Index i = 0; i < compilers.getCount(); ++i)
+    {
+        DownstreamCompiler* compiler = compilers[i];
+        auto compilerDesc = compiler->getDesc();
+
+        if (type == compilerDesc.type)
+        {
+            const Int versionValue = compilerDesc.getVersionValue();
+            switch (matchType)
+            {
+                case MatchType::MinGreaterEqual:
+                {
+                    auto diff = descVersionValue - versionValue;
+                    if (diff >= 0 && diff < minVersionDiff)
+                    {
+                        bestIndex = i;
+                        minVersionDiff = diff;
+                    }
+                    break;
+                }
+                case MatchType::MinAbsolute:
+                {
+                    auto diff = descVersionValue - versionValue;
+                    diff = (diff >= 0) ? diff : -diff;
+                    if (diff < minVersionDiff)
+                    {
+                        bestIndex = i;
+                        minVersionDiff = diff;
+                    }
+                    break;
+                }
+                case MatchType::Newest:
+                {
+                    if (versionValue > maxVersionValue)
+                    {
+                        maxVersionValue = versionValue;
+                        bestIndex = i;
+                    }
+                    break;
+                }
+            }
+        }
+    }
+
+    return (bestIndex >= 0) ? compilers[bestIndex] : nullptr;
+}
+
+/* static */DownstreamCompiler* DownstreamCompilerUtil::findClosestCompiler(const List<DownstreamCompiler*>& compilers, const DownstreamCompiler::Desc& desc)
+{
+    DownstreamCompiler* compiler;
+
+    compiler = findCompiler(compilers, MatchType::MinGreaterEqual, desc);
+    if (compiler)
+    {
+        return compiler;
+    }
+    compiler = findCompiler(compilers, MatchType::MinAbsolute, desc);
+    if (compiler)
+    {
+        return compiler;
+    }
+
+    // If we are gcc, we can try clang and vice versa
+    if (desc.type == DownstreamCompiler::CompilerType::GCC || desc.type == DownstreamCompiler::CompilerType::Clang)
+    {
+        DownstreamCompiler::Desc compatible = desc;
+        compatible.type = (compatible.type == DownstreamCompiler::CompilerType::Clang) ? DownstreamCompiler::CompilerType::GCC : DownstreamCompiler::CompilerType::Clang;
+
+        compiler = findCompiler(compilers, MatchType::MinGreaterEqual, compatible);
+        if (compiler)
+        {
+            return compiler;
+        }
+        compiler = findCompiler(compilers, MatchType::MinAbsolute, compatible);
+        if (compiler)
+        {
+            return compiler;
+        }
+    }
+
+    return nullptr;
+}
+
+static void _addGCCFamilyCompiler(const String& path, const String& inExeName, DownstreamCompilerSet* compilerSet)
+{
+    String exeName(inExeName);
+    if (path.getLength() > 0)
+    {
+        exeName = Path::combine(path, inExeName);
+    }
+
+    DownstreamCompiler::Desc desc;
+    if (SLANG_SUCCEEDED(GCCDownstreamCompilerUtil::calcVersion(exeName, desc)))
+    {
+        RefPtr<CommandLineDownstreamCompiler> compiler(new GCCDownstreamCompiler(desc));
+        compiler->m_cmdLine.setExecutableFilename(exeName);
+        compilerSet->addCompiler(compiler);
+    }
+}
+
+/* static */DownstreamCompiler* DownstreamCompilerUtil::findClosestCompiler(const DownstreamCompilerSet* set, const DownstreamCompiler::Desc& desc)
+{
+    DownstreamCompiler* compiler = set->getCompiler(desc);
+    if (compiler)
+    {
+        return compiler;
+    }
+    List<DownstreamCompiler*> compilers;
+    set->getCompilers(compilers);
+    return findClosestCompiler(compilers, desc);
+}
+
+/* static */SlangResult DownstreamCompilerUtil::initializeSet(const InitializeSetDesc& desc, DownstreamCompilerSet* set)
+{
+#if SLANG_WINDOWS_FAMILY
+    WinVisualStudioUtil::find(set);
+#endif
+
+    _addGCCFamilyCompiler(desc.getPath(CompilerType::Clang), "clang", set);
+    _addGCCFamilyCompiler(desc.getPath(CompilerType::GCC), "g++", set);
+
+    // Set the default to the compiler closest to how this source was compiled
+    set->setDefaultCompiler(findClosestCompiler(set, getCompiledWithDesc()));
+    return SLANG_OK;
+}
+
+/* !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! DownstreamCompilerSet !!!!!!!!!!!!!!!!!!!!!!*/
+
+void DownstreamCompilerSet::getCompilerDescs(List<DownstreamCompiler::Desc>& outCompilerDescs) const
+{
+    outCompilerDescs.clear();
+    for (DownstreamCompiler* compiler : m_compilers)
+    {
+        outCompilerDescs.add(compiler->getDesc());
+    }
+}
+
+Index DownstreamCompilerSet::_findIndex(const DownstreamCompiler::Desc& desc) const
+{
+    const Index count = m_compilers.getCount();
+    for (Index i = 0; i < count; ++i)
+    { 
+        if (m_compilers[i]->getDesc() == desc)
+        {
+            return i;
+        }
+    }
+    return -1;
+}
+
+DownstreamCompiler* DownstreamCompilerSet::getCompiler(const DownstreamCompiler::Desc& compilerDesc) const
+{
+    const Index index = _findIndex(compilerDesc);
+    return index >= 0 ? m_compilers[index] : nullptr;
+}
+
+void DownstreamCompilerSet::getCompilers(List<DownstreamCompiler*>& outCompilers) const
+{
+    outCompilers.clear();
+    outCompilers.addRange((DownstreamCompiler*const*)m_compilers.begin(), m_compilers.getCount());
+}
+
+bool DownstreamCompilerSet::hasCompiler(DownstreamCompiler::CompilerType compilerType) const
+{
+    for (DownstreamCompiler* compiler : m_compilers)
+    {
+        const auto& desc = compiler->getDesc();
+        if (desc.type == compilerType)
+        {
+            return true;
+        }
+    }
+    return false;
+}
+
+void DownstreamCompilerSet::addCompiler(DownstreamCompiler* compiler)
+{
+    const Index index = _findIndex(compiler->getDesc());
+    if (index >= 0)
+    {
+        m_compilers[index] = compiler;
+    }
+    else
+    {
+        m_compilers.add(compiler);
+    }
+}
+
+}
diff --git a/source/core/slang-downstream-compiler.h b/source/core/slang-downstream-compiler.h
new file mode 100644
index 000000000..12cf54a91
--- /dev/null
+++ b/source/core/slang-downstream-compiler.h
@@ -0,0 +1,403 @@
+#ifndef SLANG_DOWNSTREAM_COMPILER_H
+#define SLANG_DOWNSTREAM_COMPILER_H
+
+#include "slang-common.h"
+#include "slang-string.h"
+
+#include "slang-process-util.h"
+
+#include "slang-platform.h"
+
+#include "slang-io.h"
+
+#include "../../slang-com-ptr.h"
+
+namespace Slang
+{
+
+struct DownstreamDiagnostic
+{
+    enum class Type
+    {
+        Unknown,
+        Info,
+        Warning,
+        Error,
+        CountOf,
+    };
+    enum class Stage
+    {
+        Compile,
+        Link,
+    };
+
+    void reset()
+    {
+        type = Type::Unknown;
+        stage = Stage::Compile;
+        fileLine = 0;
+    }
+    static UnownedStringSlice getTypeText(Type type);
+
+    Type type;                      ///< The type of error
+    Stage stage;                    ///< The stage the error came from
+    String text;                    ///< The text of the error
+    String code;                    ///< The compiler specific error code
+    String filePath;                ///< The path the error originated from
+    Int fileLine;                   ///< The line number the error came from
+};
+
+struct DownstreamDiagnostics
+{
+    typedef DownstreamDiagnostic Diagnostic;
+
+    /// Reset to an initial empty state
+    void reset() { diagnostics.clear(); rawDiagnostics = String(); result = SLANG_OK; }
+
+    /// Get the number of diagnostics by type
+    Index getCountByType(Diagnostic::Type type) const;
+    /// True if there are any diagnostics  of the type
+    bool has(Diagnostic::Type type) const { return getCountByType(type) > 0; }
+
+    /// Stores in outCounts, the amount of diagnostics for the stage of each type
+    Int countByStage(Diagnostic::Stage stage, Index outCounts[Int(Diagnostic::Type::CountOf)]) const;
+
+    /// Append a summary to out
+    void appendSummary(StringBuilder& out) const;
+    /// Appends a summary that just identifies if there is an error of a type (not a count)
+    void appendSimplifiedSummary(StringBuilder& out) const;
+
+    /// Remove all diagnostics of the type
+    void removeByType(Diagnostic::Type type);
+
+    String rawDiagnostics;
+
+    SlangResult result;
+    List<Diagnostic> diagnostics;
+};
+
+class DownstreamCompileResult : public RefObject
+{
+public:
+
+    virtual SlangResult getHostCallableSharedLibrary(ComPtr<ISlangSharedLibrary>& outLibrary) = 0;
+    virtual SlangResult getBinary(ComPtr<ISlangBlob>& outBlob) = 0;
+
+    const DownstreamDiagnostics& getDiagnostics() const { return m_diagnostics; }
+    
+        /// Ctor
+    DownstreamCompileResult(const DownstreamDiagnostics& diagnostics):
+        m_diagnostics(diagnostics)
+    {}
+
+protected:
+    DownstreamDiagnostics m_diagnostics;
+};
+
+class DownstreamCompiler: public RefObject
+{
+public:
+    typedef RefObject Super;
+
+    typedef DownstreamCompileResult CompileResult;
+
+    enum class CompilerType
+    {
+        Unknown,
+        VisualStudio,
+        GCC,
+        Clang,
+        SNC,
+        GHS,
+        CountOf,
+    };
+    enum class SourceType
+    {
+        C,              ///< C source
+        CPP,            ///< C++ source
+    };
+
+    struct Desc
+    {
+        typedef Desc ThisType;
+
+        UInt GetHashCode() const { return combineHash(int(type), combineHash(int(majorVersion), int(minorVersion))); }
+        bool operator==(const ThisType& rhs) const { return type == rhs.type && majorVersion == rhs.majorVersion && minorVersion == rhs.minorVersion;  }
+        bool operator!=(const ThisType& rhs) const { return !(*this == rhs); }
+
+            /// Get the version as a value
+        Int getVersionValue() const { return majorVersion * 100 + minorVersion;  }
+
+        void appendAsText(StringBuilder& out) const;
+
+            /// Ctor
+        Desc(CompilerType inType = CompilerType::Unknown, Int inMajorVersion = 0, Int inMinorVersion = 0):type(inType), majorVersion(inMajorVersion), minorVersion(inMinorVersion) {}
+
+        CompilerType type;                      ///< The type of the compiler
+        Int majorVersion;               ///< Major version (interpretation is type specific)
+        Int minorVersion;               ///< Minor version
+    };
+
+    enum class OptimizationLevel
+    {
+        None,           ///< Don't optimize at all. 
+        Default,        ///< Default optimization level: balance code quality and compilation time. 
+        High,           ///< Optimize aggressively. 
+        Maximal,        ///< Include optimizations that may take a very long time, or may involve severe space-vs-speed tradeoffs 
+    };
+
+    enum class DebugInfoType
+    {
+        None,       ///< Don't emit debug information at all. 
+        Minimal,    ///< Emit as little debug information as possible, while still supporting stack traces. 
+        Standard,   ///< Emit whatever is the standard level of debug information for each target. 
+        Maximal,    ///< Emit as much debug information as possible for each target. 
+    };
+    enum class FloatingPointMode
+    {
+        Default, 
+        Fast,
+        Precise,
+    };
+
+    enum TargetType
+    {
+        Executable,         ///< Produce an executable
+        SharedLibrary,      ///< Produce a shared library object/dll 
+        Object,             ///< Produce an object file
+    };
+
+    struct Define
+    {
+        String nameWithSig;             ///< If macro takes parameters include in brackets
+        String value;
+    };
+
+    struct CompileOptions
+    {
+        typedef uint32_t Flags;
+        struct Flag 
+        {
+            enum Enum : Flags
+            {
+                EnableExceptionHandling = 0x01,
+                Verbose                 = 0x02,
+                EnableSecurityChecks    = 0x04,
+            };
+        };
+
+        OptimizationLevel optimizationLevel = OptimizationLevel::Default;
+        DebugInfoType debugInfoType = DebugInfoType::Standard;
+        TargetType targetType = TargetType::Executable;
+        SourceType sourceType = SourceType::CPP;
+        FloatingPointMode floatingPointMode = FloatingPointMode::Default;
+
+        Flags flags = Flag::EnableExceptionHandling;
+
+        PlatformKind platform = PlatformKind::Unknown;
+
+            /// The path/name of the output module. Should not have the extension, as that will be added for each of the target types.
+            /// If not set a module path will be internally generated internally on a command line based compiler
+        String modulePath;                  
+
+        List<Define> defines;
+
+            /// The contents of the source to compile. This can be empty is sourceFiles is set.
+            /// If the compiler is a commandLine file this source will be written to a temporary file.
+        String sourceContents;
+            /// The names/paths of source to compile. This can be empty if sourceContents is set.
+        List<String> sourceFiles;           
+
+        List<String> includePaths;
+        List<String> libraryPaths;
+    };
+
+    typedef uint32_t ProductFlags;
+    struct ProductFlag
+    {
+        enum Enum : ProductFlags
+        {
+            Debug               = 0x1,                ///< Used by debugger during execution
+            Execution           = 0x2,                ///< Required for execution
+            Compile             = 0x4,                ///< A product *required* for compilation
+            Miscellaneous       = 0x8,                ///< Anything else    
+        };
+        enum Mask : ProductFlags
+        {
+            All                 = 0xf,                ///< All the flags
+        };
+    };
+
+    enum class Product
+    {
+        DebugRun,
+        Run,
+        CompileTemporary,
+        All,
+    };
+
+        /// Get the desc of this compiler
+    const Desc& getDesc() const { return m_desc;  }
+        /// Compile using the specified options. The result is in resOut
+    virtual SlangResult compile(const CompileOptions& options, RefPtr<DownstreamCompileResult>& outResult) = 0;
+ 
+        /// Return the compiler type as name
+    static UnownedStringSlice getCompilerTypeAsText(CompilerType type);
+
+protected:
+
+    DownstreamCompiler(const Desc& desc) :
+        m_desc(desc)
+    {}
+
+    Desc m_desc;
+};
+
+class CommandLineDownstreamCompileResult : public DownstreamCompileResult
+{
+public:
+    typedef DownstreamCompileResult Super;
+
+    virtual SlangResult getHostCallableSharedLibrary(ComPtr<ISlangSharedLibrary>& outLibrary) SLANG_OVERRIDE;
+    virtual SlangResult getBinary(ComPtr<ISlangBlob>& outBlob) SLANG_OVERRIDE;
+
+    CommandLineDownstreamCompileResult(const DownstreamDiagnostics& diagnostics, const String& moduleFilePath, TemporaryFileSet* temporaryFileSet) :
+        Super(diagnostics),
+        m_moduleFilePath(moduleFilePath),
+        m_temporaryFiles(temporaryFileSet)
+    {
+    }
+    
+    RefPtr<TemporaryFileSet> m_temporaryFiles;
+
+protected:
+
+    String m_moduleFilePath;
+    DownstreamCompiler::CompileOptions m_options;
+    ComPtr<ISlangBlob> m_binaryBlob;
+    /// Cache of the shared library if appropriate
+    ComPtr<ISlangSharedLibrary> m_hostCallableSharedLibrary;
+};
+
+class CommandLineDownstreamCompiler : public DownstreamCompiler
+{
+public:
+    typedef DownstreamCompiler Super;
+
+    // DownstreamCompiler
+    virtual SlangResult compile(const CompileOptions& options, RefPtr<DownstreamCompileResult>& outResult) SLANG_OVERRIDE;
+    
+    // Functions to be implemented for a specific CommandLine
+
+        /// Given the compilation options and the module name, determines the actual file name used for output
+    virtual SlangResult calcModuleFilePath(const CompileOptions& options, StringBuilder& outPath) = 0;
+        /// Given options determines the paths to products produced (including the 'moduleFilePath').
+        /// Note that does *not* guarentee all products were or should be produced. Just aims to include all that could
+        /// be produced, such that can be removed on completion.
+    virtual SlangResult calcCompileProducts(const CompileOptions& options, ProductFlags flags, List<String>& outPaths) = 0;
+
+    virtual SlangResult calcArgs(const CompileOptions& options, CommandLine& cmdLine) = 0;
+    virtual SlangResult parseOutput(const ExecuteResult& exeResult, DownstreamDiagnostics& output) = 0;
+
+    CommandLineDownstreamCompiler(const Desc& desc, const String& exeName) :
+        Super(desc)
+    {
+        m_cmdLine.setExecutableFilename(exeName);
+    }
+
+    CommandLineDownstreamCompiler(const Desc& desc, const CommandLine& cmdLine) :
+        Super(desc),
+        m_cmdLine(cmdLine)
+    {}
+
+    CommandLineDownstreamCompiler(const Desc& desc):Super(desc) {}
+
+    CommandLine m_cmdLine;
+};
+
+class DownstreamCompilerSet : public RefObject
+{
+public:
+    typedef RefObject Super;
+
+        /// Find all the available compilers
+    void getCompilerDescs(List<DownstreamCompiler::Desc>& outCompilerDescs) const;
+        /// Returns list of all compilers
+    void getCompilers(List<DownstreamCompiler*>& outCompilers) const;
+
+        /// Get a compiler
+    DownstreamCompiler* getCompiler(const DownstreamCompiler::Desc& compilerDesc) const;
+  
+        /// Will replace if there is one with same desc
+    void addCompiler(DownstreamCompiler* compiler);
+
+        /// Get a default compiler
+    DownstreamCompiler* getDefaultCompiler() const { return m_defaultCompiler;  }
+        /// Set the default compiler
+    void setDefaultCompiler(DownstreamCompiler* compiler) { m_defaultCompiler = compiler;  }
+
+        /// True if has a compiler of the specified type
+    bool hasCompiler(DownstreamCompiler::CompilerType compilerType) const;
+
+protected:
+
+    Index _findIndex(const DownstreamCompiler::Desc& desc) const;
+
+    RefPtr<DownstreamCompiler> m_defaultCompiler;
+    // This could be a dictionary/map - but doing a linear search is going to be fine and it makes
+    // somethings easier.
+    List<RefPtr<DownstreamCompiler>> m_compilers;
+};
+
+/* Only purpose of having base-class here is to make all the DownstreamCompiler types available directly in derived Utils */
+struct DownstreamCompilerBaseUtil
+{
+    typedef DownstreamCompiler::CompileOptions CompileOptions;
+    typedef DownstreamCompiler::OptimizationLevel OptimizationLevel;
+    typedef DownstreamCompiler::TargetType TargetType;
+    typedef DownstreamCompiler::DebugInfoType DebugInfoType;
+    typedef DownstreamCompiler::SourceType SourceType;
+    typedef DownstreamCompiler::CompilerType CompilerType;
+
+    typedef DownstreamDiagnostics::Diagnostic Diagnostic;
+
+    typedef DownstreamCompiler::FloatingPointMode FloatingPointMode;
+    typedef DownstreamCompiler::ProductFlag ProductFlag;
+    typedef DownstreamCompiler::ProductFlags ProductFlags;
+};
+
+struct DownstreamCompilerUtil: public DownstreamCompilerBaseUtil
+{
+    enum class MatchType
+    {
+        MinGreaterEqual,
+        MinAbsolute,
+        Newest,
+    };
+
+    struct InitializeSetDesc
+    {
+        const String& getPath(CompilerType type) const { return paths[int(type)]; }
+        void setPath(CompilerType type, const String& path) { paths[int(type)] = path; }
+
+        String paths[int(DownstreamCompiler::CompilerType::CountOf)];
+    };
+
+        /// Find a compiler
+    static DownstreamCompiler* findCompiler(const DownstreamCompilerSet* set, MatchType matchType, const DownstreamCompiler::Desc& desc);
+    static DownstreamCompiler* findCompiler(const List<DownstreamCompiler*>& compilers, MatchType matchType, const DownstreamCompiler::Desc& desc);
+
+        /// Find the compiler closest to the desc 
+    static DownstreamCompiler* findClosestCompiler(const List<DownstreamCompiler*>& compilers, const DownstreamCompiler::Desc& desc);
+    static DownstreamCompiler* findClosestCompiler(const DownstreamCompilerSet* set, const DownstreamCompiler::Desc& desc);
+
+        /// Get the information on the compiler used to compile this source
+    static const DownstreamCompiler::Desc& getCompiledWithDesc();
+
+        /// Given a set, registers compilers found through standard means and determines a reasonable default compiler if possible
+    static SlangResult initializeSet(const InitializeSetDesc& desc, DownstreamCompilerSet* set);    
+};
+
+}
+
+#endif
diff --git a/source/core/slang-gcc-compiler-util.cpp b/source/core/slang-gcc-compiler-util.cpp
index 7838ca25b..ba077e0c5 100644
--- a/source/core/slang-gcc-compiler-util.cpp
+++ b/source/core/slang-gcc-compiler-util.cpp
@@ -11,7 +11,7 @@
 namespace Slang
 {
 
-/* static */SlangResult GCCCompilerUtil::parseVersion(const UnownedStringSlice& text, const UnownedStringSlice& prefix, CPPCompiler::Desc& outDesc)
+/* static */SlangResult GCCDownstreamCompilerUtil::parseVersion(const UnownedStringSlice& text, const UnownedStringSlice& prefix, DownstreamCompiler::Desc& outDesc)
 {
     List<UnownedStringSlice> lines;
     StringUtil::calcLines(text, lines);
@@ -55,7 +55,7 @@ namespace Slang
     return SLANG_FAIL;
 }
 
-SlangResult GCCCompilerUtil::calcVersion(const String& exeName, CPPCompiler::Desc& outDesc)
+SlangResult GCCDownstreamCompilerUtil::calcVersion(const String& exeName, DownstreamCompiler::Desc& outDesc)
 {
     CommandLine cmdLine;
     cmdLine.setExecutableFilename(exeName);
@@ -70,11 +70,11 @@ SlangResult GCCCompilerUtil::calcVersion(const String& exeName, CPPCompiler::Des
         UnownedStringSlice::fromLiteral("gcc version"),
         UnownedStringSlice::fromLiteral("Apple LLVM version"),
     };
-    const CPPCompiler::CompilerType types[] =
+    const DownstreamCompiler::CompilerType types[] =
     {
-        CPPCompiler::CompilerType::Clang,
-        CPPCompiler::CompilerType::GCC,
-        CPPCompiler::CompilerType::Clang,
+        DownstreamCompiler::CompilerType::Clang,
+        DownstreamCompiler::CompilerType::GCC,
+        DownstreamCompiler::CompilerType::Clang,
     };
 
     SLANG_COMPILE_TIME_ASSERT(SLANG_COUNT_OF(prefixes) == SLANG_COUNT_OF(types));
@@ -92,9 +92,9 @@ SlangResult GCCCompilerUtil::calcVersion(const String& exeName, CPPCompiler::Des
     return SLANG_FAIL;
 }
 
-static SlangResult _parseErrorType(const UnownedStringSlice& in, CPPCompiler::Diagnostic::Type& outType)
+static SlangResult _parseErrorType(const UnownedStringSlice& in, DownstreamDiagnostic::Type& outType)
 {
-    typedef CPPCompiler::Diagnostic::Type Type;
+    typedef DownstreamDiagnostic::Type Type;
 
     if (in == "error" || in == "fatal error")
     {
@@ -127,9 +127,9 @@ enum class LineParseResult
     
 } // anonymous
     
-static SlangResult _parseGCCFamilyLine(const UnownedStringSlice& line, LineParseResult& outLineParseResult, CPPCompiler::Diagnostic& outDiagnostic)
+static SlangResult _parseGCCFamilyLine(const UnownedStringSlice& line, LineParseResult& outLineParseResult, DownstreamDiagnostic& outDiagnostic)
 {
-    typedef CPPCompiler::Diagnostic Diagnostic;
+    typedef DownstreamDiagnostic Diagnostic;
     typedef Diagnostic::Type Type;
     
     // Set to default case
@@ -231,7 +231,7 @@ static SlangResult _parseGCCFamilyLine(const UnownedStringSlice& line, LineParse
         }
         else if (text.startsWith("ld returned"))
         {
-            outDiagnostic.stage = CPPCompiler::Diagnostic::Stage::Link;
+            outDiagnostic.stage = DownstreamDiagnostic::Stage::Link;
             SLANG_RETURN_ON_FAIL(_parseErrorType(split[1].trim(), outDiagnostic.type));
             outDiagnostic.text = line;
             outLineParseResult = LineParseResult::Single;
@@ -285,7 +285,7 @@ static SlangResult _parseGCCFamilyLine(const UnownedStringSlice& line, LineParse
     return SLANG_OK;
 }
 
-/* static */SlangResult GCCCompilerUtil::parseOutput(const ExecuteResult& exeRes, CPPCompiler::Output& outOutput)
+/* static */SlangResult GCCDownstreamCompilerUtil::parseOutput(const ExecuteResult& exeRes, DownstreamDiagnostics& outOutput)
 {
     LineParseResult prevLineResult = LineParseResult::Ignore;
     
@@ -294,7 +294,7 @@ static SlangResult _parseGCCFamilyLine(const UnownedStringSlice& line, LineParse
 
     for (auto line : LineParser(exeRes.standardError.getUnownedSlice()))
     {
-        CPPCompiler::Diagnostic diagnostic;
+        Diagnostic diagnostic;
         diagnostic.reset();
 
         LineParseResult lineRes;
@@ -341,7 +341,7 @@ static SlangResult _parseGCCFamilyLine(const UnownedStringSlice& line, LineParse
         }
     }
 
-    if (outOutput.has(CPPCompiler::Diagnostic::Type::Error) || exeRes.resultCode != 0)
+    if (outOutput.has(Diagnostic::Type::Error) || exeRes.resultCode != 0)
     {
         outOutput.result = SLANG_FAIL;
     }
@@ -349,8 +349,10 @@ static SlangResult _parseGCCFamilyLine(const UnownedStringSlice& line, LineParse
     return SLANG_OK;
 }
 
-/* static */ SlangResult GCCCompilerUtil::calcModuleFilePath(const CompileOptions& options, StringBuilder& outPath)
+/* static */ SlangResult GCCDownstreamCompilerUtil::calcModuleFilePath(const CompileOptions& options, StringBuilder& outPath)
 {
+    SLANG_ASSERT(options.modulePath.getLength());
+
     outPath.Clear();
 
     switch (options.targetType)
@@ -381,8 +383,10 @@ static SlangResult _parseGCCFamilyLine(const UnownedStringSlice& line, LineParse
     return SLANG_FAIL;
 }
 
-/* static */SlangResult GCCCompilerUtil::calcCompileProducts(const CompileOptions& options, ProductFlags flags, List<String>& outPaths)
+/* static */SlangResult GCCDownstreamCompilerUtil::calcCompileProducts(const CompileOptions& options, ProductFlags flags, List<String>& outPaths)
 {
+    SLANG_ASSERT(options.modulePath.getLength());
+
     outPaths.clear();
 
     if (flags & ProductFlag::Execution)
@@ -395,8 +399,11 @@ static SlangResult _parseGCCFamilyLine(const UnownedStringSlice& line, LineParse
     return SLANG_OK;
 }
 
-/* static */SlangResult GCCCompilerUtil::calcArgs(const CompileOptions& options, CommandLine& cmdLine)
+/* static */SlangResult GCCDownstreamCompilerUtil::calcArgs(const CompileOptions& options, CommandLine& cmdLine)
 {
+    SLANG_ASSERT(options.sourceContents.getLength() == 0);
+    SLANG_ASSERT(options.modulePath.getLength());
+
     PlatformKind platformKind = (options.platform == PlatformKind::Unknown) ? PlatformUtil::getPlatformKind() : options.platform;
         
     if (options.sourceType == SourceType::CPP)
diff --git a/source/core/slang-gcc-compiler-util.h b/source/core/slang-gcc-compiler-util.h
index df3cb8a4b..ead527e0d 100644
--- a/source/core/slang-gcc-compiler-util.h
+++ b/source/core/slang-gcc-compiler-util.h
@@ -1,25 +1,25 @@
 #ifndef SLANG_GCC_COMPILER_UTIL_H
 #define SLANG_GCC_COMPILER_UTIL_H
 
-#include "slang-cpp-compiler.h"
+#include "slang-downstream-compiler.h"
 
 namespace Slang
 {
 
 /* Utility for processing input and output of gcc-like compilers, including clang */
-struct GCCCompilerUtil : public CPPCompilerBaseUtil
+struct GCCDownstreamCompilerUtil : public DownstreamCompilerBaseUtil
 {
         /// Extracts version number into desc from text (assumes gcc/clang -v layout with a line with version)
-    static SlangResult parseVersion(const UnownedStringSlice& text, const UnownedStringSlice& prefix, CPPCompiler::Desc& outDesc);
+    static SlangResult parseVersion(const UnownedStringSlice& text, const UnownedStringSlice& prefix, DownstreamCompiler::Desc& outDesc);
 
         /// Runs the exeName, and extracts the version info into outDesc
-    static SlangResult calcVersion(const String& exeName, CPPCompiler::Desc& outDesc);
+    static SlangResult calcVersion(const String& exeName, DownstreamCompiler::Desc& outDesc);
 
         /// Calculate gcc family compilers (including clang) cmdLine arguments from options
     static SlangResult calcArgs(const CompileOptions& options, CommandLine& cmdLine);
 
         /// Parse ExecuteResult into Output
-    static SlangResult parseOutput(const ExecuteResult& exeRes, CPPCompiler::Output& outOutput);
+    static SlangResult parseOutput(const ExecuteResult& exeRes, DownstreamDiagnostics& outOutput);
 
         /// Calculate the output module filename 
     static SlangResult calcModuleFilePath(const CompileOptions& options, StringBuilder& outPath);
@@ -28,19 +28,19 @@ struct GCCCompilerUtil : public CPPCompilerBaseUtil
     static SlangResult calcCompileProducts(const CompileOptions& options, ProductFlags flags, List<String>& outPaths);
 };
 
-class GCCCPPCompiler : public CommandLineCPPCompiler
+class GCCDownstreamCompiler : public CommandLineDownstreamCompiler
 {
 public:
-    typedef CommandLineCPPCompiler Super;
-    typedef GCCCompilerUtil Util;
+    typedef CommandLineDownstreamCompiler Super;
+    typedef GCCDownstreamCompilerUtil Util;
 
     // CommandLineCPPCompiler impl  - just forwards to the Util
     virtual SlangResult calcArgs(const CompileOptions& options, CommandLine& cmdLine) SLANG_OVERRIDE { return Util::calcArgs(options, cmdLine); }
-    virtual SlangResult parseOutput(const ExecuteResult& exeResult, Output& output) SLANG_OVERRIDE { return Util::parseOutput(exeResult, output); }
+    virtual SlangResult parseOutput(const ExecuteResult& exeResult, DownstreamDiagnostics& output) SLANG_OVERRIDE { return Util::parseOutput(exeResult, output); }
     virtual SlangResult calcModuleFilePath(const CompileOptions& options, StringBuilder& outPath) SLANG_OVERRIDE { return Util::calcModuleFilePath(options, outPath); }
     virtual SlangResult calcCompileProducts(const CompileOptions& options, ProductFlags flags,  List<String>& outPaths) SLANG_OVERRIDE { return Util::calcCompileProducts(options, flags, outPaths); }
 
-    GCCCPPCompiler(const Desc& desc):Super(desc) {}
+    GCCDownstreamCompiler(const Desc& desc):Super(desc) {}
 };
 
 }
diff --git a/source/core/slang-hex-dump-util.cpp b/source/core/slang-hex-dump-util.cpp
index 4a3d4ce06..1583d8461 100644
--- a/source/core/slang-hex-dump-util.cpp
+++ b/source/core/slang-hex-dump-util.cpp
@@ -6,6 +6,7 @@
 #include "slang-writer.h"
 
 #include "../../slang-com-helper.h"
+#include "slang-hash.h"
 
 namespace Slang
 {
@@ -16,11 +17,19 @@ static const char s_hex[] = "0123456789abcdef";
 
 /* static */SlangResult HexDumpUtil::dumpWithMarkers(const List<uint8_t>& data, int maxBytesPerLine, ISlangWriter* writer)
 {
+    return dumpWithMarkers(data.getBuffer(), data.getCount(), maxBytesPerLine, writer);
+}
+
+/* static */SlangResult HexDumpUtil::dumpWithMarkers(const uint8_t* data, size_t dataCount, int maxBytesPerLine, ISlangWriter* writer)
+{
     WriterHelper helper(writer);
     SLANG_RETURN_ON_FAIL(helper.write(s_start.begin(), s_start.size()));
-    SLANG_RETURN_ON_FAIL(helper.print(" (%zu)\n", size_t(data.getCount())));
+    SLANG_RETURN_ON_FAIL(helper.print(" %zu", dataCount));
 
-    SLANG_RETURN_ON_FAIL(dump(data, maxBytesPerLine, writer));
+    const int hash = GetHashCode((const char*)data, dataCount);
+    SLANG_RETURN_ON_FAIL(helper.print(" %d\n", hash ));
+
+    SLANG_RETURN_ON_FAIL(dump(data, dataCount, maxBytesPerLine, writer));
 
     SLANG_RETURN_ON_FAIL(helper.write(s_end.begin(), s_end.size()));
     SLANG_RETURN_ON_FAIL(helper.put("\n"));
@@ -38,14 +47,19 @@ static const char s_hex[] = "0123456789abcdef";
     writer->write(c, 8);
 }
 
+
 /* static */SlangResult HexDumpUtil::dump(const List<uint8_t>& data, int maxBytesPerLine, ISlangWriter* writer)
 {
-    int maxCharsPerLine = 2 * maxBytesPerLine + 1 + maxBytesPerLine + 1;
+    return dump(data.getBuffer(), data.getCount(), maxBytesPerLine, writer);
+}
 
-    const uint8_t* cur = data.begin();
-    const uint8_t* end = data.end();
+/* static */SlangResult HexDumpUtil::dump(const uint8_t* data, size_t dataCount, int maxBytesPerLine, ISlangWriter* writer)
+{
+    int maxCharsPerLine = 2 * maxBytesPerLine + 1 + maxBytesPerLine + 1;
 
- 
+    const uint8_t* cur = data;
+    const uint8_t* end = data + dataCount;
+    
     while (cur < end)
     {
         size_t count = size_t(end - cur);
@@ -112,34 +126,16 @@ static int _parseHexDigit(char c)
 {
     outBytes.clear();
 
-    bool inHex = false;
-
     LineParser lineParser(lines);
     for (const auto& line : lineParser)
     {
-        if (!inHex)
-        {
-            if (line.startsWith(s_start))
-            {
-                inHex = true;
-                continue;
-            }
-        }
-        else
-        {
-            if (line.startsWith(s_end))
-            {
-                break;
-            }
-        }
-
         const char* cur = line.begin();
         const char* end = line.end();
 
         while(cur + 2 <= end)
         {
             const char c = cur[0];
-            if (c == ' ' || c== '\n' || c == '\r' || c == '\t')
+            if (c == ' ' || c == '\n' || c == '\r' || c == '\t')
             {
                 // Skip to next line
                 break;
@@ -160,35 +156,59 @@ static int _parseHexDigit(char c)
     return SLANG_OK;
 }
 
+static SlangResult _findLine(const UnownedStringSlice& find, UnownedStringSlice& ioRemaining, UnownedStringSlice& outLine)
+{
+    // Find the start line
+    UnownedStringSlice line;
+    while (StringUtil::extractLine(ioRemaining, line))
+    {
+        if (line.startsWith(find))
+        {
+            outLine = line;
+            return SLANG_OK;
+        }
+    }
+    return SLANG_FAIL;
+}
+
+/* static */SlangResult HexDumpUtil::findStartAndEndLines(const UnownedStringSlice& lines, UnownedStringSlice& outStart, UnownedStringSlice& outEnd)
+{
+    UnownedStringSlice remaining(lines);
+    SLANG_RETURN_ON_FAIL(_findLine(s_start, remaining, outStart));
+    SLANG_RETURN_ON_FAIL(_findLine(s_end, remaining, outEnd));
+    return SLANG_OK;
+}
+
 /* static */SlangResult HexDumpUtil::parseWithMarkers(const UnownedStringSlice& lines, List<uint8_t>& outBytes)
 {
-    UnownedStringSlice remaining(lines), line;
+    UnownedStringSlice startLine, endLine;
+    SLANG_RETURN_ON_FAIL(findStartAndEndLines(lines, startLine, endLine));
 
-    while(StringUtil::extractLine(remaining, line))
+    int hash;
+    size_t size;
     {
-        if (line.startsWith(s_start))
+        // Get the size and the hash
+        List<UnownedStringSlice> slices;
+        StringUtil::split(startLine, ' ', slices);
+        if (slices.getCount() != 3)
         {
-            // Extract next line
-            if (!StringUtil::extractLine(remaining, line))
-            {
-                return SLANG_FAIL;
-            }
-            // It's the start line
-            UnownedStringSlice startLine = line;
-
-            // Look for the ending line
-            do 
-            {
-                if (line.startsWith(s_end))
-                {
-                    return parse(UnownedStringSlice(startLine.begin(), line.begin()), outBytes);
-                }
-            }
-            while ( StringUtil::extractLine(remaining, line));
+            return SLANG_FAIL;
         }
+        // Extract the size
+        size = StringToInt(String(slices[1]));
+        hash = int(StringToInt(String(slices[2])));
     }
 
-    return SLANG_FAIL;
+    SLANG_RETURN_ON_FAIL(parse(UnownedStringSlice(startLine.end(), endLine.begin()), outBytes));
+
+    // Calc the hash
+    const int readHash = GetHashCode((const char*)outBytes.begin(), outBytes.getCount());
+
+    if (readHash != hash || size_t(outBytes.getCount()) != size)
+    {
+        return SLANG_FAIL;
+    }
+    return SLANG_OK;
 }
 
 }
diff --git a/source/core/slang-hex-dump-util.h b/source/core/slang-hex-dump-util.h
index fefe84a17..f38bfde78 100644
--- a/source/core/slang-hex-dump-util.h
+++ b/source/core/slang-hex-dump-util.h
@@ -15,15 +15,21 @@ struct HexDumpUtil
         /// Dump data to writer, with lines starting with hex data
     static SlangResult dump(const List<uint8_t>& data, int numBytesPerLine, ISlangWriter* writer);
 
+    static SlangResult dump(const uint8_t* data, size_t dataCount, int numBytesPerLine, ISlangWriter* writer);
+
         /// Dump a single value
     static void dump(uint32_t value, ISlangWriter* writer);
 
     static SlangResult dumpWithMarkers(const List<uint8_t>& data, int numBytesPerLine, ISlangWriter* writer);
 
+    static SlangResult dumpWithMarkers(const uint8_t* data, size_t dataSize, int numBytesPerLine, ISlangWriter* writer);
+
         /// Parses lines formatted by dump, back into bytes
     static SlangResult parse(const UnownedStringSlice& lines, List<uint8_t>& outBytes);
 
     static SlangResult parseWithMarkers(const UnownedStringSlice& lines, List<uint8_t>& outBytes);
+
+    static SlangResult findStartAndEndLines(const UnownedStringSlice& lines, UnownedStringSlice& outStart, UnownedStringSlice& outEnd);
 };
 
 }
diff --git a/source/core/slang-io.h b/source/core/slang-io.h
index 758a05edb..a42a6991b 100644
--- a/source/core/slang-io.h
+++ b/source/core/slang-io.h
@@ -91,8 +91,12 @@ namespace Slang
 	};
 
     // Helper class to clean up temporary files on dtor
-    struct TemporaryFileSet
+    class TemporaryFileSet: public RefObject
     {
+    public:
+        typedef RefObject Super;
+        typedef TemporaryFileSet ThisType;
+
         void remove(const String& path)
         {
             if (const Index index = m_paths.indexOf(path) >= 0)
@@ -119,6 +123,12 @@ namespace Slang
         {
             m_paths.clear();
         }
+
+        void swapWith(ThisType& rhs)
+        {
+            m_paths.swapWith(rhs.m_paths);
+        }
+
         ~TemporaryFileSet()
         {
             for (const auto& path : m_paths)
@@ -126,7 +136,15 @@ namespace Slang
                 File::remove(path);
             }
         }
+            /// Default Ctor
+        TemporaryFileSet() {}
+
         List<String> m_paths;
+    
+    private:
+        // Disable ctor/assignment
+        TemporaryFileSet(const ThisType& rhs) = delete;
+        void operator=(const ThisType& rhs) = delete;
     };
 }
 
diff --git a/source/core/slang-shared-library.h b/source/core/slang-shared-library.h
index 675ee5cae..517292908 100644
--- a/source/core/slang-shared-library.h
+++ b/source/core/slang-shared-library.h
@@ -103,7 +103,7 @@ public:
     virtual ~TemporarySharedLibrary();
 
         /// Any files specified in this set will be deleted on exit
-    TemporaryFileSet m_temporaryFileSet;
+    RefPtr<TemporaryFileSet> m_temporaryFileSet;
 
 protected:
     String m_path;
diff --git a/source/core/slang-string-util.cpp b/source/core/slang-string-util.cpp
index 4295a2c52..cd79ffce7 100644
--- a/source/core/slang-string-util.cpp
+++ b/source/core/slang-string-util.cpp
@@ -1,17 +1,8 @@
 #include "slang-string-util.h"
 
-namespace Slang {
-
-// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! StringBlob !!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-// Allocate static const storage for the various interface IDs that the Slang API needs to expose
-static const Guid IID_ISlangUnknown = SLANG_UUID_ISlangUnknown;
-static const Guid IID_ISlangBlob = SLANG_UUID_ISlangBlob;
+#include "slang-blob.h"
 
-/* static */ISlangUnknown* StringBlob::getInterface(const Guid& guid)
-{
-    return (guid == IID_ISlangUnknown || guid == IID_ISlangBlob) ? static_cast<ISlangBlob*>(this) : nullptr;
-}
+namespace Slang {
 
 // !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! StringUtil !!!!!!!!!!!!!!!!!!!!!!!!!!!
 
diff --git a/source/core/slang-string-util.h b/source/core/slang-string-util.h
index 77b7ca2a3..16588bd35 100644
--- a/source/core/slang-string-util.h
+++ b/source/core/slang-string-util.h
@@ -11,30 +11,6 @@
 
 namespace Slang {
 
-/** A blob that uses a `String` for its storage.
-*/
-class StringBlob : public ISlangBlob, public RefObject
-{
-public:
-    // ISlangUnknown
-    SLANG_REF_OBJECT_IUNKNOWN_ALL
-
-        // ISlangBlob
-    SLANG_NO_THROW void const* SLANG_MCALL getBufferPointer() SLANG_OVERRIDE { return m_string.getBuffer(); }
-    SLANG_NO_THROW size_t SLANG_MCALL getBufferSize() SLANG_OVERRIDE { return m_string.getLength(); }
-
-        /// Get the contained string
-    SLANG_FORCE_INLINE const String& getString() const { return m_string; }
-
-    explicit StringBlob(String const& string)
-        : m_string(string)
-    {}
-
-protected:
-    ISlangUnknown* getInterface(const Guid& guid);
-    String m_string;
-};
-
 struct StringUtil
 {
         /// Split in, by specified splitChar into slices out
diff --git a/source/core/slang-visual-studio-compiler-util.cpp b/source/core/slang-visual-studio-compiler-util.cpp
index 8b4598b43..8797c3384 100644
--- a/source/core/slang-visual-studio-compiler-util.cpp
+++ b/source/core/slang-visual-studio-compiler-util.cpp
@@ -12,6 +12,8 @@ namespace Slang
 
 /* static */ SlangResult VisualStudioCompilerUtil::calcModuleFilePath(const CompileOptions& options, StringBuilder& outPath)
 {
+    SLANG_ASSERT(options.modulePath.getLength());
+
     outPath.Clear();
 
     switch (options.targetType)
@@ -39,6 +41,8 @@ namespace Slang
 
 /* static */SlangResult VisualStudioCompilerUtil::calcCompileProducts(const CompileOptions& options, ProductFlags flags, List<String>& outPaths)
 {
+    SLANG_ASSERT(options.modulePath.getLength());
+
     outPaths.clear();
 
     if (flags & ProductFlag::Execution)
@@ -72,6 +76,9 @@ namespace Slang
 
 /* static */SlangResult VisualStudioCompilerUtil::calcArgs(const CompileOptions& options, CommandLine& cmdLine)
 {
+    SLANG_ASSERT(options.sourceContents.getLength() == 0);
+    SLANG_ASSERT(options.modulePath.getLength());
+
     // https://docs.microsoft.com/en-us/cpp/build/reference/compiler-options-listed-alphabetically?view=vs-2019
 
     cmdLine.addArg("/nologo");
@@ -242,9 +249,9 @@ namespace Slang
     return SLANG_OK;
 }
 
-static SlangResult _parseErrorType(const UnownedStringSlice& in, CPPCompiler::Diagnostic::Type& outType)
+static SlangResult _parseErrorType(const UnownedStringSlice& in, DownstreamDiagnostics::Diagnostic::Type& outType)
 {
-    typedef CPPCompiler::Diagnostic::Type Type;
+    typedef DownstreamDiagnostics::Diagnostic::Type Type;
 
     if (in == "error" || in == "fatal error")
     {
@@ -265,9 +272,9 @@ static SlangResult _parseErrorType(const UnownedStringSlice& in, CPPCompiler::Di
     return SLANG_OK;
 }
 
-static SlangResult _parseVisualStudioLine(const UnownedStringSlice& line, CPPCompiler::Diagnostic& outDiagnostic)
+static SlangResult _parseVisualStudioLine(const UnownedStringSlice& line, DownstreamDiagnostics::Diagnostic& outDiagnostic)
 {
-    typedef CPPCompiler::Diagnostic Diagnostic;
+    typedef DownstreamDiagnostics::Diagnostic Diagnostic;
 
     UnownedStringSlice linkPrefix = UnownedStringSlice::fromLiteral("LINK :");
     if (line.startsWith(linkPrefix))
@@ -389,11 +396,11 @@ static SlangResult _parseVisualStudioLine(const UnownedStringSlice& line, CPPCom
     return SLANG_OK;
 }
 
-/* static */SlangResult VisualStudioCompilerUtil::parseOutput(const ExecuteResult& exeRes, CPPCompiler::Output& outOutput)
+/* static */SlangResult VisualStudioCompilerUtil::parseOutput(const ExecuteResult& exeRes, DownstreamDiagnostics& outDiagnostics)
 {
-    outOutput.reset();
+    outDiagnostics.reset();
 
-    outOutput.rawDiagnostics = exeRes.standardOutput;
+    outDiagnostics.rawDiagnostics = exeRes.standardOutput;
 
     for (auto line : LineParser(exeRes.standardOutput.getUnownedSlice()))
     {
@@ -402,17 +409,17 @@ static SlangResult _parseVisualStudioLine(const UnownedStringSlice& line, CPPCom
         fprintf(stdout, "\n");
 #endif
 
-        CPPCompiler::Diagnostic diagnostic;
+        Diagnostic diagnostic;
         if (SLANG_SUCCEEDED(_parseVisualStudioLine(line, diagnostic)))
         {
-            outOutput.diagnostics.add(diagnostic);
+            outDiagnostics.diagnostics.add(diagnostic);
         }
     }
 
     // if it has a compilation error.. set on output
-    if (outOutput.has(CPPCompiler::Diagnostic::Type::Error))
+    if (outDiagnostics.has(Diagnostic::Type::Error))
     {
-        outOutput.result = SLANG_FAIL;
+        outDiagnostics.result = SLANG_FAIL;
     }
 
     return SLANG_OK;
diff --git a/source/core/slang-visual-studio-compiler-util.h b/source/core/slang-visual-studio-compiler-util.h
index 1e2fbb318..3571f4b42 100644
--- a/source/core/slang-visual-studio-compiler-util.h
+++ b/source/core/slang-visual-studio-compiler-util.h
@@ -1,37 +1,37 @@
 #ifndef SLANG_VISUAL_STUDIO_COMPILER_UTIL_H
 #define SLANG_VISUAL_STUDIO_COMPILER_UTIL_H
 
-#include "slang-cpp-compiler.h"
+#include "slang-downstream-compiler.h"
 
 namespace Slang
 {
 
 
-struct VisualStudioCompilerUtil : public CPPCompilerBaseUtil
+struct VisualStudioCompilerUtil : public DownstreamCompilerBaseUtil
 {
         /// Calculate Visual Studio family compilers cmdLine arguments from options
     static SlangResult calcArgs(const CompileOptions& options, CommandLine& cmdLine);
         /// Parse Visual Studio exeRes into CPPCompiler::Output
-    static SlangResult parseOutput(const ExecuteResult& exeRes, CPPCompiler::Output& outOutput);
+    static SlangResult parseOutput(const ExecuteResult& exeRes, DownstreamDiagnostics& outOutput);
 
     static SlangResult calcModuleFilePath(const CompileOptions& options, StringBuilder& outPath);
 
     static SlangResult calcCompileProducts(const CompileOptions& options, ProductFlags flags, List<String>& outPaths);
 };
 
-class VisualStudioCPPCompiler : public CommandLineCPPCompiler
+class VisualStudioDownstreamCompiler : public CommandLineDownstreamCompiler
 {
 public:
-    typedef CommandLineCPPCompiler Super;
+    typedef CommandLineDownstreamCompiler Super;
     typedef VisualStudioCompilerUtil Util;
 
-    // CommandLineCPPCompiler impl  - just forwards to the Util
+    // CommandLineDownstreamCompiler impl  - just forwards to the Util
     virtual SlangResult calcArgs(const CompileOptions& options, CommandLine& cmdLine) SLANG_OVERRIDE { return Util::calcArgs(options, cmdLine); }
-    virtual SlangResult parseOutput(const ExecuteResult& exeResult, Output& output) SLANG_OVERRIDE { return Util::parseOutput(exeResult, output); }
+    virtual SlangResult parseOutput(const ExecuteResult& exeResult, DownstreamDiagnostics& output) SLANG_OVERRIDE { return Util::parseOutput(exeResult, output); }
     virtual SlangResult calcModuleFilePath(const CompileOptions& options, StringBuilder& outPath) SLANG_OVERRIDE { return Util::calcModuleFilePath(options, outPath); }
     virtual SlangResult calcCompileProducts(const CompileOptions& options, ProductFlags productFlags, List<String>& outPaths) SLANG_OVERRIDE { return Util::calcCompileProducts(options, productFlags, outPaths); }
 
-    VisualStudioCPPCompiler(const Desc& desc):Super(desc) {}
+    VisualStudioDownstreamCompiler(const Desc& desc):Super(desc) {}
 };
 
 
diff --git a/source/core/windows/slang-win-visual-studio-util.cpp b/source/core/windows/slang-win-visual-studio-util.cpp
index 260f3f56f..078406d99 100644
--- a/source/core/windows/slang-win-visual-studio-util.cpp
+++ b/source/core/windows/slang-win-visual-studio-util.cpp
@@ -278,7 +278,7 @@ static SlangResult _find(int versionIndex, WinVisualStudioUtil::VersionPath& out
     return SLANG_FAIL;
 }
 
-/* static */SlangResult WinVisualStudioUtil::find(CPPCompilerSet* set)
+/* static */SlangResult WinVisualStudioUtil::find(DownstreamCompilerSet* set)
 {
     const int versionCount = SLANG_COUNT_OF(s_versionInfos);
 
@@ -290,7 +290,7 @@ static SlangResult _find(int versionIndex, WinVisualStudioUtil::VersionPath& out
         VersionPath versionPath;
         if (!set->getCompiler(desc) && SLANG_SUCCEEDED(_find(i, versionPath)))
         {
-            RefPtr<CommandLineCPPCompiler> compiler = new VisualStudioCPPCompiler(desc);
+            RefPtr<CommandLineDownstreamCompiler> compiler = new VisualStudioDownstreamCompiler(desc);
             calcExecuteCompilerArgs(versionPath, compiler->m_cmdLine);
             set->addCompiler(compiler);
         }
diff --git a/source/core/windows/slang-win-visual-studio-util.h b/source/core/windows/slang-win-visual-studio-util.h
index 34be8473d..1122fccb7 100644
--- a/source/core/windows/slang-win-visual-studio-util.h
+++ b/source/core/windows/slang-win-visual-studio-util.h
@@ -6,7 +6,7 @@
 
 #include "../slang-process-util.h"
 
-#include "../slang-cpp-compiler.h"
+#include "../slang-downstream-compiler.h"
 
 namespace Slang {
 
@@ -31,7 +31,7 @@ struct WinVisualStudioUtil
     static SlangResult find(Version version, VersionPath& outPath);
 
         /// Find and add to the set (if not already there)
-    static SlangResult find(CPPCompilerSet* set);
+    static SlangResult find(DownstreamCompilerSet* set);
 
         /// Create the cmdLine to start compiler for specified path
     static void calcExecuteCompilerArgs(const VersionPath& versionPath, CommandLine& outCmdLine);
@@ -52,10 +52,10 @@ struct WinVisualStudioUtil
     static void append(Version version, StringBuilder& outBuilder);
 
         /// Get version as desc
-    static CPPCompiler::Desc getDesc(Version version)
+    static DownstreamCompiler::Desc getDesc(Version version)
     {
-        CPPCompiler::Desc desc;
-        desc.type = CPPCompiler::CompilerType::VisualStudio;
+        DownstreamCompiler::Desc desc;
+        desc.type = DownstreamCompiler::CompilerType::VisualStudio;
         desc.majorVersion = Int(version) / 10;
         desc.minorVersion = Int(version) % 10;
         return desc;