Merge pull request #2357 from swiftwasm/main

[pull] swiftwasm from main

Author: pull[bot]

include/swift/AST/DiagnosticsParse.def

@@ -732,8 +732,7 @@ ERROR(rethrowing_function_type,none,
       "only function declarations may be marked 'rethrows'; "
       "did you mean 'throws'?", ())
 ERROR(async_or_throws_in_wrong_position,none,
-      "%select{'throws'|'rethrows'|'async'}0 may only occur before '->'",
-      (unsigned))
+      "'%0' may only occur before '->'", (StringRef))
 ERROR(throw_in_function_type,none,
       "expected throwing specifier; did you mean 'throws'?", ())
 ERROR(expected_type_before_arrow,none,
@@ -748,6 +747,8 @@ ERROR(expected_dynamic_func_attr,none,
 ERROR(async_after_throws,none,
       "'async' must precede %select{'throws'|'rethrows'}0", (bool))
 ERROR(async_init,none, "initializer cannot be marked 'async'", ())
+ERROR(duplicate_effects_specifier,none,
+      "'%0' has already been specified", (StringRef))
 
 // Enum Types
 ERROR(expected_expr_enum_case_raw_value,PointsToFirstBadToken,

include/swift/AST/FileUnit.h

@@ -183,6 +183,9 @@ class FileUnit : public DeclContext {
   /// The order of the results is not guaranteed to be meaningful.
   virtual void getTopLevelDecls(SmallVectorImpl<Decl*> &results) const {}
 
+  virtual void
+  getExportedPrespecializations(SmallVectorImpl<Decl *> &results) const {}
+
   /// Finds top-level decls in this file filtered by their attributes.
   ///
   /// This does a simple local lookup, not recursively looking through imports.

include/swift/AST/Module.h

@@ -632,6 +632,8 @@ class ModuleDecl : public DeclContext, public TypeDecl {
   /// The order of the results is not guaranteed to be meaningful.
   void getTopLevelDecls(SmallVectorImpl<Decl*> &Results) const;
 
+  void getExportedPrespecializations(SmallVectorImpl<Decl *> &results) const;
+
   /// Finds top-level decls of this module filtered by their attributes.
   ///
   /// This does a simple local lookup, not recursively looking through imports.

include/swift/Basic/Fingerprint.h

@@ -60,53 +60,51 @@ namespace swift {
 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;
 
+  using Core = std::pair<uint64_t, uint64_t>;
 private:
-  std::string Core;
+  Core core;
 
 public:
+  /// Creates a fingerprint value from a pair of 64-bit integers.
+  explicit Fingerprint(Fingerprint::Core value) : core(value) {}
+
   /// 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!");
-  }
+  static Fingerprint fromString(llvm::StringRef value);
 
   /// 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} {
+    : Fingerprint{Fingerprint::fromString({literal, N-1}).core} {
       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()} {}
+      : core{MD5Value.words()} {}
 
 public:
   /// Retrieve the raw underlying bytes of this fingerprint.
-  llvm::StringRef getRawValue() const { return Core; }
+  llvm::SmallString<Fingerprint::DIGEST_LENGTH> getRawValue() const;
 
 public:
   friend bool operator==(const Fingerprint &lhs, const Fingerprint &rhs) {
-    return lhs.Core == rhs.Core;
+    return lhs.core == rhs.core;
   }
 
   friend bool operator!=(const Fingerprint &lhs, const Fingerprint &rhs) {
-    return lhs.Core != rhs.Core;
+    return lhs.core != rhs.core;
   }
 
   friend llvm::hash_code hash_value(const Fingerprint &fp) {
-    return llvm::hash_value(fp.Core);
+    return llvm::hash_value(fp.core);
   }
 
 public:
@@ -115,7 +113,7 @@ class Fingerprint final {
   /// This fingerprint is a perfectly fine value for an MD5 hash, but it is
   /// completely arbitrary.
   static Fingerprint ZERO() {
-    return Fingerprint("00000000000000000000000000000000");
+    return Fingerprint(Fingerprint::Core{0, 0});
   }
 
 private:
@@ -124,7 +122,7 @@ class Fingerprint final {
   ///
   /// Very well, LLVM. A default value you shall have.
   friend class llvm::yaml::IO;
-  Fingerprint() : Core(DIGEST_LENGTH, '0') {}
+  Fingerprint() : core{Fingerprint::Core{0, 0}} {}
 };
 
 void simple_display(llvm::raw_ostream &out, const Fingerprint &fp);

include/swift/IDE/CodeCompletion.h

@@ -549,6 +549,7 @@ enum class CompletionKind {
   AccessorBeginning,
   AttributeBegin,
   AttributeDeclParen,
+  EffectsSpecifier,
   PoundAvailablePlatform,
   CallArg,
   LabeledTrailingClosure,

include/swift/Parse/CodeCompletionCallbacks.h

@@ -181,6 +181,9 @@ class CodeCompletionCallbacks {
   /// @available.
   virtual void completeDeclAttrParam(DeclAttrKind DK, int Index) {};
 
+  /// Complete 'async' and 'throws' at effects specifier position.
+  virtual void completeEffectsSpecifier(bool hasAsync, bool hasThrows) {};
+
   /// Complete within a precedence group decl or after a colon in an
   /// operator decl.
   virtual void completeInPrecedenceGroup(SyntaxKind SK) {};

include/swift/Parse/Parser.h

@@ -1353,9 +1353,12 @@ class Parser {
   ///
   /// \param rethrows If non-NULL, will also parse the 'rethrows' keyword in
   /// lieu of 'throws'.
-  void parseAsyncThrows(
-      SourceLoc existingArrowLoc, SourceLoc &asyncLoc, SourceLoc &throwsLoc,
-      bool *rethrows);
+  ParserStatus parseEffectsSpecifiers(SourceLoc existingArrowLoc,
+                                      SourceLoc &asyncLoc, SourceLoc &throwsLoc,
+                                      bool *rethrows);
+
+  /// Returns 'true' if \p T is considered effects specifier.
+  bool isEffectsSpecifier(const Token &T);
 
   //===--------------------------------------------------------------------===//
   // Pattern Parsing
@@ -1433,6 +1436,15 @@ class Parser {
   /// \endverbatim
   bool canParseBaseTypeForQualifiedDeclName();
 
+  /// Returns true if the current token is '->' or effects specifiers followed
+  /// by '->'.
+  ///
+  /// e.g.
+  ///  throws ->       // true
+  ///  async throws -> // true
+  ///  throws {        // false
+  bool isAtFunctionTypeArrow();
+
   //===--------------------------------------------------------------------===//
   // Expression Parsing
   ParserResult<Expr> parseExpr(Diag<> ID) {
@@ -1554,8 +1566,9 @@ class Parser {
   /// \param explicitResultType The explicit result type, if specified.
   /// \param inLoc The location of the 'in' keyword, if present.
   ///
-  /// \returns true if an error occurred, false otherwise.
-  bool parseClosureSignatureIfPresent(
+  /// \returns ParserStatus error if an error occurred. Success if no signature
+  /// is present or succssfully parsed.
+  ParserStatus parseClosureSignatureIfPresent(
           SourceRange &bracketRange,
           SmallVectorImpl<CaptureListEntry> &captureList,
           VarDecl *&capturedSelfParamDecl,

include/swift/Serialization/SerializedModuleLoader.h

@@ -398,6 +398,9 @@ class SerializedASTFile final : public LoadedFile {
 
   virtual void getTopLevelDecls(SmallVectorImpl<Decl*> &results) const override;
 
+  virtual void getExportedPrespecializations(
+      SmallVectorImpl<Decl *> &results) const override;
+
   virtual void
   getTopLevelDeclsWhereAttributesMatch(
       SmallVectorImpl<Decl*> &Results,

lib/AST/FineGrainedDependencyFormat.cpp

@@ -232,7 +232,7 @@ bool Deserializer::readFineGrainedDependencyGraph(SourceFileDepGraph &g,
       if (node == nullptr)
         llvm::report_fatal_error("Unexpected FINGERPRINT_NODE record");
 
-      node->setFingerprint(Fingerprint{BlobData.str()});
+      node->setFingerprint(Fingerprint::fromString(BlobData));
       break;
     }
 

lib/AST/Module.cpp

@@ -792,6 +792,11 @@ void ModuleDecl::getTopLevelDecls(SmallVectorImpl<Decl*> &Results) const {
   FORWARD(getTopLevelDecls, (Results));
 }
 
+void ModuleDecl::getExportedPrespecializations(
+    SmallVectorImpl<Decl *> &Results) const {
+  FORWARD(getExportedPrespecializations, (Results));
+}
+
 void ModuleDecl::getTopLevelDeclsWhereAttributesMatch(
               SmallVectorImpl<Decl*> &Results,
               llvm::function_ref<bool(DeclAttributes)> matchAttributes) const {