From 857655affeb263181f9e56c157a4759221fc4756 Mon Sep 17 00:00:00 2001
From: Wowbagger's Liquid Lunch
 <55120045+WowbaggersLiquidLunch@users.noreply.github.com>
Date: Wed, 4 Nov 2020 05:26:22 -0500
Subject: [PATCH] adapt `writeToolsVersion(at:version:fs:)` to using the new
 `ToolsVersionLoader.split(_:)`

This allows the old `ToolsVersionLoader.split(_:)` and `regex` to be fully removed instead of just deprecated.

In implementing this change, the logic of the new `ToolsVersionLoader.split(_:)` is updated for the following 2 purposes:

1. Primarily to partially match the old `split(_:)`'s behaviour in deciding if the label of the Swift tools version specification is malformed.

2. Secondarily to provide a special path of diagnosis for when the label is prefixed with "swift-tools-version:" (case-insensitive). The comments left in the source provides much better details.
---
 CHANGELOG.md                                  |   4 +-
 .../PackageLoading/ToolsVersionLoader.swift   | 159 +++++++++---------
 Sources/Workspace/ToolsVersionWriter.swift    |  29 ++--
 .../ToolsVersionLoaderTests.swift             |   5 +-
 4 files changed, 104 insertions(+), 93 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 5f652e87e03..31174b28403 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -15,7 +15,9 @@ Swift 5.3.1
   
   * API Removal
   
-    `ToolsVersionLoader.Error.malformedToolsVersion(specifier: String, currentToolsVersion: ToolsVersion)` is now obsoleted, and replaced by `ToolsVersionLoader.Error.malformedToolsVersionSpecification(_ malformation: ToolsVersionSpecificationMalformation)`.
+    `ToolsVersionLoader.Error.malformedToolsVersion(specifier: String, currentToolsVersion: ToolsVersion)` is replaced by `ToolsVersionLoader.Error.malformedToolsVersionSpecification(_ malformation: ToolsVersionSpecificationMalformation)`.
+    
+    `ToolsVersionLoader.split(_ bytes: ByteString) -> (versionSpecifier: String?, rest: [UInt8])` and `ToolsVersionLoader.regex` are together replaced by `ToolsVersionLoader.split(_ manifest: String) -> ManifestComponents`.
   
   * Source Breakages for Swift Packages
     
