Fix build

Author: stevapple

Sources/SwiftDriver/Driver/Driver.swift

@@ -280,7 +280,7 @@ public struct Driver {
   public static let stderrDiagnosticsHandler: DiagnosticsEngine.DiagnosticsHandler = { diagnostic in
     let stream = stderrStream
     if !(diagnostic.location is UnknownLocation) {
-        stream <<< diagnostic.location.description <<< ": "
+      stream <<< diagnostic.location.description <<< ": "
     }
 
     switch diagnostic.message.behavior {
@@ -293,7 +293,7 @@ public struct Driver {
     case .remark:
       stream <<< "remark: "
     case .ignored:
-        break
+      break
     }
 
     stream <<< diagnostic.localizedDescription <<< "\n"

Sources/SwiftDriver/Jobs/WindowsToolchain+LinkerSupport.swift

@@ -102,15 +102,13 @@ extension WindowsToolchain {
         isShared: hasRuntimeArgs
       )
 
-      let sharedResourceDirPath = try computeResourceDirPath(
-        for: targetTriple,
-        parsedOptions: &parsedOptions,
-        isShared: true
-      )
-
-      let swiftrtPath = sharedResourceDirPath.appending(
-        components: archName(for: targetTriple), "swiftrt.obj"
-      )
+      guard let swiftrtPath = targetInfo.sdkPath?.path
+        .appending(
+          components: "usr", "lib", "swift", "windows",
+          targetTriple.archName,
+          "swiftrt.obj") else {
+        throw ToolchainValidationError.sdkNotFound
+      }
       commandLine.appendPath(swiftrtPath)
 
       let inputFiles: [Job.ArgTemplate] = inputs.compactMap { input in
@@ -138,7 +136,7 @@ extension WindowsToolchain {
       // Add the runtime library link paths.
       for path in runtimePaths {
         commandLine.appendFlag(.L)
-        commandLine.appendPath(path.appending(component: archName(for: targetTriple)))
+        commandLine.appendPath(path.appending(component: targetTriple.archName))
       }
 
       if hasRuntimeArgs {

Sources/SwiftDriver/Toolchains/WindowsToolchain.swift

@@ -27,27 +27,15 @@ import SwiftOptions
 
   // An externally provided path from where we should find tools like ld
   public let toolDirectory: AbsolutePath?
-    
-    public let dummyForTestingObjectFormat = Triple.ObjectFormat.coff
-
-  public func archName(for triple: Triple) -> String {
-    switch triple.arch {
-    case .aarch64: return "aarch64"
-    case .arm: return "armv7"
-    case .x86: return "i386"
-    case nil, .x86_64: return "x86_64"
-    default: fatalError("unknown arch \(triple.archName) for Windows")
-    }
-  }
 
-    public init(env: [String: String], executor: DriverExecutor, fileSystem: FileSystem = localFileSystem, toolDirectory: AbsolutePath? = nil) {
-      self.env = env
-      self.executor = executor
-      self.fileSystem = fileSystem
-      self.toolDirectory = toolDirectory
-    }
+  public let dummyForTestingObjectFormat = Triple.ObjectFormat.coff
 
-  
+  public init(env: [String: String], executor: DriverExecutor, fileSystem: FileSystem = localFileSystem, toolDirectory: AbsolutePath? = nil) {
+    self.env = env
+    self.executor = executor
+    self.fileSystem = fileSystem
+    self.toolDirectory = toolDirectory
+  }
 
   /// Retrieve the absolute path for a given tool.
   public func getToolPath(_ tool: Tool) throws -> AbsolutePath {
@@ -68,7 +56,6 @@ import SwiftOptions
     case .staticLinker:
       return try lookup(executable: "lib")
     case .dynamicLinker:
-      // FIXME: This needs to look in the tools_directory first.
       return try lookup(executable: "link")
     case .clang:
       return try lookup(executable: "clang")
@@ -88,19 +75,19 @@ import SwiftOptions
   public func overrideToolPath(_ tool: Tool, path: AbsolutePath) {
     toolPaths[tool] = path
   }
-    
-    /// Path to the StdLib inside the SDK.
-    public func sdkStdlib(sdk: AbsolutePath, triple: Triple) -> AbsolutePath {
-        sdk.appending(RelativePath("usr/lib/swift/windows")).appending(component: archName(for: triple))
-    }
-    
-    public func makeLinkerOutputFilename(moduleName: String, type: LinkOutputType) -> String {
-      switch type {
-      case .executable: return "\(moduleName).exe"
-      case .dynamicLibrary: return "\(moduleName).dll"
-      case .staticLibrary: return "lib\(moduleName).lib"
-      }
+
+  /// Path to the StdLib inside the SDK.
+  public func sdkStdlib(sdk: AbsolutePath, triple: Triple) -> AbsolutePath {
+    sdk.appending(RelativePath("usr/lib/swift/windows")).appending(component: triple.archName)
+  }
+
+  public func makeLinkerOutputFilename(moduleName: String, type: LinkOutputType) -> String {
+    switch type {
+    case .executable: return "\(moduleName).exe"
+    case .dynamicLibrary: return "\(moduleName).dll"
+    case .staticLibrary: return "lib\(moduleName).lib"
     }
+  }
 
   public func defaultSDKPath(_ target: Triple?) throws -> AbsolutePath? {
     return nil
@@ -113,7 +100,7 @@ import SwiftOptions
     targetTriple: Triple,
     isShared: Bool
   ) throws -> String {
-    return "clang_rt.\(sanitizer.libraryName)-\(archName(for: targetTriple)).lib"
+    return "clang_rt.\(sanitizer.libraryName)-\(targetTriple.archName).lib"
   }
 }
 
@@ -141,13 +128,16 @@ extension WindowsToolchain {
   public enum ToolchainValidationError: Error, DiagnosticData {
     case argumentNotSupported(String)
     case illegalCrtName(String)
+    case sdkNotFound
 
     public var description: String {
       switch self {
       case .argumentNotSupported(let argument):
         return "\(argument) is not supported for Windows"
       case .illegalCrtName(let argument):
         return "\(argument) is not a valid C Runtime for Windows"
+      case .sdkNotFound:
+        return "swift development on Windows always requires SDK of the target platform"
       }
     }
   }

Sources/swift-driver/main.swift

@@ -2,7 +2,7 @@
 //
 // This source file is part of the Swift.org open source project
 //
-// Copyright (c) 2014 - 2019 Apple Inc. and the Swift project authors
+// Copyright (c) 2014 - 2020 Apple Inc. and the Swift project authors
 // Licensed under Apache License v2.0 with Runtime Library Exception
 //
 // See https://swift.org/LICENSE.txt for license information
@@ -31,9 +31,9 @@ do {
     // We are running as a subcommand, try to find the subcommand adjacent to the executable we are running as.
     // If we didn't find the tool there, let the OS search for it.
     #if os(Windows)
-    let filename = subcommand + ".exe"
+      let filename = subcommand + ".exe"
     #else
-    let filename = subcommand
+      let filename = subcommand
     #endif
     let subcommandPath = Process.findExecutable(arguments[0])?.parentDirectory.appending(component: filename)
                          ?? Process.findExecutable(filename)