Remove Foundation imports for NSString file path management.

Author: cltnschlosser

Sources/SwiftDriver/Driver/Driver.swift

@@ -9,8 +9,6 @@
 // See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
 //
 //===----------------------------------------------------------------------===//
-
-import Foundation
 import TSCBasic
 import TSCUtility
 
@@ -1338,39 +1336,28 @@ extension Driver {
       diagnosticEngine.emit(.error_bridging_header_module_interface)
     }
 
-    let objcHeader = try VirtualPath(path: objcHeaderPathArg.asSingle)
-    
-    if objcHeader.extension != FileType.objcHeader.rawValue {
-      diagnosticEngine.emit(.error_objc_header_not_header)
-    }
-    
-    return objcHeader
+    return try VirtualPath(path: objcHeaderPathArg.asSingle)
   }
-  
+
   /// Compute the path of the generated bridging PCH for the Objective-C header.
   static func computeBridgingPrecompiledHeader(_ parsedOptions: inout ParsedOptions, importedObjCHeader: VirtualPath?) throws -> VirtualPath? {
     guard let input = importedObjCHeader,
       parsedOptions.hasFlag(positive: .enableBridgingPch, negative: .disableBridgingPch, default: true) else {
         return nil
     }
+    // FIXME: Check OutputFileMap?
+
     // FIXME: should have '-.*' at the end of the filename, similar to llvm::sys::fs::createTemporaryFile
     let pchFileName = input.basenameWithoutExt.appendingFileTypeExtension(.pch)
-    let output: VirtualPath
     if let outputDirectory = parsedOptions.getLastArgument(.pchOutputDir)?.asSingle {
-      let outputPath = (outputDirectory as NSString).appendingPathComponent(pchFileName)
-      output = try VirtualPath(path: outputPath)
+      return try VirtualPath(path: outputDirectory).appending(component: pchFileName)
     } else {
-      output = .temporary(RelativePath(pchFileName))
+      return .temporary(RelativePath(pchFileName))
     }
-    return output
   }
 }
 
 extension Diagnostic.Message {
-  static var error_objc_header_not_header: Diagnostic.Message {
-    .error("ObjC header needs to be .h file")
-  }
-  
   static var error_framework_bridging_header: Diagnostic.Message {
     .error("using bridging headers with framework targets is unsupported")
   }

Sources/SwiftDriver/Jobs/FrontendJobHelpers.swift

@@ -155,14 +155,18 @@ extension Driver {
     // Pass through any subsystem flags.
     try commandLine.appendAll(.Xllvm, from: &parsedOptions)
     try commandLine.appendAll(.Xcc, from: &parsedOptions)
-    
+
     if let importedObjCHeader = importedObjCHeader {
       commandLine.appendFlag(.importObjcHeader)
       if requestPrecompiledObjCHeader, let pch = bridgingPrecompiledHeader {
         if parsedOptions.contains(.pchOutputDir) {
           commandLine.appendPath(importedObjCHeader)
-          if compilerMode != .singleCompile {
+          switch compilerMode {
+          case .standardCompile, .batchCompile, .repl, .immediate:
             commandLine.appendFlag(.pchDisableValidation)
+          case .singleCompile:
+            // Don't disable validation for single compile
+            break
           }
         } else {
           commandLine.appendPath(pch)

Sources/SwiftDriver/Jobs/GeneratePCHJob.swift

@@ -10,7 +10,6 @@
 //
 //===----------------------------------------------------------------------===//
 
-import Foundation
 import TSCBasic
 import TSCUtility
 
@@ -31,17 +30,16 @@ extension Driver {
 
     try commandLine.appendLast(.indexStorePath, from: &parsedOptions)
 
+    // TODO: Move this to Driver and check OutputFileMap
     // TODO: Should this just be pch output with extension changed?
     if parsedOptions.hasArgument(.serializeDiagnostics), let outputDirectory = parsedOptions.getLastArgument(.pchOutputDir)?.asSingle {
       commandLine.appendFlag(.serializeDiagnosticsPath)
       let path: VirtualPath
       if let modulePath = parsedOptions.getLastArgument(.emitModulePath) {
-        var outputBase = (outputDirectory as NSString).appendingPathComponent(input.file.basenameWithoutExt)
-        outputBase.append("-")
         // TODO: does this hash need to be persistent?
         let code = UInt(bitPattern: modulePath.asSingle.hashValue)
-        outputBase.append(String(code, radix: 36))
-        path = try VirtualPath(path: outputBase.appendingFileTypeExtension(.diagnostics))
+        let outputName = input.file.basenameWithoutExt + "-" + String(code, radix: 36)
+        path = try VirtualPath(path: outputDirectory).appending(component: outputName.appendingFileTypeExtension(.diagnostics))
       } else {
         // FIXME: should have '-.*' at the end of the filename, similar to llvm::sys::fs::createTemporaryFile
         path = .temporary(RelativePath(input.file.basenameWithoutExt.appendingFileTypeExtension(.diagnostics)))

Sources/SwiftDriver/Utilities/VirtualPath.swift

@@ -91,6 +91,24 @@ public enum VirtualPath: Hashable {
       return ""
     }
   }
+
+  /// Returns the virtual path with an additional literal component appended.
+  ///
+  /// This should not be used with `.standardInput` or `.standardOutput`.
+  public func appending(component: String) -> VirtualPath {
+    switch self {
+    case .absolute(let path):
+      return .absolute(path.appending(component: component))
+    case .relative(let path):
+      // FIXME: TSCBasic should probably have RelativePath.appending(component:)
+      return .relative(RelativePath(path.pathString + "/" + component))
+    case .temporary(let path):
+      return .temporary(RelativePath(path.pathString + "/" + component))
+    case .standardInput, .standardOutput:
+      assertionFailure("Can't append path component to standard in/out")
+      return self
+    }
+  }
 }
 
 extension VirtualPath: Codable {