diff --git a/Sources/PackageLoading/ToolsVersionLoader.swift b/Sources/PackageLoading/ToolsVersionLoader.swift
index 0cc160f43fa..2f0367e2699 100644
--- a/Sources/PackageLoading/ToolsVersionLoader.swift
+++ b/Sources/PackageLoading/ToolsVersionLoader.swift
@@ -124,6 +124,8 @@ public class ToolsVersionLoader: ToolsVersionLoaderProtocol {
             /// The label part of the Swift tools version specification is malformed.
             case label(_ malformationDetails: MalformationDetails)
             /// The version specifier is malformed.
+            ///
+            /// If the version specifier is diagnosed as missing, it could be a misdiagnosis due to some misspellings in the label. This is because of a compromise made in `ToolsVersionLoader.split(_:)`.
             case versionSpecifier(_ malformationDetails: MalformationDetails)
             /// An unidentifiable component of the Swift tools version specification is malformed.
             case unidentified
@@ -201,8 +203,7 @@ public class ToolsVersionLoader: ToolsVersionLoaderProtocol {
                 case .versionSpecifier(let versionSpecifier):
                     switch versionSpecifier {
                     case .isMissing:
-                        // If the version specifier is missing, then its terminator must be missing as well. So, there is nothing in between the version specifier and everything that should be in front the version specifier. So, appending a valid version specifier will fix this error.
-                        return "the Swift tools version specification is missing a version specifier; consider appending '\(ToolsVersion.currentToolsVersion)' to the line to specify the current Swift toolchain version as the lowest Swift version supported by the project"
+                        return "the Swift tools version specification is possibly missing a version specifier; consider using 'swift-tools-version:\(ToolsVersion.currentToolsVersion)' to specify the current Swift toolchain version as the lowest Swift version supported by the project"
                     case .isMisspelt(let misspeltVersionSpecifier):
                         return "the Swift tools version '\(misspeltVersionSpecifier)' is misspelt or otherwise invalid; consider replacing it with '\(ToolsVersion.currentToolsVersion)' to specify the current Swift toolchain version as the lowest Swift version supported by the project"
                     }
@@ -426,45 +427,6 @@ public class ToolsVersionLoader: ToolsVersionLoaderProtocol {
         return version
     }
     
-    // FIXME: Remove this function.
-    // This function is currently preserved because it's used in `writeToolsVersion(at:version:fs:).
-    /// Splits the bytes to find the Swift tools version specifier and the contents sans the first line of the manifest.
-    ///
-    /// - Warning: This function has been deprecated since Swift 5.3.1, please use `split(_ manifestContents: String) -> ManifestComponents` instead.
-    ///
-    /// - Note: This function imposes the following limitations that are removed in its replacement:
-    ///   - Leading whitespace, other than a sequence of newline characters (`U+000A`), is not accepted in the given manifest contents.
-    ///   - Only `U+000A` is recognised as a line terminator.
-    ///   - A Swift tools version specification must be prefixed with `// swift-tools-version:` verbatim, where the spacing between `//` and `swift-tools-version` is exactly 1 `U+0020`.
-    ///
-    /// - Bug: This function treats only `U+000A` as a line terminator.
-    /// - Bug: If there is a contiguous sequence of `U+000A` at the very beginning of the manifest file, this function mistakes the first non-empty line of the manifest as its first line.
-    ///
-    /// - Parameter bytes: The raw bytes of the content of the manifest.
-    /// - Returns: The version specifier (if present, or `nil`) and the raw bytes of the contents sans the first line of the manifest.
-    @available(swift, deprecated: 5.3.1, renamed: "ToolsVersionLoader.split(_:)")
-    public static func split(_ bytes: ByteString) -> (versionSpecifier: String?, rest: [UInt8]) {
-        let splitted = bytes.contents.split(
-            separator: UInt8(ascii: "\n"),
-            maxSplits: 1,
-            omittingEmptySubsequences: false)
-        // Try to match our regex and see if the "first" line is a valid tools version specification line.
-        guard let firstLine = ByteString(splitted[0]).validDescription,
-              let match = ToolsVersionLoader.regex.firstMatch(
-                  in: firstLine, options: [], range: NSRange(location: 0, length: firstLine.count)),
-              // The 2 ranges are:
-              //   1. The entire matched string.
-              //   2. Capture group 1: The version specifier.
-              // Since the version specifier is in the last range, if the number of ranges is less than 2, then no version specifier is captured by the regex.
-              // FIXME: Should this be `== 2` instead?
-              match.numberOfRanges >= 2 else {
-            return (nil, bytes.contents)
-        }
-        let versionSpecifier = NSString(string: firstLine).substring(with: match.range(at: 1))
-        // FIXME: We can probably optimize here and return array slice.
-        return (versionSpecifier, splitted.count == 1 ? [] : Array(splitted[1]))
-    }
-    
     /// Splits the given manifest into its constituent components.
     ///
     /// A manifest consists of the following parts:
@@ -535,42 +497,95 @@ public class ToolsVersionLoader: ToolsVersionLoaderProtocol {
         /// The position right past the last character of the spacing that immediately follows the comment marker.
         ///
         /// Because the spacing consists of only horizontal whitespace characters, this position is the same as the first character that's not a horizontal whitespace after `commentMarker`. If no such character exists, then the position is the `endIndex` of the Swift tools version specification line.
-        let endIndexOfSpacingAfterCommentMarker = specificationWithIgnoredTrailingContents[endIndexOfCommentMarker...].firstIndex(where: { !$0.isWhitespace } ) ?? specificationWithIgnoredTrailingContents.endIndex
-        //                                                                                                                                    ☝️
+        let startIndexOfLabel = specificationWithIgnoredTrailingContents[endIndexOfCommentMarker...].firstIndex(where: { !$0.isWhitespace } ) ?? specificationWithIgnoredTrailingContents.endIndex
+        //                                                                                                                  ☝️
         // Technically, this is looking for the position of the first character that's not a whitespace, BOTH HORIZONTAL AND VERTICAL. However, since all vertical horizontal whitespace characters are also line terminators, and because the Swift tools version specification does not contain any line terminator, we can safely use `Character.isWhitespace` to check if a character is a horizontal whitespace.
         
         /// The spacing that immediately follows `commentMarker`.
         ///
         /// The spacing consists of only horizontal whitespace characters.
-        let spacingAfterCommentMarker = specificationWithIgnoredTrailingContents[endIndexOfCommentMarker..<endIndexOfSpacingAfterCommentMarker]
+        let spacingAfterCommentMarker = specificationWithIgnoredTrailingContents[endIndexOfCommentMarker..<startIndexOfLabel]
+        
+        // FIXME: Improve the logic for identifying the label and the version specifier.
+        //
+        // At this point, everything before the label has been parsed, and everything starting from the label until the end of the Swift tools version specification line hasn't.
+        //
+        // The task that remains is to identify and record the following well defined components: a label, a version specifier, and an optional spacing between the label and the version specifier. However, because of the countless misspellings there could be, it's virtually impossible to teach SwiftPM to perfectly tell where the label ends and where the version specifier begins, without making the logic too complex.
+        //
+        // Let's explore this problem starting from a well-formed Swift tools version specification, because it's the only invariable that we can rely on. The current `Substring`-based strategy depends on landmarks that sit on either the `startIndex` or the `endIndex` of a component. We already know where the label starts, and it's trivial to find where the version specifier ends (its terminator is well-defined), so all that we need look for now are the `endIndex` of the label and the `startIndex` of the version specifier. In a well-formatted Swift tools version specification, the label ends with a ":", and the version specifier starts with a digit. Let's see how these 2 landmarks fare with some examples:
+        //
+        // 1. A well-formatted Swift tools version specification
+        //
+        //        // swift-tools-version: 5.3.1
+        //
+        //    The `endIndex` of the label can be clearly identified with the first ":", and the `startIndex` of the version specifier can be clearly identified with the first digit "5".
+        //
+        // 2. A misspelt label with a digit within:
+        //
+        //        // swift-too1s-version: 5.3.1
+        //    The `endIndex` of the label can be identified with the first ":"; the `startIndex` of the version specifier can be identified with the digit "5", if and only if the search for the first ":" takes precedence.
+        //
+        // 3. A misspelt label with a colon and a digit within:
+        //
+        //        // sw:ft-too1s-version: 5.3.1
+        //
+        //    The `endIndex` of the label can be identified with the last ":";  the `startIndex` of the version specifier can be identified with the digit "5", if and only if the search for the last ":" takes precedence.
+        //
+        // Between example 2 and 3, the rules are already conflicting. Although the examples above are purposely constructed to illustrate the ineffectiveness of using ":" and digits to locate the label and the version specifier, it's undeniable a human can flawlessly point out where the labels and version specifiers are at a glance. There are more examples that shows it's even harder to find a one-size-fits-all landmark-based rule than illustrated above:
+        //
+        //     // swift-too1s-version:-5.3.1
+        //     // swift-too1s-version 5:3:1
+        //     // swift tools version 5-3-l
+        //     // swift-tools-version: s.3.1
+        //     // swift-tools-version::5.3.1
+        //     ...
+        //
+        // One useful information we can glean from these examples is that using both ":" and digits as landmarks doesn't work, so it's better to stick with just one of them and ignore the other. Because the version specifier is the more important component than the label is, the current implementation of this function searches for the first numerical character in the sequence to prioritize the identification of the version specifier. The ":"-first approach isn't completely abandoned, either: If the sequence is prefixed with "swift-tools-version:" (case-insensitive), then we can be mostly certain that the user has provided a well-formatted label, and use the position past that of the first ":" in the sequence as the `startIndex` of the label. There are still countless label misspellings that begin with "swift-tools-version:", but since for all of them, the misspelt part comes after the well-formed part, in the interest of keeping the logic relatively straightforward, the labels' misspellings in this sort of situation are carried over as the version specifiers'.
+        //
+        // Although it's possible to replace the landmark-based logic altogether with a fuzzy matching-based approach or some heuristics, it overly complicates this function. Even if a more advanced method is applied at the expense of high complexity, it's still unlikely to be perfect. Maybe someone can find better solution without incurring much additional cost.
+        
+        /// The position right past the last character in the label part of the Swift tool version specification.
+        ///
+        /// If the label begins with exactly `"swift-tools-version:"`, then this position is right after the `":"`'s. Otherwise, it's the position of the first horizontal whitespace character since the spacing after the comment marker (if there is a spacing between the label and the version specifier) or the `startIndex` of the version specifier (if there is no spacing between the label and the version specifier).
+        let endIndexOfLabel: Substring.Index
         
-        // FIXME: Use `CharacterSet.decimalDigits` instead?
-        // `Character.isNumber` is true for more than just decimal characters (e.g. ㊅ and 𝟘), but `CharacterSet.contains(_:)` works only on Unicode scalars.
         /// The position of the first character in the version specifier.
         ///
-        /// Because a version specifier starts with a numeric character, and because only the version specifier is expected to have numeric characters, this position is the same as the position of the first numeric character in the Swift tools version specification line. If no such character exists, then this position is the `endIndex` of the line.
+        /// If the label begins with exactly `"swift-tools-version:"`,  then this position is that of the first non-whitespace character after the label in the Swift tools version specification line. Otherwise, it's the same as the position of the first numeric character in the Swift tools version specification line. If no suitable character exists in either case, then this position is the `endIndex` of the line.
         ///
-        /// - Note: For a misspelt Swift tools version specification `"// swift-too1s-version:5.3"`, the first `"1"` is considered as the first character of the version specifier, and so `"1s-version:5.3"` is taken as the version specifier.
-        let startIndexOfVersionSpecifier = specificationWithIgnoredTrailingContents[endIndexOfSpacingAfterCommentMarker...].firstIndex(where: \.isNumber) ?? specificationWithIgnoredTrailingContents.endIndex
-        //                                                                         ☝️
-        // We know for sure that there is no numeric characters before `endIndexOfSpacingAfterCommentMarker`, so `specificationWithIgnoredTrailingContents[endIndexOfSpacingAfterCommentMarker...]` saves a bit of unnecessary searching.
-        
-        /// The label part of the Swift tools version specification with the whitespace sequence between the label and the version specifier.
-        /// - Note: For a misspelt Swift tools version specification `"// swift-too1s-version: 5.3.1"`, the label stops at the second `"o"`, so only `"swift-too"` is recognised as the label with no spacing following it.
-        let labelWithTrailingWhitespace = specificationWithIgnoredTrailingContents[endIndexOfSpacingAfterCommentMarker..<startIndexOfVersionSpecifier]
-        
-        /// The position of the first character in the spacing after the label part of the Swift tools version specification.
+        /// - Note:
+        ///
+        ///   For a misspelt Swift tools version specification `"// swift-too1s-version:5.3"`, the first `"1"` is considered as the first character of the version specifier, and so `"1s-version:5.3"` is taken as the version specifier.
         ///
-        /// Because there is no whitespace within the label, and because the spacing consists of only horizontal whitespace characters, so this position is the same as the position of the first whitespace character between the beginning of the label and the beginning of the version specifier. If no such whitespace character exists, then there is no spacing, and so this position is the `endIndex` of these sequence of characters (i.e. the starting position of the version specifier).
-        let startIndexOfSpacingAfterLabel = labelWithTrailingWhitespace.firstIndex(where: \.isWhitespace) ?? startIndexOfVersionSpecifier
+        ///   For a misspelt Swift tools version specification `"// swift-tools-version:-5.3"`, the label begins with `"swift-tools-version:"`, so all the misspelling is treated as the version specifiers, and so `"-5.3"` is taken as the version specifier.
+        let startIndexOfVersionSpecifier: Substring.Index
+        
+        /// The trailing slice of the Swift tools version specification line starting from the label.
+        let specificationSnippetFromLabelToLineTerminator = specificationWithIgnoredTrailingContents[startIndexOfLabel...]
+        
+        if specificationSnippetFromLabelToLineTerminator.lowercased().hasPrefix("swift-tools-version:") {
+            // The optional index can be safely unwrapped, because we know for sure there is a ":" in the substring.                                     👇
+            endIndexOfLabel = specificationSnippetFromLabelToLineTerminator.index(after: specificationSnippetFromLabelToLineTerminator.firstIndex(of: ":")!)
+            // Because there is potentially a spacing between the label and the version specifier, we need to skip the whitespace first.
+            startIndexOfVersionSpecifier = specificationSnippetFromLabelToLineTerminator[endIndexOfLabel...].firstIndex(where: { !$0.isWhitespace } ) ?? specificationSnippetFromLabelToLineTerminator.endIndex
+        } else {
+            // FIXME: Use `CharacterSet.decimalDigits` instead?
+            // `Character.isNumber` is true for more than just decimal characters (e.g. ㊅ and 𝟘), but `CharacterSet.contains(_:)` works only on Unicode scalars.
+            startIndexOfVersionSpecifier = specificationSnippetFromLabelToLineTerminator.firstIndex(where: \.isNumber) ?? specificationWithIgnoredTrailingContents.endIndex
+            /// The label part of the Swift tools version specification with the whitespace sequence between the label and the version specifier.
+            /// - Note: For a misspelt Swift tools version specification `"// swift-too1s-version: 5.3.1"`, the label stops at the second `"o"`, so only `"swift-too"` is recognised as the label with no spacing following it.
+            let labelWithTrailingWhitespace = specificationWithIgnoredTrailingContents[startIndexOfLabel..<startIndexOfVersionSpecifier]
+            // Because there is no whitespace within the label, and because the spacing consists of only horizontal whitespace characters, the end index of the label is the same as the position of the first whitespace character between the beginning of the label and the beginning of the version specifier. If no such whitespace character exists, then there is no spacing, and so this position is the `endIndex` of these sequence of characters (i.e. the starting position of the version specifier).
+            endIndexOfLabel = labelWithTrailingWhitespace.firstIndex(where: \.isWhitespace) ?? startIndexOfVersionSpecifier
+        }
         
         /// The label part of the Swift tools version specification.
         /// - Note: For a misspelt Swift tools version specification `"// swift-too1s-version: 5.3.1"`, the label stops at the second `"o"`, so only `"swift-too"` is recognised as the label.
-        let label = labelWithTrailingWhitespace[..<startIndexOfSpacingAfterLabel]
+        let label = specificationSnippetFromLabelToLineTerminator[startIndexOfLabel..<endIndexOfLabel]
         
         /// The spacing between the label part of the Swift tools version specification and the version specifier.
         /// - Note: For a misspelt Swift tools version specification `"// swift-too1s-version: 5.3.1"`, the label stops at the second `"o"`, and the version specifier starts from the first `"1"`, so no spacing is recognised.
-        let spacingAfterLabel = labelWithTrailingWhitespace[startIndexOfSpacingAfterLabel...]
+        let spacingAfterLabel = specificationSnippetFromLabelToLineTerminator[endIndexOfLabel..<startIndexOfVersionSpecifier]
         
         /// The position of the version specifier's terminator.
         ///
@@ -579,11 +594,11 @@ public class ToolsVersionLoader: ToolsVersionLoaderProtocol {
         //                                                                                                                                          ☝️
         // Technically, this is looking for the position of the first ";" only, not the first line terminator. However, because the Swift tools version specification does not contain any line terminator, we can safely search just the first ";".
         
-        // The version specifier and its terminator together are first found by locating the first numeric character in the specification line, and the version specifier starts with that first numeric character. So, if the version specifier is empty, then the line has no numeric characters, then the specification's ignored trailing contents are empty too. Basically, if the version specifier is empty, then the specification has no ignored trailing contents.
+        // If the label doesn't start with "// swift-too1s-version: 5.3.1", the version specifier and its terminator together are first found by locating the first numeric character in the specification line, and the version specifier starts with that first numeric character. So, if the version specifier is empty, then the line has no numeric characters, then the specification's ignored trailing contents are empty too. Basically, if the version specifier is empty, then the specification has no ignored trailing contents. This is only true for when the label doesn't start with "// swift-too1s-version: 5.3.1".
         
         /// The version specifier.
         /// - Note: For a misspelt Swift tools version specification `"// swift-too1s-version:5.3"`, the first `"1"` is considered as the first character of the version specifier, and so `"1s-version:5.3"` is taken as the version specifier.
-        let versionSpecifier = specificationWithIgnoredTrailingContents[startIndexOfVersionSpecifier..<indexOfVersionSpecifierTerminator]
+        let versionSpecifier = specificationSnippetFromLabelToLineTerminator[startIndexOfVersionSpecifier..<indexOfVersionSpecifierTerminator]
         
         // The tertiary condition checks if the specification line's end index is the same as the manifest's.
         // If it is, then just use the index, because the rest of the manifest is empty, and because using `index(after:)` on it results in an index-out-of-bound error.
@@ -608,22 +623,4 @@ public class ToolsVersionLoader: ToolsVersionLoaderProtocol {
         )
     }
     
-    // This property is preserved only because of the old `split(_:)`.
-    // When the old `split(_:)` is removed, this should be removed too.
-    /// The regex to match swift tools version specification.
-    ///
-    /// The specification must have the following format:
-    /// - It should start with `//` followed by any amount of _horizontal_ whitespace characters.
-    /// - Following that it should contain the case insensitive string `swift-tools-version:`.
-    /// - The text between the above string and `;` or string end becomes the tools version specifier.
-    ///
-    /// There are 2 capture groups in the regex pattern:
-    /// 1. The continuous sequence of whitespace characters between "//" and "swift-tools-version".
-    /// 2. The version specifier.
-    ///
-    /// - Bug: Although any combination of all _horizontal_ whitespace characters should be allowed between `//`and `swift-tools-version:`, currently only a single space (`U+0020`) is allowed.
-    @available(swift, deprecated: 5.3.1)
-    static let regex = try! NSRegularExpression(
-        pattern: "^// swift-tools-version:(.*?)(?:;.*|$)",
-        options: [.caseInsensitive])
 }
diff --git a/Sources/Workspace/ToolsVersionWriter.swift b/Sources/Workspace/ToolsVersionWriter.swift
index af8161feb45..e54d2af41c1 100644
--- a/Sources/Workspace/ToolsVersionWriter.swift
+++ b/Sources/Workspace/ToolsVersionWriter.swift
@@ -22,7 +22,7 @@ public func writeToolsVersion(at path: AbsolutePath, version: ToolsVersion, fs:
     let file = path.appending(component: Manifest.filename)
     assert(fs.isFile(file), "Tools version file not present")
 
-    // Get the current contents of the file.
+    /// The current contents of the file.
     let contents = try fs.readFileContents(file)
 
     let stream = BufferedOutputByteStream()
@@ -33,15 +33,24 @@ public func writeToolsVersion(at path: AbsolutePath, version: ToolsVersion, fs:
         stream <<< "." <<< Format.asJSON(version.patch)
     }
     stream <<< "\n"
-    // Append the file contents except for version specifier line.
-    stream <<< ToolsVersionLoader.split(contents).rest
-	// FIXME: `split(_:)` above has been deprecated.
-	// However, its replacement (commented out below) causes failures in `FunctionTests` and `WorkspaceTests`.
-//	guard let contentsDecodedWithUTF8 = contents.validDescription else {
-//		throw ToolsVersionLoader.Error.nonUTF8EncodedManifest(path: file)
-//	}
-//	// It's safe to force-unwrap, because `contentsDecodedWithUTF8` has been successfully decoded using UTF-8.
-//	stream <<< ToolsVersionLoader.split(contentsDecodedWithUTF8).contentsAfterToolsVersionSpecification.data(using: .utf8)!
+    
+    // The following lines up to line 54 append the file contents except for the Swift tools version specification line.
+    
+    guard let contentsDecodedWithUTF8 = contents.validDescription else {
+        throw ToolsVersionLoader.Error.nonUTF8EncodedManifest(path: file)
+    }
+    
+    let manifestComponents = ToolsVersionLoader.split(contentsDecodedWithUTF8)
+    
+    let toolsVersionSpecificationComponents = manifestComponents.toolsVersionSpecificationComponents
+    
+    // Replace the Swift tools version specification line if and only if it's well-formed up to the version specifier.
+    // This matches the behaviour of the old (now removed) [`ToolsVersionLoader.split(:_)`](https://github.com/WowbaggersLiquidLunch/swift-package-manager/blob/49cfc46bc5defd3ce8e0c0261e3e2cb475bcdb91/Sources/PackageLoading/ToolsVersionLoader.swift#L160).
+    if toolsVersionSpecificationComponents.everythingUpToVersionSpecifierIsWellFormed {
+        stream <<< ByteString(encodingAsUTF8: String(manifestComponents.contentsAfterToolsVersionSpecification))
+    } else {
+        stream <<< contents
+    }
 
     try fs.writeFileContents(file, bytes: stream.bytes)
 }
diff --git a/Tests/PackageLoadingTests/ToolsVersionLoaderTests.swift b/Tests/PackageLoadingTests/ToolsVersionLoaderTests.swift
index 921b5bbafca..794fced487f 100644
--- a/Tests/PackageLoadingTests/ToolsVersionLoaderTests.swift
+++ b/Tests/PackageLoadingTests/ToolsVersionLoaderTests.swift
@@ -273,7 +273,7 @@ class ToolsVersionLoaderTests: XCTestCase {
                 }
                 XCTAssertEqual(
                     error.description,
-                    "the Swift tools version specification is missing a version specifier; consider appending '\(ToolsVersion.currentToolsVersion)' to the line to specify the current Swift toolchain version as the lowest Swift version supported by the project"
+                    "the Swift tools version specification is possibly missing a version specifier; consider using 'swift-tools-version:\(ToolsVersion.currentToolsVersion)' to specify the current Swift toolchain version as the lowest Swift version supported by the project"
                 )
             }
         }
@@ -345,6 +345,9 @@ class ToolsVersionLoaderTests: XCTestCase {
             "// swift-tools-version:5²",
             "// swift-tools-version:5⃣️.2⃣️",
             "// swift-tools-version:5 ÷ 2 = 2.5",
+            // If the label starts with exactly "swift-tools-version:" (case-insensitive), then all its misspellings are treated as the version specifier's.
+            "// swift-tools-version::5.2",
+            "// Swift-tOOls-versIon:-2.5",
             // Misspelt version specifiers are diagnosed before backward-compatibility checks.
             "\u{A}\u{B}\u{C}\u{D}//\u{3000}swift-tools-version:五.二\u{2028}",
         ]