Add more incremental logic

Author: David Ungar

Sources/SwiftDriver/Driver/Driver.swift

@@ -18,6 +18,13 @@ public enum ModuleOutput: Equatable {
       return path
     }
   }
+
+  public var isTopLevel: Bool {
+    switch self {
+    case .topLevel: return true
+    default: return false
+    }
+  }
 }
 
 /// The Swift driver.
@@ -63,12 +70,6 @@ public struct Driver {
   /// The mode in which the compiler will execute.
   public let compilerMode: CompilerMode
 
-  /// Whether to print out incremental build decisions
-  public let showIncrementalBuildDecisions: Bool
-
-  /// Is the build incremental?
-  public let isIncremental: Bool
-
   /// The type of the primary output generated by the compiler.
   public let compilerOutputType: FileType?
 
@@ -88,6 +89,9 @@ public struct Driver {
   /// \c nil if no module should be emitted.
   public let moduleOutput: ModuleOutput?
 
+  /// Code & data for incremental compilation
+  public let incrementalCompilation: IncrementalCompilation
+
   /// The name of the Swift module being built.
   public let moduleName: String
 
@@ -196,24 +200,17 @@ public struct Driver {
     self.inputFiles = try Self.collectInputFiles(&self.parsedOptions)
 
     // Initialize an empty output file map, which will be populated when we start creating jobs.
-    let outputFileMap: OutputFileMap?
     if let outputFileMapArg = parsedOptions.getLastArgument(.output_file_map)?.asSingle {
       let path = try AbsolutePath(validating: outputFileMapArg)
-      outputFileMap = try .load(file: path, diagnosticEngine: diagnosticEngine)
+      self.outputFileMap = try .load(file: path, diagnosticEngine: diagnosticEngine)
     }
     else {
-      outputFileMap = nil
+      self.outputFileMap = nil
     }
-    self.outputFileMap = outputFileMap
 
     // Determine the compilation mode.
     self.compilerMode = Self.computeCompilerMode(&parsedOptions, driverKind: driverKind)
 
-    // Determine whether the compilation should be incremental
-    (showIncrementalBuildDecisions: self.showIncrementalBuildDecisions,
-     shouldBeIncremental: self.isIncremental) =
-        Self.computeIncrementalPredicates(&parsedOptions, driverKind: driverKind)
-
     // Figure out the primary outputs from the driver.
     (self.compilerOutputType, self.linkerOutputType) = Self.determinePrimaryOutputs(&parsedOptions, driverKind: driverKind, diagnosticsEngine: diagnosticEngine)
 
@@ -224,9 +221,20 @@ public struct Driver {
     (self.debugInfoLevel, self.debugInfoFormat) = Self.computeDebugInfo(&parsedOptions, diagnosticsEngine: diagnosticEngine)
 
     // Determine the module we're building and whether/how the module file itself will be emitted.
-    (self.moduleOutput, self.moduleName) = try Self.computeModuleInfo(
+    let moduleOutput: ModuleOutput?
+    (moduleOutput, self.moduleName) = try Self.computeModuleInfo(
       &parsedOptions, compilerOutputType: compilerOutputType, compilerMode: compilerMode, linkerOutputType: linkerOutputType,
       debugInfoLevel: debugInfoLevel, diagnosticsEngine: diagnosticEngine)
+    self.moduleOutput = moduleOutput
+
+    // Determine the state for incremental compilation
+    self.incrementalCompilation = IncrementalCompilation(
+      &parsedOptions,
+      compilerMode: compilerMode,
+      outputFileMap: self.outputFileMap,
+      compilerOutputType: self.compilerOutputType,
+      moduleOutput: moduleOutput,
+      diagnosticEngine: diagnosticEngine)
 
     self.sdkPath = Self.computeSDKPath(&parsedOptions, compilerMode: compilerMode, toolchain: toolchain, diagnosticsEngine: diagnosticEngine)
 
@@ -402,31 +410,6 @@ extension Driver {
   }
 }
 
-extension Driver {
-    /// Compute whether the compilation should be incremental
-    private static func computeIncrementalPredicates(
-        _ parsedOptions: inout ParsedOptions,
-        driverKind: DriverKind) -> (showIncrementalBuildDecisions: Bool, shouldBeIncremental: Bool) {
-        let showIncrementalBuildDecisions = parsedOptions.hasArgument(.driver_show_incremental))
-        guard (parsedOptions.hasArgument(.incremental) else {
-            return (showIncrementalBuildDecisions: showIncrementalBuildDecisions, shouldBeIncremental: false)
-            }
-        guard let reasonToDisable = parsedOptions.hasArgument(.whole_module_optimization)
-            ? "is not compatible with whole module optimization."
-            : parsedOptions.hasArgument(.embed_bitcode)
-            ? "is not currently compatible with embedding LLVM IR bitcode."
-            : nil
-        else {
-            return (showIncrementalBuildDecisions: showIncrementalBuildDecisions, shouldBeIncremental: true)
-        }
-        if (showIncrementalBuildDecisions) {
-            stderrStream <<<"Incremental compilation has been disabled, because it \(reasonToDisable)\n"
-            stderrStream.flush()
-        }
-        return (showIncrementalBuildDecisions: showIncrementalBuildDecisions, shouldBeIncremental: false)
-    }
-}
-
 /// Input and output file handling.
 extension Driver {
   /// Apply the given working directory to all paths in the parsed options.

Sources/SwiftDriver/Driver/IncrementalCompilation.swift

@@ -0,0 +1,112 @@
+import TSCBasic
+import TSCUtility
+
+public struct IncrementalCompilation {
+  public let showIncrementalBuildDecisions: Bool
+  public let shouldCompileIncrementally: Bool
+  public let buildRecordPath: VirtualPath?
+  public let outputBuildRecordForModuleOnlyBuild: Bool
+
+  public init(_ parsedOptions: inout ParsedOptions,
+       compilerMode: CompilerMode,
+       outputFileMap: OutputFileMap?,
+       compilerOutputType: FileType?,
+       moduleOutput: ModuleOutput?,
+       diagnosticEngine: DiagnosticsEngine
+  ) {
+    let showIncrementalBuildDecisions = Self.getShowIncrementalBuildDecisions(&parsedOptions)
+    self.showIncrementalBuildDecisions = showIncrementalBuildDecisions
+
+    let shouldCompileIncrementally = Self.computeAndExplainShouldCompileIncrementally(
+      &parsedOptions,
+      showIncrementalBuildDecisions: showIncrementalBuildDecisions,
+      compilerMode: compilerMode)
+
+    self.shouldCompileIncrementally = shouldCompileIncrementally
+
+    self.buildRecordPath = Self.computeBuildRecordPath(
+      outputFileMap: outputFileMap,
+      compilerOutputType: compilerOutputType,
+      diagnosticEngine: shouldCompileIncrementally ? diagnosticEngine : nil)
+
+    // If we emit module along with full compilation, emit build record
+    // file for '-emit-module' only mode as well.
+    self.outputBuildRecordForModuleOnlyBuild = self.buildRecordPath != nil &&
+      moduleOutput?.isTopLevel ?? false
+  }
+
+  private static func getShowIncrementalBuildDecisions(_ parsedOptions: inout ParsedOptions)  -> Bool {
+    parsedOptions.hasArgument(.driver_show_incremental)
+  }
+
+  private static func computeAndExplainShouldCompileIncrementally(
+    _ parsedOptions: inout ParsedOptions,
+    showIncrementalBuildDecisions: Bool,
+    compilerMode: CompilerMode
+  )
+    -> Bool
+  {
+    func explain(disabledBecause why: String) {
+      stdoutStream <<< "Incremental compilation has been disabled, because it \(why).\n"
+      stdoutStream.flush()
+    }
+    guard parsedOptions.hasArgument(.incremental) else {
+      return false
+    }
+    guard compilerMode.supportsIncrementalCompilation else {
+      explain(disabledBecause: "is not compatible with \(compilerMode)")
+      return false
+    }
+    guard !parsedOptions.hasArgument(.embed_bitcode) else {
+      explain(disabledBecause: "is not currently compatible with embedding LLVM IR bitcode")
+      return false
+    }
+    return true
+  }
+
+  private static func computeBuildRecordPath(
+    outputFileMap: OutputFileMap?,
+    compilerOutputType: FileType?,
+    diagnosticEngine: DiagnosticsEngine?
+  ) -> VirtualPath? {
+    // FIXME: This should work without an output file map. We should have
+    // another way to specify a build record and where to put intermediates.
+    guard let ofm = outputFileMap else {
+      diagnosticEngine.map { $0.emit(.warning_incremental_requires_output_file_map) }
+      return nil
+    }
+    guard let partialBuildRecordPath = ofm.existingOutputForSingleInput(outputType: .swiftDeps)
+      else {
+        diagnosticEngine.map { $0.emit(.warning_incremental_requires_build_record_entry) }
+        return nil
+    }
+    // In 'emit-module' only mode, use build-record filename suffixed with
+    // '~moduleonly'. So that module-only mode doesn't mess up build-record
+    // file for full compilation.
+    return try! compilerOutputType == .swiftModule
+      ? VirtualPath(path: partialBuildRecordPath.name + "~moduleonly")
+      : partialBuildRecordPath
+  }
+}
+
+
+fileprivate extension CompilerMode {
+  var supportsIncrementalCompilation: Bool {
+    switch self {
+    case .standardCompile, .immediate, .repl: return true
+    case .singleCompile: return false
+    }
+  }
+}
+
+public extension Diagnostic.Message {
+  static var warning_incremental_requires_output_file_map: Diagnostic.Message {
+    .warning("ignoring -incremental (currently requires an output file map)")
+  }
+  static var warning_incremental_requires_build_record_entry: Diagnostic.Message {
+    .warning(
+      "ignoring -incremental; " +
+      "output file map has no master dependencies entry under \(FileType.swiftDeps)"
+    )
+  }
+}