Don't pass -rpath and -lswiftCore for embedded Wasm

These options already aren't passed to the linker when linking statically, we shouldn't pass them in embedded mode either, where everything is linked statically too.

Author: MaxDesiatov

Sources/SwiftDriver/Jobs/FrontendJobHelpers.swift

@@ -112,11 +112,10 @@ extension Driver {
       commandLine.appendFlag("-aarch64-use-tbi")
     }
 
-    let experimentalFeatures = parsedOptions.arguments(for: .enableExperimentalFeature)
-    let embeddedEnabled = experimentalFeatures.map(\.argument).map(\.asSingle).contains("Embedded")
+    let isEmbeddedEnabled = parsedOptions.isEmbeddedEnabled
 
     // Enable or disable ObjC interop appropriately for the platform
-    if targetTriple.isDarwin && !embeddedEnabled {
+    if targetTriple.isDarwin && !isEmbeddedEnabled {
       commandLine.appendFlag(.enableObjcInterop)
     } else {
       commandLine.appendFlag(.disableObjcInterop)
@@ -130,18 +129,18 @@ extension Driver {
       commandLine.appendFlag("-stdlib=\(stdlibVariant)")
     }
 
-    if embeddedEnabled && parsedOptions.hasArgument(.enableLibraryEvolution) {
+    if isEmbeddedEnabled && parsedOptions.hasArgument(.enableLibraryEvolution) {
       diagnosticEngine.emit(.error_no_library_evolution_embedded)
       throw ErrorDiagnostics.emitted
     }
 
-    if embeddedEnabled &&
+    if isEmbeddedEnabled &&
        (!parsedOptions.hasArgument(.wmo) || !parsedOptions.hasArgument(.wholeModuleOptimization)) {
       diagnosticEngine.emit(.error_need_wmo_embedded)
       throw ErrorDiagnostics.emitted
     }
 
-    if embeddedEnabled && parsedOptions.hasArgument(.enableObjcInterop) {
+    if isEmbeddedEnabled && parsedOptions.hasArgument(.enableObjcInterop) {
       diagnosticEngine.emit(.error_no_objc_interop_embedded)
       throw ErrorDiagnostics.emitted
     }
@@ -873,3 +872,13 @@ extension Driver {
     return try cas.computeCacheKey(commandLine: arguments, input: remappedPath.name)
   }
 }
+
+extension ParsedOptions {
+  /// Checks whether experimental embedded mode is enabled.
+  var isEmbeddedEnabled: Bool {
+    mutating get {
+      let experimentalFeatures = self.arguments(for: .enableExperimentalFeature)
+      return experimentalFeatures.map(\.argument).map(\.asSingle).contains("Embedded")
+    }
+  }
+}

Sources/SwiftDriver/Jobs/GenericUnixToolchain+LinkerSupport.swift

@@ -158,11 +158,13 @@ extension GenericUnixToolchain {
       let staticExecutable = parsedOptions.hasFlag(positive: .staticExecutable,
                                                    negative: .noStaticExecutable,
                                                   default: false)
+      let isEmbeddedEnabled = parsedOptions.isEmbeddedEnabled
+
       let toolchainStdlibRpath = parsedOptions
                                  .hasFlag(positive: .toolchainStdlibRpath,
                                           negative: .noToolchainStdlibRpath,
                                           default: true)
-      let hasRuntimeArgs = !(staticStdlib || staticExecutable)
+      let hasRuntimeArgs = !(staticStdlib || staticExecutable || isEmbeddedEnabled)
 
       let runtimePaths = try runtimeLibraryPaths(
         for: targetInfo,
@@ -251,7 +253,7 @@ extension GenericUnixToolchain {
         linkFilePath = linkFilePath?.appending(component: "static-executable-args.lnk")
       } else if staticStdlib {
         linkFilePath = linkFilePath?.appending(component: "static-stdlib-args.lnk")
-      } else {
+      } else if !isEmbeddedEnabled {
         linkFilePath = nil
         commandLine.appendFlag("-lswiftCore")
       }

Tests/SwiftDriverTests/SwiftDriverTests.swift

@@ -6482,6 +6482,9 @@ final class SwiftDriverTests: XCTestCase {
   }
 
   func testEmbeddedSwiftOptions() throws {
+    var env = ProcessEnv.vars
+    env["SWIFT_DRIVER_SWIFT_AUTOLINK_EXTRACT_EXEC"] = "/garbage/swift-autolink-extract"
+
     do {
       var driver = try Driver(args: ["swiftc", "-target", "arm64-apple-macosx10.13",  "test.swift", "-enable-experimental-feature", "Embedded", "-parse-as-library", "-wmo", "-o", "a.out", "-module-name", "main"])
       let plannedJobs = try driver.planBuild()
@@ -6491,6 +6494,18 @@ final class SwiftDriverTests: XCTestCase {
       XCTAssertTrue(compileJob.commandLine.contains(.flag("-disable-objc-interop")))
       XCTAssertFalse(linkJob.commandLine.contains(.flag("-force_load")))
     }
+    do {
+      var driver = try Driver(args: ["swiftc", "-target", "wasm32-none-none-wasm",  "test.swift", "-enable-experimental-feature", "Embedded", "-wmo", "-o", "a.wasm"], env: env)
+      let plannedJobs = try driver.planBuild()
+      XCTAssertEqual(plannedJobs.count, 3)
+      let compileJob = plannedJobs[0]
+      let _ /*autolinkJob*/ = plannedJobs[1]
+      let linkJob = plannedJobs[2]
+      XCTAssertTrue(compileJob.commandLine.contains(.flag("-disable-objc-interop")))
+      XCTAssertFalse(linkJob.commandLine.contains(.flag("-force_load")))
+      XCTAssertFalse(linkJob.commandLine.contains(.flag("-rpath")))
+      XCTAssertFalse(linkJob.commandLine.contains(.flag("-lswiftCore")))
+    }
     do {
       let diags = DiagnosticsEngine()
       var driver = try Driver(args: ["swiftc", "-target", "arm64-apple-macosx10.13",  "test.swift", "-enable-experimental-feature", "Embedded", "-parse-as-library", "-wmo", "-o", "a.out", "-module-name", "main", "-enable-library-evolution"], diagnosticsEngine: diags)