Revert "Replace lenient version parsing implementation with the one in TSC"

Sources/SwiftDriver/Driver/Driver.swift

@@ -2155,7 +2155,7 @@ extension Driver {
       diagnosticsEngine.emit(.warning_no_sdksettings_json(sdkPath.pathString))
       return false
     }
-    guard let sdkVersion = try? Version(versionString: sdkInfo.versionString, usesLenientParsing: true) else {
+    guard let sdkVersion = Version(potentiallyIncompleteVersionString: sdkInfo.versionString) else {
       diagnosticsEngine.emit(.warning_fail_parse_sdk_ver(sdkInfo.versionString, sdkPath.pathString))
       return false
     }

Sources/SwiftDriver/Toolchains/DarwinToolchain.swift

@@ -254,12 +254,12 @@ public final class DarwinToolchain: Toolchain {
         let mappingDict = try keyedContainer.decode([String: String].self, forKey: .macOSToCatalystMapping)
         self.macOSToCatalystMapping = [:]
         try mappingDict.forEach { key, value in
-          guard let newKey = try? Version(versionString: key, usesLenientParsing: true) else {
+          guard let newKey = Version(potentiallyIncompleteVersionString: key) else {
             throw DecodingError.dataCorruptedError(forKey: .macOSToCatalystMapping,
                                                    in: keyedContainer,
                                                    debugDescription: "Malformed version string")
           }
-          guard let newValue = try? Version(versionString: value, usesLenientParsing: true) else {
+          guard let newValue = Version(potentiallyIncompleteVersionString: value) else {
             throw DecodingError.dataCorruptedError(forKey: .macOSToCatalystMapping,
                                                    in: keyedContainer,
                                                    debugDescription: "Malformed version string")
@@ -277,7 +277,7 @@ public final class DarwinToolchain: Toolchain {
 
       self.versionString = try keyedContainer.decode(String.self, forKey: .version)
       self.canonicalName = try keyedContainer.decode(String.self, forKey: .canonicalName)
-      guard let version = try? Version(versionString: versionString, usesLenientParsing: true) else {
+      guard let version = Version(potentiallyIncompleteVersionString: versionString) else {
         throw DecodingError.dataCorruptedError(forKey: .version,
                                                in: keyedContainer,
                                                debugDescription: "Malformed version string")

Sources/SwiftDriver/Utilities/VersionExtensions.swift

@@ -14,6 +14,45 @@ import TSCUtility
 
 // TODO: maybe move this to TSC.
 extension Version {
+  /// Create a version from a string, replacing unknown trailing components with '0'.
+  init?(potentiallyIncompleteVersionString string: String) {
+    // This is a copied version of TSC's version parsing, modified to fill
+    // in missing components if needed.
+    let prereleaseStartIndex = string.firstIndex(of: "-")
+    let metadataStartIndex = string.firstIndex(of: "+")
+
+    let requiredEndIndex = prereleaseStartIndex ?? metadataStartIndex ?? string.endIndex
+    let requiredCharacters = string.prefix(upTo: requiredEndIndex)
+    var requiredComponents = requiredCharacters
+      .split(separator: ".", maxSplits: 2, omittingEmptySubsequences: false)
+      .map(String.init).compactMap({ Int($0) }).filter({ $0 >= 0 })
+
+    requiredComponents.append(contentsOf:
+                                Array(repeating: 0,
+                                      count: max(0, 3 - requiredComponents.count)))
+
+    let major = requiredComponents[0]
+    let minor = requiredComponents[1]
+    let patch = requiredComponents[2]
+
+    func identifiers(start: String.Index?, end: String.Index) -> [String] {
+      guard let start = start else { return [] }
+      let identifiers = string[string.index(after: start)..<end]
+      return identifiers.split(separator: ".").map(String.init)
+    }
+
+    let prereleaseIdentifiers = identifiers(
+      start: prereleaseStartIndex,
+      end: metadataStartIndex ?? string.endIndex)
+    let buildMetadataIdentifiers = identifiers(
+      start: metadataStartIndex,
+      end: string.endIndex)
+
+    self.init(major, minor, patch,
+              prereleaseIdentifiers: prereleaseIdentifiers,
+              buildMetadataIdentifiers: buildMetadataIdentifiers)
+  }
+
   /// Returns the version with out any build/release metadata numbers.
   var withoutBuildNumbers: Version {
     return Version(self.major, self.minor, self.patch)