Merge pull request #283 from davidungar/module-dep-graph-10-1b

Cargo-culted, but then Swift-ified and cleaned-up ModuleDependencyGraph

Author: David Ungar

Sources/SwiftDriver/CMakeLists.txt

@@ -29,10 +29,21 @@ add_library(SwiftDriver
  Execution/ParsableOutput.swift
  Execution/ProcessProtocol.swift
 
+ "Incremental Compilation/ModuleDependencyGraph Parts/Integrator.swift"
+ "Incremental Compilation/ModuleDependencyGraph Parts/JobTracker.swift"
+ "Incremental Compilation/ModuleDependencyGraph Parts/Node.swift"
+ "Incremental Compilation/ModuleDependencyGraph Parts/NodeFinder.swift"
+ "Incremental Compilation/ModuleDependencyGraph Parts/SwiftDeps.swift"
+ "Incremental Compilation/ModuleDependencyGraph Parts/Tracer.swift"
+ "Incremental Compilation/DependencyKey.swift"
+ "Incremental Compilation/DictionaryOfDictionaries.swift"
  "Incremental Compilation/IncrementalCompilationState.swift"
  "Incremental Compilation/InputIInfoMap.swift"
  "Incremental Compilation/InputInfo.swift"
+ "Incremental Compilation/ModuleDependencyGraph.swift"
+ "Incremental Compilation/Multidictionary.swift"
  "Incremental Compilation/SourceFileDependencyGraph.swift"
+ "Incremental Compilation/TwoDMap.swift"
 
  Jobs/AutolinkExtractJob.swift
  Jobs/BackendJob.swift

Sources/SwiftDriver/Incremental Compilation/DependencyKey.swift

@@ -0,0 +1,87 @@
+
+import Foundation
+
+/// A filename from another module
+@_spi(Testing) public struct ExternalDependency: Hashable, CustomStringConvertible {
+ let fileName: String
+
+ @_spi(Testing) public init(_ path: String) {
+ self.fileName = path
+ }
+
+ public var description: String {
+ fileName.description
+ }
+}
+
+
+
+@_spi(Testing) public struct DependencyKey: Hashable {
+ /// Instead of the status quo scheme of two kinds of "Depends", cascading and
+ /// non-cascading this code represents each entity ("Provides" in the status
+ /// quo), by a pair of nodes. One node represents the "implementation." If the
+ /// implementation changes, users of the entity need not be recompiled. The
+ /// other node represents the "interface." If the interface changes, any uses of
+ /// that definition will need to be recompiled. The implementation always
+ /// depends on the interface, since any change that alters the interface will
+ /// require the implementation to be rebuilt. The interface does not depend on
+ /// the implementation. In the dot files, interfaces are yellow and
+ /// implementations white. Each node holds an instance variable describing which
+ /// aspect of the entity it represents.
+
+ @_spi(Testing) public enum DeclAspect {
+ case interface, implementation
+ }
+
+ /// Encode the current sorts of dependencies as kinds of nodes in the dependency
+ /// graph, splitting the current *member* into \ref member and \ref
+ /// potentialMember and adding \ref sourceFileProvide.
+ ///
+ @_spi(Testing) public enum Designator: Hashable {
+ case
+ topLevel(name: String),
+ dynamicLookup(name: String),
+ externalDepend(ExternalDependency),
+ sourceFileProvide(name: String)
+
+ case
+ nominal(context: String),
+ potentialMember(context: String)
+
+ case
+ member(context: String, name: String)
+
+ var externalDependency: ExternalDependency? {
+ switch self {
+ case let .externalDepend(externalDependency):
+ return externalDependency
+ default:
+ return nil}
+ }
+ }
+
+ @_spi(Testing) public let aspect: DeclAspect
+ @_spi(Testing) public let designator: Designator
+
+
+ @_spi(Testing) public init(
+ aspect: DeclAspect,
+ designator: Designator)
+ {
+ self.aspect = aspect
+ self.designator = designator
+ }
+
+
+ @_spi(Testing) public var correspondingImplementation: Self {
+ assert(aspect == .interface)
+ return Self(aspect: .implementation, designator: designator)
+ }
+
+ @discardableResult
+ func verify() -> Bool {
+ // This space reserved for future use.
+ return true
+ }
+}
+

Sources/SwiftDriver/Incremental Compilation/DictionaryOfDictionaries.swift

@@ -0,0 +1,137 @@
+//===---------------- DictionaryOfDictionaries.swift ----------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 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
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+
+/// A dictionary of dictionaries that also behaves like dictionary of tuples
+/// It supports iterating over all 2nd-level pairs. See \code subscript(key: OuterKey)
+
+import Foundation
+@_spi(Testing) public struct DictionaryOfDictionaries<OuterKey: Hashable, InnerKey: Hashable, Value>: Collection {
+ public typealias InnerDict = [InnerKey: Value]
+ public typealias OuterDict = [OuterKey: InnerDict]
+ 
+ public typealias Key = (OuterKey, InnerKey)
+ public typealias Element = (Key, Value)
+ 
+ var outerDict = [OuterKey: [InnerKey: Value]]()
+}
+
+// MARK: indices
+extension DictionaryOfDictionaries {
+ public enum Index: Comparable {
+ case end
+ case notEnd(OuterDict.Index, InnerDict.Index)
+ 
+ public static func < (lhs: Self, rhs: Self)
+ -> Bool
+ {
+ switch (lhs, rhs) {
+ case (.end, .end): return false
+ case (_, .end): return true
+ case (.end, _): return false
+ case let (.notEnd(lo, li), .notEnd(ro, ri)):
+ switch (lo, ro, li, ri) {
+ case let (lo, ro, _, _) where lo != ro: return lo < ro
+ case let (_, _, li, ri): return li < ri
+ }
+ }
+ }
+ }
+ 
+ private func makeIndex(_ oi: OuterDict.Index, _ ii: InnerDict.Index) -> Index {
+ assert(outerDict[oi].value.indices.contains(ii))
+ return .notEnd(oi, ii)
+ }
+ 
+ public var startIndex: Index {
+ return outerDict.isEmpty
+ ? endIndex
+ : makeIndex(outerDict.startIndex,
+ outerDict.first!.value.startIndex)
+ }
+ public var endIndex: Index {
+ return .end
+ }
+ 
+ public func index(after i: Index) -> Index {
+ switch i {
+ case .end: fatalError("index at end")
+ case let .notEnd(outerIndex, innerIndex):
+ let innerDict = outerDict[outerIndex].value
+ let nextInnerIndex = innerDict.index(after: innerIndex)
+ if nextInnerIndex < innerDict.endIndex {
+ return makeIndex(outerIndex, nextInnerIndex)
+ }
+ let nextOuterIndex = outerDict.index(after: outerIndex)
+ if nextOuterIndex < outerDict.endIndex {
+ return .notEnd(nextOuterIndex, outerDict[nextOuterIndex].value.startIndex)
+ }
+ return .end
+ }
+ }
+}
+
+// MARK: - subscripting
+extension DictionaryOfDictionaries {
+ public subscript(position: Index) -> Element {
+ switch position {
+ case .end: fatalError("index at end")
+ case let .notEnd(outerIndex, innerIndex):
+ let (outerKey, innerDict) = outerDict[outerIndex]
+ let (innerKey, value) = innerDict[innerIndex]
+ return (key: (outerKey, innerKey), value: value)
+ }
+ }
+ 
+ public subscript(key: Key) -> Value? {
+ get {outerDict[key.0]?[key.1]}
+ set {
+ if let v = newValue { _ = updateValue(v, forKey: key) }
+ else { _ = removeValue(forKey: key) }
+ }
+ }
+ 
+ public subscript(key: OuterKey) -> [InnerKey: Value]? {
+ get {outerDict[key]}
+ set {
+ if let v = newValue { _ = outerDict.updateValue(v, forKey: key) }
+ else { _ = outerDict.removeValue(forKey: key) }
+ }
+ }
+}
+
+// MARK: - mutating
+extension DictionaryOfDictionaries {
+ mutating func updateValue(_ v: Value, forKey keys : (OuterKey,InnerKey)
+ ) -> Value? {
+ if var innerDict = outerDict[keys.0] {
+ let old = innerDict.updateValue(v, forKey: keys.1)
+ outerDict.updateValue(innerDict, forKey: keys.0)
+ return old
+ }
+ outerDict.updateValue([keys.1: v], forKey: keys.0)
+ return nil
+ }
+ 
+ mutating func removeValue(forKey keys : (OuterKey,InnerKey)
+ ) -> Value? {
+ guard var innerDict = outerDict[keys.0]
+ else { return nil }
+ let old = innerDict.removeValue(forKey: keys.1)
+ if innerDict.isEmpty {
+ outerDict.removeValue(forKey: keys.0)
+ }
+ else {
+ outerDict.updateValue(innerDict, forKey: keys.0)
+ }
+ return old
+ }
+}

Sources/SwiftDriver/Incremental Compilation/IncrementalCompilationState.swift

@@ -22,43 +22,43 @@ import SwiftOptions
  public let lastBuildTime: Date
  public let outOfDateMap: InputInfoMap?
  public var rebuildEverything: Bool { return outOfDateMap == nil }
-
+ 
  public init(_ parsedOptions: inout ParsedOptions,
- compilerMode: CompilerMode,
- outputFileMap: OutputFileMap?,
- compilerOutputType: FileType?,
- moduleOutput: ModuleOutputInfo.ModuleOutput?,
- fileSystem: FileSystem,
- inputFiles: [TypedVirtualPath],
- diagnosticEngine: DiagnosticsEngine,
- actualSwiftVersion: String?
+  compilerMode: CompilerMode,
+  outputFileMap: OutputFileMap?,
+  compilerOutputType: FileType?,
+  moduleOutput: ModuleOutputInfo.ModuleOutput?,
+  fileSystem: FileSystem,
+  inputFiles: [TypedVirtualPath],
+  diagnosticEngine: DiagnosticsEngine,
+  actualSwiftVersion: String?
  ) {
  let showIncrementalBuildDecisions = Self.getShowIncrementalBuildDecisions(&parsedOptions)
  self.showIncrementalBuildDecisions = showIncrementalBuildDecisions
-
+ 
  let enableIncrementalBuild = Self.computeAndExplainShouldCompileIncrementally(
  &parsedOptions,
  showIncrementalBuildDecisions: showIncrementalBuildDecisions,
  compilerMode: compilerMode,
  diagnosticEngine: diagnosticEngine)
-
+ 
  self.enableIncrementalBuild = enableIncrementalBuild
-
+ 
  self.buildRecordPath = Self.computeBuildRecordPath(
  outputFileMap: outputFileMap,
  compilerOutputType: compilerOutputType,
  diagnosticEngine: enableIncrementalBuild ? 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
-
+ 
  let argsHash = Self.computeArgsHash(parsedOptions)
  self.argsHash = argsHash
  let lastBuildTime = Date()
  self.lastBuildTime = lastBuildTime
-
+ 
  if let buRP = buildRecordPath, enableIncrementalBuild {
  let outOfDateMap = InputInfoMap.populateOutOfDateMap(
  argsHash: argsHash,
@@ -84,27 +84,25 @@ import SwiftOptions
  self.outOfDateMap = nil
  }
  }
-
- private static func getShowIncrementalBuildDecisions(_ parsedOptions: inout ParsedOptions)
- -> Bool {
+ 
+ private static func getShowIncrementalBuildDecisions(
+ _ parsedOptions: inout ParsedOptions) -> Bool {
  parsedOptions.hasArgument(.driverShowIncremental)
  }
-
+ 
  private static func computeAndExplainShouldCompileIncrementally(
  _ parsedOptions: inout ParsedOptions,
  showIncrementalBuildDecisions: Bool,
  compilerMode: CompilerMode,
  diagnosticEngine: DiagnosticsEngine
- )
- -> Bool
- {
+ ) -> Bool {
  guard parsedOptions.hasArgument(.incremental) else {
  return false
  }
  guard compilerMode.supportsIncrementalCompilation else {
- diagnosticEngine.emit(
- .remark_incremental_compilation_disabled(
- because: "it is not compatible with \(compilerMode)"))
+  diagnosticEngine.emit(
+  .remark_incremental_compilation_disabled(
+  because: "it is not compatible with \(compilerMode)"))
  return false
  }
  guard !parsedOptions.hasArgument(.embedBitcode) else {
@@ -115,7 +113,7 @@ import SwiftOptions
  }
  return true
  }
-
+ 
  private static func computeBuildRecordPath(
  outputFileMap: OutputFileMap?,
  compilerOutputType: FileType?,
@@ -128,9 +126,9 @@ import SwiftOptions
  return nil
  }
  guard let partialBuildRecordPath = ofm.existingOutputForSingleInput(outputType: .swiftDeps)
-  else {
-  diagnosticEngine.map { $0.emit(.warning_incremental_requires_build_record_entry) }
-  return nil
+ 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
@@ -139,8 +137,8 @@ import SwiftOptions
  ? partialBuildRecordPath.appendingToBaseName("~moduleonly")
  : partialBuildRecordPath
  }
-
- static private func computeArgsHash(_ parsedOptionsArg: ParsedOptions) -> String {
+ 
+ private static func computeArgsHash(_ parsedOptionsArg: ParsedOptions) -> String {
  var parsedOptions = parsedOptionsArg
  let hashInput = parsedOptions
  .filter { $0.option.affectsIncrementalBuild && $0.option.kind != .input}
@@ -168,7 +166,7 @@ extension Diagnostic.Message {
  static var warning_incremental_requires_build_record_entry: Diagnostic.Message {
  .warning(
  "ignoring -incremental; " +
- "output file map has no master dependencies entry under \(FileType.swiftDeps)"
+  "output file map has no master dependencies entry under \(FileType.swiftDeps)"
  )
  }
  static func remark_incremental_compilation_disabled(because why: String) -> Diagnostic.Message {