6.2 merge main

Package.swift

@@ -1022,7 +1022,7 @@ func swiftSyntaxDependencies(_ names: [String]) -> [Target.Dependency] {
 // this right now.
 
 /// When not using local dependencies, the branch to use for llbuild and TSC repositories.
-let relatedDependenciesBranch = "main"
+let relatedDependenciesBranch = "release/6.2"
 
 if ProcessInfo.processInfo.environment["SWIFTPM_LLBUILD_FWK"] == nil {
     if ProcessInfo.processInfo.environment["SWIFTCI_USE_LOCAL_DEPS"] == nil {

Sources/Basics/Graph/GraphAlgorithms.swift

@@ -131,3 +131,50 @@ public func depthFirstSearch<T: Hashable>(
         }
     }
 }
+
+/// Implements a pre-order depth-first search that traverses the whole graph and
+/// doesn't distinguish between unique and duplicate nodes. The visitor can abort
+/// a path as needed to prune the tree.
+/// The method expects the graph to be acyclic but doesn't check that.
+///
+/// - Parameters:
+///   - nodes: The list of input nodes to sort.
+///   - successors: A closure for fetching the successors of a particular node.
+///   - onNext: A callback to indicate the node currently being processed
+///             including its parent (if any) and its depth. Returns whether to
+///             continue down the current path.
+///
+/// - Complexity: O(v + e) where (v, e) are the number of vertices and edges
+/// reachable from the input nodes via the relation.
+public enum DepthFirstContinue {
+    case `continue`
+    case abort
+}
+
+public func depthFirstSearch<T: Hashable>(
+    _ nodes: [T],
+    successors: (T) throws -> [T],
+    visitNext: (T, _ parent: T?) throws -> DepthFirstContinue
+) rethrows {
+    var stack = OrderedSet<TraversalNode<T>>()
+
+    for node in nodes {
+        precondition(stack.isEmpty)
+        stack.append(TraversalNode(parent: nil, curr: node))
+
+        while !stack.isEmpty {
+            let node = stack.removeLast()
+
+            if try visitNext(node.curr, node.parent) == .continue {
+                for succ in try successors(node.curr) {
+                    stack.append(
+                        TraversalNode(
+                            parent: node.curr,
+                            curr: succ
+                        )
+                    )
+                }
+            }
+        }
+    }
+}

Sources/Build/BuildDescription/ModuleBuildDescription.swift

@@ -187,8 +187,30 @@ extension ModuleBuildDescription {
         var dependencies: [Dependency] = []
         plan.traverseDependencies(of: self) { product, _, description in
             dependencies.append(.product(product, description))
+            return .continue
         } onModule: { module, _, description in
             dependencies.append(.module(module, description))
+            return .continue
+        }
+        return dependencies
+    }
+
+    package func recursiveLinkDependencies(using plan: BuildPlan) -> [Dependency] {
+        var dependencies: [Dependency] = []
+        plan.traverseDependencies(of: self) { product, _, description in
+            guard product.type != .macro && product.type != .plugin else {
+                return .abort
+            }
+
+            dependencies.append(.product(product, description))
+            return .continue
+        } onModule: { module, _, description in
+            guard module.type != .macro && module.type != .plugin else {
+                return .abort
+            }
+
+            dependencies.append(.module(module, description))
+            return .continue
         }
         return dependencies
     }

Sources/Build/BuildPlan/BuildPlan.swift

@@ -1175,8 +1175,8 @@ extension BuildPlan {
 
     package func traverseDependencies(
         of description: ModuleBuildDescription,
-        onProduct: (ResolvedProduct, BuildParameters.Destination, ProductBuildDescription?) -> Void,
-        onModule: (ResolvedModule, BuildParameters.Destination, ModuleBuildDescription?) -> Void
+        onProduct: (ResolvedProduct, BuildParameters.Destination, ProductBuildDescription?) -> DepthFirstContinue,
+        onModule: (ResolvedModule, BuildParameters.Destination, ModuleBuildDescription?) -> DepthFirstContinue
     ) {
         var visited = Set<TraversalNode>()
         func successors(
@@ -1217,16 +1217,16 @@ extension BuildPlan {
             case .package:
                 []
             }
-        } onNext: { module, _ in
+        } visitNext: { module, _ in
             switch module {
             case .package:
-                break
+                return .continue
 
             case .product(let product, let destination):
-                onProduct(product, destination, self.description(for: product, context: destination))
+                return onProduct(product, destination, self.description(for: product, context: destination))
 
             case .module(let module, let destination):
-                onModule(module, destination, self.description(for: module, context: destination))
+                return onModule(module, destination, self.description(for: module, context: destination))
             }
         }
     }

Sources/_InternalTestSupport/XCTAssertHelpers.swift

@@ -101,6 +101,14 @@ public func XCTRequires(
     }
 }
 
+public func XCTSkipIfWindowsCI(file: StaticString = #filePath, line: UInt = #line) throws {
+    #if os(Windows)
+    if ProcessInfo.processInfo.environment["SWIFTCI_IS_SELF_HOSTED"] != nil {
+        throw XCTSkip("Skipping because the test is being run on CI", file: file, line: line)
+    }
+    #endif
+}
+
 /// An `async`-friendly replacement for `XCTAssertThrowsError`.
 public func XCTAssertAsyncThrowsError<T>(
     _ expression: @autoclosure () async throws -> T,

Tests/BuildTests/BuildPlanTraversalTests.swift

@@ -146,8 +146,10 @@ final class BuildPlanTraversalTests: XCTestCase {
             XCTAssertEqual(product.name, "SwiftSyntax")
             XCTAssertEqual(destination, .host)
             XCTAssertNil(description)
+            return .continue
         } onModule: { module, destination, description in
             moduleDependencies.append((module, destination, description))
+            return .continue
         }
 
         XCTAssertEqual(moduleDependencies.count, 2)

Utilities/build-using-self

@@ -163,6 +163,7 @@ def filterNone(items: t.Iterable) -> t.Iterable:
 
 def main() -> None:
     args = get_arguments()
+    ignore = "-Xlinker /ignore:4217" if os.name == "nt" else ""
     logging.getLogger().setLevel(logging.DEBUG if args.is_verbose else logging.INFO)
     logging.debug("Args: %r", args)
     ignore_args = ["-Xlinker", "/ignore:4217"] if os.name == "nt" else []