Merge pull request #21 from cltnschlosser/cs_emitPCH

Add generate PCH job

Author: DougGregor

Sources/SwiftDriver/Driver/Driver.swift

@@ -124,6 +124,9 @@ public struct Driver {
   /// The path to the imported Objective-C header.
   public let importedObjCHeader: VirtualPath?
 
+  /// The path to the pch for the imported Objective-C header.
+  public let bridgingPrecompiledHeader: VirtualPath?
+
   /// Path to the dependencies file.
   public let dependenciesFilePath: VirtualPath?
 
@@ -289,6 +292,9 @@ public struct Driver {
     self.sdkPath = Self.computeSDKPath(&parsedOptions, compilerMode: compilerMode, toolchain: toolchain, diagnosticsEngine: diagnosticEngine, env: env)
 
     self.importedObjCHeader = try Self.computeImportedObjCHeader(&parsedOptions, compilerMode: compilerMode, diagnosticEngine: diagnosticEngine)
+    self.bridgingPrecompiledHeader = try Self.computeBridgingPrecompiledHeader(&parsedOptions,
+                                                                               importedObjCHeader: importedObjCHeader,
+                                                                               outputFileMap: outputFileMap)
 
     self.enabledSanitizers = try Self.parseSanitizerArgValues(&parsedOptions, diagnosticEngine: diagnosticEngine, toolchain: toolchain, targetTriple: targetTriple)
 
@@ -1332,9 +1338,29 @@ extension Driver {
       diagnosticEngine.emit(.error_bridging_header_module_interface)
     }
 
-    let objcHeaderPath = try VirtualPath(path: objcHeaderPathArg.asSingle)
-    // FIXME: Precompile bridging header if requested.
-    return objcHeaderPath
+    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?,
+                                               outputFileMap: OutputFileMap?) throws -> VirtualPath? {
+    guard let input = importedObjCHeader,
+      parsedOptions.hasFlag(positive: .enableBridgingPch, negative: .disableBridgingPch, default: true) else {
+        return nil
+    }
+
+    if let outputPath = outputFileMap?.existingOutput(inputFile: input, outputType: .pch) {
+      return outputPath
+    }
+
+    // FIXME: should have '-.*' at the end of the filename, similar to llvm::sys::fs::createTemporaryFile
+    let pchFileName = input.basenameWithoutExt.appendingFileTypeExtension(.pch)
+    if let outputDirectory = parsedOptions.getLastArgument(.pchOutputDir)?.asSingle {
+      return try VirtualPath(path: outputDirectory).appending(component: pchFileName)
+    } else {
+      return .temporary(RelativePath(pchFileName))
+    }
   }
 }
 

Sources/SwiftDriver/Jobs/CompileJob.swift

@@ -26,7 +26,7 @@ extension Driver {
   }
 
   /// Add the compiler inputs for a frontend compilation job, and return the corresponding primary set of outputs.
