     // from one path separator to the next on-demand.
     //
     var components: [String] {
-#if os(Windows)
         let normalized: UnsafePointer<Int8> = string.fileSystemRepresentation
         defer { normalized.deallocate() }
 
         return String(cString: normalized).components(separatedBy: "\\").filter { !$0.isEmpty }
-#else
-        // FIXME: This isn't particularly efficient; needs optimization, and
-        // in fact, it might well be best to return a custom iterator so we
-        // don't have to allocate everything up-front.  It would be backed by
-        // the path string and just return a slice at a time.
-        let components = string.components(separatedBy: "/").filter({ !$0.isEmpty })
-
-        if string.hasPrefix("/") {
-            return ["/"] + components
-        } else {
-            return components
-        }
-#endif
-    }
-
-    var parentDirectory: UNIXPath {
+    }
+
+    var parentDirectory: Self {
         return self == .root ? self : Self(string: dirname)
     }
 


        // If the result is empty, return `.`, otherwise we return it as a string.
        self.init(string: result.isEmpty ? "." : result)
      #endif
    }

    init(validatingAbsolutePath path: String) throws {
      #if os(Windows)
        let fsr: UnsafePointer<Int8> = path.fileSystemRepresentation
        defer { fsr.deallocate() }

        let realpath = String(cString: fsr)
        if !UNIXPath.isAbsolutePath(realpath) {
            throw PathValidationError.invalidAbsolutePath(path)
        }
        self.init(normalizingAbsolutePath: path)
      #else
        switch path.first {
        case "/":
            self.init(normalizingAbsolutePath: path)

        }
        // If we get this far, there is no suffix.
        return nil
    }

    func appending(component name: String) -> Self {
        assert(!name.contains("/"), "\(name) is invalid path component")

        // Handle pseudo paths.
