Merge pull request #283 from swiftwasm/release/5.3

[pull] swiftwasm-release/5.3 from release/5.3

Author: pull[bot]

IntegrationTests/Tests/IntegrationTests/BasicTests.swift

@@ -232,4 +232,80 @@ final class BasicTests: XCTestCase {
             }
         }
     }
+  
+    func testSwiftTestWithResources() throws {
+        try withTemporaryDirectory { dir in
+            let toolDir = dir.appending(component: "swiftTestResources")
+            try localFileSystem.createDirectory(toolDir)
+            try localFileSystem.writeFileContents(
+              toolDir.appending(component: "Package.swift"),
+              bytes: ByteString(encodingAsUTF8: """
+                    // swift-tools-version:5.3
+                    import PackageDescription
+
+                    let package = Package(
+                       name: "AwesomeResources",
+                       targets: [
+                           .target(name: "AwesomeResources", resources: [.copy("hello.txt")]),
+                           .testTarget(name: "AwesomeResourcesTest", dependencies: ["AwesomeResources"], resources: [.copy("world.txt")])
+                       ]
+                    )
+                    """)
+            )
+            try localFileSystem.createDirectory(toolDir.appending(component: "Sources"))
+            try localFileSystem.createDirectory(toolDir.appending(components: "Sources", "AwesomeResources"))
+            try localFileSystem.writeFileContents(
+              toolDir.appending(components: "Sources", "AwesomeResources", "AwesomeResource.swift"),
+              bytes: ByteString(encodingAsUTF8: """
+                    import Foundation
+
+                    public struct AwesomeResource {
+                      public init() {}
+                      public let hello = try! String(contentsOf: Bundle.module.url(forResource: "hello", withExtension: "txt")!)
+                    }
+
+                    """)
+            )
+
+            try localFileSystem.writeFileContents(
+              toolDir.appending(components: "Sources", "AwesomeResources", "hello.txt"),
+              bytes: ByteString(encodingAsUTF8: "hello")
+            )
+
+            try localFileSystem.createDirectory(toolDir.appending(component: "Tests"))
+            try localFileSystem.createDirectory(toolDir.appending(components: "Tests", "AwesomeResourcesTest"))
+
+            try localFileSystem.writeFileContents(
+              toolDir.appending(components: "Tests", "AwesomeResourcesTest", "world.txt"),
+              bytes: ByteString(encodingAsUTF8: "world")
+            )
+
+            try localFileSystem.writeFileContents(
+                toolDir.appending(components: "Tests", "AwesomeResourcesTest", "MyTests.swift"),
+                bytes: ByteString(encodingAsUTF8: """
+                    import XCTest
+                    import Foundation
+                    import AwesomeResources
+
+                    final class MyTests: XCTestCase {
+                        func testFoo() {
+                            XCTAssertTrue(AwesomeResource().hello == "hello")
+                        }
+                        func testBar() {
+                            let world = try! String(contentsOf: Bundle.module.url(forResource: "world", withExtension: "txt")!)
+                            XCTAssertTrue(world == "world")
+                        }
+                    }
+                    """))
+          
+            let testOutput = try sh(swiftTest, "--package-path", toolDir, "--filter", "MyTests.*").stderr
+
+//             Check the test log.
+              XCTAssertContents(testOutput) { checker in
+                  checker.check(.contains("Test Suite 'MyTests' started"))
+                  checker.check(.contains("Test Suite 'MyTests' passed"))
+                  checker.check(.contains("Executed 2 tests, with 0 failures"))
+              }
+        }
+    }
 }

Sources/Build/BuildPlan.swift

