Remove triple from SwiftBuild system output path

The triple name in the SwiftBuild build system is redundant.  Remove the
triple from the output path.

Author: bkhouri

Sources/SPMBuildCore/Triple+Extensions.swift

@@ -32,7 +32,9 @@ extension Triple {
             // can be used to build for any Apple platform and it has its own
             // conventions for build subpaths based on platforms.
             return "apple"
-        case .swiftbuild, .native:
+        case .swiftbuild:
+            return "out"
+        case .native:
             return self.platformBuildPathComponent
         }
     }

Sources/_InternalTestSupport/BuildSystemProvider+Configuration.swift

@@ -66,7 +66,7 @@ extension BuildSystemProvider.Kind {
         case .native:
             return scratchPath + [tripleString, "\(config)".lowercased()]
         case .swiftbuild:
-            return scratchPath + [tripleString, "Products", "\(config)".capitalized + suffix]
+            return scratchPath + ["out", "Products", "\(config)".capitalized + suffix]
         case .xcode:
             return scratchPath + ["apple", "Products", "\(config)".capitalized + suffix]
         }

Tests/CommandsTests/BuildCommandTests.swift

@@ -818,31 +818,27 @@ struct BuildCommandTestCases {
         data: BuildData,
     ) async throws {
         let buildSystem = data.buildSystem
-        try await withKnownIssue {
-            try await fixture(name: "Miscellaneous/LibraryEvolution") { fixturePath in
-                let result = try await build(
-                    [],
-                    packagePath: fixturePath,
-                    configuration: data.config,
-                    buildSystem: buildSystem,
-                )
-                switch buildSystem {
-                    case .native:
-                        #expect(result.moduleContents.contains("A.swiftinterface"))
-                        #expect(result.moduleContents.contains("B.swiftinterface"))
-                    case .swiftbuild, .xcode:
-                        let moduleARegex = try Regex(#"A[.]swiftmodule[/].*[.]swiftinterface"#)
-                        let moduleBRegex = try Regex(#"B[.]swiftmodule[/].*[.]swiftmodule"#)
-                        withKnownIssue("SWBINTTODO: Test failed because of missing 'A.swiftmodule/*.swiftinterface' files") {
-                            #expect(result.moduleContents.contains { $0.contains(moduleARegex) })
-                        } when: {
-                            buildSystem == .swiftbuild
-                        }
-                        #expect(result.moduleContents.contains { $0.contains(moduleBRegex) })
-                }
+        try await fixture(name: "Miscellaneous/LibraryEvolution") { fixturePath in
+            let result = try await build(
+                [],
+                packagePath: fixturePath,
+                configuration: data.config,
+                buildSystem: buildSystem,
+            )
+            switch buildSystem {
+                case .native:
+                    #expect(result.moduleContents.contains("A.swiftinterface"))
+                    #expect(result.moduleContents.contains("B.swiftinterface"))
+                case .swiftbuild, .xcode:
+                    let moduleARegex = try Regex(#"A[.]swiftmodule[/].*[.]swiftinterface"#)
+                    let moduleBRegex = try Regex(#"B[.]swiftmodule[/].*[.]swiftmodule"#)
+                    withKnownIssue("SWBINTTODO: Test failed because of missing 'A.swiftmodule/*.swiftinterface' files") {
+                        #expect(result.moduleContents.contains { $0.contains(moduleARegex) })
+                    } when: {
+                        buildSystem == .swiftbuild
+                    }
+                    #expect(result.moduleContents.contains { $0.contains(moduleBRegex) })
             }
-        } when: {
-            buildSystem == .swiftbuild && ProcessInfo.hostOperatingSystem == .windows
         }
     }
 
@@ -857,47 +853,43 @@ struct BuildCommandTestCases {
         data: BuildData,
     ) async throws {
         let buildSystem = data.buildSystem
-        try await withKnownIssue {
-            try await fixture(name: "DependencyResolution/Internal/Simple") { fixturePath in
-                let buildCompleteRegex = try Regex(#"Build complete!\s?(\([0-9]*\.[0-9]*\s*s(econds)?\))?"#)
-                do {
-                    let result = try await execute(
-                        packagePath: fixturePath,
-                        configuration: data.config,
-                        buildSystem: buildSystem,
-                    )
-                    // This test fails to match the 'Compiling' regex; rdar://101815761
-                    // XCTAssertMatch(result.stdout, .regex("\\[[1-9][0-9]*\\/[1-9][0-9]*\\] Compiling"))
-                    let lines = result.stdout.split(whereSeparator: { $0.isNewline })
-                    let lastLine = try #require(lines.last)
-                    #expect(lastLine.contains(buildCompleteRegex))
-                }
+        try await fixture(name: "DependencyResolution/Internal/Simple") { fixturePath in
+            let buildCompleteRegex = try Regex(#"Build complete!\s?(\([0-9]*\.[0-9]*\s*s(econds)?\))?"#)
+            do {
+                let result = try await execute(
+                    packagePath: fixturePath,
+                    configuration: data.config,
+                    buildSystem: buildSystem,
+                )
+                // This test fails to match the 'Compiling' regex; rdar://101815761
+                // XCTAssertMatch(result.stdout, .regex("\\[[1-9][0-9]*\\/[1-9][0-9]*\\] Compiling"))
+                let lines = result.stdout.split(whereSeparator: { $0.isNewline })
+                let lastLine = try #require(lines.last)
+                #expect(lastLine.contains(buildCompleteRegex))
+            }
 
-                do {
-                    // test second time, to stabilize the cache
-                    try await execute(
-                        packagePath: fixturePath,
-                        configuration: data.config,
-                        buildSystem: buildSystem,
-                    )
-                }
+            do {
+                // test second time, to stabilize the cache
+                try await execute(
+                    packagePath: fixturePath,
+                    configuration: data.config,
+                    buildSystem: buildSystem,
+                )
+            }
 
-                do {
-                    // test third time, to make sure message is presented even when nothing to build (cached)
-                    let result = try await execute(
-                        packagePath: fixturePath,
-                        configuration: data.config,
-                        buildSystem: buildSystem,
-                    )
-                    // This test fails to match the 'Compiling' regex; rdar://101815761
-                    // XCTAssertNoMatch(result.stdout, .regex("\\[[1-9][0-9]*\\/[1-9][0-9]*\\] Compiling"))
-                    let lines = result.stdout.split(whereSeparator: { $0.isNewline })
-                    let lastLine = try #require(lines.last)
-                    #expect(lastLine.contains(buildCompleteRegex))
-                }
+            do {
+                // test third time, to make sure message is presented even when nothing to build (cached)
+                let result = try await execute(
+                    packagePath: fixturePath,
+                    configuration: data.config,
+                    buildSystem: buildSystem,
+                )
+                // This test fails to match the 'Compiling' regex; rdar://101815761
+                // XCTAssertNoMatch(result.stdout, .regex("\\[[1-9][0-9]*\\/[1-9][0-9]*\\] Compiling"))
+                let lines = result.stdout.split(whereSeparator: { $0.isNewline })
+                let lastLine = try #require(lines.last)
+                #expect(lastLine.contains(buildCompleteRegex))
             }
-        } when: {
-            buildSystem == .swiftbuild && (ProcessInfo.hostOperatingSystem == .windows)
         }
     }
 
@@ -1135,31 +1127,24 @@ struct BuildCommandTestCases {
     func swiftDriverRawOutputGetsNewlines(
         buildSystem: BuildSystemProvider.Kind,
     ) async throws {
-         try await withKnownIssue(
-            "error produced for this fixture",
-            isIntermittent: ProcessInfo.hostOperatingSystem == .linux,
-        ) {
-            try await fixture(name: "DependencyResolution/Internal/Simple") { fixturePath in
-                // Building with `-wmo` should result in a `remark: Incremental compilation has been disabled: it is not
-                // compatible with whole module optimization` message, which should have a trailing newline.  Since that
-                // message won't be there at all when the legacy compiler driver is used, we gate this check on whether the
-                // remark is there in the first place.
-                let result = try await execute(
-                    ["-Xswiftc", "-wmo"],
-                    packagePath: fixturePath,
-                    configuration: .release,
-                    buildSystem: buildSystem,
-                )
-                if result.stdout.contains(
-                    "remark: Incremental compilation has been disabled: it is not compatible with whole module optimization"
-                ) {
-                    #expect(result.stdout.contains("optimization\n"))
-                    #expect(!result.stdout.contains("optimization["))
-                    #expect(!result.stdout.contains("optimizationremark"))
-                }
+        try await fixture(name: "DependencyResolution/Internal/Simple") { fixturePath in
+            // Building with `-wmo` should result in a `remark: Incremental compilation has been disabled: it is not
+            // compatible with whole module optimization` message, which should have a trailing newline.  Since that
+            // message won't be there at all when the legacy compiler driver is used, we gate this check on whether the
+            // remark is there in the first place.
+            let result = try await execute(
+                ["-Xswiftc", "-wmo"],
+                packagePath: fixturePath,
+                configuration: .release,
+                buildSystem: buildSystem,
+            )
+            if result.stdout.contains(
+                "remark: Incremental compilation has been disabled: it is not compatible with whole module optimization"
+            ) {
+                #expect(result.stdout.contains("optimization\n"))
+                #expect(!result.stdout.contains("optimization["))
+                #expect(!result.stdout.contains("optimizationremark"))
             }
-        } when: {
-            ProcessInfo.hostOperatingSystem == .windows && buildSystem == .swiftbuild
         }
     }
 
@@ -1469,7 +1454,7 @@ struct BuildCommandTestCases {
             """
             Windows: Sometimes failed to build due to a possible path issue
             All: --very-verbose causes rebuild on SwiftBuild (https://github.com/swiftlang/swift-package-manager/issues/9299)
-            """, 
+            """,
             isIntermittent: true) {
             try await fixture(name: "ValidLayouts/SingleModule/ExecutableNew") { fixturePath in
                 _ = try await build(

Tests/CommandsTests/RunCommandTests.swift

@@ -53,7 +53,7 @@ struct RunCommandTests {
         buildSystem: BuildSystemProvider.Kind
     ) async throws {
         let stdout = try await execute(["-help"], buildSystem: buildSystem).stdout
-        
+
         #expect(stdout.contains("USAGE: swift run <options>") || stdout.contains("USAGE: swift run [<options>]"), "got stdout:\n \(stdout)")
     }
 
@@ -106,7 +106,6 @@ struct RunCommandTests {
     func toolsetDebugger(
         buildSystem: BuildSystemProvider.Kind,
     ) async throws {
-        try await withKnownIssue {
         try await fixture(name: "Miscellaneous/EchoExecutable") { fixturePath in
             #if os(Windows)
                 let win32 = ".win32"
@@ -135,10 +134,6 @@ struct RunCommandTests {
                 buildSystem == .swiftbuild
             }
         }
-        } when: {
-            (.swiftbuild == buildSystem && ProcessInfo.hostOperatingSystem == .windows)
-            || (.native == buildSystem && ProcessInfo.hostOperatingSystem == .windows && CiEnvironment.runningInSmokeTestPipeline)
-        }
     }
 
     @Test(
@@ -152,34 +147,29 @@ struct RunCommandTests {
     func productArgumentPassing(
         buildSystem: BuildSystemProvider.Kind,
     ) async throws {
-        try await withKnownIssue {
-            try await fixture(name: "Miscellaneous/EchoExecutable") { fixturePath in
-                let (stdout, stderr) = try await execute(
-                    ["secho", "1", "--hello", "world"],
-                    packagePath: fixturePath,
-                    buildSystem: buildSystem,
-                )
+        try await fixture(name: "Miscellaneous/EchoExecutable") { fixturePath in
+            let (stdout, stderr) = try await execute(
+                ["secho", "1", "--hello", "world"],
+                packagePath: fixturePath,
+                buildSystem: buildSystem,
+            )
 
-                // We only expect tool's output on the stdout stream.
-                #expect(stdout.contains("""
-                    "1" "--hello" "world"
-                    """))
+            // We only expect tool's output on the stdout stream.
+            #expect(stdout.contains("""
+                "1" "--hello" "world"
+                """))
 
-                // swift-build-tool output should go to stderr.
-                withKnownIssue {
-                    #expect(stderr.contains("Compiling"))
-                } when: {
-                    buildSystem == .swiftbuild
-                }
-                withKnownIssue {
-                    #expect(stderr.contains("Linking"))
-                } when: {
-                    buildSystem == .swiftbuild
-                }
+            // swift-build-tool output should go to stderr.
+            withKnownIssue {
+                #expect(stderr.contains("Compiling"))
+            } when: {
+                buildSystem == .swiftbuild
+            }
+            withKnownIssue {
+                #expect(stderr.contains("Linking"))
+            } when: {
+                buildSystem == .swiftbuild
             }
-        } when: {
-            (.windows == ProcessInfo.hostOperatingSystem && buildSystem == .swiftbuild)
-            || (.windows == ProcessInfo.hostOperatingSystem && buildSystem == .native && CiEnvironment.runningInSmokeTestPipeline)
         }
     }
 
@@ -220,7 +210,6 @@ struct RunCommandTests {
     func multipleExecutableAndExplicitExecutable(
         buildSystem: BuildSystemProvider.Kind,
     ) async throws {
-        try await withKnownIssue {
         try await fixture(name: "Miscellaneous/MultipleExecutables") { fixturePath in
 
             let error = await #expect(throws: SwiftPMError.self ) {
@@ -242,10 +231,6 @@ struct RunCommandTests {
             (runOutput, _) = try await execute(["exec2"], packagePath: fixturePath, buildSystem: buildSystem)
             #expect(runOutput.contains("2"))
         }
-        } when: {
-            ([.windows].contains(ProcessInfo.hostOperatingSystem) && buildSystem == .swiftbuild && CiEnvironment.runningInSelfHostedPipeline)
-            || (.windows == ProcessInfo.hostOperatingSystem && [.native, .swiftbuild].contains(buildSystem) && CiEnvironment.runningInSmokeTestPipeline)
-        }
     }
 
 

Tests/IntegrationTests/SwiftPMTests.swift

@@ -192,7 +192,7 @@ private struct SwiftPMTests {
                     )
                 case .swiftbuild:
                     fooPath = try AbsolutePath(
-                        validating: ".build/\(arch)-apple-macosx/Products/Debug/foo",
+                        validating: ".build/Products/Debug/foo",
                         relativeTo: packagePath
                     )
                 default:
@@ -225,7 +225,7 @@ private struct SwiftPMTests {
                 )
             case .swiftbuild:
                 fooPath = try AbsolutePath(
-                    validating: ".build/\(hostArch)-apple-macosx/Products/Debug/foo",
+                    validating: ".build/Products/Debug/foo",
                     relativeTo: packagePath
                 )
             default: