Merge pull request #1778 from owenv/ovoorhees/remove-legacy-incremental

Obselete -disable-incremental-imports setting

Author: owenv

Sources/SwiftDriver/Driver/Driver.swift

@@ -1778,68 +1778,33 @@ extension Driver {
     // In case the write fails, don't crash the build.
     // A mitigation to rdar://76359678.
     // If the write fails, import incrementality is lost, but it is not a fatal error.
-    guard
-      let buildRecordInfo = self.buildRecordInfo,
-      let absPath = buildRecordInfo.buildRecordPath.absolutePath
-    else {
+    guard let buildRecordInfo = self.buildRecordInfo, let incrementalCompilationState = self.incrementalCompilationState else {
       return
     }
-
+    
     let buildRecord = buildRecordInfo.buildRecord(
       jobs, self.incrementalCompilationState?.blockingConcurrentMutationToProtectedState{
         $0.skippedCompilationInputs
       })
-
-    if
-      let incrementalCompilationState = self.incrementalCompilationState,
-      incrementalCompilationState.info.isCrossModuleIncrementalBuildEnabled
-    {
-      do {
-        try incrementalCompilationState.writeDependencyGraph(to: buildRecordInfo.dependencyGraphPath, buildRecord)
-      } catch {
-        diagnosticEngine.emit(
-          .warning("next compile won't be incremental; could not write dependency graph: \(error.localizedDescription)"))
-        /// Ensure that a bogus dependency graph is not used next time.
-        buildRecordInfo.removeBuildRecord()
-        buildRecordInfo.removeInterModuleDependencyGraph()
-        return
-      }
-      do {
-        try incrementalCompilationState.writeInterModuleDependencyGraph(buildRecordInfo)
-      } catch {
-        diagnosticEngine.emit(
-          .warning("next compile must run a full dependency scan; could not write inter-module dependency graph: \(error.localizedDescription)"))
-        buildRecordInfo.removeBuildRecord()
-        buildRecordInfo.removeInterModuleDependencyGraph()
-        return
-      }
-    } else {
-      // FIXME: This is all legacy code. Once the cross module incremental build
-      // becomes the default:
-      //
-      // 1) Delete this branch
-      // 2) Delete the parts of the incremental build that talk about anything
-      //    derived from `buildRecordPath`
-      // 3) Delete the Yams dependency.
-
-      // Before writing to the dependencies file path, preserve any previous file
-      // that may have been there. No error handling -- this is just a nicety, it
-      // doesn't matter if it fails.
-      // Added for the sake of compatibility with the legacy driver.
-      try? fileSystem.move(
-        from: absPath, to: absPath.appending(component: absPath.basename + "~"))
-
-      guard let contents = buildRecord.encode(diagnosticEngine: diagnosticEngine) else {
-        diagnosticEngine.emit(.warning_could_not_write_build_record(absPath))
-        return
-      }
-
-      do {
-        try fileSystem.writeFileContents(absPath,
-                                         bytes: ByteString(encodingAsUTF8: contents))
-      } catch {
-        diagnosticEngine.emit(.warning_could_not_write_build_record(absPath))
-      }
+    
+    do {
+      try incrementalCompilationState.writeDependencyGraph(to: buildRecordInfo.dependencyGraphPath, buildRecord)
+    } catch {
+      diagnosticEngine.emit(
+        .warning("next compile won't be incremental; could not write dependency graph: \(error.localizedDescription)"))
+      /// Ensure that a bogus dependency graph is not used next time.
+      buildRecordInfo.removeBuildRecord()
+      buildRecordInfo.removeInterModuleDependencyGraph()
+      return
+    }
+    do {
+      try incrementalCompilationState.writeInterModuleDependencyGraph(buildRecordInfo)
+    } catch {
+      diagnosticEngine.emit(
+        .warning("next compile must run a full dependency scan; could not write inter-module dependency graph: \(error.localizedDescription)"))
+      buildRecordInfo.removeBuildRecord()
+      buildRecordInfo.removeInterModuleDependencyGraph()
+      return
     }
   }
 

Sources/SwiftDriver/IncrementalCompilation/BuildRecord.swift

@@ -14,8 +14,6 @@ import class TSCBasic.DiagnosticsEngine
 import struct TSCBasic.AbsolutePath
 import struct TSCBasic.Diagnostic
 
-@_implementationOnly import Yams
-
 /// Holds the info about inputs needed to plan incremenal compilation
 /// A.k.a. BuildRecord was the legacy name
 public struct BuildRecord {
@@ -40,155 +38,6 @@ public struct BuildRecord {
     self.buildEndTime = buildEndTime
     self.inputInfos = inputInfos
   }
-
-  public enum SectionName: String, CaseIterable {
-    case swiftVersion = "version"
-    case argsHash = "options"
-    // Implement this for a smoother transition
-    case legacyBuildStartTime = "build_time"
-    case buildStartTime = "build_start_time"
-    case buildEndTime = "build_end_time"
-    case inputInfos = "inputs"
-
-    var serializedName: String { rawValue }
-  }
-
-  var allInputs: Set<VirtualPath> {
-    Set(inputInfos.map { $0.key })
-  }
-}
-
-// MARK: - Reading the old map and deciding whether to use it
-public extension BuildRecord {
-  enum Error: Swift.Error {
-    case malformedYAML
-    case invalidKey
-    case missingTimeStamp
-    case missingInputSequenceNode
-    case missingInputEntryNode
-    case missingPriorBuildState
-    case unexpectedKey(String)
-    case malformed(SectionName)
-
-    var reason: String {
-      switch self {
-      case .malformedYAML:
-        return ""
-      case .invalidKey:
-        return ""
-      case .missingTimeStamp:
-        return "could not read time value in build record"
-      case .missingInputSequenceNode:
-        return "no sequence node for input entry in build record"
-      case .missingInputEntryNode:
-        return "no input entry in build record"
-      case .missingPriorBuildState:
-        return "no previous build state in build record"
-      case .unexpectedKey(let key):
-        return "Unexpected key '\(key)'"
-      case .malformed(let section):
-        return "Malformed value for key '\(section.serializedName)'"
-      }
-    }
-  }
-  init(contents: String) throws {
-    guard let sections = try? Parser(yaml: contents, resolver: .basic, encoding: .utf8)
-            .singleRoot()?.mapping
-    else {
-      throw Error.malformedYAML
-    }
-    var argsHash: String?
-    var swiftVersion: String?
-    // Legacy driver does not disable incremental if no buildTime field.
-    var buildStartTime: TimePoint = .distantPast
-    var buildEndTime: TimePoint = .distantFuture
-    var inputInfos: [VirtualPath: InputInfo]?
-    for (key, value) in sections {
-      guard let k = key.string else {
-        throw Error.invalidKey
-      }
-      switch k {
-      case SectionName.swiftVersion.serializedName:
-        // There's a test that uses "" for an illegal value
-        guard let s = value.string, s != "" else {
-          break
-        }
-        swiftVersion = s
-      case SectionName.argsHash.serializedName:
-        guard let s = value.string, s != "" else {
-          break
-        }
-        argsHash = s
-      case SectionName.buildStartTime.serializedName,
-           SectionName.legacyBuildStartTime.serializedName:
-        buildStartTime = try Self.decodeDate(value, forInputInfo: false)
-      case SectionName.buildEndTime.serializedName:
-        buildEndTime = try Self.decodeDate(value, forInputInfo: false)
-      case SectionName.inputInfos.serializedName:
-        inputInfos = try Self.decodeInputInfos(value)
-      default:
-        throw Error.unexpectedKey(k)
-      }
-    }
-    // The legacy driver allows argHash to be absent to ease testing.
-    // Mimic the legacy driver for testing ease: If no `argsHash` section,
-    // record still matches.
-    guard let sv = swiftVersion else {
-      throw Error.malformed(.swiftVersion)
-    }
-    guard let iis = inputInfos else {
-      throw Error.malformed(.inputInfos)
-    }
-    guard let argsHash = argsHash else {
-      throw Error.malformed(.argsHash)
-    }
-    self.init(argsHash: argsHash,
-              swiftVersion: sv,
-              buildStartTime: buildStartTime,
-              buildEndTime: buildEndTime,
-              inputInfos: iis)
-  }
-
-  private static func decodeDate(
-    _ node: Yams.Node,
-    forInputInfo: Bool
-  ) throws -> TimePoint {
-    guard let vals = node.sequence else {
-      if forInputInfo {
-        throw Error.missingInputSequenceNode
-      } else {
-        throw Error.missingTimeStamp
-      }
-    }
-    guard vals.count == 2,
-          let secs = vals[0].int,
-          let ns = vals[1].int
-    else {
-      throw Error.missingTimeStamp
-    }
-    return TimePoint(seconds: UInt64(secs), nanoseconds: UInt32(ns))
-  }
-
-  private static func decodeInputInfos(
-    _ node: Yams.Node
-  ) throws -> [VirtualPath: InputInfo] {
-    guard let map = node.mapping else {
-      throw BuildRecord.Error.malformed(.inputInfos)
-    }
-    var infos = [VirtualPath: InputInfo]()
-    for (keyNode, valueNode) in map {
-      guard let pathString = keyNode.string,
-            let path = try? VirtualPath(path: pathString)
-      else {
-        throw BuildRecord.Error.missingInputEntryNode
-      }
-      let previousModTime = try decodeDate(valueNode, forInputInfo: true)
-      let inputInfo = try InputInfo(
-        tag: valueNode.tag.description, previousModTime: previousModTime)
-      infos[path] = inputInfo
-    }
-    return infos
-   }
 }
 
 // MARK: - Creating and writing a new map
@@ -222,82 +71,4 @@ extension BuildRecord {
       inputInfos: Dictionary(uniqueKeysWithValues: inputInfosArray)
     )
   }
-
-  /// Pass in `currentArgsHash` to ensure it is non-nil
-  public func encode(diagnosticEngine: DiagnosticsEngine) -> String? {
-      let pathsAndInfos = inputInfos.map {
-        input, inputInfo -> (String, InputInfo) in
-        return (input.name, inputInfo)
-      }
-      let inputInfosNode = Yams.Node(
-        pathsAndInfos
-          .sorted {$0.0 < $1.0}
-          .map {(Yams.Node($0.0, .implicit, .doubleQuoted), Self.encode($0.1))}
-      )
-    let fieldNodes = [
-      (SectionName.swiftVersion,    Yams.Node(swiftVersion,    .implicit, .doubleQuoted)),
-      (SectionName.argsHash,        Yams.Node(argsHash, .implicit, .doubleQuoted)),
-      (SectionName.buildStartTime,  Self.encode(buildStartTime)),
-      (SectionName.buildEndTime,    Self.encode(buildEndTime)),
-      (SectionName.inputInfos,      inputInfosNode )
-      ] .map { (Yams.Node($0.0.serializedName), $0.1) }
-
-    let buildRecordNode = Yams.Node(fieldNodes, .implicit, .block)
-   // let options = Yams.Emitter.Options(canonical: true)
-    do {
-      return try Yams.serialize(node: buildRecordNode,
-                                width: -1,
-                                sortKeys: false)
-    } catch {
-      diagnosticEngine.emit(.warning_could_not_serialize_build_record(error))
-      return nil
-    }
-  }
-
-  private static func encode(_ date: TimePoint, tag tagString: String? = nil) -> Yams.Node {
-    return Yams.Node(
-      [ Yams.Node(String(date.seconds)), Yams.Node(String(date.nanoseconds)) ],
-      tagString.map {Yams.Tag(Yams.Tag.Name(rawValue: $0))} ?? .implicit,
-      .flow)
-  }
-
-  private static func encode(_ inputInfo: InputInfo) -> Yams.Node {
-    encode(inputInfo.previousModTime, tag: inputInfo.tag)
-  }
-
-}
-
-extension Diagnostic.Message {
-  static func warning_could_not_serialize_build_record(_ err: Error
-  ) -> Diagnostic.Message {
-    .warning("next compile won't be incremental; Could not serialize build record: \(err.localizedDescription)")
-  }
-  static func warning_could_not_write_build_record_not_absolutePath(
-    _ path: VirtualPath
-  ) -> Diagnostic.Message {
-    .warning("next compile won't be incremental; build record path was not absolute: \(path)")
-  }
-  static func warning_could_not_write_build_record(_ path: AbsolutePath
-  ) -> Diagnostic.Message {
-    .warning("next compile won't be incremental; could not write build record to \(path)")
-  }
-}
-
-
-// MARK: - reading
-extension InputInfo {
-  fileprivate init(
-    tag: String,
-    previousModTime: TimePoint
-  ) throws {
-    guard let status = Status(identifier: tag) else {
-      throw BuildRecord.Error.missingPriorBuildState
-    }
-    self.init(status: status, previousModTime: previousModTime)
-  }
-}
-
-// MARK: - writing
-extension InputInfo {
-  fileprivate var tag: String { status.identifier }
 }

Sources/SwiftDriver/IncrementalCompilation/IncrementalCompilationState+Extensions.swift

@@ -374,16 +374,6 @@ extension IncrementalCompilationState {
     /// integrity of the driver's dependency graph and aborts if any errors
     /// are detected.
     public static let verifyDependencyGraphAfterEveryImport  = Options(rawValue: 1 << 3)
-    /// Enables the cross-module incremental build infrastructure.
-    ///
-    /// FIXME: This option is transitory. We intend to make this the
-    /// default behavior. This option should flip to a "disable" bit after that.
-    public static let enableCrossModuleIncrementalBuild      = Options(rawValue: 1 << 4)
-    /// Enables an optimized form of start-up for the incremental build state
-    /// that reads the dependency graph from a serialized format on disk instead
-    /// of reading O(N) swiftdeps files.
-    public static let readPriorsFromModuleDependencyGraph    = Options(rawValue: 1 << 5)
-
     /// Enables additional handling of explicit module build artifacts:
     /// Additional reading and writing of the inter-module dependency graph.
     public static let explicitModuleBuild                    = Options(rawValue: 1 << 6)
@@ -410,7 +400,6 @@ extension IncrementalCompilationState {
     to path: VirtualPath,
     _ buildRecord: BuildRecord
   ) throws {
-    precondition(info.isCrossModuleIncrementalBuildEnabled)
     try blockingConcurrentAccessOrMutationToProtectedState {
       try $0.writeGraph(
         to: path,

Sources/SwiftDriver/IncrementalCompilation/IncrementalCompilationState.swift

@@ -60,9 +60,6 @@ public final class IncrementalCompilationState {
                  outputFileMap: driver.outputFileMap)
       : nil
 
-    reporter?.reportOnIncrementalImports(
-      initialState.incrementalOptions.contains(.enableCrossModuleIncrementalBuild))
-
     let firstWave = try FirstWaveComputer(
       initialState: initialState,
       jobsInPhases: jobsInPhases,
@@ -104,10 +101,3 @@ extension IncrementalCompilationState: IncrementalCompilationSynchronizer {
     info.incrementalCompilationQueue
   }
 }
-
-fileprivate extension IncrementalCompilationState.Reporter {
-  func reportOnIncrementalImports(_ enabled: Bool) {
-    report(
-      "\(enabled ? "Enabling" : "Disabling") incremental cross-module building")
-  }
-}