[xcodegen] Match common prefix in CommandArgTree

Rather than forming a set intersection, only look for a common prefix
with the parent arguments. This is both quicker and more correct
since arguments can be order-dependent. This does mean we'll end up
with more per-file arguments for "umbrella" targets, but that at
least will no longer prevent us from forming buildable folders for
them.

Author: hamishknight

utils/swift-xcodegen/Sources/SwiftXcodeGen/BuildArgs/ClangBuildArgsProvider.swift

@@ -58,17 +58,16 @@ struct ClangBuildArgsProvider {
 
   /// Retrieve the arguments at a given path, including those in the parent.
   func getArgs(for path: RelativePath) -> BuildArgs {
-    // Sort the arguments to get a deterministic ordering.
     // FIXME: We ought to get the command from the arg tree.
-    .init(for: .clang, args: args.getArgs(for: path).sorted())
+    .init(for: .clang, args: args.getArgs(for: path))
   }
 
   /// Retrieve the arguments at a given path, excluding those already covered
   /// by a parent.
   func getUniqueArgs(
     for path: RelativePath, parent: RelativePath, infer: Bool = false
   ) -> BuildArgs {
-    var fileArgs: Set<Command.Argument> = []
+    var fileArgs: [Command.Argument] = []
     if hasBuildArgs(for: path) {
       fileArgs = args.getUniqueArgs(for: path, parent: parent)
     } else if infer {
@@ -78,14 +77,8 @@ struct ClangBuildArgsProvider {
         fileArgs = args.getUniqueArgs(for: component, parent: parent)
       }
     }
-    // Sort the arguments to get a deterministic ordering.
     // FIXME: We ought to get the command from the arg tree.
-    return .init(for: .clang, args: fileArgs.sorted())
-  }
-
-  /// Whether the given path has any unique args not covered by `parent`.
-  func hasUniqueArgs(for path: RelativePath, parent: RelativePath) -> Bool {
-    args.hasUniqueArgs(for: path, parent: parent)
+    return .init(for: .clang, args: fileArgs)
   }
 
   /// Whether the given file has build arguments.

utils/swift-xcodegen/Sources/SwiftXcodeGen/BuildArgs/CommandArgTree.swift

@@ -11,49 +11,43 @@
 //===----------------------------------------------------------------------===//
 
 /// A tree of compile command arguments, indexed by path such that those unique
-/// to a particular file can be queried, with common arguments associated
-/// with a common parent.
+/// to a particular file can be queried, with common-prefixed arguments
+/// associated with a common parent.
 struct CommandArgTree {
-  private var storage: [RelativePath: Set<Command.Argument>]
+  private var storage: [RelativePath: [Command.Argument]]
 
   init() {
     self.storage = [:]
   }
 
   mutating func insert(_ args: [Command.Argument], for path: RelativePath) {
-    let args = Set(args)
     for component in path.stackedComponents {
       // If we haven't added any arguments, add them. If we're adding arguments
       // for the file itself, this is the only way we'll add arguments,
-      // otherwise we can form an intersection with the other arguments.
+      // otherwise we can form a common prefix with the other arguments.
       let inserted = storage.insertValue(args, for: component)
       guard !inserted && component != path else { continue }
 
-      // We use subscript(_:default:) to mutate in-place without CoW.
-      storage[component, default: []].formIntersection(args)
+      // We use withValue(for:default:) to mutate in-place without CoW.
+      storage.withValue(for: component, default: []) { existingArgs in
+        let slice = existingArgs.commonPrefix(with: args)
+        existingArgs.removeSubrange(slice.endIndex...)
+      }
     }
   }
 
   /// Retrieve the arguments at a given path, including those in the parent.
-  func getArgs(for path: RelativePath) -> Set<Command.Argument> {
+  func getArgs(for path: RelativePath) -> [Command.Argument] {
     storage[path] ?? []
   }
 
   /// Retrieve the arguments at a given path, excluding those already covered
   /// by a given parent.
   func getUniqueArgs(
     for path: RelativePath, parent: RelativePath
-  ) -> Set<Command.Argument> {
-    getArgs(for: path).subtracting(getArgs(for: parent))
-  }
-
-  /// Whether the given path has any unique args not covered by `parent`.
-  func hasUniqueArgs(for path: RelativePath, parent: RelativePath) -> Bool {
-    let args = getArgs(for: path)
-    guard !args.isEmpty else { return false }
-    // Assuming `parent` is an ancestor of path, the arguments for parent is
-    // guaranteed to be a subset of the arguments for `path`. As such, we
-    // only have to compare sizes here.
-    return args.count != getArgs(for: parent).count
+  ) -> [Command.Argument] {
+    let childArgs = getArgs(for: path)
+    let parentArgs = getArgs(for: parent)
+    return Array(childArgs[parentArgs.count...])
   }
 }

utils/swift-xcodegen/Sources/SwiftXcodeGen/Command/Command.swift

@@ -240,47 +240,3 @@ extension Command.Flag: CustomStringConvertible {
 extension Command.Option: CustomStringConvertible {
   var description: String { printed }
 }
-
-// MARK: Comparable
-// We sort the resulting command-line arguments to ensure deterministic
-// ordering.
-
-extension Command.Flag: Comparable {
-  static func < (lhs: Self, rhs: Self) -> Bool {
-    guard lhs.dash == rhs.dash else {
-      return lhs.dash < rhs.dash
-    }
-    return lhs.name.rawValue < rhs.name.rawValue
-  }
-}
-
-extension Command.Option: Comparable {
-  static func < (lhs: Self, rhs: Self) -> Bool {
-    guard lhs.flag == rhs.flag else {
-      return lhs.flag < rhs.flag
-    }
-    guard lhs.spacing == rhs.spacing else {
-      return lhs.spacing < rhs.spacing
-    }
-    return lhs.value < rhs.value
-  }
-}
-
-extension Command.Argument: Comparable {
-  static func < (lhs: Self, rhs: Self) -> Bool {
-    switch (lhs, rhs) {
-    // Sort flags < options < values
-    case (.flag, .option):  true
-    case (.flag, .value):   true
-    case (.option, .value): true
-
-    case (.option, .flag):  false
-    case (.value, .flag):   false
-    case (.value, .option): false
-
-    case (.flag(let lhs), .flag(let rhs)):     lhs < rhs
-    case (.option(let lhs), .option(let rhs)): lhs < rhs
-    case (.value(let lhs), .value(let rhs)):   lhs < rhs
-    }
-  }
-}

utils/swift-xcodegen/Sources/SwiftXcodeGen/Utils.swift

@@ -34,6 +34,18 @@ extension Sequence {
   }
 }
 
+extension Collection where Element: Equatable {
+  func commonPrefix(with other: some Collection<Element>) -> SubSequence {
+    var (i, j) = (self.startIndex, other.startIndex)
+    while i < self.endIndex, j < other.endIndex {
+      guard self[i] == other[j] else { break }
+      self.formIndex(after: &i)
+      other.formIndex(after: &j)
+    }
+    return self[..<i]
+  }
+}
+
 extension String {
   init(utf8 buffer: UnsafeRawBufferPointer) {
     guard !buffer.isEmpty else {