Merge pull request #5 from apple/update

Sync with SwiftPM trunk

Author: aciidgh

.gitignore

@@ -3,3 +3,4 @@
 /Packages
 /*.xcodeproj
 xcuserdata/
+.swiftpm

Package.swift

@@ -1,4 +1,4 @@
-// swift-tools-version:4.2
+// swift-tools-version:5.1
 
 /*
  This source file is part of the Swift.org open source project

Sources/TSCBasic/DictionaryLiteralExtensions.swift

@@ -11,7 +11,7 @@
 // Can't conform a protocol explicitly with certain where clause for now but it'd be resolved by SE-0143.
 // ref: https://github.com/apple/swift-evolution/blob/master/proposals/0143-conditional-conformances.md
 // MARK: CustomStringConvertible
-extension DictionaryLiteral where Key: CustomStringConvertible, Value: CustomStringConvertible {
+extension KeyValuePairs where Key: CustomStringConvertible, Value: CustomStringConvertible {
     /// A string that represents the contents of the dictionary literal.
     public var description: String {
         let lastCount = self.count - 1
@@ -25,8 +25,8 @@ extension DictionaryLiteral where Key: CustomStringConvertible, Value: CustomStr
 }
 
 // MARK: Equatable
-extension DictionaryLiteral where Key: Equatable, Value: Equatable {
-    public static func ==(lhs: DictionaryLiteral<Key,Value>, rhs: DictionaryLiteral<Key,Value>) -> Bool {
+extension KeyValuePairs where Key: Equatable, Value: Equatable {
+    public static func ==(lhs: KeyValuePairs<Key,Value>, rhs: KeyValuePairs<Key,Value>) -> Bool {
         if lhs.count != rhs.count {
             return false
         }

Sources/TSCBasic/FileSystem.swift

@@ -665,7 +665,7 @@ public class InMemoryFileSystem: FileSystem {
         // Ignore root and get the parent node's content if its a directory.
         guard !path.isRoot,
               let parent = try? getNode(path.parentDirectory),
-              case .directory(let contents)? = parent?.contents else {
+            case .directory(let contents) = parent.contents else {
             return
         }
         // Set it to nil to release the contents.

Sources/TSCBasic/GraphAlgorithms.swift

@@ -121,7 +121,7 @@ public func findCycle<T: Hashable>(
     func visit(_ node: T, _ successors: (T) throws -> [T]) rethrows -> (path: [T], cycle: [T])? {
         // If this node is already in the current path then we have found a cycle.
         if !path.append(node) {
-            let index = path.index(of: node)!
+            let index = path.firstIndex(of: node)!
             return (Array(path[path.startIndex..<index]), Array(path[index..<path.endIndex]))
         }
 

Sources/TSCBasic/JSON.swift

@@ -45,7 +45,7 @@ public enum JSON {
     case dictionary([String: JSON])
 
     /// An ordered dictionary.
-    case orderedDictionary(DictionaryLiteral<String, JSON>)
+    case orderedDictionary(KeyValuePairs<String, JSON>)
 }
 
 /// A JSON representation of an element.
@@ -262,7 +262,7 @@ extension JSON {
 
     /// Load a JSON item from a byte string.
     public init(bytes: ByteString) throws {
-        try self.init(data: Data(bytes: bytes.contents))
+        try self.init(data: Data(bytes.contents))
     }
 
     /// Convenience initalizer for UTF8 encoded strings.

Sources/TSCBasic/JSONMapper.swift

@@ -41,7 +41,10 @@ extension JSON {
 
     /// Returns an optional JSON mappable object from a given key.
     public func get<T: JSONMappable>(_ key: String) -> T? {
-        return try? get(key)
+        if let object: JSON = try? get(key) {
+            return try? T.init(json: object)
+        }
+        return nil
     }
 
     /// Returns a JSON mappable array from a given key.

Sources/TSCBasic/OrderedDictionary.swift

@@ -75,7 +75,7 @@ public struct OrderedDictionary<Key: Hashable, Value> {
             return nil
         }
         dict[key] = nil
-        array.remove(at: array.index(of: key)!)
+        array.remove(at: array.firstIndex(of: key)!)
         return value
     }
 

Sources/TSCBasic/OrderedSet.swift

@@ -98,7 +98,7 @@ public struct OrderedSet<E: Hashable>: Equatable, Collection {
         let _removedElement = set.remove(element)
         guard let removedElement = _removedElement else { return nil }
 
-        let idx = array.index(of: element)!
+        let idx = array.firstIndex(of: element)!
         array.remove(at: idx)
 
         return removedElement

Sources/TSCBasic/StringConversions.swift

@@ -45,12 +45,12 @@ extension String {
     public func spm_shellEscaped() -> String {
 
         // If all the characters in the string are in whitelist then no need to escape.
-        guard let pos = utf8.index(where: { !inShellWhitelist($0) }) else {
+        guard let pos = utf8.firstIndex(where: { !inShellWhitelist($0) }) else {
             return self
         }
 
         // If there are no single quotes then we can just wrap the string around single quotes.
-        guard let singleQuotePos = utf8[pos...].index(of: UInt8(ascii: "'")) else {
+        guard let singleQuotePos = utf8[pos...].firstIndex(of: UInt8(ascii: "'")) else {
             return "'" + self + "'"
         }
 

Sources/TSCUtility/PkgConfig.swift

@@ -200,7 +200,7 @@ struct PkgConfigParser {
 
     mutating func parse() throws {
         func removeComment(line: String) -> String {
-            if let commentIndex = line.index(of: "#") {
+            if let commentIndex = line.firstIndex(of: "#") {
                 return String(line[line.startIndex..<commentIndex])
             }
             return line
@@ -321,9 +321,9 @@ struct PkgConfigParser {
         // We make sure it of form ${name} otherwise it is not a variable.
         func findVariable(_ fragment: String)
             -> (name: String, startIndex: String.Index, endIndex: String.Index)? {
-            guard let dollar = fragment.index(of: "$"),
+            guard let dollar = fragment.firstIndex(of: "$"),
                   dollar != fragment.endIndex && fragment[fragment.index(after: dollar)] == "{",
-                  let variableEndIndex = fragment.index(of: "}")
+                  let variableEndIndex = fragment.firstIndex(of: "}")
             else { return nil }
             return (String(fragment[fragment.index(dollar, offsetBy: 2)..<variableEndIndex]), dollar, variableEndIndex)
         }

Sources/TSCUtility/Version.swift

@@ -110,8 +110,8 @@ public extension Version {
     /// - Parameters:
     ///   - string: The string to parse.
     init?(string: String) {
-        let prereleaseStartIndex = string.index(of: "-")
-        let metadataStartIndex = string.index(of: "+")
+        let prereleaseStartIndex = string.firstIndex(of: "-")
+        let metadataStartIndex = string.firstIndex(of: "+")
 
         let requiredEndIndex = prereleaseStartIndex ?? metadataStartIndex ?? string.endIndex
         let requiredCharacters = string.prefix(upTo: requiredEndIndex)

Tests/TSCBasicTests/DictionaryLiteralExtensionsTests.swift

@@ -14,17 +14,17 @@ import TSCBasic
 class DictionaryLiteralExtensionsTests: XCTestCase {
 
     func testDescription() {
-        XCTAssertEqual(DictionaryLiteral(dictionaryLiteral: ("foo", 1)).description, "[foo: 1]")
-        XCTAssertEqual(DictionaryLiteral(dictionaryLiteral: ("foo", 1), ("bar", 2)).description, "[foo: 1, bar: 2]")
+        XCTAssertEqual(KeyValuePairs(dictionaryLiteral: ("foo", 1)).description, "[foo: 1]")
+        XCTAssertEqual(KeyValuePairs(dictionaryLiteral: ("foo", 1), ("bar", 2)).description, "[foo: 1, bar: 2]")
     }
 
     func testEquality() {
-        XCTAssertTrue(DictionaryLiteral(dictionaryLiteral: ("foo", 1)) == DictionaryLiteral(dictionaryLiteral: ("foo", 1)))
-        XCTAssertTrue(DictionaryLiteral(dictionaryLiteral: ("foo", 1), ("bar", 2)) == DictionaryLiteral(dictionaryLiteral: ("foo", 1), ("bar", 2)))
+        XCTAssertTrue(KeyValuePairs(dictionaryLiteral: ("foo", 1)) == KeyValuePairs(dictionaryLiteral: ("foo", 1)))
+        XCTAssertTrue(KeyValuePairs(dictionaryLiteral: ("foo", 1), ("bar", 2)) == KeyValuePairs(dictionaryLiteral: ("foo", 1), ("bar", 2)))
 
-        XCTAssertFalse(DictionaryLiteral(dictionaryLiteral: ("no-foo", 1), ("bar", 2)) == DictionaryLiteral(dictionaryLiteral: ("foo", 1), ("bar", 2)))
-        XCTAssertFalse(DictionaryLiteral(dictionaryLiteral: ("foo", 0), ("bar", 2)) == DictionaryLiteral(dictionaryLiteral: ("foo", 1), ("bar", 2)))
-        XCTAssertFalse(DictionaryLiteral(dictionaryLiteral: ("foo", 1), ("bar", 2), ("hoge", 3)) == DictionaryLiteral(dictionaryLiteral: ("foo", 1), ("bar", 2)))
-        XCTAssertFalse(DictionaryLiteral(dictionaryLiteral: ("foo", 1), ("bar", 2)) == DictionaryLiteral(dictionaryLiteral: ("bar", 2), ("foo", 1)))
+        XCTAssertFalse(KeyValuePairs(dictionaryLiteral: ("no-foo", 1), ("bar", 2)) == KeyValuePairs(dictionaryLiteral: ("foo", 1), ("bar", 2)))
+        XCTAssertFalse(KeyValuePairs(dictionaryLiteral: ("foo", 0), ("bar", 2)) == KeyValuePairs(dictionaryLiteral: ("foo", 1), ("bar", 2)))
+        XCTAssertFalse(KeyValuePairs(dictionaryLiteral: ("foo", 1), ("bar", 2), ("hoge", 3)) == KeyValuePairs(dictionaryLiteral: ("foo", 1), ("bar", 2)))
+        XCTAssertFalse(KeyValuePairs(dictionaryLiteral: ("foo", 1), ("bar", 2)) == KeyValuePairs(dictionaryLiteral: ("bar", 2), ("foo", 1)))
     }
 }

Tests/TSCBasicTests/PathShimTests.swift

@@ -70,7 +70,7 @@ class WalkTests : XCTestCase {
             AbsolutePath("/sbin")
         ]
         for x in try! walk(AbsolutePath("/"), recursively: false) {
-            if let i = expected.index(of: x) {
+            if let i = expected.firstIndex(of: x) {
                 expected.remove(at: i)
             }
             XCTAssertEqual(2, x.components.count)
@@ -81,11 +81,11 @@ class WalkTests : XCTestCase {
     func testRecursive() {
         let root = AbsolutePath(#file).parentDirectory.parentDirectory.parentDirectory.appending(component: "Sources")
         var expected = [
-            root.appending(component: "Build"),
-            root.appending(component: "Commands")
+            root.appending(component: "TSCBasic"),
+            root.appending(component: "TSCUtility")
         ]
         for x in try! walk(root) {
-            if let i = expected.index(of: x) {
+            if let i = expected.firstIndex(of: x) {
                 expected.remove(at: i)
             }
         }

Tests/TSCBasicTests/PathShimTests.swift.orig

@@ -0,0 +1,132 @@
+/*
+ This source file is part of the Swift.org open source project
+
+ Copyright (c) 2014 - 2017 Apple Inc. and the Swift project authors
+ Licensed under Apache License v2.0 with Runtime Library Exception
+
+ See http://swift.org/LICENSE.txt for license information
+ See http://swift.org/CONTRIBUTORS.txt for Swift project authors
+*/
+
+import Foundation
+import XCTest
+
+import TSCBasic
+
+class PathShimTests : XCTestCase {
+
+    func testResolvingSymlinks() {
+        // Make sure the root path resolves to itself.
+        XCTAssertEqual(resolveSymlinks(AbsolutePath.root), AbsolutePath.root)
+
+        // For the rest of the tests we'll need a temporary directory.
+        try! withTemporaryDirectory(removeTreeOnDeinit: true) { path in
+            // FIXME: it would be better to not need to resolve symbolic links, but we end up relying on /tmp -> /private/tmp.
+            let tmpDirPath = resolveSymlinks(path)
+
+            // Create a symbolic link and directory.
+            let slnkPath = tmpDirPath.appending(component: "slnk")
+            let fldrPath = tmpDirPath.appending(component: "fldr")
+
+            // Create a symbolic link pointing at the (so far non-existent) directory.
+            try! createSymlink(slnkPath, pointingAt: fldrPath, relative: true)
+
+            // Resolving the symlink should not yet change anything.
+            XCTAssertEqual(resolveSymlinks(slnkPath), slnkPath)
+
+            // Create a directory to be the referent of the symbolic link.
+            try! makeDirectories(fldrPath)
+
+            // Resolving the symlink should now point at the directory.
+            XCTAssertEqual(resolveSymlinks(slnkPath), fldrPath)
+
+            // Resolving the directory should still not change anything.
+            XCTAssertEqual(resolveSymlinks(fldrPath), fldrPath)
+        }
+    }
+
+    func testRescursiveDirectoryCreation() {
+        // For the tests we'll need a temporary directory.
+        try! withTemporaryDirectory(removeTreeOnDeinit: true) { path in
+            // Create a directory under several ancestor directories.
+            let dirPath = path.appending(components: "abc", "def", "ghi", "mno", "pqr")
+            try! makeDirectories(dirPath)
+
+            // Check that we were able to actually create the directory.
+            XCTAssertTrue(localFileSystem.isDirectory(dirPath))
+
+            // Check that there's no error if we try to create the directory again.
+            try! makeDirectories(dirPath)
+        }
+    }
+}
+
+class WalkTests : XCTestCase {
+
+    func testNonRecursive() {
+        var expected = [
+            AbsolutePath("/usr"),
+            AbsolutePath("/bin"),
+            AbsolutePath("/sbin")
+        ]
+        for x in try! walk(AbsolutePath("/"), recursively: false) {
+            if let i = expected.firstIndex(of: x) {
+                expected.remove(at: i)
+            }
+            XCTAssertEqual(2, x.components.count)
+        }
+        XCTAssertEqual(expected.count, 0)
+    }
+
+    func testRecursive() {
+        let root = AbsolutePath(#file).parentDirectory.parentDirectory.parentDirectory.appending(component: "Sources")
+        var expected = [
+            root.appending(component: "Build"),
+            root.appending(component: "Commands")
+        ]
+        for x in try! walk(root) {
+            if let i = expected.firstIndex(of: x) {
+                expected.remove(at: i)
+            }
+        }
+        XCTAssertEqual(expected, [])
+    }
+
+    func testSymlinksNotWalked() {
+        try! withTemporaryDirectory(removeTreeOnDeinit: true) { path in
+            // FIXME: it would be better to not need to resolve symbolic links, but we end up relying on /tmp -> /private/tmp.
+            let tmpDirPath = resolveSymlinks(path)
+
+            try! makeDirectories(tmpDirPath.appending(component: "foo"))
+            try! makeDirectories(tmpDirPath.appending(components: "bar", "baz", "goo"))
+            try! createSymlink(tmpDirPath.appending(components: "foo", "symlink"), pointingAt: tmpDirPath.appending(component: "bar"), relative: true)
+
+            XCTAssertTrue(localFileSystem.isSymlink(tmpDirPath.appending(components: "foo", "symlink")))
+            XCTAssertEqual(resolveSymlinks(tmpDirPath.appending(components: "foo", "symlink")), tmpDirPath.appending(component: "bar"))
+            XCTAssertTrue(localFileSystem.isDirectory(resolveSymlinks(tmpDirPath.appending(components: "foo", "symlink", "baz"))))
+
+            let results = try! walk(tmpDirPath.appending(component: "foo")).map{ $0 }
+
+            XCTAssertEqual(results, [tmpDirPath.appending(components: "foo", "symlink")])
+        }
+    }
+
+    func testWalkingADirectorySymlinkResolvesOnce() {
+        try! withTemporaryDirectory(removeTreeOnDeinit: true) { tmpDirPath in
+            try! makeDirectories(tmpDirPath.appending(components: "foo", "bar"))
+            try! makeDirectories(tmpDirPath.appending(components: "abc", "bar"))
+            try! createSymlink(tmpDirPath.appending(component: "symlink"), pointingAt: tmpDirPath.appending(component: "foo"), relative: true)
+            try! createSymlink(tmpDirPath.appending(components: "foo", "baz"), pointingAt: tmpDirPath.appending(component: "abc"), relative: true)
+
+            XCTAssertTrue(localFileSystem.isSymlink(tmpDirPath.appending(component: "symlink")))
+
+            let results = try! walk(tmpDirPath.appending(component: "symlink")).map{ $0 }.sorted()
+
+            // we recurse a symlink to a directory, so this should work,
+            // but `abc` should not show because `baz` is a symlink too
+            // and that should *not* be followed
+
+            XCTAssertEqual(results, [tmpDirPath.appending(components: "symlink", "bar"), tmpDirPath.appending(components: "symlink", "baz")])
+        }
+    }
+}