Move .swiftmodule output directory

neonichu · neonichu · commit d98c8c7ab1f9 · 2023-11-30T14:24:49.000-08:00
While working on #7090, we noticed that any builds of Swift sources will currently find lots of unrelated module maps because of the structure of the build arena. We pass a `-I` to the top-level of the arena which leads to *everything* being recursively searched for modules, so the compiler will find module maps that aren't intended to be included at all. Changing this so that the search paths won't include random module maps should actually solve various issues around seeing incomplete module maps, such as ones referring to ObjC compatibility headers that haven't been written, yet. rdar://89082987
diff --git a/Sources/Build/BuildDescription/SwiftTargetBuildDescription.swift b/Sources/Build/BuildDescription/SwiftTargetBuildDescription.swift
@@ -103,13 +103,16 @@ public final class SwiftTargetBuildDescription {
         }
     }
 
+    var modulesPath: AbsolutePath {
+        return self.buildParameters.buildPath.appending(component: "Modules")
+    }
+
     /// The path to the swiftmodule file after compilation.
     var moduleOutputPath: AbsolutePath {
         // If we're an executable and we're not allowing test targets to link against us, we hide the module.
         let allowLinkingAgainstExecutables = (buildParameters.targetTriple.isDarwin() || self.buildParameters.targetTriple
             .isLinux() || self.buildParameters.targetTriple.isWindows()) && self.toolsVersion >= .v5_5
-        let dirPath = (target.type == .executable && !allowLinkingAgainstExecutables) ? self.tempsPath : self
-            .buildParameters.buildPath
+        let dirPath = (target.type == .executable && !allowLinkingAgainstExecutables) ? self.tempsPath : self.modulesPath
         return dirPath.appending(component: self.target.c99name + ".swiftmodule")
     }
 
