Merge pull request #3975 from swiftwasm/main

[pull] swiftwasm from main

Author: MaxDesiatov

include/swift/ABI/Executor.h

@@ -149,6 +149,8 @@ template <class AsyncSignature>
 class AsyncFunctionPointer;
 template <class AsyncSignature>
 struct AsyncFunctionTypeImpl;
+template <class AsyncSignature>
+struct AsyncContinuationTypeImpl;
 
 /// The abstract signature for an asynchronous function.
 template <class Sig, bool HasErrorResult>
@@ -163,6 +165,7 @@ struct AsyncSignature<DirectResultTy(ArgTys...), HasErrorResult> {
 
   using FunctionPointer = AsyncFunctionPointer<AsyncSignature>;
   using FunctionType = typename AsyncFunctionTypeImpl<AsyncSignature>::type;
+  using ContinuationType = typename AsyncContinuationTypeImpl<AsyncSignature>::type;
 };
 
 /// A signature for a thin async function that takes no arguments
@@ -175,30 +178,58 @@ using ThinNullaryAsyncSignature =
 using ThickNullaryAsyncSignature =
   AsyncSignature<void(HeapObject*), false>;
 
-/// A class which can be used to statically query whether a type
-/// is a specialization of AsyncSignature.
-template <class T>
-struct IsAsyncSignature {
-  static const bool value = false;
-};
+template <class Signature>
+struct AsyncFunctionTypeImpl;
+
 template <class DirectResultTy, class... ArgTys, bool HasErrorResult>
