Merge pull request #1 from apple/master

merge upstream

Author: sjavora

Sources/SwiftDriver/Driver/ToolExecutionDelegate.swift

@@ -51,11 +51,10 @@ public struct ToolExecutionDelegate: JobExecutorDelegate {
   public func jobFinished(job: Job, result: ProcessResult, pid: Int) {
     switch mode {
     case .regular, .verbose:
-      // FIXME: Check what the current driver does.
       let output = (try? result.utf8Output() + result.utf8stderrOutput()) ?? ""
       if !output.isEmpty {
-        stdoutStream <<< output
-        stdoutStream.flush()
+        stderrStream <<< output
+        stderrStream.flush()
       }
 
     case .parsableOutput:

Sources/SwiftDriver/Options/OptionParsing.swift

@@ -9,7 +9,7 @@
 // See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
 //
 //===----------------------------------------------------------------------===//
-public enum OptionParseError : Error {
+public enum OptionParseError : Error, Equatable {
   case unknownOption(index: Int, argument: String)
   case missingArgument(index: Int, argument: String)
 }

Sources/SwiftDriver/Utilities/PrefixTrie.swift

@@ -57,21 +57,36 @@ public struct PrefixTrie<Key: Collection, Value> where Key.Element: Hashable {
     set {
       var index = key.startIndex
       var current = root
+      // Keep track of which nodes we've visited along the way,
+      // so we can walk back up this if we need to prune dead branches.
+      // Note: This is only used (and is only appended to) if the new
+      //       value being stored is `nil`.
+      var traversed: [(parent: Node, step: Key.Element)] = []
 
       // Traverse as much of the prefix as we can, keeping track of the index
       // we ended on
       while index < key.endIndex, let next = current.next[key[index]] {
+        if newValue == nil {
+            traversed.append((current, key[index]))
+        }
+
         key.formIndex(after: &index)
         current = next
       }
 
       // We're matching a prefix of an existing key in the trie
       if index == key.endIndex {
         // Update the value in the trie with the new value
-
-        // FIXME: If `newValue` is `nil`, we won't clean up intermediate entries
-        //        in the trie.
         current.value = newValue
+        // remove dead nodes if the current child is a leaf
+        if newValue == nil && current.next.keys.count == 0 {
+          self.pruneEmptyBranchesIfNeeded(traversed)
+        }
+        return
+      }
+
+      // If the value we're adding is `nil` just return and don't create the trie
+      guard newValue != nil else {
         return
       }
 
@@ -87,4 +102,32 @@ public struct PrefixTrie<Key: Collection, Value> where Key.Element: Hashable {
       }
     }
   }
+
+
+  /// Given a list of nodes starting from a root node to any other node along a branch,
+  /// prune the branch of any dead nodes along the way.
+  private func pruneEmptyBranchesIfNeeded(_ traversed: [(parent: Node, step: Key.Element)]) {
+    for (parent, step) in traversed.reversed() {
+      // find the first parent with a value or more than one child.
+      // If we traversed up to the root then chop everything regarless.
+      if parent.value != nil || parent.next.keys.count > 1 || parent === traversed.first!.parent {
+        parent.next[step] = nil
+        break
+      }
+    }
+  }
+
+  /// Returns the number of nodes in the trie
+  public var nodeCount: Int {
+
+      var count = 0
+
+      var nodes = [self.root]
+      while let currentNode = nodes.popLast() {
+          nodes.append(contentsOf: currentNode.next.values)
+          count += currentNode.next.keys.count
+      }
+
+      return count
+  }
 }

Tests/SwiftDriverTests/PrefixTrieTests.swift

@@ -4,11 +4,17 @@ import SwiftDriver
 final class PrefixTrieTests: XCTestCase {
   func testSimpleTrie() {
     var trie = PrefixTrie<String, Int>()
+
+    trie["1234"] = nil
+    XCTAssertEqual(trie.nodeCount, 0)
+
     trie["a"] = 0
     trie["b"] = 1
     trie["abcd"] = 2
     trie["abc"] = 3
 
+    XCTAssertEqual(trie.nodeCount, 5)
+
     XCTAssertEqual(trie["a"], 0)
     XCTAssertEqual(trie["ab"], 0)
     XCTAssertEqual(trie["b"], 1)
@@ -37,6 +43,7 @@ final class PrefixTrieTests: XCTestCase {
   }
 
   func testUpdating() {
+
     var trie = PrefixTrie<String, Int>()
     trie["garbage"] = 0
     XCTAssertEqual(trie["garbage"], 0)
@@ -46,6 +53,23 @@ final class PrefixTrieTests: XCTestCase {
 
     trie["garbage"] = nil
     XCTAssertNil(trie["garbage"])
+    XCTAssertEqual(trie.nodeCount, 0)
+
+    trie["12345"] = 12345 // 5 nodes
+    trie["12367"] = 12367 // 3 common nodes, 2 new nodes
+    XCTAssertEqual(trie.nodeCount, 7)
+    trie["123890"] = 123890 // 3 common nodes, 3 new nodes
+    XCTAssertEqual(trie.nodeCount, 10)
+    trie["123890"] = nil
+    XCTAssertEqual(trie.nodeCount, 7)
+    XCTAssertNil(trie["123890"])
+    trie["abc"] = 979899 // 3 new nodes, 0 common nodes
+    XCTAssertEqual(trie.nodeCount, 10)
+    // existing prefix that cannot be deleted since
+    // 12345 & 12367 exist
+    trie["123"] = nil
+    XCTAssertEqual(trie.nodeCount, 10)
+
   }
 
   func testCollectionMatching() {

Tests/SwiftDriverTests/SwiftDriverTests.swift

@@ -30,10 +30,21 @@ final class SwiftDriverTests: XCTestCase {
   func testParseErrors() {
     let options = OptionTable()
 
-    // FIXME: Check for the exact form of the error
-    XCTAssertThrowsError(try options.parse(["-unrecognized"]))
-    XCTAssertThrowsError(try options.parse(["-I"]))
-    XCTAssertThrowsError(try options.parse(["-module-name"]))
+    XCTAssertThrowsError(try options.parse(["-unrecognized"])) { error in
+      XCTAssertEqual(error as? OptionParseError, .unknownOption(index: 0, argument: "-unrecognized"))
+    }
+
+    XCTAssertThrowsError(try options.parse(["-I"])) { error in
+      XCTAssertEqual(error as? OptionParseError, .missingArgument(index: 0, argument: "-I"))
+    }
+
+    XCTAssertThrowsError(try options.parse(["-color-diagnostics", "-I"])) { error in
+      XCTAssertEqual(error as? OptionParseError, .missingArgument(index: 1, argument: "-I"))
+    }
+
+    XCTAssertThrowsError(try options.parse(["-module-name"])) { error in
+      XCTAssertEqual(error as? OptionParseError, .missingArgument(index: 0, argument: "-module-name"))
+    }
   }
 
   func testDriverKindParsing() throws {