[AST] Move getInterfaceHashIncludingTypeMembers() to SourceFile

Author: rintaro

include/swift/AST/SourceFile.h

@@ -531,6 +531,9 @@ class SourceFile final : public FileUnit {
     out << getInterfaceHash() << '\n';
   }
 
+  /// Get this file's interface hash including the type members in the file.
+  Fingerprint getInterfaceHashIncludingTypeMembers() const;
+
   /// If this source file has been told to collect its parsed tokens, retrieve
   /// those tokens.
   ArrayRef<Token> getAllTokens() const;

lib/AST/Module.cpp

@@ -1099,6 +1099,30 @@ Fingerprint SourceFile::getInterfaceHash() const {
   return Fingerprint{std::move(result)};
 }
 
+Fingerprint SourceFile::getInterfaceHashIncludingTypeMembers() const {
+  /// FIXME: Gross. Hashing multiple "hash" values.
+  llvm::MD5 hash;
+  hash.update(getInterfaceHash().getRawValue());
+
+  std::function<void(IterableDeclContext *)> hashTypeBodyFingerprints =
+      [&](IterableDeclContext *IDC) {
+        if (auto fp = IDC->getBodyFingerprint())
+          hash.update(fp->getRawValue());
+        for (auto *member : IDC->getParsedMembers())
+          if (auto *childIDC = dyn_cast<IterableDeclContext>(member))
+            hashTypeBodyFingerprints(childIDC);
+      };
+
+  for (auto *D : getTopLevelDecls()) {
+    if (auto IDC = dyn_cast<IterableDeclContext>(D))
+      hashTypeBodyFingerprints(IDC);
+  }
+
+  llvm::MD5::MD5Result result;
+  hash.final(result);
+  return Fingerprint{std::move(result)};
+}
+
 syntax::SourceFileSyntax SourceFile::getSyntaxRoot() const {
   assert(shouldBuildSyntaxTree() && "Syntax tree disabled");
   auto &eval = getASTContext().evaluator;

lib/IDE/CompletionInstance.cpp

@@ -277,49 +277,6 @@ static bool areAnyDependentFilesInvalidated(
       });
 }
 
-/// Get interface hash of \p SF including the type members in the file.
-///
-/// See if the inteface of the function and types visible from a function body
-/// has changed since the last completion. If they haven't changed, completion
-/// can reuse the existing AST of the source file. \c SF->getInterfaceHash() is
-/// not enough because it doesn't take the interface of the type members into
-/// account. For example:
-///
-///   struct S {
-///     func foo() {}
-///   }
-///   func main(val: S) {
-///     val.<HERE>
-///   }
-///
-/// In this case, we need to ensure that the interface of \c S hasn't changed.
-/// Note that we don't care about local types (i.e. type declarations inside
-/// function bodies, closures, or top level statement bodies) because they are
-/// not visible from other functions where the completion is happening.
-static Fingerprint getInterfaceHashIncludingTypeMembers(const SourceFile *SF) {
-  /// FIXME: Gross. Hashing multiple "hash" values.
-  llvm::MD5 hash;
-  hash.update(SF->getInterfaceHash().getRawValue());
-
-  std::function<void(IterableDeclContext *)> hashTypeBodyFingerprints =
-      [&](IterableDeclContext *IDC) {
-        if (auto fp = IDC->getBodyFingerprint())
-          hash.update(fp->getRawValue());
-        for (auto *member : IDC->getParsedMembers())
-          if (auto *childIDC = dyn_cast<IterableDeclContext>(member))
-            hashTypeBodyFingerprints(childIDC);
-      };
-
-  for (auto *D : SF->getTopLevelDecls()) {
-    if (auto IDC = dyn_cast<IterableDeclContext>(D))
-      hashTypeBodyFingerprints(IDC);
-  }
-
-  llvm::MD5::MD5Result result;
-  hash.final(result);
-  return Fingerprint{std::move(result)};
-}
-
 } // namespace
 
 bool CompletionInstance::performCachedOperationIfPossible(
@@ -396,8 +353,26 @@ bool CompletionInstance::performCachedOperationIfPossible(
   switch (newInfo.Kind) {
   case CodeCompletionDelayedDeclKind::FunctionBody: {
     // If the interface has changed, AST must be refreshed.
-    const auto oldInterfaceHash = getInterfaceHashIncludingTypeMembers(oldSF);
-    const auto newInterfaceHash = getInterfaceHashIncludingTypeMembers(tmpSF);
+    // See if the inteface of the function and types visible from a function
+    // body has changed since the last completion. If they haven't changed,
+    // completion can reuse the existing AST of the source file.
+    // \c getInterfaceHash() is not enough because it doesn't take the interface
+    // of the type members into account. For example:
+    //
+    //   struct S {
+    //     func foo() {}
+    //   }
+    //   func main(val: S) {
+    //     val.<HERE>
+    //   }
+    //
+    // In this case, we need to ensure that the interface of \c S hasn't
+    // changed. Note that we don't care about local types (i.e. type
+    // declarations inside function bodies, closures, or top level statement
+    // bodies) because they are not visible from other functions where the
+    // completion is happening.
+    const auto oldInterfaceHash = oldSF->getInterfaceHashIncludingTypeMembers();
+    const auto newInterfaceHash = tmpSF->getInterfaceHashIncludingTypeMembers();
     if (oldInterfaceHash != newInterfaceHash)
       return false;