@@ -122,7 +125,7 @@ public final class SwiftTargetBuildDescription {
 
     /// The path to the swifinterface file after compilation.
     var parseableModuleInterfaceOutputPath: AbsolutePath {
-        self.buildParameters.buildPath.appending(component: self.target.c99name + ".swiftinterface")
+        self.modulesPath.appending(component: self.target.c99name + ".swiftinterface")
     }
 
     /// Path to the resource Info.plist file, if generated.
@@ -638,7 +641,7 @@ public final class SwiftTargetBuildDescription {
         result.append(contentsOf: self.sources.map(\.pathString))
 
         result.append("-I")
-        result.append(self.buildParameters.buildPath.pathString)
+        result.append(self.modulesPath.pathString)
 
         result += try self.compileArguments()
         return result
diff --git a/Sources/Build/BuildManifest/LLBuildManifestBuilder+Swift.swift b/Sources/Build/BuildManifest/LLBuildManifestBuilder+Swift.swift
@@ -380,7 +380,7 @@ extension LLBuildManifestBuilder {
             moduleName: target.target.c99name,
             moduleAliases: target.target.moduleAliases,
             moduleOutputPath: target.moduleOutputPath,
-            importPath: target.buildParameters.buildPath,
+            importPath: target.modulesPath,
             tempsPath: target.tempsPath,
             objects: try target.objects,
             otherArguments: try target.compileArguments(),
diff --git a/Sources/Build/BuildPlan/BuildPlan.swift b/Sources/Build/BuildPlan/BuildPlan.swift
@@ -467,10 +467,11 @@ public class BuildPlan: SPMBuildCore.BuildPlan {
         }
         arguments += extraSwiftCFlags
 
-        // Add the search path to the directory containing the modulemap file.
+        // Add search paths to the directories containing module maps and Swift modules.
         for target in targets {
             switch target {
-            case .swift: break
+            case .swift(let targetDescription):
+                arguments += ["-I", targetDescription.moduleOutputPath.pathString]
             case .clang(let targetDescription):
                 if let includeDir = targetDescription.moduleMap?.parentDirectory {
                     arguments += ["-I", includeDir.pathString]
diff --git a/Tests/BuildTests/BuildPlanTests.swift b/Tests/BuildTests/BuildPlanTests.swift
@@ -645,8 +645,8 @@ final class BuildPlanTests: XCTestCase {
             "@\(buildPath.appending(components: "exe.product", "Objects.LinkFileList"))",
             "-Xlinker", "-rpath", "-Xlinker", "/fake/path/lib/swift-5.5/macosx",
             "-target", defaultTargetTriple,
+            "-Xlinker", "-add_ast_path", "-Xlinker", buildPath.appending(components: "Modules", "lib.swiftmodule").pathString,
             "-Xlinker", "-add_ast_path", "-Xlinker", buildPath.appending(components: "exe.build", "exe.swiftmodule").pathString,
-            "-Xlinker", "-add_ast_path", "-Xlinker", buildPath.appending(components: "lib.swiftmodule").pathString,
             "-g",
         ]
       #elseif os(Windows)
@@ -869,7 +869,7 @@ final class BuildPlanTests: XCTestCase {
             let contents: String = try fs.readFileContents(yaml)
             let swiftGetVersionFilePath = try XCTUnwrap(llbuild.swiftGetVersionFiles.first?.value)
             XCTAssertMatch(contents, .contains("""
-                    inputs: ["\(Pkg.appending(components: "Sources", "exe", "main.swift").escapedPathString)","\(swiftGetVersionFilePath.escapedPathString)","\(buildPath.appending(components: "PkgLib.swiftmodule").escapedPathString)","\(buildPath.appending(components: "exe.build", "sources").escapedPathString)"]
+                    inputs: ["\(Pkg.appending(components: "Sources", "exe", "main.swift").escapedPathString)","\(swiftGetVersionFilePath.escapedPathString)","\(buildPath.appending(components: "Modules", "PkgLib.swiftmodule").escapedPathString)","\(buildPath.appending(components: "exe.build", "sources").escapedPathString)"]
                 """))
 
         }
@@ -1736,8 +1736,8 @@ final class BuildPlanTests: XCTestCase {
             "@\(buildPath.appending(components: "PkgPackageTests.product", "Objects.LinkFileList"))"] +
             rpathsForBackdeployment +
             ["-target", "\(hostTriple.tripleString(forPlatformVersion: version))",
-            "-Xlinker", "-add_ast_path", "-Xlinker", buildPath.appending(components: "Foo.swiftmodule").pathString,
-            "-Xlinker", "-add_ast_path", "-Xlinker", buildPath.appending(components: "FooTests.swiftmodule").pathString,
+            "-Xlinker", "-add_ast_path", "-Xlinker", buildPath.appending(components: "Modules", "Foo.swiftmodule").pathString,
+            "-Xlinker", "-add_ast_path", "-Xlinker", buildPath.appending(components: "Modules", "FooTests.swiftmodule").pathString,
             "-g",
         ])
       #elseif os(Windows)
@@ -2313,7 +2313,7 @@ final class BuildPlanTests: XCTestCase {
             "@\(buildPath.appending(components: "Bar-Baz.product", "Objects.LinkFileList"))",
             "-Xlinker", "-rpath", "-Xlinker", "/fake/path/lib/swift-5.5/macosx",
             "-target", defaultTargetTriple,
-            "-Xlinker", "-add_ast_path", "-Xlinker", buildPath.appending(components: "Bar.swiftmodule").pathString,
+            "-Xlinker", "-add_ast_path", "-Xlinker", buildPath.appending(components: "Modules", "Bar.swiftmodule").pathString,
             "-g",
         ])
       #elseif os(Windows)
@@ -2432,7 +2432,7 @@ final class BuildPlanTests: XCTestCase {
                 "@\(buildPath.appending(components: "lib.product", "Objects.LinkFileList"))",
                 "-Xlinker", "-rpath", "-Xlinker", "/fake/path/lib/swift-5.5/macosx",
                 "-target", defaultTargetTriple,
-                "-Xlinker", "-add_ast_path", "-Xlinker", buildPath.appending(components: "lib.swiftmodule").pathString,
+                "-Xlinker", "-add_ast_path", "-Xlinker", buildPath.appending(components: "Modules", "lib.swiftmodule").pathString,
                 "-g",
             ]
         #elseif os(Windows)
@@ -4110,7 +4110,7 @@ final class BuildPlanTests: XCTestCase {
         XCTAssertMatch(contents, .contains("""
               "\(buildPath.appending(components: "Bar.build", "main.m.o").escapedPathString)":
                 tool: clang
-                inputs: ["\(buildPath.appending(components: "Foo.swiftmodule").escapedPathString)","\(PkgA.appending(components: "Sources", "Bar", "main.m").escapedPathString)"]
+                inputs: ["\(buildPath.appending(components: "Modules", "Foo.swiftmodule").escapedPathString)","\(PkgA.appending(components: "Sources", "Bar", "main.m").escapedPathString)"]
                 outputs: ["\(buildPath.appending(components: "Bar.build", "main.m.o").escapedPathString)"]
                 description: "Compiling Bar main.m"
             """))
@@ -4184,7 +4184,7 @@ final class BuildPlanTests: XCTestCase {
         XCTAssertMatch(contents, .contains("""
                "\(buildPath.appending(components: "Bar.build", "main.m.o").escapedPathString)":
                  tool: clang
-                 inputs: ["\(buildPath.appending(components: "Foo.swiftmodule").escapedPathString)","\(PkgA.appending(components: "Sources", "Bar", "main.m").escapedPathString)"]
+                 inputs: ["\(buildPath.appending(components: "Modules", "Foo.swiftmodule").escapedPathString)","\(PkgA.appending(components: "Sources", "Bar", "main.m").escapedPathString)"]
                  outputs: ["\(buildPath.appending(components: "Bar.build", "main.m.o").escapedPathString)"]
                  description: "Compiling Bar main.m"
              """))
@@ -4322,10 +4322,10 @@ final class BuildPlanTests: XCTestCase {
         XCTAssertMatch(contents, .contains("""
               "\(buildPath.appending(components: "lib.build", "lib.swiftmodule.o").escapedPathString)":
                 tool: shell
-                inputs: ["\(buildPath.appending(components: "lib.swiftmodule").escapedPathString)"]
+                inputs: ["\(buildPath.appending(components: "Modules", "lib.swiftmodule").escapedPathString)"]
                 outputs: ["\(buildPath.appending(components: "lib.build", "lib.swiftmodule.o").escapedPathString)"]
                 description: "Wrapping AST for lib for debugging"
-                args: ["\(result.plan.buildParameters.toolchain.swiftCompilerPath.escapedPathString)","-modulewrap","\(buildPath.appending(components: "lib.swiftmodule").escapedPathString)","-o","\(buildPath.appending(components: "lib.build", "lib.swiftmodule.o").escapedPathString)","-target","x86_64-unknown-linux-gnu"]
+                args: ["\(result.plan.buildParameters.toolchain.swiftCompilerPath.escapedPathString)","-modulewrap","\(buildPath.appending(components: "Modules", "lib.swiftmodule").escapedPathString)","-o","\(buildPath.appending(components: "lib.build", "lib.swiftmodule.o").escapedPathString)","-target","x86_64-unknown-linux-gnu"]
             """))
     }
 
@@ -4958,7 +4958,7 @@ final class BuildPlanTests: XCTestCase {
 
         let yamlContents: String = try fs.readFileContents(yaml)
         let inputs: SerializedJSON = """
-            inputs: ["\(AbsolutePath("/Pkg/Snippets/ASnippet.swift"))","\(swiftGetVersionFilePath)","\(AbsolutePath("/Pkg/.build/debug/Lib.swiftmodule"))"
+            inputs: ["\(AbsolutePath("/Pkg/Snippets/ASnippet.swift"))","\(swiftGetVersionFilePath)","\(AbsolutePath("/Pkg/.build/debug/Modules/Lib.swiftmodule"))"
         """
         XCTAssertMatch(yamlContents, .contains(inputs.underlying))
     }
@@ -5173,8 +5173,8 @@ final class BuildPlanTests: XCTestCase {
             "@\(buildPath.appending(components: "exe.product", "Objects.LinkFileList"))",
             "-Xlinker", "-rpath", "-Xlinker", "/fake/path/lib/swift-5.5/macosx",
             "-target", defaultTargetTriple,
+            "-Xlinker", "-add_ast_path", "-Xlinker", buildPath.appending(components: "Modules", "lib.swiftmodule").pathString,
             "-Xlinker", "-add_ast_path", "-Xlinker", buildPath.appending(components: "exe.build", "exe.swiftmodule").pathString,
-            "-Xlinker", "-add_ast_path", "-Xlinker", buildPath.appending(components: "lib.swiftmodule").pathString,
             "-g",
         ]
       #elseif os(Windows)
diff --git a/Tests/CommandsTests/BuildToolTests.swift b/Tests/CommandsTests/BuildToolTests.swift
@@ -26,6 +26,7 @@ struct BuildResult {
     let stdout: String
     let stderr: String
     let binContents: [String]
+    let moduleContents: [String]
 }
 
 final class BuildToolTests: CommandsTestCase {
@@ -55,7 +56,14 @@ final class BuildToolTests: CommandsTestCase {
             // is what `binContents` is meant to represent.
             return contents != ["output-file-map.json"]
         }
-        return BuildResult(binPath: binPath, stdout: stdout, stderr: stderr, binContents: binContents)
+        let moduleContents = (try? localFileSystem.getDirectoryContents(binPath.appending(component: "Modules"))) ?? []
+        return BuildResult(
+            binPath: binPath,
+            stdout: stdout,
+            stderr: stderr,
+            binContents: binContents,
+            moduleContents: moduleContents
+        )
     }
 
     func testUsage() throws {
@@ -325,9 +333,9 @@ final class BuildToolTests: CommandsTestCase {
                 // Also make sure we didn't emit parseable module interfaces
                 // (do this here to avoid doing a second build in
                 // testParseableInterfaces().
-                XCTAssertNoMatch(result.binContents, ["ATarget.swiftinterface"])
-                XCTAssertNoMatch(result.binContents, ["BTarget.swiftinterface"])
-                XCTAssertNoMatch(result.binContents, ["CTarget.swiftinterface"])
+                XCTAssertNoMatch(result.moduleContents, ["ATarget.swiftinterface"])
+                XCTAssertNoMatch(result.moduleContents, ["BTarget.swiftinterface"])
+                XCTAssertNoMatch(result.moduleContents, ["CTarget.swiftinterface"])
             }
         }
     }
@@ -336,8 +344,8 @@ final class BuildToolTests: CommandsTestCase {
         try fixture(name: "Miscellaneous/ParseableInterfaces") { fixturePath in
             do {
                 let result = try build(["--enable-parseable-module-interfaces"], packagePath: fixturePath)
-                XCTAssertMatch(result.binContents, ["A.swiftinterface"])
-                XCTAssertMatch(result.binContents, ["B.swiftinterface"])
+                XCTAssertMatch(result.moduleContents, ["A.swiftinterface"])
+                XCTAssertMatch(result.moduleContents, ["B.swiftinterface"])
             } catch SwiftPMError.executionFailure(_, _, let stderr) {
                 XCTFail(stderr)
             }
@@ -348,8 +356,8 @@ final class BuildToolTests: CommandsTestCase {
         try fixture(name: "Miscellaneous/LibraryEvolution") { fixturePath in
             do {
                 let result = try build([], packagePath: fixturePath)
-                XCTAssertMatch(result.binContents, ["A.swiftinterface"])
-                XCTAssertMatch(result.binContents, ["B.swiftinterface"])
+                XCTAssertMatch(result.moduleContents, ["A.swiftinterface"])
+                XCTAssertMatch(result.moduleContents, ["B.swiftinterface"])
             }
         }
     }
diff --git a/Tests/FunctionalTests/MiscellaneousTests.swift b/Tests/FunctionalTests/MiscellaneousTests.swift
@@ -54,8 +54,8 @@ class MiscellaneousTestCase: XCTestCase {
             XCTAssertBuilds(fixturePath.appending("app"))
             let buildDir = fixturePath.appending(components: "app", ".build", try UserToolchain.default.targetTriple.platformBuildPathComponent, "debug")
             XCTAssertFileExists(buildDir.appending("FooExec"))
-            XCTAssertFileExists(buildDir.appending("FooLib1.swiftmodule"))
-            XCTAssertFileExists(buildDir.appending("FooLib2.swiftmodule"))
+            XCTAssertFileExists(buildDir.appending(components: "Modules", "FooLib1.swiftmodule"))
+            XCTAssertFileExists(buildDir.appending(components: "Modules", "FooLib2.swiftmodule"))
         }
     }
 
diff --git a/Tests/FunctionalTests/ModuleAliasingFixtureTests.swift b/Tests/FunctionalTests/ModuleAliasingFixtureTests.swift
@@ -25,8 +25,8 @@ class ModuleAliasingFixtureTests: XCTestCase {
             let buildPath = pkgPath.appending(components: ".build", try UserToolchain.default.targetTriple.platformBuildPathComponent, "debug")
             XCTAssertBuilds(pkgPath, extraArgs: ["--vv"])
             XCTAssertFileExists(buildPath.appending(components: "App"))
-            XCTAssertFileExists(buildPath.appending(components: "GameUtils.swiftmodule"))
-            XCTAssertFileExists(buildPath.appending(components: "Utils.swiftmodule"))
+            XCTAssertFileExists(buildPath.appending(components: "Modules", "GameUtils.swiftmodule"))
+            XCTAssertFileExists(buildPath.appending(components: "Modules", "Utils.swiftmodule"))
             _ = try SwiftPM.Build.execute(packagePath: pkgPath)
         }
     }
@@ -37,8 +37,8 @@ class ModuleAliasingFixtureTests: XCTestCase {
             let buildPath = pkgPath.appending(components: ".build", try UserToolchain.default.targetTriple.platformBuildPathComponent, "debug")
             XCTAssertBuilds(pkgPath, extraArgs: ["--vv"])
             XCTAssertFileExists(buildPath.appending(components: "App"))
-            XCTAssertFileExists(buildPath.appending(components: "AUtils.swiftmodule"))
-            XCTAssertFileExists(buildPath.appending(components: "BUtils.swiftmodule"))
+            XCTAssertFileExists(buildPath.appending(components: "Modules", "AUtils.swiftmodule"))
+            XCTAssertFileExists(buildPath.appending(components: "Modules", "BUtils.swiftmodule"))
             _ = try SwiftPM.Build.execute(packagePath: pkgPath)
         }
     }
diff --git a/Tests/WorkspaceTests/InitTests.swift b/Tests/WorkspaceTests/InitTests.swift
@@ -94,7 +94,7 @@ class InitTests: XCTestCase {
 #else
             XCTAssertFileExists(binPath.appending("Foo"))
 #endif
-            XCTAssertFileExists(binPath.appending(components: "Foo.swiftmodule"))
+            XCTAssertFileExists(binPath.appending(components: "Modules", "Foo.swiftmodule"))
         }
     }
 
@@ -145,7 +145,7 @@ class InitTests: XCTestCase {
             // Try building it
             XCTAssertBuilds(path)
             let triple = try UserToolchain.default.targetTriple
-            XCTAssertFileExists(path.appending(components: ".build", triple.platformBuildPathComponent, "debug", "Foo.swiftmodule"))
+            XCTAssertFileExists(path.appending(components: ".build", triple.platformBuildPathComponent, "debug", "Modules", "Foo.swiftmodule"))
         }
     }
         
@@ -243,7 +243,7 @@ class InitTests: XCTestCase {
             // Try building it.
             XCTAssertBuilds(packageRoot)
             let triple = try UserToolchain.default.targetTriple
-            XCTAssertFileExists(packageRoot.appending(components: ".build", triple.platformBuildPathComponent, "debug", "some_package.swiftmodule"))
+            XCTAssertFileExists(packageRoot.appending(components: ".build", triple.platformBuildPathComponent, "debug", "Modules", "some_package.swiftmodule"))
         }
     }
     
diff --git a/Utilities/bootstrap b/Utilities/bootstrap
@@ -450,19 +450,23 @@ def install_dylib(args, library_name, install_dir, module_names):
     for module in module_names:
         # If we're cross-compiling, we expect the .swiftmodule to be a directory that contains everything.
         if args.cross_compile_hosts:
-            install_binary(args, module + ".swiftmodule", install_dir, ['Project', '*.swiftmodule'])
+            install_binary(args, module + ".swiftmodule", install_dir, ['Project', '*.swiftmodule'], subpath="Modules")
         else:
             # Otherwise we have either a .swiftinterface or a .swiftmodule, plus a .swiftdoc.
             if os.path.exists(os.path.join(args.bin_dir, module + ".swiftinterface")):
-                install_binary(args, module + ".swiftinterface", install_dir)
+                install_binary(args, module + ".swiftinterface", install_dir, subpath="Modules")
             else:
-                install_binary(args, module + ".swiftmodule", install_dir)
-            install_binary(args, module + ".swiftdoc", install_dir)
+                install_binary(args, module + ".swiftmodule", install_dir, subpath="Modules")
+            install_binary(args, module + ".swiftdoc", install_dir, subpath="Modules")
 
 
 # Helper function that installs a single built artifact to a particular directory. The source may be either a file or a directory.
-def install_binary(args, binary, destination, destination_is_directory=True, ignored_patterns=[]):
-    src = os.path.join(args.bin_dir, binary)
+def install_binary(args, binary, destination, destination_is_directory=True, ignored_patterns=[], subpath=None):
+    if subpath:
+        basepath = os.path.join(args.bin_dir, subpath)
+    else:
+        basepath = args.bin_dir
+    src = os.path.join(basepath, binary)
     install_file(args, src, destination, destination_is_directory=destination_is_directory, ignored_patterns=ignored_patterns)
 
 def install_file(args, src, destination, destination_is_directory=True, ignored_patterns=[]):

Original file line number	Diff line number	Diff line change
`@@ -26,6 +26,7 @@ struct BuildResult {`
`26`	`26`	`let stdout: String`
`27`	`27`	`let stderr: String`
`28`	`28`	`let binContents: [String]`
	`29`	`+ let moduleContents: [String]`
`29`	`30`	`}`
`30`	`31`
`31`	`32`	`final class BuildToolTests: CommandsTestCase {`
`@@ -55,7 +56,14 @@ final class BuildToolTests: CommandsTestCase {`
`55`	`56`	// is what `binContents` is meant to represent.
`56`	`57`	`return contents != ["output-file-map.json"]`
`57`	`58`	`}`
`58`		`- return BuildResult(binPath: binPath, stdout: stdout, stderr: stderr, binContents: binContents)`
	`59`	`+ let moduleContents = (try? localFileSystem.getDirectoryContents(binPath.appending(component: "Modules"))) ?? []`
	`60`	`+ return BuildResult(`
	`61`	`+ binPath: binPath,`
	`62`	`+ stdout: stdout,`
	`63`	`+ stderr: stderr,`
	`64`	`+ binContents: binContents,`
	`65`	`+ moduleContents: moduleContents`
	`66`	`+ )`
`59`	`67`	`}`
`60`	`68`
`61`	`69`	`func testUsage() throws {`
`@@ -325,9 +333,9 @@ final class BuildToolTests: CommandsTestCase {`
`325`	`333`	`// Also make sure we didn't emit parseable module interfaces`
`326`	`334`	`// (do this here to avoid doing a second build in`
`327`	`335`	`// testParseableInterfaces().`
`328`		`- XCTAssertNoMatch(result.binContents, ["ATarget.swiftinterface"])`
`329`		`- XCTAssertNoMatch(result.binContents, ["BTarget.swiftinterface"])`
`330`		`- XCTAssertNoMatch(result.binContents, ["CTarget.swiftinterface"])`
	`336`	`+ XCTAssertNoMatch(result.moduleContents, ["ATarget.swiftinterface"])`
	`337`	`+ XCTAssertNoMatch(result.moduleContents, ["BTarget.swiftinterface"])`
	`338`	`+ XCTAssertNoMatch(result.moduleContents, ["CTarget.swiftinterface"])`
`331`	`339`	`}`
`332`	`340`	`}`
`333`	`341`	`}`
`@@ -336,8 +344,8 @@ final class BuildToolTests: CommandsTestCase {`
`336`	`344`	`try fixture(name: "Miscellaneous/ParseableInterfaces") { fixturePath in`
`337`	`345`	`do {`
`338`	`346`	`let result = try build(["--enable-parseable-module-interfaces"], packagePath: fixturePath)`
`339`		`- XCTAssertMatch(result.binContents, ["A.swiftinterface"])`
`340`		`- XCTAssertMatch(result.binContents, ["B.swiftinterface"])`
	`347`	`+ XCTAssertMatch(result.moduleContents, ["A.swiftinterface"])`
	`348`	`+ XCTAssertMatch(result.moduleContents, ["B.swiftinterface"])`
`341`	`349`	`} catch SwiftPMError.executionFailure(_, _, let stderr) {`
`342`	`350`	`XCTFail(stderr)`
`343`	`351`	`}`
`@@ -348,8 +356,8 @@ final class BuildToolTests: CommandsTestCase {`
`348`	`356`	`try fixture(name: "Miscellaneous/LibraryEvolution") { fixturePath in`
`349`	`357`	`do {`
`350`	`358`	`let result = try build([], packagePath: fixturePath)`
`351`		`- XCTAssertMatch(result.binContents, ["A.swiftinterface"])`
`352`		`- XCTAssertMatch(result.binContents, ["B.swiftinterface"])`
	`359`	`+ XCTAssertMatch(result.moduleContents, ["A.swiftinterface"])`
	`360`	`+ XCTAssertMatch(result.moduleContents, ["B.swiftinterface"])`
`353`	`361`	`}`
`354`	`362`	`}`
`355`	`363`	`}`
Original file line number	Diff line number	Diff line change
`@@ -54,8 +54,8 @@ class MiscellaneousTestCase: XCTestCase {`
`54`	`54`	`XCTAssertBuilds(fixturePath.appending("app"))`
`55`	`55`	`let buildDir = fixturePath.appending(components: "app", ".build", try UserToolchain.default.targetTriple.platformBuildPathComponent, "debug")`
`56`	`56`	`XCTAssertFileExists(buildDir.appending("FooExec"))`
`57`		`- XCTAssertFileExists(buildDir.appending("FooLib1.swiftmodule"))`
`58`		`- XCTAssertFileExists(buildDir.appending("FooLib2.swiftmodule"))`
	`57`	`+ XCTAssertFileExists(buildDir.appending(components: "Modules", "FooLib1.swiftmodule"))`
	`58`	`+ XCTAssertFileExists(buildDir.appending(components: "Modules", "FooLib2.swiftmodule"))`
`59`	`59`	`}`
`60`	`60`	`}`
`61`	`61`
Original file line number	Diff line number	Diff line change
`@@ -25,8 +25,8 @@ class ModuleAliasingFixtureTests: XCTestCase {`
`25`	`25`	`let buildPath = pkgPath.appending(components: ".build", try UserToolchain.default.targetTriple.platformBuildPathComponent, "debug")`
`26`	`26`	`XCTAssertBuilds(pkgPath, extraArgs: ["--vv"])`
`27`	`27`	`XCTAssertFileExists(buildPath.appending(components: "App"))`
`28`		`- XCTAssertFileExists(buildPath.appending(components: "GameUtils.swiftmodule"))`
`29`		`- XCTAssertFileExists(buildPath.appending(components: "Utils.swiftmodule"))`
	`28`	`+ XCTAssertFileExists(buildPath.appending(components: "Modules", "GameUtils.swiftmodule"))`
	`29`	`+ XCTAssertFileExists(buildPath.appending(components: "Modules", "Utils.swiftmodule"))`
`30`	`30`	`_ = try SwiftPM.Build.execute(packagePath: pkgPath)`
`31`	`31`	`}`
`32`	`32`	`}`
`@@ -37,8 +37,8 @@ class ModuleAliasingFixtureTests: XCTestCase {`
`37`	`37`	`let buildPath = pkgPath.appending(components: ".build", try UserToolchain.default.targetTriple.platformBuildPathComponent, "debug")`
`38`	`38`	`XCTAssertBuilds(pkgPath, extraArgs: ["--vv"])`
`39`	`39`	`XCTAssertFileExists(buildPath.appending(components: "App"))`
`40`		`- XCTAssertFileExists(buildPath.appending(components: "AUtils.swiftmodule"))`
`41`		`- XCTAssertFileExists(buildPath.appending(components: "BUtils.swiftmodule"))`
	`40`	`+ XCTAssertFileExists(buildPath.appending(components: "Modules", "AUtils.swiftmodule"))`
	`41`	`+ XCTAssertFileExists(buildPath.appending(components: "Modules", "BUtils.swiftmodule"))`
`42`	`42`	`_ = try SwiftPM.Build.execute(packagePath: pkgPath)`
`43`	`43`	`}`
`44`	`44`	`}`
Original file line number	Diff line number	Diff line change
`@@ -94,7 +94,7 @@ class InitTests: XCTestCase {`
`94`	`94`	`#else`
`95`	`95`	`XCTAssertFileExists(binPath.appending("Foo"))`
`96`	`96`	`#endif`
`97`		`- XCTAssertFileExists(binPath.appending(components: "Foo.swiftmodule"))`
	`97`	`+ XCTAssertFileExists(binPath.appending(components: "Modules", "Foo.swiftmodule"))`
`98`	`98`	`}`
`99`	`99`	`}`
`100`	`100`
`@@ -145,7 +145,7 @@ class InitTests: XCTestCase {`
`145`	`145`	`// Try building it`
`146`	`146`	`XCTAssertBuilds(path)`
`147`	`147`	`let triple = try UserToolchain.default.targetTriple`
`148`		`- XCTAssertFileExists(path.appending(components: ".build", triple.platformBuildPathComponent, "debug", "Foo.swiftmodule"))`
	`148`	`+ XCTAssertFileExists(path.appending(components: ".build", triple.platformBuildPathComponent, "debug", "Modules", "Foo.swiftmodule"))`
`149`	`149`	`}`
`150`	`150`	`}`
`151`	`151`
`@@ -243,7 +243,7 @@ class InitTests: XCTestCase {`
`243`	`243`	`// Try building it.`
`244`	`244`	`XCTAssertBuilds(packageRoot)`
`245`	`245`	`let triple = try UserToolchain.default.targetTriple`
`246`		`- XCTAssertFileExists(packageRoot.appending(components: ".build", triple.platformBuildPathComponent, "debug", "some_package.swiftmodule"))`
	`246`	`+ XCTAssertFileExists(packageRoot.appending(components: ".build", triple.platformBuildPathComponent, "debug", "Modules", "some_package.swiftmodule"))`
`247`	`247`	`}`
`248`	`248`	`}`
`249`	`249`