Merge pull request #16669 from davidungar/refdep-refactor

NFC, [Incremental Compilation] Refactor ReferenceDependencies

Author: David Ungar

docs/DependencyAnalysis.rst

@@ -91,7 +91,8 @@ External Dependencies
 =====================
 
 External dependencies, including imported Swift module files and Clang headers,
-are tracked using a special ``depends-external`` set. The Swift driver
+are tracked using a special ``depends-external`` set. These dependencies refer
+to files that are external to the module. The Swift driver
 interprets this set specially and decides whether or not the cross-module
 dependencies have changed.
 

include/swift/AST/Module.h

@@ -977,6 +977,10 @@ class SourceFile final : public FileUnit {
   ReferencedNameTracker *getReferencedNameTracker() {
     return ReferencedNames ? ReferencedNames.getPointer() : nullptr;
   }
+  const ReferencedNameTracker *getReferencedNameTracker() const {
+    return ReferencedNames ? ReferencedNames.getPointer() : nullptr;
+  }
+
   void createReferencedNameTracker();
 
   /// \brief The buffer ID for the file that was imported, or None if there

include/swift/Driver/DependencyGraph.h

@@ -123,8 +123,16 @@ class DependencyGraphImpl {
   /// The set of marked nodes.
   llvm::SmallPtrSet<const void *, 16> Marked;
 
-  /// A list of all "external" dependencies that cannot be resolved just from
-  /// this dependency graph.
+  /// A list of all external dependencies that cannot be resolved from just this
+  /// dependency graph. Each member of the set is the name of a file which is
+  /// not in the module. These files' contents may (or may not) have affected
+  /// the module's compilation. This list may even include the paths of
+  /// non-existent files whose absence is significant.
+  ///
+  /// Furthermore, this set might not exhaustive. It only includes dependencies
+  /// that will be checked by the driver's incremental mode.
+  /// For example, it might excludes headers in the SDK if the cost
+  /// of `stat`ing them were to outweigh the likelihood that they would change.
   llvm::StringSet<> ExternalDependencies;
 
   /// The interface hash for each node. This determines if the interface of

include/swift/Frontend/ReferenceDependencyKeys.h

@@ -0,0 +1,38 @@
+//===--- ReferenceDependencyKeys.h - Keys for swiftdeps files ---*- C++ -*-===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2017 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
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef SWIFT_FRONTENDTOOL_REFERENCEDEPENDENCYKEYS_H
+#define SWIFT_FRONTENDTOOL_REFERENCEDEPENDENCYKEYS_H
+
+#include "swift/Basic/LLVM.h"
+#include "llvm/ADT/StringRef.h"
+
+namespace swift {
+/// Define these string constants for reference dependencies (a.k.a. swiftdeps)
+/// in one place to ensure consistency.
+namespace reference_dependency_keys {
+static constexpr StringLiteral providesTopLevel("provides-top-level");
+static constexpr StringLiteral providesNominal("provides-nominal");
+static constexpr StringLiteral providesMember("provides-member");
+static constexpr StringLiteral providesDynamicLookup("provides-dynamic-lookup");
+
+static constexpr StringLiteral dependsTopLevel("depends-top-level");
+static constexpr StringLiteral dependsMember("depends-member");
+static constexpr StringLiteral dependsNominal("depends-nominal");
+static constexpr StringLiteral dependsDynamicLookup("depends-dynamic-lookup");
+static constexpr StringLiteral dependsExternal("depends-external");
+
+static constexpr StringLiteral interfaceHash("interface-hash");
+} // end namespace reference_dependency_keys
+} // end namespace swift
+
+#endif

lib/Driver/DependencyGraph.cpp

@@ -13,6 +13,7 @@
 #include "swift/Basic/Statistic.h"
 #include "swift/Driver/DependencyGraph.h"
 #include "swift/Demangling/Demangle.h"
+#include "swift/Frontend/ReferenceDependencyKeys.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringSwitch.h"
@@ -99,7 +100,9 @@ parseDependencyFile(llvm::MemoryBuffer &buffer,
       return LoadResult::HadError;
     StringRef keyString = key->getValue(scratch);
 
-    if (keyString == "interface-hash") {
+    using namespace reference_dependency_keys;
+
+    if (keyString == interfaceHash) {
       auto *value = dyn_cast<yaml::ScalarNode>(i->getValue());
       if (!value)
         return LoadResult::HadError;
@@ -115,31 +118,31 @@ parseDependencyFile(llvm::MemoryBuffer &buffer,
       using KindPair = std::pair<DependencyKind, DependencyDirection>;
 
       KindPair dirAndKind = llvm::StringSwitch<KindPair>(key->getValue(scratch))
-        .Case("depends-top-level",
+        .Case(dependsTopLevel,
               std::make_pair(DependencyKind::TopLevelName,
                              DependencyDirection::Depends))
-        .Case("depends-nominal",
+        .Case(dependsNominal,
               std::make_pair(DependencyKind::NominalType,
                              DependencyDirection::Depends))
-        .Case("depends-member",
+        .Case(dependsMember,
               std::make_pair(DependencyKind::NominalTypeMember,
                              DependencyDirection::Depends))
-        .Case("depends-dynamic-lookup",
+        .Case(dependsDynamicLookup,
               std::make_pair(DependencyKind::DynamicLookupName,
                              DependencyDirection::Depends))
-        .Case("depends-external",
+        .Case(dependsExternal,
               std::make_pair(DependencyKind::ExternalFile,
                              DependencyDirection::Depends))
-        .Case("provides-top-level",
+        .Case(providesTopLevel,
               std::make_pair(DependencyKind::TopLevelName,
                              DependencyDirection::Provides))
-        .Case("provides-nominal",
+        .Case(providesNominal,
               std::make_pair(DependencyKind::NominalType,
                              DependencyDirection::Provides))
-        .Case("provides-member",
+        .Case(providesMember,
               std::make_pair(DependencyKind::NominalTypeMember,
                              DependencyDirection::Provides))
-        .Case("provides-dynamic-lookup",
+        .Case(providesDynamicLookup,
               std::make_pair(DependencyKind::DynamicLookupName,
                              DependencyDirection::Provides))
         .Default(std::make_pair(DependencyKind(),