@@ -578,19 +578,21 @@ public final class SwiftTargetBuildDescription {
         // Do nothing if we're not generating a bundle.
         guard let bundlePath = self.bundlePath else { return }
 
-        // Compute the basename of the bundle.
-        let bundleBasename = bundlePath.basename
-
         let stream = BufferedOutputByteStream()
         stream <<< """
         import class Foundation.Bundle
 
         extension Foundation.Bundle {
             static var module: Bundle = {
-                let bundlePath = Bundle.main.bundlePath + "/" + "\(bundleBasename)"
-                guard let bundle = Bundle(path: bundlePath) else {
-                    fatalError("could not load resource bundle: \\(bundlePath)")
+                let mainPath = Bundle.main.bundlePath + "/" + "\(bundlePath.basename)"
+                let buildPath = "\(bundlePath.pathString)"
+
+                let preferredBundle = Bundle(path: mainPath)
+
+                guard let bundle = preferredBundle != nil ? preferredBundle : Bundle(path: buildPath) else {
+                    fatalError("could not load resource bundle: from \\(mainPath) or \\(buildPath)")
                 }
+
                 return bundle
             }()
         }

Sources/Build/XCFrameworkInfo.swift

@@ -9,6 +9,7 @@ See http://swift.org/CONTRIBUTORS.txt for Swift project authors
 */
 
 import TSCBasic
+import TSCUtility
 import PackageModel
 import SPMBuildCore
 import Foundation

Sources/PackageLoading/ManifestLoader.swift

@@ -494,6 +494,7 @@ public final class ManifestLoader: ManifestLoaderProtocol {
         }
     }
 
+    private static var _hostTriple: Triple?
     private static var _packageDescriptionMinimumDeploymentTarget: String?
 
     /// Parse the manifest at the given path to JSON.
@@ -558,11 +559,15 @@ public final class ManifestLoader: ManifestLoaderProtocol {
 
             // Use the same minimum deployment target as the PackageDescription library (with a fallback of 10.15).
             #if os(macOS)
+            if Self._hostTriple == nil {
+                Self._hostTriple = Triple.getHostTriple(usingSwiftCompiler: resources.swiftCompiler)
+            }
+            let triple = Self._hostTriple!
             if Self._packageDescriptionMinimumDeploymentTarget == nil {
                 Self._packageDescriptionMinimumDeploymentTarget = (try MinimumDeploymentTarget.computeMinimumDeploymentTarget(of: macOSPackageDescriptionPath))?.versionString ?? "10.15"
             }
             let version = Self._packageDescriptionMinimumDeploymentTarget!
-            cmd += ["-target", "x86_64-apple-macosx\(version)"]
+            cmd += ["-target", "\(triple.tripleString(forPlatformVersion: version))"]
             #endif
 
             cmd += compilerFlags

Sources/SPMBuildCore/CMakeLists.txt

@@ -11,8 +11,7 @@ add_library(SPMBuildCore
   BuildSystem.swift
   BuiltTestProduct.swift
   Sanitizers.swift
-  Toolchain.swift
-  Triple.swift)
+  Toolchain.swift)
 # NOTE(compnerd) workaround for CMake not setting up include flags yet
 set_target_properties(SPMBuildCore PROPERTIES
   INTERFACE_INCLUDE_DIRECTORIES ${CMAKE_Swift_MODULE_DIRECTORY})

Tests/BuildTests/BuildPlanTests.swift

@@ -59,7 +59,7 @@ final class BuildPlanTests: XCTestCase {
         config: BuildConfiguration = .debug,
         flags: BuildFlags = BuildFlags(),
         shouldLinkStaticSwiftStdlib: Bool = false,
-        destinationTriple: Triple = hostTriple,
+        destinationTriple: TSCUtility.Triple = hostTriple,
         indexStoreMode: BuildParameters.IndexStoreMode = .off
     ) -> BuildParameters {
         return BuildParameters(
@@ -75,7 +75,7 @@ final class BuildPlanTests: XCTestCase {
     }
 
     func mockBuildParameters(environment: BuildEnvironment) -> BuildParameters {
-        let triple: Triple
+        let triple: TSCUtility.Triple
         switch environment.platform {
         case .macOS:
             triple = Triple.macOS
@@ -1765,7 +1765,7 @@ final class BuildPlanTests: XCTestCase {
         )
         XCTAssertNoDiagnostics(diagnostics)
 
-        func createResult(for dest: Triple) throws -> BuildPlanResult {
+        func createResult(for dest: TSCUtility.Triple) throws -> BuildPlanResult {
             return BuildPlanResult(plan: try BuildPlan(
                 buildParameters: mockBuildParameters(destinationTriple: dest),
                 graph: graph, diagnostics: diagnostics,
@@ -2207,7 +2207,8 @@ final class BuildPlanTests: XCTestCase {
         ])
     }
 
-    func testBinaryTargets(platform: String, arch: String, destinationTriple: Triple) throws {
+    func testBinaryTargets(platform: String, arch: String, destinationTriple: TSCUtility.Triple)
+    throws {
         let fs = InMemoryFileSystem(emptyFiles:
             "/Pkg/Sources/exe/main.swift",
             "/Pkg/Sources/Library/Library.swift",
@@ -2345,9 +2346,9 @@ final class BuildPlanTests: XCTestCase {
 
     func testBinaryTargets() throws {
         try testBinaryTargets(platform: "macos", arch: "x86_64", destinationTriple: .macOS)
-        let arm64Triple = try Triple("arm64-apple-macosx")
+        let arm64Triple = try TSCUtility.Triple("arm64-apple-macosx")
         try testBinaryTargets(platform: "macos", arch: "arm64", destinationTriple: arm64Triple)
-        let arm64eTriple = try Triple("arm64e-apple-macosx")
+        let arm64eTriple = try TSCUtility.Triple("arm64e-apple-macosx")
         try testBinaryTargets(platform: "macos", arch: "arm64e", destinationTriple: arm64eTriple)
     }
 
@@ -2481,7 +2482,7 @@ fileprivate extension TargetBuildDescription {
     }
 }
 
-fileprivate extension Triple {
+fileprivate extension TSCUtility.Triple {
     static let x86_64Linux = try! Triple("x86_64-unknown-linux-gnu")
     static let arm64Linux = try! Triple("aarch64-unknown-linux-gnu")
     static let arm64Android = try! Triple("aarch64-unknown-linux-android")

swift-tools-support-core/Sources/TSCUtility/CMakeLists.txt

@@ -29,6 +29,7 @@ add_library(TSCUtility
   SimplePersistence.swift
   StringExtensions.swift
   StringMangling.swift
+  Triple.swift
   URL.swift
   Verbosity.swift
   Version.swift