-  mutating func addCompileInputs(primaryInputs: [TypedVirtualPath], inputs: inout [TypedVirtualPath], commandLine: inout [Job.ArgTemplate]) -> [TypedVirtualPath] {
+  func addCompileInputs(primaryInputs: [TypedVirtualPath], inputs: inout [TypedVirtualPath], commandLine: inout [Job.ArgTemplate]) -> [TypedVirtualPath] {
     // Collect the set of input files that are part of the Swift compilation.
     let swiftInputFiles: [TypedVirtualPath] = inputFiles.compactMap { inputFile in
       if inputFile.type.isPartOfSwiftCompilation {

Sources/SwiftDriver/Jobs/FrontendJobHelpers.swift

@@ -22,7 +22,8 @@ fileprivate func shouldColorDiagnostics() -> Bool {
 
 extension Driver {
   /// Add frontend options that are common to different frontend invocations.
-  mutating func addCommonFrontendOptions(commandLine: inout [Job.ArgTemplate]) throws {
+  mutating func addCommonFrontendOptions(commandLine: inout [Job.ArgTemplate],
+                                         requestPrecompiledObjCHeader: Bool = true) throws {
     // Only pass -target to the REPL or immediate modes if it was explicitly
     // specified on the command line.
     switch compilerMode {
@@ -157,7 +158,22 @@ extension Driver {
 
     if let importedObjCHeader = importedObjCHeader {
       commandLine.appendFlag(.importObjcHeader)
-      commandLine.appendPath(importedObjCHeader)
+      if requestPrecompiledObjCHeader, let pch = bridgingPrecompiledHeader {
+        if parsedOptions.contains(.pchOutputDir) {
+          commandLine.appendPath(importedObjCHeader)
+          switch compilerMode {
+          case .standardCompile, .batchCompile, .repl, .immediate:
+            commandLine.appendFlag(.pchDisableValidation)
+          case .singleCompile:
+            // Don't disable validation for single compile
+            break
+          }
+        } else {
+          commandLine.appendPath(pch)
+        }
+      } else {
+        commandLine.appendPath(importedObjCHeader)
+      }
     }
 
     // Repl Jobs may include -module-name depending on the selected REPL (LLDB or integrated).

Sources/SwiftDriver/Jobs/GeneratePCHJob.swift

@@ -0,0 +1,68 @@
+//===--------------- GeneratePCHJob.swift - Generate PCH Job ----===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2019 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
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+
+import TSCBasic
+import TSCUtility
+
+extension Driver {
+  mutating func generatePCHJob(input: TypedVirtualPath, output: TypedVirtualPath) throws -> Job {
+    var inputs = [TypedVirtualPath]()
+    var outputs = [TypedVirtualPath]()
+    
+    var commandLine: [Job.ArgTemplate] = swiftCompilerPrefixArgs.map { Job.ArgTemplate.flag($0) }
+    
+    inputs.append(input)
+    commandLine.appendPath(input.file)
+    commandLine.appendFlag(.emitPch)
+    
+    outputs.append(output)
+    
+    try addCommonFrontendOptions(commandLine: &commandLine, requestPrecompiledObjCHeader: false)
+    
+    try commandLine.appendLast(.indexStorePath, from: &parsedOptions)
+
+    // 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 outputPath = outputFileMap?.existingOutput(inputFile: input.file, outputType: .diagnostics) {
+        path = outputPath
+      } else if let modulePath = parsedOptions.getLastArgument(.emitModulePath) {
+        // TODO: does this hash need to be persistent?
+        let code = UInt(bitPattern: modulePath.asSingle.hashValue)
+        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)))
+      }
+      commandLine.appendPath(path)
+      outputs.append(.init(file: path, type: .diagnostics))
+    }
+    
+    if parsedOptions.hasArgument(.pchOutputDir) {
+      try commandLine.appendLast(.pchOutputDir, from: &parsedOptions)
+    } else {
+      commandLine.appendFlag(.o)
+      commandLine.appendPath(output.file)
+    }
+    
+    return Job(
+      kind: .generatePCH,
+      tool: .absolute(try toolchain.getToolPath(.swiftCompiler)),
+      commandLine: commandLine,
+      displayInputs: [],
+      inputs: inputs,
+      outputs: outputs
+    )
+  }
+}

Sources/SwiftDriver/Jobs/Job.swift

@@ -20,6 +20,7 @@ public struct Job: Codable, Equatable {
     case generateDSYM = "generate-dsym"
     case autolinkExtract = "autolink-extract"
     case emitModule = "emit-module"
+    case generatePCH = "generate-pch"
     case interpret
     case repl
     case verifyDebugInfo = "verify-debug-info"

Sources/SwiftDriver/Jobs/Planning.swift

@@ -45,6 +45,12 @@ extension Driver {
         }
       }
     }
+    
+    if let importedObjCHeader = importedObjCHeader,
+      let bridgingPrecompiledHeader = bridgingPrecompiledHeader {
+      jobs.append(try generatePCHJob(input: .init(file: importedObjCHeader, type: .objcHeader),
+                                     output: .init(file: bridgingPrecompiledHeader, type: .pch)))
+    }
 
     // If we should create emit module job, do so.
     if shouldCreateEmitModuleJob {

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 {