Merge pull request #2249 from swiftwasm/main

[pull] swiftwasm from main

Author: pull[bot]

include/swift/AST/ASTTypeIDZone.def

@@ -21,6 +21,7 @@ SWIFT_TYPEID(BodyInitKind)
 SWIFT_TYPEID(BodyInitKindAndExpr)
 SWIFT_TYPEID(CtorInitializerKind)
 SWIFT_TYPEID(ResultBuilderBodyPreCheck)
+SWIFT_TYPEID(Fingerprint)
 SWIFT_TYPEID(GenericSignature)
 SWIFT_TYPEID(ImplicitImportList)
 SWIFT_TYPEID(ImplicitMemberAction)

include/swift/AST/ASTTypeIDs.h

@@ -34,6 +34,7 @@ class ConstructorDecl;
 class CustomAttr;
 class Decl;
 class EnumDecl;
+class Fingerprint;
 class FuncDecl;
 enum class ResultBuilderBodyPreCheck : uint8_t;
 class GenericParamList;

include/swift/AST/AbstractSourceFileDepGraphFactory.h

@@ -32,7 +32,7 @@ class AbstractSourceFileDepGraphFactory {
   const std::string swiftDeps;
 
   /// The fingerprint of the whole file
-  const std::string fileFingerprint;
+  Fingerprint fileFingerprint;
 
   /// For debugging
   const bool emitDotFileAfterConstruction;
@@ -47,7 +47,7 @@ class AbstractSourceFileDepGraphFactory {
   /// See the instance variable comments for explanation.
   AbstractSourceFileDepGraphFactory(bool hadCompilationError,
                                     StringRef swiftDeps,
-                                    StringRef fileFingerprint,
+                                    Fingerprint fileFingerprint,
                                     bool emitDotFileAfterConstruction,
                                     DiagnosticEngine &diags);
 
@@ -71,33 +71,30 @@ class AbstractSourceFileDepGraphFactory {
   template <NodeKind kind, typename ContentsT>
   void addAllDefinedDeclsOfAGivenType(std::vector<ContentsT> &contentsVec) {
     for (const auto &declOrPair : contentsVec) {
-      Optional<std::string> fp =
+      auto fp =
           AbstractSourceFileDepGraphFactory::getFingerprintIfAny(declOrPair);
       addADefinedDecl(
           DependencyKey::createForProvidedEntityInterface<kind>(declOrPair),
-          fp ? StringRef(fp.getValue()) : Optional<StringRef>());
+          fp);
     }
   }
 
   /// Add an pair of interface, implementation nodes to the graph, which
   /// represent some \c Decl defined in this source file. \param key the
   /// interface key of the pair
   void addADefinedDecl(const DependencyKey &key,
-                       Optional<StringRef> fingerprint);
+                       Optional<Fingerprint> fingerprint);
 
   void addAUsedDecl(const DependencyKey &def, const DependencyKey &use);
 
-  static Optional<std::string> getFingerprintIfAny(
-      std::pair<const NominalTypeDecl *, const ValueDecl *>) {
+  static Optional<Fingerprint>
+  getFingerprintIfAny(std::pair<const NominalTypeDecl *, const ValueDecl *>) {
     return None;
   }
 
-  static Optional<std::string> getFingerprintIfAny(const Decl *d) {
+  static Optional<Fingerprint> getFingerprintIfAny(const Decl *d) {
     if (const auto *idc = dyn_cast<IterableDeclContext>(d)) {
-      auto result = idc->getBodyFingerprint();
-      assert((!result || !result->empty()) &&
-             "Fingerprint should never be empty");
-      return result;
+      return idc->getBodyFingerprint();
     }
     return None;
   }

include/swift/AST/DeclContext.h

@@ -24,6 +24,7 @@
 #include "swift/AST/ResilienceExpansion.h"
 #include "swift/AST/TypeAlignments.h"
 #include "swift/Basic/Debug.h"
+#include "swift/Basic/Fingerprint.h"
 #include "swift/Basic/LLVM.h"
 #include "swift/Basic/STLExtras.h"
 #include "swift/Basic/SourceLoc.h"
@@ -871,7 +872,7 @@ class IterableDeclContext {
 
   /// Return a hash of all tokens in the body for dependency analysis, if
   /// available.
-  Optional<std::string> getBodyFingerprint() const;
+  Optional<Fingerprint> getBodyFingerprint() const;
 
 private:
   /// Add a member to the list for iteration purposes, but do not notify the

include/swift/AST/FileUnit.h

@@ -110,6 +110,9 @@ class FileUnit : public DeclContext {
                             const ModuleDecl *importedModule,
                             SmallSetVector<Identifier, 4> &spiGroups) const {};
 
+  virtual Optional<Fingerprint>
+  loadFingerprint(const IterableDeclContext *IDC) const { return None; }
+
 protected:
   /// Look up an operator declaration. Do not call directly, use
   /// \c DirectOperatorLookupRequest instead.

include/swift/AST/FineGrainedDependencies.h

@@ -14,6 +14,7 @@
 #define SWIFT_AST_FINE_GRAINED_DEPENDENCIES_H
 
 #include "swift/Basic/Debug.h"
+#include "swift/Basic/Fingerprint.h"
 #include "swift/Basic/LLVM.h"
 #include "swift/Basic/NullablePtr.h"
 #include "swift/Basic/Range.h"
@@ -599,22 +600,15 @@ class DepGraphNode {
   /// frontend creates an interface node,
   //  it adds a dependency to it from the implementation source file node (which
   //  has the intefaceHash as its fingerprint).
-  Optional<std::string> fingerprint;
+  Optional<Fingerprint> fingerprint;
 
   friend ::llvm::yaml::MappingTraits<DepGraphNode>;
 
 public:
   /// See \ref SourceFileDepGraphNode::SourceFileDepGraphNode().
   DepGraphNode() : key(), fingerprint() {}
 
-  /// See SourceFileDepGraphNode::SourceFileDepGraphNode(...) and
-  /// ModuleDepGraphNode::ModuleDepGraphNode(...) Don't set swiftDeps on
-  /// creation because this field can change if a node is moved.
-  DepGraphNode(DependencyKey key, Optional<StringRef> fingerprint)
-      : DepGraphNode(key, fingerprint ? fingerprint->str()
-                                      : Optional<std::string>()) {}
-
-  DepGraphNode(DependencyKey key, Optional<std::string> fingerprint)
+  DepGraphNode(DependencyKey key, Optional<Fingerprint> fingerprint)
       : key(key), fingerprint(fingerprint) {}
   DepGraphNode(const DepGraphNode &other) = default;
 
@@ -630,12 +624,7 @@ class DepGraphNode {
     this->key = key;
   }
 
-  const Optional<StringRef> getFingerprint() const {
-    if (fingerprint) {
-      return StringRef(fingerprint.getValue());
-    }
-    return None;
-  }
+  const Optional<Fingerprint> getFingerprint() const { return fingerprint; }
   /// When driver reads a SourceFileDepGraphNode, it may be a node that was
   /// created to represent a name-lookup (a.k.a a "depend") in the frontend. In
   /// that case, the node represents an entity that resides in some other file
@@ -644,9 +633,7 @@ class DepGraphNode {
   /// (someday) have a fingerprint. In order to preserve the
   /// ModuleDepGraphNode's identity but bring its fingerprint up to date, it
   /// needs to set the fingerprint *after* the node has been created.
-  void setFingerprint(Optional<StringRef> fp) {
-    fingerprint = fp ? fp->str() : Optional<std::string>();
-  }
+  void setFingerprint(Optional<Fingerprint> fp) { fingerprint = fp; }
 
   SWIFT_DEBUG_DUMP;
   void dump(llvm::raw_ostream &os) const;
@@ -693,7 +680,7 @@ class SourceFileDepGraphNode : public DepGraphNode {
   SourceFileDepGraphNode() : DepGraphNode() {}
 
   /// Used by the frontend to build nodes.
-  SourceFileDepGraphNode(DependencyKey key, Optional<StringRef> fingerprint,
+  SourceFileDepGraphNode(DependencyKey key, Optional<Fingerprint> fingerprint,
                          bool isProvides)
       : DepGraphNode(key, fingerprint), isProvides(isProvides) {
     assert(key.verify());
@@ -827,14 +814,14 @@ class SourceFileDepGraph {
   /// file itself.
   InterfaceAndImplementationPair<SourceFileDepGraphNode>
   findExistingNodePairOrCreateAndAddIfNew(const DependencyKey &interfaceKey,
-                                          Optional<StringRef> fingerprint);
+                                          Optional<Fingerprint> fingerprint);
 
   NullablePtr<SourceFileDepGraphNode>
   findExistingNode(const DependencyKey &key);
 
   SourceFileDepGraphNode *
   findExistingNodeOrCreateIfNew(const DependencyKey &key,
-                                const Optional<StringRef> fingerprint,
+                                const Optional<Fingerprint> fingerprint,
                                 bool isProvides);
 
   /// \p Use is the Node that must be rebuilt when \p def changes.

include/swift/AST/Module.h

@@ -572,6 +572,9 @@ class ModuleDecl : public DeclContext, public TypeDecl {
          ObjCSelector selector,
          SmallVectorImpl<AbstractFunctionDecl *> &results) const;
 
+  Optional<Fingerprint>
+  loadFingerprint(const IterableDeclContext *IDC) const;
+
   /// Find all SPI names imported from \p importedModule by this module,
   /// collecting the identifiers in \p spiGroups.
   void lookupImportedSPIGroups(

include/swift/AST/ParseRequests.h

@@ -19,6 +19,7 @@
 #include "swift/AST/ASTTypeIDs.h"
 #include "swift/AST/EvaluatorDependencies.h"
 #include "swift/AST/SimpleRequest.h"
+#include "swift/Basic/Fingerprint.h"
 #include "swift/Syntax/SyntaxNodes.h"
 
 namespace swift {
@@ -30,7 +31,7 @@ void reportEvaluatedRequest(UnifiedStatsReporter &stats,
                             const Request &request);
 
 struct FingerprintAndMembers {
-  Optional<std::string> fingerprint = None;
+  Optional<Fingerprint> fingerprint = None;
   ArrayRef<Decl *> members = {};
   bool operator==(const FingerprintAndMembers &x) const {
     return fingerprint == x.fingerprint && members == x.members;

include/swift/AST/SourceFile.h

@@ -525,12 +525,10 @@ class SourceFile final : public FileUnit {
   }
 
   /// Output this file's interface hash into the provided string buffer.
-  void getInterfaceHash(llvm::SmallString<32> &str) const;
+  Fingerprint getInterfaceHash() const;
 
   void dumpInterfaceHash(llvm::raw_ostream &out) {
-    llvm::SmallString<32> str;
-    getInterfaceHash(str);
-    out << str << '\n';
+    out << getInterfaceHash() << '\n';
   }
 
   /// If this source file has been told to collect its parsed tokens, retrieve

include/swift/Basic/Fingerprint.h

@@ -0,0 +1,138 @@
+//===--- Fingerprint.h - A stable identity for compiler data ----*- C++ -*-===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 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
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef SWIFT_BASIC_FINGERPRINT_H
+#define SWIFT_BASIC_FINGERPRINT_H
+
+#include "llvm/ADT/Hashing.h"
+#include "llvm/ADT/SmallString.h"
+#include "llvm/ADT/StringRef.h"
+#include "llvm/Support/MD5.h"
+
+#include <string>
+
+namespace llvm {
+namespace yaml {
+class IO;
+}
+}; // namespace llvm
+
+namespace swift {
+
+/// A \c Fingerprint represents a stable summary of a given piece of data
+/// in the compiler.
+///
+/// A \c Fingerprint value is subject to the following invariants:
+/// 1) For two values \c x and \c y of type T, if \c T::operator==(x, y) is
+///    \c true, then the Fingerprint of \c x and the Fingerprint of \c y must be
+///    equal.
+/// 2) For two values \c x and \c y of type T, the chance of a collision in
+///    fingerprints is a rare occurrence - especially if \c y is a minor
+///    perturbation of \c x.
+/// 3) The \c Fingerprint value is required to be stable *across compilation
+///    sessions*.
+///
+/// Property 3) is the most onerous. It implies that data like addresses, file
+/// paths, and other ephemeral compiler state *may not* be used as inputs to the
+/// fingerprint generation function.
+///
+/// \c Fingerprint values are currently used in two places by the compiler's
+/// dependency tracking subsystem. They are used at the level of files to detect
+/// when tokens (outside of the body of a function or an iterable decl context)
+/// have been perturbed. Additionally, they are used at the level of individual
+/// iterable decl contexts to detect when the tokens in their bodies have
+/// changed. This makes them a coarse - yet safe - overapproximation for when a
+/// decl has changed semantically.
+///
+/// \c Fingerprints are currently implemented as a thin wrapper around an MD5
+/// hash. MD5 is known to be neither the fastest nor the most
+/// cryptographically capable algorithm, but it does afford us the avalanche
+/// effect we desire. We should revisit the modeling decision here.
+class Fingerprint final {
+public:
+  /// The size (in bytes) of the raw value of all fingerprints.
+  ///
+  /// This constant's value is justified by a static assertion in the
+  /// corresponding cpp file.
+  constexpr static size_t DIGEST_LENGTH = 32;
+
+private:
+  std::string Core;
+
+public:
+  /// Creates a fingerprint value from the given input string that is known to
+  /// be a 32-byte hash value.
+  ///
+  /// In +asserts builds, strings that violate this invariant will crash. If a
+  /// fingerprint value is needed to represent an "invalid" state, use a
+  /// vocabulary type like \c Optional<Fingerprint> instead.
+  explicit Fingerprint(std::string value) : Core(std::move(value)) {
+    assert(Core.size() == Fingerprint::DIGEST_LENGTH &&
+           "Only supports 32-byte hash values!");
+  }
+
+  /// Creates a fingerprint value from the given input string literal.
+  template <std::size_t N>
+  explicit Fingerprint(const char (&literal)[N])
+    : Core{literal, N-1} {
+      static_assert(N == Fingerprint::DIGEST_LENGTH + 1,
+                    "String literal must be 32 bytes in length!");
+    }
+
+  /// Creates a fingerprint value by consuming the given \c MD5Result from LLVM.
+  explicit Fingerprint(llvm::MD5::MD5Result &&MD5Value)
+      : Core{MD5Value.digest().str()} {}
+
+public:
+  /// Retrieve the raw underlying bytes of this fingerprint.
+  llvm::StringRef getRawValue() const { return Core; }
+
+public:
+  friend bool operator==(const Fingerprint &lhs, const Fingerprint &rhs) {
+    return lhs.Core == rhs.Core;
+  }
+
+  friend bool operator!=(const Fingerprint &lhs, const Fingerprint &rhs) {
+    return lhs.Core != rhs.Core;
+  }
+
+  friend llvm::hash_code hash_value(const Fingerprint &fp) {
+    return llvm::hash_value(fp.Core);
+  }
+
+public:
+  /// The fingerprint value consisting of 32 bytes of zeroes.
+  ///
+  /// This fingerprint is a perfectly fine value for an MD5 hash, but it is
+  /// completely arbitrary.
+  static Fingerprint ZERO() {
+    return Fingerprint("00000000000000000000000000000000");
+  }
+
+private:
+  /// llvm::yaml would like us to be default constructible, but \c Fingerprint
+  /// would prefer to enforce its internal invariants.
+  ///
+  /// Very well, LLVM. A default value you shall have.
+  friend class llvm::yaml::IO;
+  Fingerprint() : Core{DIGEST_LENGTH, '0'} {}
+};
+
+void simple_display(llvm::raw_ostream &out, const Fingerprint &fp);
+}; // namespace swift
+
+namespace llvm {
+class raw_ostream;
+raw_ostream &operator<<(raw_ostream &OS, const swift::Fingerprint &fp);
+}; // namespace llvm
+
+#endif // SWIFT_BASIC_FINGERPRINT_H

include/swift/Driver/FineGrainedDependencyDriverGraph.h

@@ -15,6 +15,7 @@
 
 #include "swift/AST/FineGrainedDependencies.h"
 #include "swift/Basic/Debug.h"
+#include "swift/Basic/Fingerprint.h"
 #include "swift/Basic/LLVM.h"
 #include "swift/Basic/OptionSet.h"
 #include "swift/Driver/Job.h"
@@ -55,7 +56,8 @@ class ModuleDepGraphNode : public DepGraphNode {
   bool hasBeenTracedAsADependent = false;
 
 public:
-  ModuleDepGraphNode(const DependencyKey &key, Optional<StringRef> fingerprint,
+  ModuleDepGraphNode(const DependencyKey &key,
+                     Optional<Fingerprint> fingerprint,
                      Optional<std::string> swiftDeps)
       : DepGraphNode(key, fingerprint), swiftDeps(swiftDeps) {}