Use the (versioned) triple from swiftc instead.

Here, swiftc is invoked to get the textual unversioned triple from the
compiler. However, TSC wants to use this unversioned triple for the
target flag, which causes breakage on the compiler side on platforms
with versioned triples, because the compiler can't find the stdlib with
the unversioned triple.

Instead, default to getting versioned triples. When clients of TSC want
to do funky things with unversioned triples, we lop the version numbers
off versioned triples to get an unversioned triple. This is somewhat
crude, but the alternative is to get both versioned _and_ unversioned
triples from swiftc, which is similarly awkward.

Author: 3405691582

Sources/TSCUtility/Triple.swift

@@ -27,6 +27,7 @@ public struct Triple: Encodable, Equatable {
     public let vendor: Vendor
     public let os: OS
     public let abi: ABI
+    public let version: String?
 
     public enum Error: Swift.Error {
         case badFormat
@@ -83,12 +84,15 @@ public struct Triple: Encodable, Equatable {
             throw Error.unknownOS
         }
 
+        let version = Triple.parseVersion(components[2])
+
         let abi = components.count > 3 ? Triple.parseABI(components[3]) : nil
 
         self.tripleString = string
         self.arch = arch
         self.vendor = vendor
         self.os = os
+        self.version = version
         self.abi = abi ?? .unknown
     }
 
@@ -100,6 +104,15 @@ public struct Triple: Encodable, Equatable {
         return nil
     }
 
+    fileprivate static func parseVersion(_ string: String) -> String? {
+        let candidate = String(string.drop(while: { $0.isLetter }))
+        if candidate != string {
+            return candidate
+        }
+
+        return nil
+    }
+
     fileprivate static func parseABI(_ string: String) -> ABI? {
         if string.hasPrefix(ABI.android.rawValue) {
             return ABI.android
@@ -132,18 +145,18 @@ public struct Triple: Encodable, Equatable {
     /// This is currently meant for Apple platforms only.
     public func tripleString(forPlatformVersion version: String) -> String {
         precondition(isDarwin())
-        return self.tripleString + version
+        return String(self.tripleString.dropLast(self.version?.count ?? 0)) + version
     }
 
     public static let macOS = try! Triple("x86_64-apple-macosx")
 
-    /// Determine the host triple using the Swift compiler.
+    /// Determine the versioned host triple using the Swift compiler.
     public static func getHostTriple(usingSwiftCompiler swiftCompiler: AbsolutePath) -> Triple {
         do {
             let result = try Process.popen(args: swiftCompiler.pathString, "-print-target-info")
             let output = try result.utf8Output().spm_chomp()
             let targetInfo = try JSON(string: output)
-            let tripleString: String = try targetInfo.get("target").get("unversionedTriple")
+            let tripleString: String = try targetInfo.get("target").get("triple")
             return try Triple(tripleString)
         } catch {
             // FIXME: Remove the macOS special-casing once the latest version of Xcode comes with