Merge pull request #33147 from DougGregor/async-function-types

[Concurrency] Add `async` to the Swift type system.

Author: DougGregor

docs/ABI/Mangling.rst

@@ -527,13 +527,14 @@ Types
   FUNCTION-KIND ::= 'H'                      // @differentiable(linear) function type
   FUNCTION-KIND ::= 'I'                      // @differentiable(linear) function type (escaping)
 
-  function-signature ::= params-type params-type throws? // results and parameters
+  function-signature ::= params-type params-type async? throws? // results and parameters
 
   params-type ::= type 'z'? 'h'?              // tuple in case of multiple parameters or a single parameter with a single tuple type
                                              // with optional inout convention, shared convention. parameters don't have labels,
                                              // they are mangled separately as part of the entity.
   params-type ::= empty-list                  // shortcut for no parameters
 
+  async ::= 'Y'                              // 'async' annotation on function types
   throws ::= 'K'                             // 'throws' annotation on function types
 
   type-list ::= list-type '_' list-type*     // list of types

include/swift/ABI/Metadata.h

@@ -1634,6 +1634,7 @@ struct TargetFunctionTypeMetadata : public TargetMetadata<Runtime> {
   FunctionMetadataConvention getConvention() const {
     return Flags.getConvention();
   }
+  bool async() const { return Flags.async(); }
   bool throws() const { return Flags.throws(); }
   bool hasParameterFlags() const { return Flags.hasParameterFlags(); }
   bool isEscaping() const { return Flags.isEscaping(); }

include/swift/ABI/MetadataValues.h

@@ -794,8 +794,9 @@ class TargetFunctionTypeFlags {
     ThrowsMask        = 0x01000000U,
     ParamFlagsMask    = 0x02000000U,
     EscapingMask      = 0x04000000U,
-    DifferentiableMask  = 0x08000000U,
-    LinearMask          = 0x10000000U
+    DifferentiableMask = 0x08000000U,
+    LinearMask        = 0x10000000U,
+    AsyncMask         = 0x20000000U,
   };
   int_type Data;
 
@@ -813,7 +814,13 @@ class TargetFunctionTypeFlags {
     return TargetFunctionTypeFlags((Data & ~ConventionMask)
                              | (int_type(c) << ConventionShift));
   }
-  
+
+  constexpr TargetFunctionTypeFlags<int_type>
+  withAsync(bool async) const {
+    return TargetFunctionTypeFlags<int_type>((Data & ~AsyncMask) |
+                                             (async ? AsyncMask : 0));
+  }
+
   constexpr TargetFunctionTypeFlags<int_type>
   withThrows(bool throws) const {
     return TargetFunctionTypeFlags<int_type>((Data & ~ThrowsMask) |
@@ -847,7 +854,11 @@ class TargetFunctionTypeFlags {
   FunctionMetadataConvention getConvention() const {
     return FunctionMetadataConvention((Data&ConventionMask) >> ConventionShift);
   }
-  
+
+  bool async() const {
+    return bool(Data & AsyncMask);
+  }
+
   bool throws() const {
     return bool(Data & ThrowsMask);
   }

include/swift/AST/Decl.h

@@ -385,7 +385,7 @@ class alignas(1 << DeclAlignInBits) Decl {
   SWIFT_INLINE_BITFIELD(SubscriptDecl, VarDecl, 2,
     StaticSpelling : 2
   );
-  SWIFT_INLINE_BITFIELD(AbstractFunctionDecl, ValueDecl, 3+8+1+1+1+1+1+1,
+  SWIFT_INLINE_BITFIELD(AbstractFunctionDecl, ValueDecl, 3+8+1+1+1+1+1+1+1,
     /// \see AbstractFunctionDecl::BodyKind
     BodyKind : 3,
 
@@ -398,6 +398,9 @@ class alignas(1 << DeclAlignInBits) Decl {
     /// Whether we are overridden later.
     Overridden : 1,
 
+    /// Whether the function is async.
+    Async : 1,
+
     /// Whether the function body throws.
     Throws : 1,
 
@@ -5792,6 +5795,9 @@ class AbstractFunctionDecl : public GenericContext, public ValueDecl {
 
   CaptureInfo Captures;
 
+  /// Location of the 'async' token.
+  SourceLoc AsyncLoc;
+
   /// Location of the 'throws' token.
   SourceLoc ThrowsLoc;
 
@@ -5801,15 +5807,17 @@ class AbstractFunctionDecl : public GenericContext, public ValueDecl {
   } LazySemanticInfo = { };
 
   AbstractFunctionDecl(DeclKind Kind, DeclContext *Parent, DeclName Name,
-                       SourceLoc NameLoc, bool Throws, SourceLoc ThrowsLoc,
+                       SourceLoc NameLoc, bool Async, SourceLoc AsyncLoc,
+                       bool Throws, SourceLoc ThrowsLoc,
                        bool HasImplicitSelfDecl,
                        GenericParamList *GenericParams)
       : GenericContext(DeclContextKind::AbstractFunctionDecl, Parent, GenericParams),
         ValueDecl(Kind, Parent, Name, NameLoc),
-        Body(nullptr), ThrowsLoc(ThrowsLoc) {
+        Body(nullptr), AsyncLoc(AsyncLoc), ThrowsLoc(ThrowsLoc) {
     setBodyKind(BodyKind::None);
     Bits.AbstractFunctionDecl.HasImplicitSelfDecl = HasImplicitSelfDecl;
     Bits.AbstractFunctionDecl.Overridden = false;
+    Bits.AbstractFunctionDecl.Async = Async;
     Bits.AbstractFunctionDecl.Throws = Throws;
     Bits.AbstractFunctionDecl.Synthesized = false;
     Bits.AbstractFunctionDecl.HasSingleExpressionBody = false;
@@ -5869,9 +5877,16 @@ class AbstractFunctionDecl : public GenericContext, public ValueDecl {
     Bits.AbstractFunctionDecl.IAMStatus = newValue.getRawValue();
   }
 
+  /// Retrieve the location of the 'async' keyword, if present.
+  SourceLoc getAsyncLoc() const { return AsyncLoc; }
+
   /// Retrieve the location of the 'throws' keyword, if present.
   SourceLoc getThrowsLoc() const { return ThrowsLoc; }
 
+  /// Returns true if the function is marked as `async`. The
+  /// type of the function will be `async` as well.
+  bool hasAsync() const { return Bits.AbstractFunctionDecl.Async; }
+
   /// Returns true if the function body throws.
   bool hasThrows() const { return Bits.AbstractFunctionDecl.Throws; }
 
@@ -6117,11 +6132,13 @@ class FuncDecl : public AbstractFunctionDecl {
            SourceLoc StaticLoc, StaticSpellingKind StaticSpelling,
            SourceLoc FuncLoc,
            DeclName Name, SourceLoc NameLoc,
+           bool Async, SourceLoc AsyncLoc,
            bool Throws, SourceLoc ThrowsLoc,
            bool HasImplicitSelfDecl,
            GenericParamList *GenericParams, DeclContext *Parent)
     : AbstractFunctionDecl(Kind, Parent,
                            Name, NameLoc,
+                           Async, AsyncLoc,
                            Throws, ThrowsLoc,
                            HasImplicitSelfDecl, GenericParams),
       StaticLoc(StaticLoc), FuncLoc(FuncLoc) {
@@ -6143,6 +6160,7 @@ class FuncDecl : public AbstractFunctionDecl {
                               StaticSpellingKind StaticSpelling,
                               SourceLoc FuncLoc,
                               DeclName Name, SourceLoc NameLoc,
+                              bool Async, SourceLoc AsyncLoc,
                               bool Throws, SourceLoc ThrowsLoc,
                               GenericParamList *GenericParams,
                               DeclContext *Parent,
@@ -6168,6 +6186,7 @@ class FuncDecl : public AbstractFunctionDecl {
                                       StaticSpellingKind StaticSpelling,
                                       SourceLoc FuncLoc,
                                       DeclName Name, SourceLoc NameLoc,
+                                      bool Async, SourceLoc AsyncLoc,
                                       bool Throws, SourceLoc ThrowsLoc,
                                       GenericParamList *GenericParams,
                                       DeclContext *Parent);
@@ -6176,6 +6195,7 @@ class FuncDecl : public AbstractFunctionDecl {
                           StaticSpellingKind StaticSpelling,
                           SourceLoc FuncLoc,
                           DeclName Name, SourceLoc NameLoc,
+                          bool Async, SourceLoc AsyncLoc,
                           bool Throws, SourceLoc ThrowsLoc,
                           GenericParamList *GenericParams,
                           ParameterList *ParameterList,
@@ -6317,7 +6337,8 @@ class AccessorDecl final : public FuncDecl {
     : FuncDecl(DeclKind::Accessor,
                staticLoc, staticSpelling, /*func loc*/ declLoc,
                /*name*/ Identifier(), /*name loc*/ declLoc,
-               throws, throwsLoc, hasImplicitSelfDecl, genericParams, parent),
+               /*Async=*/false, SourceLoc(), throws, throwsLoc,
+               hasImplicitSelfDecl, genericParams, parent),
       AccessorKeywordLoc(accessorKeywordLoc),
       Storage(storage) {
     Bits.AccessorDecl.AccessorKind = unsigned(accessorKind);

include/swift/AST/DiagnosticsParse.def

@@ -727,10 +727,9 @@ ERROR(generic_non_function,PointsToFirstBadToken,
 ERROR(rethrowing_function_type,none,
       "only function declarations may be marked 'rethrows'; "
       "did you mean 'throws'?", ())
-ERROR(throws_in_wrong_position,none,
-      "'throws' may only occur before '->'", ())
-ERROR(rethrows_in_wrong_position,none,
-      "'rethrows' may only occur before '->'", ())
+ERROR(async_or_throws_in_wrong_position,none,
+      "%select{'throws'|'rethrows'|'async'}0 may only occur before '->'",
+      (unsigned))
 ERROR(throw_in_function_type,none,
       "expected throwing specifier; did you mean 'throws'?", ())
 ERROR(expected_type_before_arrow,none,
@@ -742,6 +741,9 @@ ERROR(function_type_argument_label,none,
       (Identifier))
 ERROR(expected_dynamic_func_attr,none,
       "expected a dynamically_replaceable function", ())
+ERROR(async_after_throws,none,
+      "'async' must precede %select{'throws'|'rethrows'}0", (bool))
+ERROR(async_init,none, "initializer cannot be marked 'async'", ())
 
 // Enum Types
 ERROR(expected_expr_enum_case_raw_value,PointsToFirstBadToken,

include/swift/AST/DiagnosticsSema.def

@@ -2167,6 +2167,9 @@ NOTE(protocol_witness_settable_conflict,none,
      "candidate is not settable, but protocol requires it", ())
 NOTE(protocol_witness_rethrows_conflict,none,
      "candidate is not 'rethrows', but protocol requires it", ())
+NOTE(protocol_witness_async_conflict,none,
+     "candidate is %select{not |}0'async', but protocol requirement is%select{| not}0",
+     (bool))
 NOTE(protocol_witness_throws_conflict,none,
      "candidate throws, but protocol does not allow it", ())
 NOTE(protocol_witness_not_objc,none,
@@ -4377,6 +4380,10 @@ NOTE(not_objc_generic_type_param,none,
 NOTE(not_objc_function_type_param,none,
      "function types cannot be represented in Objective-C unless their "
      "parameters and returns can be", ())
+ERROR(not_objc_function_async,none,
+      "'async' function cannot be represented in Objective-C", ())
+NOTE(not_objc_function_type_async,none,
+      "'async' function types cannot be represented in Objective-C", ())
 NOTE(not_objc_function_type_throwing,none,
       "throwing function types cannot be represented in Objective-C", ())
 NOTE(objc_inferring_on_objc_protocol_member,none,

include/swift/AST/Expr.h

@@ -4812,32 +4812,38 @@ class CoerceExpr final : public ExplicitCastExpr {
 /// may be preceded by the 'throws' keyword. Currently this only exists to be
 /// transformed into a FunctionTypeRepr by simplifyTypeExpr() in Sema.
 class ArrowExpr : public Expr {
+  SourceLoc AsyncLoc;
   SourceLoc ThrowsLoc;
   SourceLoc ArrowLoc;
   Expr *Args;
   Expr *Result;
 public:
-  ArrowExpr(Expr *Args, SourceLoc ThrowsLoc, SourceLoc ArrowLoc, Expr *Result)
+  ArrowExpr(Expr *Args, SourceLoc AsyncLoc, SourceLoc ThrowsLoc,
+            SourceLoc ArrowLoc, Expr *Result)
     : Expr(ExprKind::Arrow, /*implicit=*/false, Type()),
-      ThrowsLoc(ThrowsLoc), ArrowLoc(ArrowLoc), Args(Args), Result(Result)
+      AsyncLoc(AsyncLoc), ThrowsLoc(ThrowsLoc), ArrowLoc(ArrowLoc), Args(Args),
+      Result(Result)
   { }
 
-  ArrowExpr(SourceLoc ThrowsLoc, SourceLoc ArrowLoc)
+  ArrowExpr(SourceLoc AsyncLoc, SourceLoc ThrowsLoc, SourceLoc ArrowLoc)
     : Expr(ExprKind::Arrow, /*implicit=*/false, Type()),
-      ThrowsLoc(ThrowsLoc), ArrowLoc(ArrowLoc), Args(nullptr), Result(nullptr)
+      AsyncLoc(AsyncLoc), ThrowsLoc(ThrowsLoc), ArrowLoc(ArrowLoc),
+      Args(nullptr), Result(nullptr)
   { }
 
   Expr *getArgsExpr() const { return Args; }
   void setArgsExpr(Expr *E) { Args = E; }
   Expr *getResultExpr() const { return Result; }
   void setResultExpr(Expr *E) { Result = E; }
+  SourceLoc getAsyncLoc() const { return AsyncLoc; }
   SourceLoc getThrowsLoc() const { return ThrowsLoc; }
   SourceLoc getArrowLoc() const { return ArrowLoc; }
   bool isFolded() const { return Args != nullptr && Result != nullptr; }
 
   SourceLoc getSourceLoc() const { return ArrowLoc; }
   SourceLoc getStartLoc() const {
     return isFolded() ? Args->getStartLoc() :
+           AsyncLoc.isValid() ? AsyncLoc :
            ThrowsLoc.isValid() ? ThrowsLoc : ArrowLoc;
   }
   SourceLoc getEndLoc() const {

include/swift/AST/TypeRepr.h

@@ -482,12 +482,14 @@ class FunctionTypeRepr : public TypeRepr {
 
   TupleTypeRepr *ArgsTy;
   TypeRepr *RetTy;
-  SourceLoc ArrowLoc;
+  SourceLoc AsyncLoc;
   SourceLoc ThrowsLoc;
+  SourceLoc ArrowLoc;
 
 public:
   FunctionTypeRepr(GenericParamList *genericParams, TupleTypeRepr *argsTy,
-                   SourceLoc throwsLoc, SourceLoc arrowLoc, TypeRepr *retTy,
+                   SourceLoc asyncLoc, SourceLoc throwsLoc, SourceLoc arrowLoc,
+                   TypeRepr *retTy,
                    GenericParamList *patternGenericParams = nullptr,
                    ArrayRef<TypeRepr *> patternSubs = {},
                    ArrayRef<TypeRepr *> invocationSubs = {})
@@ -497,7 +499,7 @@ class FunctionTypeRepr : public TypeRepr {
       PatternGenericParams(patternGenericParams), PatternGenericEnv(nullptr),
       PatternSubs(patternSubs),
       ArgsTy(argsTy), RetTy(retTy),
-      ArrowLoc(arrowLoc), ThrowsLoc(throwsLoc) {
+      AsyncLoc(asyncLoc), ThrowsLoc(throwsLoc), ArrowLoc(arrowLoc) {
   }
 
   GenericParamList *getGenericParams() const { return GenericParams; }
@@ -527,10 +529,12 @@ class FunctionTypeRepr : public TypeRepr {
 
   TupleTypeRepr *getArgsTypeRepr() const { return ArgsTy; }
   TypeRepr *getResultTypeRepr() const { return RetTy; }
+  bool async() const { return AsyncLoc.isValid(); }
   bool throws() const { return ThrowsLoc.isValid(); }
 
-  SourceLoc getArrowLoc() const { return ArrowLoc; }
+  SourceLoc getAsyncLoc() const { return AsyncLoc; }
   SourceLoc getThrowsLoc() const { return ThrowsLoc; }
+  SourceLoc getArrowLoc() const { return ArrowLoc; }
 
   static bool classof(const TypeRepr *T) {
     return T->getKind() == TypeReprKind::Function;

include/swift/AST/Types.h

@@ -311,7 +311,7 @@ class alignas(1 << TypeAlignInBits) TypeBase {
   }
 
 protected:
-  enum { NumAFTExtInfoBits = 8 };
+  enum { NumAFTExtInfoBits = 9 };
   enum { NumSILExtInfoBits = 8 };
   union { uint64_t OpaqueBits;
 
@@ -2972,7 +2972,7 @@ class AnyFunctionType : public TypeBase {
   /// A class which abstracts out some details necessary for
   /// making a call.
   class ExtInfo {
-    // If bits are added or removed, then TypeBase::AnyFunctionTypeBits
+    // If bits are added or removed, then TypeBase::NumAFTExtInfoBits
     // and NumMaskBits must be updated, and they must match.
     //
     //   |representation|noEscape|throws|differentiability|
@@ -2981,10 +2981,11 @@ class AnyFunctionType : public TypeBase {
     enum : unsigned {
       RepresentationMask          = 0xF << 0,
       NoEscapeMask                = 1 << 4,
-      ThrowsMask                  = 1 << 5,
-      DifferentiabilityMaskOffset = 6,
+      AsyncMask                   = 1 << 5,
+      ThrowsMask                  = 1 << 6,
+      DifferentiabilityMaskOffset = 7,
       DifferentiabilityMask       = 0x3 << DifferentiabilityMaskOffset,
-      NumMaskBits                 = 8
+      NumMaskBits                 = 9
     };
 
     unsigned Bits; // Naturally sized for speed.
@@ -3051,6 +3052,7 @@ class AnyFunctionType : public TypeBase {
     }
 
     bool isNoEscape() const { return Bits & NoEscapeMask; }
+    bool async() const { return Bits & AsyncMask; }
     bool throws() const { return Bits & ThrowsMask; }
     bool isDifferentiable() const {
       return getDifferentiabilityKind() >
@@ -3120,6 +3122,11 @@ class AnyFunctionType : public TypeBase {
                      Other);
     }
     LLVM_NODISCARD
+    ExtInfo withAsync(bool Async = true) const {
+      return ExtInfo(Async ? (Bits | AsyncMask) : (Bits & ~AsyncMask),
+                     Other);
+    }
+    LLVM_NODISCARD
     ExtInfo withThrows(bool Throws = true) const {
       return ExtInfo(Throws ? (Bits | ThrowsMask) : (Bits & ~ThrowsMask),
                      Other);
@@ -3378,6 +3385,10 @@ class AnyFunctionType : public TypeBase {
     return getExtInfo().isNoEscape();
   }
 
+  bool async() const {
+    return getExtInfo().async();
+  }
+
   bool throws() const {
     return getExtInfo().throws();
   }

include/swift/Basic/LangOptions.h

@@ -235,6 +235,9 @@ namespace swift {
     /// Enable experimental #assert feature.
     bool EnableExperimentalStaticAssert = false;
 
+    /// Enable experimental concurrency model.
+    bool EnableExperimentalConcurrency = false;
+
     /// Should we check the target OSs of serialized modules to see that they're
     /// new enough?
     bool EnableTargetOSChecking = true;