-struct IsAsyncSignature<AsyncSignature<DirectResultTy(ArgTys...),
-                                       HasErrorResult>> {
-  static const bool value = true;
+struct AsyncFunctionTypeImpl<
+    AsyncSignature<DirectResultTy(ArgTys...), HasErrorResult>> {
+
+  using type = SWIFT_CC(swiftasync) void(SWIFT_ASYNC_CONTEXT AsyncContext *,
+                                         ArgTys...);
 };
 
 template <class Signature>
-struct AsyncFunctionTypeImpl {
-  static_assert(IsAsyncSignature<Signature>::value,
-                "template argument is not an AsyncSignature");
+struct AsyncContinuationTypeImpl;
+
+template <class DirectResultTy, class... ArgTys>
+struct AsyncContinuationTypeImpl<
+  AsyncSignature<DirectResultTy(ArgTys...), /*throws=*/true>> {
+
+  using type = SWIFT_CC(swiftasync) void(SWIFT_ASYNC_CONTEXT AsyncContext *,
+                                         DirectResultTy,
+                                         SWIFT_CONTEXT void *);
+};
 
-  // TODO: expand and include the arguments in the parameters.
-  using type = TaskContinuationFunction;
+template <class DirectResultTy, class... ArgTys>
+struct AsyncContinuationTypeImpl<
+  AsyncSignature<DirectResultTy(ArgTys...), /*throws=*/false>> {
+
+  using type = SWIFT_CC(swiftasync) void(SWIFT_ASYNC_CONTEXT AsyncContext *,
+                                         DirectResultTy);
+};
+
+template <class... ArgTys>
+struct AsyncContinuationTypeImpl<
+  AsyncSignature<void(ArgTys...), /*throws=*/true>> {
+
+  using type = SWIFT_CC(swiftasync) void(SWIFT_ASYNC_CONTEXT AsyncContext *,
+                                         SWIFT_CONTEXT void *);
+};
+
+template <class... ArgTys>
+struct AsyncContinuationTypeImpl<
+  AsyncSignature<void(ArgTys...), /*throws=*/false>> {
+
+  using type = SWIFT_CC(swiftasync) void(SWIFT_ASYNC_CONTEXT AsyncContext *);
 };
 
 template <class Fn>
 using AsyncFunctionType = typename AsyncFunctionTypeImpl<Fn>::type;
 
+template <class Fn>
+using AsyncContinuationType = typename AsyncContinuationTypeImpl<Fn>::type;
+
 /// A "function pointer" for an async function.
 ///
 /// Eventually, this will always be signed with the data key

include/swift/AST/ASTContext.h

@@ -620,6 +620,9 @@ class ASTContext final {
   ConcreteDeclRef getBuiltinInitDecl(NominalTypeDecl *decl,
                                      KnownProtocolKind builtinProtocol,
                 llvm::function_ref<DeclName (ASTContext &ctx)> initName) const;
+
+  /// Retrieve _StringProcessing.Regex.init(_regexString: String).
+  ConcreteDeclRef getRegexInitDecl(Type regexType) const;
 
   /// Retrieve the declaration of Swift.<(Int, Int) -> Bool.
   FuncDecl *getLessThanIntDecl() const;

include/swift/AST/CaptureInfo.h

@@ -36,6 +36,7 @@ namespace swift {
 class ValueDecl;
 class FuncDecl;
 class OpaqueValueExpr;
+class VarDecl;
 
 /// CapturedValue includes both the declaration being captured, along with flags
 /// that indicate how it is captured.
@@ -219,6 +220,11 @@ class CaptureInfo {
     return StorageAndFlags.getPointer()->getOpaqueValue();
   }
 
+  /// Retrieve the variable corresponding to an isolated parameter that has
+  /// been captured, if there is one. This might be a capture variable
+  /// that was initialized with an isolated parameter.
+  VarDecl *getIsolatedParamCapture() const;
+
   SWIFT_DEBUG_DUMP;
   void print(raw_ostream &OS) const;
 };

include/swift/AST/Decl.h

@@ -520,7 +520,7 @@ class alignas(1 << DeclAlignInBits) Decl : public ASTAllocated<Decl> {
     IsComputingSemanticMembers : 1
   );
 
-  SWIFT_INLINE_BITFIELD_FULL(ProtocolDecl, NominalTypeDecl, 1+1+1+1+1+1+1+1+1+8+16,
+  SWIFT_INLINE_BITFIELD_FULL(ProtocolDecl, NominalTypeDecl, 1+1+1+1+1+1+1+1+1+1+1+8+16,
     /// Whether the \c RequiresClass bit is valid.
     RequiresClassValid : 1,
 
@@ -533,6 +533,12 @@ class alignas(1 << DeclAlignInBits) Decl : public ASTAllocated<Decl> {
     /// Whether the existential of this protocol conforms to itself.
     ExistentialConformsToSelf : 1,
 
+    /// Whether the \c ExistentialRequiresAny bit is valid.
+    ExistentialRequiresAnyValid : 1,
+
+    /// Whether the existential of this protocol must be spelled with \c any.
+    ExistentialRequiresAny : 1,
+
     /// True if the protocol has requirements that cannot be satisfied (e.g.
     /// because they could not be imported from Objective-C).
     HasMissingRequirements : 1,
@@ -4244,6 +4250,21 @@ class ProtocolDecl final : public NominalTypeDecl {
     Bits.ProtocolDecl.ExistentialConformsToSelf = result;
   }
 
+  /// Returns the cached result of \c existentialRequiresAny or \c None if it
+  /// hasn't yet been computed.
+  Optional<bool> getCachedExistentialRequiresAny() {
+    if (Bits.ProtocolDecl.ExistentialRequiresAnyValid)
+      return Bits.ProtocolDecl.ExistentialRequiresAny;
+
+    return None;
+  }
+
+  /// Caches the result of \c existentialRequiresAny
+  void setCachedExistentialRequiresAny(bool requiresAny) {
+    Bits.ProtocolDecl.ExistentialRequiresAnyValid = true;
+    Bits.ProtocolDecl.ExistentialRequiresAny = requiresAny;
+  }
+
   bool hasLazyRequirementSignature() const {
     return Bits.ProtocolDecl.HasLazyRequirementSignature;
   }
@@ -4257,6 +4278,7 @@ class ProtocolDecl final : public NominalTypeDecl {
   friend class RequirementSignatureRequestRQM;
   friend class ProtocolRequiresClassRequest;
   friend class ExistentialConformsToSelfRequest;
+  friend class ExistentialRequiresAnyRequest;
   friend class InheritedProtocolsRequest;
 
 public:
@@ -4345,6 +4367,11 @@ class ProtocolDecl final : public NominalTypeDecl {
   /// contain 'Self' in 'parameter' or 'other' position.
   bool isAvailableInExistential(const ValueDecl *decl) const;
 
+  /// Determine whether an existential type must be explicitly prefixed
+  /// with \c any. \c any is required if any of the members contain
+  /// an associated type, or if \c Self appears in non-covariant position.
+  bool existentialRequiresAny() const;
+
   /// Returns a list of protocol requirements that must be assessed to
   /// determine a concrete's conformance effect polymorphism kind.
   PolymorphicEffectRequirementList getPolymorphicEffectRequirements(
@@ -5155,6 +5182,9 @@ class VarDecl : public AbstractStorageDecl {
       Bits.VarDecl.IsSelfParamCapture = IsSelfParamCapture;
   }
 
+  /// Check whether this capture of the self param is actor-isolated.
+  bool isSelfParamCaptureIsolated() const;
+
   /// Determines if this var has an initializer expression that should be
   /// exposed to clients.
   ///

include/swift/AST/DiagnosticsFrontend.def

@@ -80,6 +80,8 @@ ERROR(error_unknown_arg,none,
       "unknown argument: '%0'", (StringRef))
 ERROR(error_invalid_arg_value,none,
       "invalid value '%1' in '%0'", (StringRef, StringRef))
+ERROR(error_invalid_arg_combination,none,
+      "unsupported argument combination: '%0' and '%1'", (StringRef, StringRef))
 WARNING(warning_invalid_locale_code,none,
       "unsupported locale code; supported locale codes are: '%0'", (StringRef))
 WARNING(warning_locale_path_not_found,none,
@@ -145,6 +147,8 @@ WARNING(emit_reference_dependencies_without_primary_file,none,
 
 WARNING(warn_implicit_concurrency_import_failed,none,
         "unable to perform implicit import of \"_Concurrency\" module: no such module found", ())
+WARNING(warn_implicit_string_processing_import_failed,none,
+        "unable to perform implicit import of \"_StringProcessing\" module: no such module found", ())
 
 ERROR(error_module_name_required,none, "-module-name is required", ())
 ERROR(error_bad_module_name,none,

include/swift/AST/DiagnosticsParse.def

@@ -873,7 +873,8 @@ ERROR(sil_function_subs_without_generics,none,
 
 // Opaque types
 ERROR(opaque_mid_composition,none,
-      "'some' should appear at the beginning of a composition", ())
+      "'%0' should appear at the beginning of a composition",
+      (StringRef))
 
 //------------------------------------------------------------------------------
 // MARK: Layout constraint diagnostics

include/swift/AST/DiagnosticsSema.def

@@ -2533,6 +2533,11 @@ WARNING(associated_type_override_typealias,none,
         "associated type %0 is redundant with type %0 declared in inherited "
         "%1 %2", (Identifier, DescriptiveDeclKind, Type))
 
+ERROR(requirement_machine_completion_failed,none,
+      "cannot build rewrite system for %select{generic signature|protocol}0; "
+      "%select{step|depth}1 limit exceeded",
+      (unsigned, unsigned))
+
 ERROR(associated_type_objc,none,
       "associated type %0 cannot be declared inside '@objc' protocol %1",
       (Identifier, Identifier))
@@ -3668,9 +3673,6 @@ ERROR(builtin_string_literal_broken_proto,none,
 ERROR(string_literal_broken_proto,none,
       "protocol 'ExpressibleByStringLiteral' is broken", ())
 
-ERROR(regex_decl_broken,none,
-      "cannot find 'Regex' type in scope", ())
-
 // Array literals
 ERROR(should_use_dictionary_literal,none,
       "dictionary of type %0 cannot be %select{used|initialized}1 "
@@ -4618,6 +4620,19 @@ ERROR(unchecked_not_inheritance_clause,none,
 ERROR(unchecked_not_existential,none,
       "'unchecked' attribute cannot apply to non-protocol type %0", (Type))
 
+WARNING(unnecessary_any,none,
+         "'any' is redundant on type %0", (Type))
+ERROR(any_not_existential,none,
+       "'any' has no effect on %select{concrete type|type parameter}0 %1",
+       (bool, Type))
+ERROR(existential_requires_any,none,
+      "protocol %0 as a type must be explicitly marked as 'any'",
+      (Identifier))
+ERROR(explicit_existential_not_supported,none,
+       "explicit 'any' not supported; use frontend flag "
+       "-enable-explicit-existential-types to enable this feature",
+       ())
+
 ERROR(nonisolated_let,none,
       "'nonisolated' is meaningless on 'let' declarations because "
       "they are immutable",
@@ -4722,6 +4737,14 @@ ERROR(async_unavailable_decl,none,
       "%0 %1 is unavailable from asynchronous contexts%select{|; %3}2",
       (DescriptiveDeclKind, DeclBaseName, bool, StringRef))
 
+//------------------------------------------------------------------------------
+// MARK: String Processing
+//------------------------------------------------------------------------------
+
+ERROR(string_processing_lib_missing,none,
+      "missing '%0' declaration, probably because the '_StringProcessing' "
+      "module was not imported properly", (StringRef))
+
 //------------------------------------------------------------------------------
 // MARK: Type Check Types
 //------------------------------------------------------------------------------

include/swift/AST/Expr.h

@@ -966,26 +966,18 @@ class InterpolatedStringLiteralExpr : public LiteralExpr {
 class RegexLiteralExpr : public LiteralExpr {
   SourceLoc Loc;
   StringRef RegexText;
-  Expr *SemanticExpr;
 
-  RegexLiteralExpr(SourceLoc loc, StringRef regexText, Expr *semanticExpr,
-                   bool isImplicit)
+  RegexLiteralExpr(SourceLoc loc, StringRef regexText, bool isImplicit)
       : LiteralExpr(ExprKind::RegexLiteral, isImplicit), Loc(loc),
-        RegexText(regexText), SemanticExpr(semanticExpr) {}
+        RegexText(regexText) {}
 
 public:
   static RegexLiteralExpr *createParsed(ASTContext &ctx, SourceLoc loc,
-                                        StringRef regexText,
-                                        Expr *semanticExpr);
+                                        StringRef regexText);
 
   /// Retrieve the raw regex text.
   StringRef getRegexText() const { return RegexText; }
 
-  /// Retrieve the semantic expression that the regex will be type-checked and
-  /// emitted as.
-  Expr *getSemanticExpr() const { return SemanticExpr; }
-  void setSemanticExpr(Expr *expr) { SemanticExpr = expr; }
-
   SourceRange getSourceRange() const { return Loc; }
 
   static bool classof(const Expr *E) {

include/swift/AST/GenericSignature.h

@@ -217,6 +217,12 @@ class GenericSignature {
 
   /// Check invariants.
   void verify() const;
+
+  /// Check invariants for a list of requirements that are understood to
+  /// be valid in the given signature; used to verify a protocol's
+  /// requirement signature against the protocol generic signature
+  /// <Self where Self : P>.
+  void verify(ArrayRef<Requirement> reqts) const;
 };
 
 /// A reference to a canonical generic signature.

include/swift/AST/KnownIdentifiers.def

@@ -250,9 +250,10 @@ IDENTIFIER(pullback)
 IDENTIFIER(TangentVector)
 IDENTIFIER(zero)
 
-// Regex literals
+// String processing
 IDENTIFIER(Regex)
-IDENTIFIER(_regexString)
+IDENTIFIER_(regexString)
+IDENTIFIER_(StringProcessing)
 
 // Distributed actors
 IDENTIFIER(transport)

include/swift/AST/KnownSDKTypes.def

@@ -48,4 +48,8 @@ KNOWN_SDK_TYPE_DECL(Distributed, DistributedActor, ProtocolDecl, 0)
 KNOWN_SDK_TYPE_DECL(Distributed, ActorIdentity, ProtocolDecl, 0)
 KNOWN_SDK_TYPE_DECL(Distributed, AnyActorIdentity, StructDecl, 0)
 
+// String processing
+KNOWN_SDK_TYPE_DECL(StringProcessing, Regex, StructDecl, 1)
+KNOWN_SDK_TYPE_DECL(StringProcessing, DynamicCaptures, EnumDecl, 0)
+
 #undef KNOWN_SDK_TYPE_DECL

include/swift/AST/TypeCheckRequests.h

@@ -287,6 +287,32 @@ class ExistentialConformsToSelfRequest :
   void cacheResult(bool value) const;
 };
 
+/// Determine whether an existential type conforming to this protocol
+/// requires the \c any syntax.
+class ExistentialRequiresAnyRequest :
+    public SimpleRequest<ExistentialRequiresAnyRequest,
+                         bool(ProtocolDecl *),
+                         RequestFlags::SeparatelyCached> {
+public:
+  using SimpleRequest::SimpleRequest;
+
+private:
+  friend SimpleRequest;
+
+  // Evaluation.
+  bool evaluate(Evaluator &evaluator, ProtocolDecl *decl) const;
+
+public:
+  // Cycle handling.
+  void diagnoseCycle(DiagnosticEngine &diags) const;
+  void noteCycleStep(DiagnosticEngine &diags) const;
+
+  // Separate caching.
+  bool isCached() const { return true; }
+  Optional<bool> getCachedResult() const;
+  void cacheResult(bool value) const;
+};
+
 class PolymorphicEffectRequirementsRequest :
     public SimpleRequest<PolymorphicEffectRequirementsRequest,
                          PolymorphicEffectRequirementList(EffectKind, ProtocolDecl *),
@@ -3095,15 +3121,15 @@ class SynthesizeMainFunctionRequest
 /// the Sendable protocol.
 class GetImplicitSendableRequest :
     public SimpleRequest<GetImplicitSendableRequest,
-                         NormalProtocolConformance *(NominalTypeDecl *),
+                         ProtocolConformance *(NominalTypeDecl *),
                          RequestFlags::Cached> {
 public:
   using SimpleRequest::SimpleRequest;
 
 private:
   friend SimpleRequest;
 
-  NormalProtocolConformance *evaluate(
+  ProtocolConformance *evaluate(
       Evaluator &evaluator, NominalTypeDecl *nominal) const;
 
 public: