Improvements around Visual Studio versions/matching versions (#2267)

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

* Use TerminatedUnownedStringSlice for literals in output C++.

* Remove Escape/Unescape functions used in slang-token-reader.cpp
Add target type of 'host-cpp' etc to map to the target types.

* Fix some corner cases around string encoding.

* Added unit test for string escaping.
Fixed some assorted escaping bugs.

* Updated test output.

* Added decode test.

* Stop using hex output, to get around 'greedy' aspect. Use octal instead.

* Added HostHostCallable
Small changes to use ArtifactDesc/Info instead of large switches.

* Fix C++ emit to handle arbitrary function export.

* Add options handling for callable without an output being specified.

* Can compile with COM interface. Added example using com interface.

* Use the IR Ptr type instead of hack in C++ emit for interfaces.

* Fix issue with outputting the COM call when ptr is used.

* Fix crash issue on compilation failure.

* Add support for __global.

* Added `ActualGlobalRate`
Added special handling around globals and COM interfaces.
Tested out in cpu-com-example.

* Fix typo in NodeBase.

* Support for accessing globals by name working.

* Check that actual global initialization is working.

* Refactor the com replacement such that it doesn't need a cache or do anything special with GlobalVar.

* Remove context.
Only create replacement if needed.

* Split out COM host-callable into a unit-test.

* host-callable com testing on C++and llvm.

* Comment around the COM ptr replacement.

* Disable com test on vs 32 bit.
Fix C++ prelude

* Disable 32 bit targets testing com host-callable.

* Use JSON parsing to locate VS version.

* Need platform detection in C++prelude.

* Fix com host callable test for LLVM.

* WIP improments finding downstream compiler version.

* Work around for not being able to include "targetConditionals.h"

* Matching semantic versioning support.

* DownstreamMatchVersion -> DownstreamCompilerMatchVersion
Small improvements.

1 files changed, 153 insertions, 0 deletions

diff --git a/source/core/slang-semantic-version.cpp b/source/core/slang-semantic-version.cpp
index 7f603fd9c..cc631d292 100644
--- a/source/core/slang-semantic-version.cpp
+++ b/source/core/slang-semantic-version.cpp
@@ -7,6 +7,8 @@
 
 namespace Slang {
 
+// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! SemanticVersion !!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
 SlangResult SemanticVersion::parse(const UnownedStringSlice& value, char separatorChar, SemanticVersion& outVersion)
 {
     outVersion.reset();
@@ -52,4 +54,155 @@ void SemanticVersion::append(StringBuilder& buf) const
     }
 }
 
+/* static */SemanticVersion SemanticVersion::getEarliest(const ThisType* versions, Count count)
+{
+    if (count <= 0)
+    {
+        return SemanticVersion();
+    }
+
+    SemanticVersion bestVersion = versions[0];
+    for (const auto version : makeConstArrayView(versions + 1, count - 1))
+    {
+        if (version < bestVersion)
+        {
+            bestVersion = version;
+        }
+    }
+    return bestVersion;
+}
+
+/* static */SemanticVersion SemanticVersion::getLatest(const ThisType* versions, Count count)
+{
+    if (count <= 0)
+    {
+        return SemanticVersion();
+    }
+
+    SemanticVersion bestVersion = versions[0];
+    for (const auto version : makeConstArrayView(versions + 1, count - 1))
+    {
+        if (version > bestVersion)
+        {
+            bestVersion = version;
+        }
+    }
+    return bestVersion;
+}
+
+
+
+// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! MatchSemanticVersion !!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+/* static */SemanticVersion MatchSemanticVersion::findAnyBest(const SemanticVersion* versions, Count count, const ThisType& matchVersion)
+{
+    // If there aren't any we are done
+    if (count <= 0)
+    {
+        return SemanticVersion();
+    }
+
+    // If there is only one it must be the best
+    if (count == 1)
+    {
+        return versions[0];
+    }
+
+    // Define a version range [start, end)
+    SemanticVersion start, end;
+
+    switch (matchVersion.m_kind)
+    {
+        case Kind::Past:      
+        {
+            return SemanticVersion::getEarliest(versions, count);
+        }
+        case Kind::Unknown:
+        case Kind::Future:    
+        {
+            // If it's unknown, we just get the latest
+            return SemanticVersion::getLatest(versions, count);
+        }
+        case Kind::Major:
+        {
+            start = SemanticVersion(matchVersion.m_version.m_major, 0, 0);
+            end = SemanticVersion(matchVersion.m_version.m_major + 1, 0, 0);
+            break;
+        }
+        case Kind::MajorMinor:
+        {
+            start = SemanticVersion(matchVersion.m_version.m_major, matchVersion.m_version.m_minor, 0);
+            end = SemanticVersion(matchVersion.m_version.m_major, matchVersion.m_version.m_minor + 1, 0);
+            break;
+        }
+        case Kind::MajorMinorPatch:
+        {
+            start = SemanticVersion(matchVersion.m_version);
+            end = SemanticVersion(matchVersion.m_version.m_major, matchVersion.m_version.m_minor, matchVersion.m_version.m_patch + 1);
+            break;
+        }
+        default: break;
+    }
+
+    List<SemanticVersion> sortedVersions;
+    sortedVersions.addRange(versions, count);
+
+    // Sort into increasing values
+    sortedVersions.sort([&](const SemanticVersion& a, const SemanticVersion& b) -> bool { return a < b; });
+
+    Index startIndex = 0;
+    for (; startIndex < count && sortedVersions[startIndex] < start; ++startIndex);
+
+    Index endIndex = startIndex;
+    for (; endIndex < count && sortedVersions[endIndex] < end; ++endIndex);
+
+    // If we have a span of versions, get the last in the span
+    if (startIndex < endIndex)
+    {
+        // Get the last one
+        return sortedVersions[endIndex - 1];
+    }
+
+    // Get the next greatest if there is one
+    if (endIndex < count)
+    {
+        return sortedVersions[endIndex];
+    }
+
+    // Get the prior prior to the start
+    if (startIndex > 0)
+    {
+        return sortedVersions[startIndex - 1];
+    }
+
+    // All cases should be covered, but return the last one 
+    return sortedVersions[count - 1];
+}
+
+void MatchSemanticVersion::append(StringBuilder& buf) const
+{
+    switch (m_kind)
+    {
+        default:
+        case Kind::Unknown:     buf << "unknown"; break;
+        case Kind::Past:        buf << "past";  break;
+        case Kind::Future:      buf << "future"; break;
+        case Kind::Major:
+        {
+            buf << m_version.m_major;
+            break;
+        }
+        case Kind::MajorMinor:
+        {
+            buf << m_version.m_major << "." << m_version.m_minor;
+            break;
+        }
+        case Kind::MajorMinorPatch:
+        {
+            m_version.append(buf);
+            break;
+        }
+    }
+}
+
 } // namespace Slang