cleanup

Author: tomerd

Sources/TSCBasic/Path.swift

@@ -240,33 +240,6 @@ public struct RelativePath: Hashable, Sendable {
         _impl = impl
     }
 
-    /// Private initializer for constructing a relative path without performing
-    /// normalization or canonicalization.  This will construct a path without
-    /// an anchor and thus may be invalid.
-    ///
-    /*
-    fileprivate init(unsafeUncheckedPath string: String) {
-        self.init(PathImpl(string: string))
-    }*/
-
-    /// Initializes the RelativePath from `str`, which must be a relative path
-    /// (which means that it must not begin with a path separator or a tilde).
-    /// An empty input path is allowed, but will be normalized to a single `.`
-    /// character.  The input string will be normalized if needed, as described
-    /// in the documentation for RelativePath.
-    /*public init(_ string: String) {
-        // Normalize the relative string and store it as our Path.
-        self.init(PathImpl(normalizingRelativePath: string))
-    }*/
-
-    /*
-    public init(static path: StaticString) {
-        let pathString = path.withUTF8Buffer {
-            String(decoding: $0, as: UTF8.self)
-        }
-        try! self.init(validating: pathString)
-    }*/
-
     /// Convenience initializer that verifies that the path is relative.
     public init(validating path: String) throws {
         try self.init(PathImpl(validatingRelativePath: path))
@@ -441,12 +414,6 @@ protocol Path: Hashable {
     /// Creates a path from its normalized string representation.
     init(string: String)
 
-    /// Creates a path from an absolute string representation and normalizes it.
-    //init(normalizingAbsolutePath: String)
-
-    /// Creates a path from an relative string representation and normalizes it.
-    //init(normalizingRelativePath: String)
-
     /// Creates a path from a string representation, validates that it is a valid absolute path and normalizes it.
     init(validatingAbsolutePath: String) throws
 
@@ -539,33 +506,6 @@ private struct WindowsPath: Path, Sendable {
         self.string = string
     }
 
-    /*
-    init(normalizingAbsolutePath path: String) {
-        let normalized: UnsafePointer<Int8> = path.fileSystemRepresentation
-        defer { normalized.deallocate() }
-
-        self.init(string: String(cString: normalized)
-                              .withCString(encodedAs: UTF16.self) { pwszPath in
-          var canonical: PWSTR!
-          _ = PathAllocCanonicalize(pwszPath,
-                                    ULONG(PATHCCH_ALLOW_LONG_PATHS.rawValue),
-                                    &canonical)
-          return String(decodingCString: canonical, as: UTF16.self)
-        })
-    }
-
-    init(normalizingRelativePath path: String) {
-        if path.isEmpty || path == "." {
-            self.init(string: ".")
-        } else {
-            var buffer: [WCHAR] = Array<WCHAR>(repeating: 0, count: Int(MAX_PATH + 1))
-            _ = path.replacingOccurrences(of: "/", with: "\\").withCString(encodedAs: UTF16.self) {
-                PathCanonicalizeW(&buffer, $0)
-            }
-            self.init(string: String(decodingCString: buffer, as: UTF16.self))
-        }
-    }*/
-
     init(validatingAbsolutePath path: String) throws {
         let fsr: UnsafePointer<Int8> = path.fileSystemRepresentation
         defer { fsr.deallocate() }
@@ -842,7 +782,7 @@ private struct UNIXPath: Path, Sendable {
 
     init(validatingRelativePath path: String) throws {
         switch path.first {
-        case "/": //, "~":
+        case "/":
             throw PathValidationError.invalidRelativePath(path)
         default:
             self.init(normalizingRelativePath: path)

Sources/TSCTestSupport/FileSystemExtensions.swift

@@ -82,7 +82,7 @@ extension AbsolutePath {
         try! self.init(validating: pathString)
     }
 
-    @available(*, deprecated, message: "use init(static: relativeTo:) instead")
+    @available(*, deprecated, message: "use init(: relativeTo:) instead")
     public init(path: StaticString, relativeTo basePath: AbsolutePath) {
         let pathString = path.withUTF8Buffer {
             String(decoding: $0, as: UTF8.self)