Sample work on C++ Resumable functions (N4453).

[EricWF]

Summary

Just putting this patch up to show the work done on resumable functions to others. It is not intended for review.

include/clang/AST/Decl.h

class NonParmVarDeclBitfields {
     unsigned IsInline : 1;
 
     /// Whether this variable has (C++1z) inline explicitly specified.
     unsigned IsInlineSpecified : 1;
 
     /// Whether this variable is (C++0x) constexpr.
     unsigned IsConstexpr : 1;
 
+    /// Whether this variable is a suspension point for a resumable expression.
+    unsigned IsResumable : 1;
+
     /// Whether this variable is the implicit variable for a lambda
     /// init-capture.
     unsigned IsInitCapture : 1;
 
     /// Whether this local extern variable's previous declaration was
     /// declared in the same block scope. This controls whether we should merge
     /// the type of this declaration with its previous declaration.
     unsigned PreviousDeclInSameBlockScope : 1;
public:
   bool isConstexpr() const {
     return isa<ParmVarDecl>(this) ? false : NonParmVarDeclBits.IsConstexpr;
   }
   void setConstexpr(bool IC) {
     assert(!isa<ParmVarDecl>(this));
     NonParmVarDeclBits.IsConstexpr = IC;
   }
 
+  /// Wheither this variable is specified with the 'resumable' keyword.
+  bool isResumableSpecified() const {
+    return isa<ParmVarDecl>(this) ? false : NonParmVarDeclBits.IsResumable;
+  }
+  void setResumableSpecified(bool IR) {
+    assert(!isa<ParmVarDecl>(this));
+    NonParmVarDeclBits.IsResumable = IR;
+  }
+
   /// Whether this variable is the implicit variable for a lambda init-capture.
   bool isInitCapture() const {
     return isa<ParmVarDecl>(this) ? false : NonParmVarDeclBits.IsInitCapture;
   }
   void setInitCapture(bool IC) {
     assert(!isa<ParmVarDecl>(this));
     NonParmVarDeclBits.IsInitCapture = IC;
   }
private:
   /// constructor or a destructor.
   unsigned IsTrivialForCall : 1;
 
   unsigned IsDefaulted : 1; // sunk from CXXMethoDecl
   unsigned IsExplicitlyDefaulted : 1; //sunk from CXXMethodDecl
   unsigned HasImplicitReturnZero : 1;
   unsigned IsLateTemplateParsed : 1;
   unsigned IsConstexpr : 1;
+  unsigned IsResumableSpecified : 1;
+  unsigned IsImplicitlyResumable : 1;
   unsigned InstantiationIsPending : 1;
 
   /// Indicates if the function uses __try.
   unsigned UsesSEHTry : 1;
 
   /// Indicates if the function was a definition but its body was
   /// skipped.
   unsigned HasSkippedBody : 1;
void setInstantiationOfMemberFunction(ASTContext &C, FunctionDecl *FD,
                                         TemplateSpecializationKind TSK);
 
   void setParams(ASTContext &C, ArrayRef<ParmVarDecl *> NewParamInfo);
 
 protected:
   FunctionDecl(Kind DK, ASTContext &C, DeclContext *DC, SourceLocation StartLoc,
                const DeclarationNameInfo &NameInfo, QualType T,
                TypeSourceInfo *TInfo, StorageClass S, bool isInlineSpecified,
-               bool isConstexprSpecified)
+               bool isConstexprSpecified, bool isResumableSpecified)
       : DeclaratorDecl(DK, DC, NameInfo.getLoc(), NameInfo.getName(), T, TInfo,
                        StartLoc),
         DeclContext(DK), redeclarable_base(C), SClass(S),
         IsInline(isInlineSpecified), IsInlineSpecified(isInlineSpecified),
         IsExplicitSpecified(false), IsVirtualAsWritten(false), IsPure(false),
         HasInheritedPrototype(false), HasWrittenPrototype(true),
         IsDeleted(false), IsTrivial(false), IsTrivialForCall(false),
-        IsDefaulted(false),
-        IsExplicitlyDefaulted(false), HasImplicitReturnZero(false),
-        IsLateTemplateParsed(false), IsConstexpr(isConstexprSpecified),
-        InstantiationIsPending(false), UsesSEHTry(false), HasSkippedBody(false),
-        WillHaveBody(false), IsMultiVersion(false),
-        IsCopyDeductionCandidate(false), HasODRHash(false), ODRHash(0),
-        EndRangeLoc(NameInfo.getEndLoc()), DNLoc(NameInfo.getInfo()) {}
+        IsDefaulted(false), IsExplicitlyDefaulted(false),
+        HasImplicitReturnZero(false), IsLateTemplateParsed(false),
+        IsConstexpr(isConstexprSpecified),
+        IsResumableSpecified(isResumableSpecified),
+        IsImplicitlyResumable(false), InstantiationIsPending(false),
+        UsesSEHTry(false), HasSkippedBody(false), WillHaveBody(false),
+        IsMultiVersion(false), IsCopyDeductionCandidate(false),
+        HasODRHash(false), ODRHash(0), EndRangeLoc(NameInfo.getEndLoc()),
+        DNLoc(NameInfo.getInfo()) {}
 
   using redeclarable_base = Redeclarable<FunctionDecl>;
 
   FunctionDecl *getNextRedeclarationImpl() override {
     return getNextRedeclaration();
   }
 
   FunctionDecl *getPreviousDeclImpl() override {
public:
 
   using redeclarable_base::redecls_begin;
   using redeclarable_base::redecls_end;
   using redeclarable_base::redecls;
   using redeclarable_base::getPreviousDecl;
   using redeclarable_base::getMostRecentDecl;
   using redeclarable_base::isFirstDecl;
 
-  static FunctionDecl *Create(ASTContext &C, DeclContext *DC,
-                              SourceLocation StartLoc, SourceLocation NLoc,
-                              DeclarationName N, QualType T,
-                              TypeSourceInfo *TInfo,
-                              StorageClass SC,
-                              bool isInlineSpecified = false,
-                              bool hasWrittenPrototype = true,
-                              bool isConstexprSpecified = false) {
+  static FunctionDecl *
+  Create(ASTContext &C, DeclContext *DC, SourceLocation StartLoc,
+         SourceLocation NLoc, DeclarationName N, QualType T,
+         TypeSourceInfo *TInfo, StorageClass SC, bool isInlineSpecified = false,
+         bool hasWrittenPrototype = true, bool isConstexprSpecified = false,
+         bool isResumableSpecified = false) {
     DeclarationNameInfo NameInfo(N, NLoc);
-    return FunctionDecl::Create(C, DC, StartLoc, NameInfo, T, TInfo,
-                                SC,
+    return FunctionDecl::Create(C, DC, StartLoc, NameInfo, T, TInfo, SC,
                                 isInlineSpecified, hasWrittenPrototype,
-                                isConstexprSpecified);
+                                isConstexprSpecified, isResumableSpecified);
   }
 
-  static FunctionDecl *Create(ASTContext &C, DeclContext *DC,
-                              SourceLocation StartLoc,
-                              const DeclarationNameInfo &NameInfo,
-                              QualType T, TypeSourceInfo *TInfo,
-                              StorageClass SC,
-                              bool isInlineSpecified,
-                              bool hasWrittenPrototype,
-                              bool isConstexprSpecified = false);
+  static FunctionDecl *
+  Create(ASTContext &C, DeclContext *DC, SourceLocation StartLoc,
+         const DeclarationNameInfo &NameInfo, QualType T, TypeSourceInfo *TInfo,
+         StorageClass SC, bool isInlineSpecified, bool hasWrittenPrototype,
+         bool isConstexprSpecified = false, bool isResumableSpecified = false);
 
   static FunctionDecl *CreateDeserialized(ASTContext &C, unsigned ID);
                        
   DeclarationNameInfo getNameInfo() const {
     return DeclarationNameInfo(getDeclName(), getLocation(), DNLoc);
   }
 
   void getNameForDiagnostic(raw_ostream &OS, const PrintingPolicy &Policy,
public:
   /// previous declaration.
   bool hasInheritedPrototype() const { return HasInheritedPrototype; }
   void setHasInheritedPrototype(bool P = true) { HasInheritedPrototype = P; }
 
   /// Whether this is a (C++11) constexpr function or constexpr constructor.
   bool isConstexpr() const { return IsConstexpr; }
   void setConstexpr(bool IC) { IsConstexpr = IC; }
 
+  bool isResumable() const {
+    return IsResumableSpecified || IsImplicitlyResumable;
+  }
+
+  bool isResumableSpecified() const { return IsResumableSpecified; }
+  void setResumableSpecified(bool IR) { IsResumableSpecified = IR; }
+
+  bool isImplicitlyResumable() const { return IsImplicitlyResumable; }
+  void setImplicitlyResumable(bool IR) { IsImplicitlyResumable = IR; }
+
   /// Whether the instantiation of this function is pending.
   /// This bit is set when the decision to instantiate this function is made
   /// and unset if and when the function body is created. That leaves out
   /// cases where instantiation did not happen because the template definition
   /// was not seen in this TU. This bit remains set in those cases, under the
   /// assumption that the instantiation will happen in some other TU.
   bool instantiationIsPending() const { return InstantiationIsPending; }
   void setInstantiationIsPending(bool IC) { InstantiationIsPending = IC; }

include/clang/AST/DeclCXX.h

   void anchor() override;
 
 private:
   CXXDeductionGuideDecl(ASTContext &C, DeclContext *DC, SourceLocation StartLoc,
                         bool IsExplicit, const DeclarationNameInfo &NameInfo,
                         QualType T, TypeSourceInfo *TInfo,
                         SourceLocation EndLocation)
       : FunctionDecl(CXXDeductionGuide, C, DC, StartLoc, NameInfo, T, TInfo,
-                     SC_None, false, false) {
+                     SC_None, false, false, false) {
     if (EndLocation.isValid())
       setRangeEnd(EndLocation);
     IsExplicitSpecified = IsExplicit;
   }
 
 public:
   friend class ASTDeclReader;
   friend class ASTDeclWriter;

 /// In the terminology of the C++ Standard, these are the (static and
 /// non-static) member functions, whether virtual or not.
 class CXXMethodDecl : public FunctionDecl {
   void anchor() override;
 
 protected:
   CXXMethodDecl(Kind DK, ASTContext &C, CXXRecordDecl *RD,
                 SourceLocation StartLoc, const DeclarationNameInfo &NameInfo,
-                QualType T, TypeSourceInfo *TInfo,
-                StorageClass SC, bool isInline,
-                bool isConstexpr, SourceLocation EndLocation)
-    : FunctionDecl(DK, C, RD, StartLoc, NameInfo, T, TInfo,
-                   SC, isInline, isConstexpr) {
+                QualType T, TypeSourceInfo *TInfo, StorageClass SC,
+                bool isInline, bool isConstexpr, bool isResumable,
+                SourceLocation EndLocation)
+      : FunctionDecl(DK, C, RD, StartLoc, NameInfo, T, TInfo, SC, isInline,
+                     isConstexpr, isResumable) {
     if (EndLocation.isValid())
       setRangeEnd(EndLocation);
   }
 
 public:
   static CXXMethodDecl *Create(ASTContext &C, CXXRecordDecl *RD,
                                SourceLocation StartLoc,
-                               const DeclarationNameInfo &NameInfo,
-                               QualType T, TypeSourceInfo *TInfo,
-                               StorageClass SC,
-                               bool isInline,
-                               bool isConstexpr,
-                               SourceLocation EndLocation);
+                               const DeclarationNameInfo &NameInfo, QualType T,
+                               TypeSourceInfo *TInfo, StorageClass SC,
+                               bool isInline, bool isConstexpr,
+                               bool isResumable, SourceLocation EndLocation);
 
   static CXXMethodDecl *CreateDeserialized(ASTContext &C, unsigned ID);
 
   bool isStatic() const;
   bool isInstance() const { return !isStatic(); }
 
   /// Returns true if the given operator is implicitly static in a record
   /// context.

   unsigned NumCtorInitializers : 31;
   /// \}
 
   /// Whether this constructor declaration is an implicitly-declared
   /// inheriting constructor.
   unsigned IsInheritingConstructor : 1;
 
   CXXConstructorDecl(ASTContext &C, CXXRecordDecl *RD, SourceLocation StartLoc,
-                     const DeclarationNameInfo &NameInfo,
-                     QualType T, TypeSourceInfo *TInfo,
-                     bool isExplicitSpecified, bool isInline,
-                     bool isImplicitlyDeclared, bool isConstexpr,
+                     const DeclarationNameInfo &NameInfo, QualType T,
+                     TypeSourceInfo *TInfo, bool isExplicitSpecified,
+                     bool isInline, bool isImplicitlyDeclared, bool isConstexpr,
                      InheritedConstructor Inherited)
       : CXXMethodDecl(CXXConstructor, C, RD, StartLoc, NameInfo, T, TInfo,
-                    SC_None, isInline, isConstexpr, SourceLocation()),
-      NumCtorInitializers(0), IsInheritingConstructor((bool)Inherited) {
+                      SC_None, isInline, isConstexpr, /*isResumable=*/false,
+                      SourceLocation()),
+        NumCtorInitializers(0), IsInheritingConstructor((bool)Inherited) {
     setImplicit(isImplicitlyDeclared);
     if (Inherited)
       *getTrailingObjects<InheritedConstructor>() = Inherited;
     IsExplicitSpecified = isExplicitSpecified;
   }
 
   void anchor() override;
 

   friend class ASTDeclWriter;
 
   // FIXME: Don't allocate storage for these except in the first declaration
   // of a virtual destructor.
   FunctionDecl *OperatorDelete = nullptr;
   Expr *OperatorDeleteThisArg = nullptr;
 
   CXXDestructorDecl(ASTContext &C, CXXRecordDecl *RD, SourceLocation StartLoc,
-                    const DeclarationNameInfo &NameInfo,
-                    QualType T, TypeSourceInfo *TInfo,
-                    bool isInline, bool isImplicitlyDeclared)
+                    const DeclarationNameInfo &NameInfo, QualType T,
+                    TypeSourceInfo *TInfo, bool isInline,
+                    bool isImplicitlyDeclared)
       : CXXMethodDecl(CXXDestructor, C, RD, StartLoc, NameInfo, T, TInfo,
-                    SC_None, isInline, /*isConstexpr=*/false, SourceLocation())
-  {
+                      SC_None, isInline, /*isConstexpr=*/false,
+                      /*isResumable=*/false, SourceLocation()) {
     setImplicit(isImplicitlyDeclared);
   }
 
   void anchor() override;
 
 public:
   static CXXDestructorDecl *Create(ASTContext &C, CXXRecordDecl *RD,
                                    SourceLocation StartLoc,

 ///   operator bool();
 /// };
 /// \endcode
 class CXXConversionDecl : public CXXMethodDecl {
   CXXConversionDecl(ASTContext &C, CXXRecordDecl *RD, SourceLocation StartLoc,
                     const DeclarationNameInfo &NameInfo, QualType T,
                     TypeSourceInfo *TInfo, bool isInline,
                     bool isExplicitSpecified, bool isConstexpr,
-                    SourceLocation EndLocation)
+                    bool isResumable, SourceLocation EndLocation)
       : CXXMethodDecl(CXXConversion, C, RD, StartLoc, NameInfo, T, TInfo,
-                      SC_None, isInline, isConstexpr, EndLocation) {
+                      SC_None, isInline, isConstexpr, isResumable,
+                      EndLocation) {
     IsExplicitSpecified = isExplicitSpecified;
   }
 
   void anchor() override;
 
 public:
   friend class ASTDeclReader;
   friend class ASTDeclWriter;
 
-  static CXXConversionDecl *Create(ASTContext &C, CXXRecordDecl *RD,
-                                   SourceLocation StartLoc,
-                                   const DeclarationNameInfo &NameInfo,
-                                   QualType T, TypeSourceInfo *TInfo,
-                                   bool isInline, bool isExplicit,
-                                   bool isConstexpr,
-                                   SourceLocation EndLocation);
+  static CXXConversionDecl *
+  Create(ASTContext &C, CXXRecordDecl *RD, SourceLocation StartLoc,
+         const DeclarationNameInfo &NameInfo, QualType T, TypeSourceInfo *TInfo,
+         bool isInline, bool isExplicit, bool isConstexpr, bool isResumable,
+         SourceLocation EndLocation);
   static CXXConversionDecl *CreateDeserialized(ASTContext &C, unsigned ID);
 
   /// Whether this function is marked as explicit explicitly.
   bool isExplicitSpecified() const { return IsExplicitSpecified; }
 
   /// Whether this function is explicit.
   bool isExplicit() const {
     return getCanonicalDecl()->isExplicitSpecified();

include/clang/AST/Stmt.h

protected:
   class IfStmtBitfields {
     friend class IfStmt;
 
     unsigned : NumStmtBits;
 
     unsigned IsConstexpr : 1;
   };
 
+  class BreakStmtBitfields {
+    friend class BreakStmt;
+
+    unsigned : NumStmtBits;
+
+    unsigned IsResumable : 1;
+  };
+
   class ExprBitfields {
     friend class ASTStmtReader; // deserialization
     friend class AtomicExpr; // ctor
     friend class BlockDeclRefExpr; // ctor
     friend class CallExpr; // ctor
     friend class CXXConstructExpr; // ctor
     friend class CXXDependentScopeMemberExpr; // ctor
     friend class CXXNewExpr; // ctor
class CoawaitExprBitfields {
 
     unsigned IsImplicit : 1;
   };
 
   union {
     StmtBitfields StmtBits;
     CompoundStmtBitfields CompoundStmtBits;
     IfStmtBitfields IfStmtBits;
+    BreakStmtBitfields BreakStmtBits;
     ExprBitfields ExprBits;
     CharacterLiteralBitfields CharacterLiteralBits;
     FloatingLiteralBitfields FloatingLiteralBits;
     UnaryExprOrTypeTraitExprBitfields UnaryExprOrTypeTraitExprBits;
     DeclRefExprBitfields DeclRefExprBits;
     CastExprBitfields CastExprBits;
     CallExprBitfields CallExprBits;
     ExprWithCleanupsBitfields ExprWithCleanupsBits;
public:
   child_range children() {
     return child_range(child_iterator(), child_iterator());
   }
 };
 
 /// BreakStmt - This represents a break.
 class BreakStmt : public Stmt {
   SourceLocation BreakLoc;
+  SourceLocation ResumableLoc;
 
 public:
-  BreakStmt(SourceLocation BL) : Stmt(BreakStmtClass), BreakLoc(BL) {
-    static_assert(sizeof(BreakStmt) == 2 * sizeof(SourceLocation),
+  BreakStmt(SourceLocation BL, bool IsResumable = false,
+            SourceLocation ResumableLoc = SourceLocation())
+      : Stmt(BreakStmtClass), BreakLoc(BL), ResumableLoc(ResumableLoc) {
+    assert(IsResumable == ResumableLoc.isValid());
+    BreakStmtBits.IsResumable = IsResumable;
+    // FIXME(EricWF): Figure out why this assert was here, and specified
+    // sizeof(BreakStmt) == 2 * sizeof(SourceLocation)
+    static_assert(sizeof(BreakStmt) == 4 * sizeof(SourceLocation),
                   "BreakStmt too large");
   }
 
   /// Build an empty break statement.
   explicit BreakStmt(EmptyShell Empty) : Stmt(BreakStmtClass, Empty) {}
 
+  bool isResumableSpecified() const { return BreakStmtBits.IsResumable; }
+  void setResumableSpecified() { BreakStmtBits.IsResumable = true; }
+
   SourceLocation getBreakLoc() const { return BreakLoc; }
   void setBreakLoc(SourceLocation L) { BreakLoc = L; }
 
+  SourceLocation getResumableLoc() const { return ResumableLoc; }
+  void setResumableLoc(SourceLocation L) { ResumableLoc = L; }
+
   SourceLocation getLocStart() const LLVM_READONLY { return BreakLoc; }
-  SourceLocation getLocEnd() const LLVM_READONLY { return BreakLoc; }
+  SourceLocation getLocEnd() const LLVM_READONLY {
+    return isResumableSpecified() ? ResumableLoc : BreakLoc;
+  }
 
   static bool classof(const Stmt *T) {
     return T->getStmtClass() == BreakStmtClass;
   }
 
   // Iterators
   child_range children() {
     return child_range(child_iterator(), child_iterator());

include/clang/Basic/DiagnosticSemaKinds.td

 def err_inline_main : Error<"'main' is not allowed to be declared inline">;
 def ext_variadic_main : ExtWarn<
   "'main' is not allowed to be declared variadic">, InGroup<Main>;
 def ext_noreturn_main : ExtWarn<
   "'main' is not allowed to be declared _Noreturn">, InGroup<Main>;
 def note_main_remove_noreturn : Note<"remove '_Noreturn'">;
 def err_constexpr_main : Error<
   "'main' is not allowed to be declared constexpr">;
+def err_resumable_main : Error<
+  "'main' is not allowed to be declared resumable">;
 def err_deleted_main : Error<"'main' is not allowed to be deleted">;
 def err_mainlike_template_decl : Error<"%0 cannot be a template">;
 def err_main_returns_nonint : Error<"'main' must return 'int'">;
 def ext_main_returns_nonint : ExtWarn<"return type of 'main' is not 'int'">,
     InGroup<MainReturnType>;
 def note_main_change_return_type : Note<"change return type to 'int'">;
 def err_main_surplus_args : Error<"too many parameters (%0) for 'main': "
     "must be 0, 2, or 3">;

 def note_non_literal_lambda : Note<
   "lambda closure types are non-literal types before C++17">;
 def warn_private_extern : Warning<
   "use of __private_extern__ on a declaration may not produce external symbol "
   "private to the linkage unit and is deprecated">, InGroup<PrivateExtern>;
 def note_private_extern : Note<
   "use __attribute__((visibility(\"hidden\"))) attribute instead">;
 
+// C++ Resumable functions
+def err_resumable_ctor_dtor : Error<
+  "%select{constructor|destructor}0 cannot be marked resumable">;
+def err_invalid_resumable : Error<
+  "%select{function parameter|typedef|non-static data member|global variable}0 "
+  "cannot be resumable">;
+def err_resumable_tag : Error<
+  "%select{class|struct|interface|union|enum}0 cannot be marked resumable">;
+def err_resumable_no_declarators : Error<
+  "resumable can only be used in variable and function declarations">;
+def err_invalid_resumable_var_decl : Error<
+  "resumable variable declaration must be a definition">;
+def err_resumable_redecl_mismatch : Error<
+  "%select{non-resumable declaration of %0 follows resumable declaration"
+  "|resumable declaration of %0 follows non-resumable declaration}1">;
+def err_resumable_virtual : Error<"virtual function cannot be resumable">;
+def err_resumable_local_var_static : Error<
+  "%select{static|thread_local}1 variable not permitted in a resumable "
+  "%select{function|constructor}0">;
+def err_resumable_var_decl_type : Error<
+  "resumable variable cannot be declared with type %0; "
+  "declared type must be 'auto'">;
+def err_resumable_var_decl_constexpr : Error<
+  "resumable variable declaration %0 cannot be constexpr">;
+def err_resumable_var_decl_requires_init : Error<
+  "resumable variable declaration %0 requires an initializer">;
+def err_resumable_func_is_coroutine : Error<
+  "resumable function %0 cannot be a coroutine">;
+def err_resumable_var_decl_init_not_call_expr : Error<
+  "initializer for the resumable variable declaration %0 must be a call to a "
+  "resumable function">;
+def err_resumable_var_decl_init_not_resumable_expr : Error<
+  "initializer for resumable variable declaration %0 calls a non-resumable "
+  "function">;
+def note_function_declared_here : Note<
+  "function declared here">;
+def err_addrof_resumable_fn : Error<
+    "cannot take address of resumable function %0">;
+def note_addrof_ovl_candidate_resumable_fn : Note<
+    "candidate function address cannot be taken because the function is resumable">;
+
+
 // C++ Concepts TS
 def err_concept_wrong_decl_kind : Error<
   "'concept' can only appear on the definition of a function template or variable template">;
 def err_concept_decls_may_only_appear_in_namespace_scope : Error<
   "concept declarations may only appear in namespace scope">;
 def err_function_concept_not_defined : Error<
   "function concept declaration must be a definition">;
 def err_var_concept_not_initialized : Error<

 def warn_os_log_format_narg : Error<
  "os_log() '%%n' format specifier is not allowed">, DefaultError;
 
 // Statements.
 def err_continue_not_in_loop : Error<
   "'continue' statement not in loop statement">;
 def err_break_not_in_loop_or_switch : Error<
   "'break' statement not in loop or switch statement">;
+def err_break_resumable_not_in_resumable_function : Error<
+  "'break resumable' statement not in a resumable function">;
 def warn_loop_ctrl_binds_to_inner : Warning<
   "'%0' is bound to current loop, GCC binds it to the enclosing loop">,
   InGroup<GccCompat>;
 def warn_break_binds_to_switch : Warning<
   "'break' is bound to loop, GCC binds it to switch">,
   InGroup<GccCompat>;
 def err_default_not_in_switch : Error<
   "'default' statement not in switch statement">;

   "multiversioned function redeclarations require identical target attributes">;
 def err_multiversion_noproto : Error<
   "multiversioned function must have a prototype">;
 def err_multiversion_no_other_attrs : Error<
   "attribute 'target' multiversioning cannot be combined with other "
   "attributes">;
 def err_multiversion_diff : Error<
   "multiversioned function declaration has a different %select{calling convention"
-  "|return type|constexpr specification|inline specification|storage class|"
-  "linkage}0">;
+  "|return type|constexpr specification|inline specification"
+  "|resumable specification|storage class|linkage}0">;
 def err_multiversion_doesnt_support : Error<
   "multiversioned functions do not yet support %select{function templates|"
   "virtual functions|deduced return types|constructors|destructors|"
   "deleted functions|defaulted functions}0">;
 def err_multiversion_not_allowed_on_main : Error<
   "'main' cannot be a multiversioned function">;
 def err_multiversion_not_supported : Error<
  "function multiversioning is not supported on the current target">;

include/clang/Basic/LangOptions.def

 LANGOPT(RTTIData          , 1, 1, "emit run-time type information data")
 LANGOPT(MSBitfields       , 1, 0, "Microsoft-compatible structure layout")
 LANGOPT(Freestanding, 1, 0, "freestanding implementation")
 LANGOPT(NoBuiltin         , 1, 0, "disable builtin functions")
 LANGOPT(NoMathBuiltin     , 1, 0, "disable math builtin functions")
 LANGOPT(GNUAsm            , 1, 1, "GNU-style inline assembly")
 LANGOPT(CoroutinesTS      , 1, 0, "C++ coroutines TS")
 LANGOPT(RelaxedTemplateTemplateArgs, 1, 0, "C++17 relaxed matching of template template arguments")
+LANGOPT(ResumableFunctions, 1, 0, "C++ Resumable Functions (N4453)")
 
 LANGOPT(DoubleSquareBracketAttributes, 1, 0, "'[[]]' attributes extension for all language standard modes")
 
 BENIGN_LANGOPT(ThreadsafeStatics , 1, 1, "thread-safe static initializers")
 LANGOPT(POSIXThreads      , 1, 0, "POSIX thread support")
 LANGOPT(Blocks            , 1, 0, "blocks extension to C")
 BENIGN_LANGOPT(EmitAllDecls      , 1, 0, "emitting all declarations")
 LANGOPT(MathErrno         , 1, 1, "errno in math functions")

include/clang/Basic/TokenKinds.def

 CONCEPTS_KEYWORD(concept)
 CONCEPTS_KEYWORD(requires)
 
 // C++ coroutines TS keywords
 KEYWORD(co_await                    , KEYCOROUTINES)
 KEYWORD(co_return                   , KEYCOROUTINES)
 KEYWORD(co_yield                    , KEYCOROUTINES)
 
+// C++ resumable function proposal keywords (N4453)
+KEYWORD(resumable, KEYRESUMABLEFUNCS)
+
 // C++ modules TS keywords
 MODULES_KEYWORD(module)
 MODULES_KEYWORD(import)
 
 // C++ char8_t proposal
 KEYWORD(char8_t                     , CHAR8SUPPORT)
 
 // C11 Extension

include/clang/Driver/Options.td

 
 // C++ Coroutines TS
 def fcoroutines_ts : Flag <["-"], "fcoroutines-ts">, Group<f_Group>,
   Flags<[DriverOption, CC1Option]>,
   HelpText<"Enable support for the C++ Coroutines TS">;
 def fno_coroutines_ts : Flag <["-"], "fno-coroutines-ts">, Group<f_Group>,
   Flags<[DriverOption]>;
 
+// C++ Resumable Functions (N4453)
+def fresumable_functions : Flag<["-"], "fresumable-functions">, Group<f_Group>,
+  Flags<[DriverOption, CC1Option]>,
+  HelpText<"Enable support for C++ resumable functions">;
+
 def fembed_bitcode_EQ : Joined<["-"], "fembed-bitcode=">,
     Group<f_Group>, Flags<[DriverOption, CC1Option]>, MetaVarName<"<option>">,
     HelpText<"Embed LLVM bitcode (option: off, all, bitcode, marker)">;
 def fembed_bitcode : Flag<["-"], "fembed-bitcode">, Group<f_Group>,
   Alias<fembed_bitcode_EQ>, AliasArgs<["all"]>,
   HelpText<"Embed LLVM IR bitcode as data">;
 def fembed_bitcode_marker : Flag<["-"], "fembed-bitcode-marker">,
   Alias<fembed_bitcode_EQ>, AliasArgs<["marker"]>,

include/clang/Sema/DeclSpec.h

private:
   unsigned FS_noreturn_specified : 1;
 
   // friend-specifier
   unsigned Friend_specified : 1;
 
   // constexpr-specifier
   unsigned Constexpr_specified : 1;
 
+  // resumable-specifier
+  unsigned Resumable_specified : 1;
+
   union {
     UnionParsedType TypeRep;
     Decl *DeclRep;
     Expr *ExprRep;
   };
 
   // attributes.
   ParsedAttributes Attrs;
private:
   /// otherwise, it is the same as TSTLoc. Hence, the pair TSTLoc and
   /// TSTNameLoc provides source range info for tag types.
   SourceLocation TSTNameLoc;
   SourceRange TypeofParensRange;
   SourceLocation TQ_constLoc, TQ_restrictLoc, TQ_volatileLoc, TQ_atomicLoc,
       TQ_unalignedLoc;
   SourceLocation FS_inlineLoc, FS_virtualLoc, FS_explicitLoc, FS_noreturnLoc;
   SourceLocation FS_forceinlineLoc;
-  SourceLocation FriendLoc, ModulePrivateLoc, ConstexprLoc;
+  SourceLocation FriendLoc, ModulePrivateLoc, ConstexprLoc, ResumableLoc;
   SourceLocation TQ_pipeLoc;
 
   WrittenBuiltinSpecs writtenBS;
   void SaveWrittenBuiltinSpecs();
 
   ObjCDeclSpec *ObjCQualifiers;
 
   static bool isTypeRep(TST T) {

 public:
   static bool isDeclRep(TST T) {
     return (T == TST_enum || T == TST_struct ||
             T == TST_interface || T == TST_union ||
             T == TST_class);
   }
 
   DeclSpec(AttributeFactory &attrFactory)
       : StorageClassSpec(SCS_unspecified),
         ThreadStorageClassSpec(TSCS_unspecified),
-      SCS_extern_in_linkage_spec(false),
-      TypeSpecWidth(TSW_unspecified),
-      TypeSpecComplex(TSC_unspecified),
-      TypeSpecSign(TSS_unspecified),
-      TypeSpecType(TST_unspecified),
-      TypeAltiVecVector(false),
-      TypeAltiVecPixel(false),
-      TypeAltiVecBool(false),
-      TypeSpecOwned(false),
-      TypeSpecPipe(false),
-      TypeQualifiers(TQ_unspecified),
-      FS_inline_specified(false),
-      FS_forceinline_specified(false),
-      FS_virtual_specified(false),
-      FS_explicit_specified(false),
-      FS_noreturn_specified(false),
-      Friend_specified(false),
-      Constexpr_specified(false),
-      Attrs(attrFactory),
-      writtenBS(),
-      ObjCQualifiers(nullptr) {
-  }
+        SCS_extern_in_linkage_spec(false), TypeSpecWidth(TSW_unspecified),
+        TypeSpecComplex(TSC_unspecified), TypeSpecSign(TSS_unspecified),
+        TypeSpecType(TST_unspecified), TypeAltiVecVector(false),
+        TypeAltiVecPixel(false), TypeAltiVecBool(false), TypeSpecOwned(false),
+        TypeSpecPipe(false), TypeQualifiers(TQ_unspecified),
+        FS_inline_specified(false), FS_forceinline_specified(false),
+        FS_virtual_specified(false), FS_explicit_specified(false),
+        FS_noreturn_specified(false), Friend_specified(false),
+        Constexpr_specified(false), Resumable_specified(false),
+        Attrs(attrFactory), writtenBS(), ObjCQualifiers(nullptr) {}
 
   // storage-class-specifier
   SCS getStorageClassSpec() const { return (SCS)StorageClassSpec; }
   TSCS getThreadStorageClassSpec() const {
     return (TSCS)ThreadStorageClassSpec;
   }
   bool isExternInLinkageSpec() const { return SCS_extern_in_linkage_spec; }
   void setExternInLinkageSpec(bool Value) {
bool setFunctionSpecNoreturn(SourceLocation Loc, const char *&PrevSpec,
                                unsigned &DiagID);
 
   bool SetFriendSpec(SourceLocation Loc, const char *&PrevSpec,
                      unsigned &DiagID);
   bool setModulePrivateSpec(SourceLocation Loc, const char *&PrevSpec,
                             unsigned &DiagID);
   bool SetConstexprSpec(SourceLocation Loc, const char *&PrevSpec,
                         unsigned &DiagID);
+  bool SetResumableSpec(SourceLocation Loc, const char *&PrevSpec,
+                        unsigned &DiagID);
 
   bool isFriendSpecified() const { return Friend_specified; }
   SourceLocation getFriendSpecLoc() const { return FriendLoc; }
 
   bool isModulePrivateSpecified() const { return ModulePrivateLoc.isValid(); }
   SourceLocation getModulePrivateSpecLoc() const { return ModulePrivateLoc; }
   
   bool isConstexprSpecified() const { return Constexpr_specified; }
   SourceLocation getConstexprSpecLoc() const { return ConstexprLoc; }
 
+  bool isResumableSpecified() const { return Resumable_specified; }
+  SourceLocation getResumableSpecLoc() const { return ResumableLoc; }
+
   void ClearConstexprSpec() {
     Constexpr_specified = false;
     ConstexprLoc = SourceLocation();
   }
 
   AttributePool &getAttributePool() const {
     return Attrs.getPool();
   }

include/clang/Sema/ScopeInfo.h

public:
   /// An enumeration represeting the kind of the first coroutine statement
   /// in the function. One of co_return, co_await, or co_yield.
   unsigned char FirstCoroutineStmtKind : 2;
 
   /// First coroutine statement in the current function.
   /// (ex co_return, co_await, co_yield)
   SourceLocation FirstCoroutineStmtLoc;
 
+  /// First resumable expression location.
+  /// (ex 'break resumable' or a call to a resumable function)
+  SourceLocation FirstResumableStmtLoc;
+
+  SourceLocation FirstBreakResumableStmtLoc;
+
   /// First 'return' statement in the current function.
   SourceLocation FirstReturnLoc;
 
   /// First C++ 'try' statement in the current function.
   SourceLocation FirstCXXTryLoc;
 
   /// First SEH '__try' statement in the current function.
   SourceLocation FirstSEHTryLoc;
public:
   void setCoroutineSuspends(Stmt *Initial, Stmt *Final) {
     assert(Initial && Final && "suspend points cannot be null");
     assert(CoroutineSuspends.first == nullptr && "suspend points already set");
     NeedsCoroutineSuspends = false;
     CoroutineSuspends.first = Initial;
     CoroutineSuspends.second = Final;
   }
 
+  void setFirstResumableStmt(SourceLocation Loc) {
+    if (FirstResumableStmtLoc.isInvalid())
+      FirstResumableStmtLoc = Loc;
+  }
+
+  bool hasResumableStmt() const { return FirstResumableStmtLoc.isValid(); }
+
+  void setFirstBreakResumableStmt(SourceLocation Loc) {
+    if (FirstBreakResumableStmtLoc.isInvalid())
+      FirstBreakResumableStmtLoc = Loc;
+    setFirstResumableStmt(Loc);
+  }
+
+  bool hasBreakResumableStmt() const {
+    return FirstBreakResumableStmtLoc.isValid();
+  }
+
   /// Clear out the information in this function scope, making it
   /// suitable for reuse.
   void Clear();
 };
 
 class Capture {
   // There are three categories of capture: capturing 'this', capturing
   // local variables, and C++1y initialized captures (which can have an

include/clang/Sema/Sema.h

                                      LookupResult &Previous,
                                      MultiTemplateParamsArg TemplateParamLists,
                                      bool &AddToScope);
   bool AddOverriddenMethods(CXXRecordDecl *DC, CXXMethodDecl *MD);
 
   bool CheckConstexprFunctionDecl(const FunctionDecl *FD);
   bool CheckConstexprFunctionBody(const FunctionDecl *FD, Stmt *Body);
 
+  /// Check whether a function declaration satisfies the requirements
+  /// of a constexpr function. If so, return true. If not, produce the
+  /// appropriate diagnostics and return false.
+  bool CheckResumableFunctionDecl(const FunctionDecl *FD);
+  void CheckCompletedResumableFunctionBody(FunctionDecl *FD, Stmt *Body);
+
+  bool CheckResumableVarDecl(VarDecl *VD, Expr *Init);
+
+  void SetCurFunctionImplicitlyResumable(SourceLocation Loc,
+                                         bool IsBreakResumable = false);
+
   void DiagnoseHiddenVirtualMethods(CXXMethodDecl *MD);
   void FindHiddenVirtualMethods(CXXMethodDecl *MD,
                           SmallVectorImpl<CXXMethodDecl*> &OverloadedMethods);
   void NoteHiddenVirtualMethods(CXXMethodDecl *MD,
                           SmallVectorImpl<CXXMethodDecl*> &OverloadedMethods);
   // Returns true if the function declaration is a redeclaration
   bool CheckFunctionDeclaration(Scope *S,
                                 FunctionDecl *NewFD, LookupResult &Previous,

 
   StmtResult ActOnGotoStmt(SourceLocation GotoLoc,
                            SourceLocation LabelLoc,
                            LabelDecl *TheDecl);
   StmtResult ActOnIndirectGotoStmt(SourceLocation GotoLoc,
                                    SourceLocation StarLoc,
                                    Expr *DestExp);
   StmtResult ActOnContinueStmt(SourceLocation ContinueLoc, Scope *CurScope);
-  StmtResult ActOnBreakStmt(SourceLocation BreakLoc, Scope *CurScope);
+  StmtResult ActOnBreakStmt(SourceLocation BreakLoc, Scope *CurScope,
+                            bool IsResumable = false,
+                            SourceLocation ResumableLoc = SourceLocation());
 
   void ActOnCapturedRegionStart(SourceLocation Loc, Scope *CurScope,
                                 CapturedRegionKind Kind, unsigned NumParams);
   typedef std::pair<StringRef, QualType> CapturedParamNameType;
   void ActOnCapturedRegionStart(SourceLocation Loc, Scope *CurScope,
                                 CapturedRegionKind Kind,
                                 ArrayRef<CapturedParamNameType> Params);
   StmtResult ActOnCapturedRegionEnd(Stmt *S);

 
   ExprResult ActOnFinishFullExpr(Expr *Expr) {
     return ActOnFinishFullExpr(Expr, Expr ? Expr->getExprLoc()
                                           : SourceLocation());
   }
   ExprResult ActOnFinishFullExpr(Expr *Expr, SourceLocation CC,
                                  bool DiscardedValue = false,
                                  bool IsConstexpr = false,
-                                 bool IsLambdaInitCaptureInitializer = false);
+                                 bool IsLambdaInitCaptureInitializer = false,
+                                 bool IsResumable = false);
   StmtResult ActOnFinishFullStmt(Stmt *Stmt);
 
   // Marks SS invalid if it represents an incomplete type.
   bool RequireCompleteDeclContext(CXXScopeSpec &SS, DeclContext *DC);
 
   DeclContext *computeDeclContext(QualType T);
   DeclContext *computeDeclContext(const CXXScopeSpec &SS,
                                   bool EnteringContext = false);

lib/AST/ASTDumper.cpp

public:
     // Stmts.
     void VisitStmt(const Stmt *Node);
     void VisitDeclStmt(const DeclStmt *Node);
     void VisitAttributedStmt(const AttributedStmt *Node);
     void VisitLabelStmt(const LabelStmt *Node);
     void VisitGotoStmt(const GotoStmt *Node);
     void VisitCXXCatchStmt(const CXXCatchStmt *Node);
     void VisitCapturedStmt(const CapturedStmt *Node);
+    void VisitBreakStmt(const BreakStmt *Node);
 
     // OpenMP
     void VisitOMPExecutableDirective(const OMPExecutableDirective *Node);
 
     // Exprs
     void VisitExpr(const Expr *Node);
     void VisitCastExpr(const CastExpr *Node);
     void VisitDeclRefExpr(const DeclRefExpr *Node);
dumpChild([=] {
     if (D->isImplicit())
       OS << " implicit";
     if (D->isUsed())
       OS << " used";
     else if (D->isThisDeclarationReferenced())
       OS << " referenced";
     if (D->isInvalidDecl())
       OS << " invalid";
-    if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D))
+    if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
       if (FD->isConstexpr())
         OS << " constexpr";
-
+      if (FD->isResumableSpecified())
+        OS << " resumable";
+    }
 
     ConstDeclVisitor<ASTDumper>::Visit(D);
 
     for (Decl::attr_iterator I = D->attr_begin(), E = D->attr_end(); I != E;
          ++I)
       dumpAttr(*I);
 
     if (const FullComment *Comment =
void ASTDumper::VisitVarDecl(const VarDecl *D) {
   if (D->isModulePrivate())
     OS << " __module_private__";
   if (D->isNRVOVariable())
     OS << " nrvo";
   if (D->isInline())
     OS << " inline";
   if (D->isConstexpr())
     OS << " constexpr";
+  if (D->isResumableSpecified())
+    OS << " resumable";
+
   if (D->hasInit()) {
     switch (D->getInitStyle()) {
     case VarDecl::CInit: OS << " cinit"; break;
     case VarDecl::CallInit: OS << " callinit"; break;
     case VarDecl::ListInit: OS << " listinit"; break;
     }
     dumpStmt(D->getInit());
   }
void ASTDumper::VisitCXXCatchStmt(const CXXCatchStmt *Node) {
   dumpDecl(Node->getExceptionDecl());
 }
 
 void ASTDumper::VisitCapturedStmt(const CapturedStmt *Node) {
   VisitStmt(Node);
   dumpDecl(Node->getCapturedDecl());
 }
 
+void ASTDumper::VisitBreakStmt(const BreakStmt *Node) {
+  VisitStmt(Node);
+  if (Node->isResumableSpecified())
+    OS << " resumable";
+}
+
 //===----------------------------------------------------------------------===//
 //  OpenMP dumping methods.
 //===----------------------------------------------------------------------===//
 
 void ASTDumper::VisitOMPExecutableDirective(
     const OMPExecutableDirective *Node) {
   VisitStmt(Node);
   for (auto *C : Node->clauses()) {

lib/AST/ASTImporter.cpp

   } else if (isa<CXXDestructorDecl>(D)) {
     ToFunction = CXXDestructorDecl::Create(Importer.getToContext(),
                                            cast<CXXRecordDecl>(DC),
                                            InnerLocStart,
                                            NameInfo, T, TInfo,
                                            D->isInlineSpecified(),
                                            D->isImplicit());
   } else if (auto *FromConversion = dyn_cast<CXXConversionDecl>(D)) {
-    ToFunction = CXXConversionDecl::Create(Importer.getToContext(), 
-                                           cast<CXXRecordDecl>(DC),
-                                           InnerLocStart,
-                                           NameInfo, T, TInfo,
-                                           D->isInlineSpecified(),
-                                           FromConversion->isExplicit(),
-                                           D->isConstexpr(),
-                                           Importer.Import(D->getLocEnd()));
+    ToFunction = CXXConversionDecl::Create(
+        Importer.getToContext(), cast<CXXRecordDecl>(DC), InnerLocStart,
+        NameInfo, T, TInfo, D->isInlineSpecified(),
+        FromConversion->isExplicit(), D->isConstexpr(), D->isResumable(),
+        Importer.Import(D->getLocEnd()));
   } else if (auto *Method = dyn_cast<CXXMethodDecl>(D)) {
-    ToFunction = CXXMethodDecl::Create(Importer.getToContext(), 
-                                       cast<CXXRecordDecl>(DC),
-                                       InnerLocStart,
-                                       NameInfo, T, TInfo,
-                                       Method->getStorageClass(),
-                                       Method->isInlineSpecified(),
-                                       D->isConstexpr(),
-                                       Importer.Import(D->getLocEnd()));
+    ToFunction = CXXMethodDecl::Create(
+        Importer.getToContext(), cast<CXXRecordDecl>(DC), InnerLocStart,
+        NameInfo, T, TInfo, Method->getStorageClass(),
+        Method->isInlineSpecified(), D->isConstexpr(), D->isResumable(),
+        Importer.Import(D->getLocEnd()));
   } else {
-    ToFunction = FunctionDecl::Create(Importer.getToContext(), DC,
-                                      InnerLocStart,
-                                      NameInfo, T, TInfo, D->getStorageClass(),
-                                      D->isInlineSpecified(),
-                                      D->hasWrittenPrototype(),
-                                      D->isConstexpr());
+    ToFunction = FunctionDecl::Create(
+        Importer.getToContext(), DC, InnerLocStart, NameInfo, T, TInfo,
+        D->getStorageClass(), D->isInlineSpecified(), D->hasWrittenPrototype(),
+        D->isConstexpr(), D->isResumable());
   }
 
   // Import the qualifier, if any.
   ToFunction->setQualifierInfo(Importer.Import(D->getQualifierLoc()));
   ToFunction->setAccess(D->getAccess());
   ToFunction->setLexicalDeclContext(LexicalDC);
   ToFunction->setVirtualAsWritten(D->isVirtualAsWritten());
   ToFunction->setTrivial(D->isTrivial());

lib/AST/Decl.cpp

   return new (C, nullptr) ImplicitParamDecl(C, Type, ParamKind);
 }
 
 ImplicitParamDecl *ImplicitParamDecl::CreateDeserialized(ASTContext &C,
                                                          unsigned ID) {
   return new (C, ID) ImplicitParamDecl(C, QualType(), ImplicitParamKind::Other);
 }
 
-FunctionDecl *FunctionDecl::Create(ASTContext &C, DeclContext *DC,
-                                   SourceLocation StartLoc,
-                                   const DeclarationNameInfo &NameInfo,
-                                   QualType T, TypeSourceInfo *TInfo,
-                                   StorageClass SC,
-                                   bool isInlineSpecified,
-                                   bool hasWrittenPrototype,
-                                   bool isConstexprSpecified) {
-  FunctionDecl *New =
-      new (C, DC) FunctionDecl(Function, C, DC, StartLoc, NameInfo, T, TInfo,
-                               SC, isInlineSpecified, isConstexprSpecified);
+FunctionDecl *
+FunctionDecl::Create(ASTContext &C, DeclContext *DC, SourceLocation StartLoc,
+                     const DeclarationNameInfo &NameInfo, QualType T,
+                     TypeSourceInfo *TInfo, StorageClass SC,
+                     bool isInlineSpecified, bool hasWrittenPrototype,
+                     bool isConstexprSpecified, bool isResumableSpecified) {
+  FunctionDecl *New = new (C, DC) FunctionDecl(
+      Function, C, DC, StartLoc, NameInfo, T, TInfo, SC, isInlineSpecified,
+      isConstexprSpecified, isResumableSpecified);
   New->HasWrittenPrototype = hasWrittenPrototype;
   return New;
 }
 
 FunctionDecl *FunctionDecl::CreateDeserialized(ASTContext &C, unsigned ID) {
   return new (C, ID) FunctionDecl(Function, C, nullptr, SourceLocation(),
                                   DeclarationNameInfo(), QualType(), nullptr,
-                                  SC_None, false, false);
+                                  SC_None, false, false, false);
 }
 
 BlockDecl *BlockDecl::Create(ASTContext &C, DeclContext *DC, SourceLocation L) {
   return new (C, DC) BlockDecl(DC, L);
 }
 
 BlockDecl *BlockDecl::CreateDeserialized(ASTContext &C, unsigned ID) {
   return new (C, ID) BlockDecl(nullptr, SourceLocation());

lib/AST/DeclCXX.cpp

     CXXMethodDecl *T = this->getCorrespondingMethodInClass(Base);
     if (T)
       return T;
   }
 
   return nullptr;
 }
 
-CXXMethodDecl *
-CXXMethodDecl::Create(ASTContext &C, CXXRecordDecl *RD,
-                      SourceLocation StartLoc,
-                      const DeclarationNameInfo &NameInfo,
-                      QualType T, TypeSourceInfo *TInfo,
-                      StorageClass SC, bool isInline,
-                      bool isConstexpr, SourceLocation EndLocation) {
-  return new (C, RD) CXXMethodDecl(CXXMethod, C, RD, StartLoc, NameInfo,
-                                   T, TInfo, SC, isInline, isConstexpr,
-                                   EndLocation);
+CXXMethodDecl *CXXMethodDecl::Create(ASTContext &C, CXXRecordDecl *RD,
+                                     SourceLocation StartLoc,
+                                     const DeclarationNameInfo &NameInfo,
+                                     QualType T, TypeSourceInfo *TInfo,
+                                     StorageClass SC, bool isInline,
+                                     bool isConstexpr, bool isResumable,
+                                     SourceLocation EndLocation) {
+  return new (C, RD)
+      CXXMethodDecl(CXXMethod, C, RD, StartLoc, NameInfo, T, TInfo, SC,
+                    isInline, isConstexpr, isResumable, EndLocation);
 }
 
 CXXMethodDecl *CXXMethodDecl::CreateDeserialized(ASTContext &C, unsigned ID) {
-  return new (C, ID) CXXMethodDecl(CXXMethod, C, nullptr, SourceLocation(),
-                                   DeclarationNameInfo(), QualType(), nullptr,
-                                   SC_None, false, false, SourceLocation());
+  return new (C, ID) CXXMethodDecl(
+      CXXMethod, C, nullptr, SourceLocation(), DeclarationNameInfo(),
+      QualType(), nullptr, SC_None, false, false, false, SourceLocation());
 }
 
 CXXMethodDecl *CXXMethodDecl::getDevirtualizedMethod(const Expr *Base,
                                                      bool IsAppleKext) {
   assert(isVirtual() && "this method is expected to be virtual");
 
   // When building with -fapple-kext, all calls must go through the vtable since
   // the kernel linker can do runtime patching of vtables.

       L->ResolvedOperatorDelete(First, OD, ThisArg);
   }
 }
 
 void CXXConversionDecl::anchor() {}
 
 CXXConversionDecl *
 CXXConversionDecl::CreateDeserialized(ASTContext &C, unsigned ID) {
-  return new (C, ID) CXXConversionDecl(C, nullptr, SourceLocation(),
-                                       DeclarationNameInfo(), QualType(),
-                                       nullptr, false, false, false,
-                                       SourceLocation());
+  return new (C, ID) CXXConversionDecl(
+      C, nullptr, SourceLocation(), DeclarationNameInfo(), QualType(), nullptr,
+      false, false, false, false, SourceLocation());
 }
 
-CXXConversionDecl *
-CXXConversionDecl::Create(ASTContext &C, CXXRecordDecl *RD,
-                          SourceLocation StartLoc,
-                          const DeclarationNameInfo &NameInfo,
-                          QualType T, TypeSourceInfo *TInfo,
-                          bool isInline, bool isExplicit,
-                          bool isConstexpr, SourceLocation EndLocation) {
+CXXConversionDecl *CXXConversionDecl::Create(
+    ASTContext &C, CXXRecordDecl *RD, SourceLocation StartLoc,
+    const DeclarationNameInfo &NameInfo, QualType T, TypeSourceInfo *TInfo,
+    bool isInline, bool isExplicit, bool isConstexpr, bool isResumable,
+    SourceLocation EndLocation) {
   assert(NameInfo.getName().getNameKind()
          == DeclarationName::CXXConversionFunctionName &&
          "Name must refer to a conversion function");
-  return new (C, RD) CXXConversionDecl(C, RD, StartLoc, NameInfo, T, TInfo,
-                                       isInline, isExplicit, isConstexpr,
-                                       EndLocation);
+  return new (C, RD)
+      CXXConversionDecl(C, RD, StartLoc, NameInfo, T, TInfo, isInline,
+                        isExplicit, isConstexpr, isResumable, EndLocation);
 }
 
 bool CXXConversionDecl::isLambdaToBlockPointerConversion() const {
   return isImplicit() && getParent()->isLambda() &&
          getConversionType()->isBlockPointerType();
 }
 
 void LinkageSpecDecl::anchor() {}

lib/AST/DeclPrinter.cpp

if (!Policy.SuppressSpecifiers) {
     case SC_Auto: case SC_Register:
       llvm_unreachable("invalid for functions");
     }
 
     if (D->isInlineSpecified())  Out << "inline ";
     if (D->isVirtualAsWritten()) Out << "virtual ";
     if (D->isModulePrivate())    Out << "__module_private__ ";
     if (D->isConstexpr() && !D->isExplicitlyDefaulted()) Out << "constexpr ";
+    if (D->isResumable())
+      Out << "resumable ";
     if ((CDecl && CDecl->isExplicitSpecified()) ||
         (ConversionDecl && ConversionDecl->isExplicitSpecified()) ||
         (GuideDecl && GuideDecl->isExplicitSpecified()))
       Out << "explicit ";
   }
 
   PrintingPolicy SubPolicy(Policy);
   SubPolicy.SuppressSpecifiers = false;
if (!Policy.SuppressSpecifiers) {
 
     if (D->isModulePrivate())
       Out << "__module_private__ ";
 
     if (D->isConstexpr()) {
       Out << "constexpr ";
       T.removeLocalConst();
     }
+
+    if (D->isResumableSpecified())
+      Out << "resumable ";
   }
 
   printDeclType(T, D->getName());
   Expr *Init = D->getInit();
   if (!Policy.SuppressInitializers && Init) {
     bool ImplicitInit = false;
     if (CXXConstructExpr *Construct =
             dyn_cast<CXXConstructExpr>(Init->IgnoreImplicit())) {

lib/AST/ODRHash.cpp

if (!isa<FunctionDecl>(D)) {
       AddQualType(D->getType());
     }
     Inherited::VisitValueDecl(D);
   }
 
   void VisitVarDecl(const VarDecl *D) {
     Hash.AddBoolean(D->isStaticLocal());
     Hash.AddBoolean(D->isConstexpr());
+    Hash.AddBoolean(D->isResumableSpecified());
     const bool HasInit = D->hasInit();
     Hash.AddBoolean(HasInit);
     if (HasInit) {
       AddStmt(D->getInit());
     }
     Inherited::VisitVarDecl(D);
   }
 

lib/Basic/IdentifierTable.cpp

 
 //===----------------------------------------------------------------------===//
 // Language Keyword Implementation
 //===----------------------------------------------------------------------===//
 
 // Constants for TokenKinds.def
 namespace {
 
-  enum {
-    KEYC99 = 0x1,
-    KEYCXX = 0x2,
-    KEYCXX11 = 0x4,
-    KEYGNU = 0x8,
-    KEYMS = 0x10,
-    BOOLSUPPORT = 0x20,
-    KEYALTIVEC = 0x40,
-    KEYNOCXX = 0x80,
-    KEYBORLAND = 0x100,
-    KEYOPENCLC = 0x200,
-    KEYC11 = 0x400,
-    KEYARC = 0x800,
-    KEYNOMS18 = 0x01000,
-    KEYNOOPENCL = 0x02000,
-    WCHARSUPPORT = 0x04000,
-    HALFSUPPORT = 0x08000,
-    CHAR8SUPPORT = 0x10000,
-    KEYCONCEPTS = 0x20000,
-    KEYOBJC2    = 0x40000,
-    KEYZVECTOR  = 0x80000,
-    KEYCOROUTINES = 0x100000,
-    KEYMODULES = 0x200000,
-    KEYCXX2A = 0x400000,
-    KEYOPENCLCXX = 0x800000,
-    KEYALLCXX = KEYCXX | KEYCXX11 | KEYCXX2A,
-    KEYALL = (0xffffff & ~KEYNOMS18 &
-              ~KEYNOOPENCL) // KEYNOMS18 and KEYNOOPENCL are used to exclude.
-  };
+  KEYOBJC2 = 0x40000,
+  KEYZVECTOR = 0x80000,
+  KEYRESUMABLEFUNCS = 0x1000000,
 
-  /// How a keyword is treated in the selected standard.
-  enum KeywordStatus {
-    KS_Disabled,    // Disabled
-    KS_Extension,   // Is an extension
-    KS_Enabled,     // Enabled
-    KS_Future       // Is a keyword in future standard
-  };
+  KS_Disabled,  // Disabled
+  KS_Extension, // Is an extension
+  KS_Enabled,   // Enabled
+  KS_Future     // Is a keyword in future standard
 
 } // namespace
 
 /// Translates flags as specified in TokenKinds.def into keyword status
 /// in the given language standard.
 static KeywordStatus getKeywordStatus(const LangOptions &LangOpts,
                                       unsigned Flags) {
   if (Flags == KEYALL) return KS_Enabled;
static KeywordStatus getKeywordStatus(const LangOptions &LangOpts,
   if (LangOpts.C11 && (Flags & KEYC11)) return KS_Enabled;
   // We treat bridge casts as objective-C keywords so we can warn on them
   // in non-arc mode.
   if (LangOpts.ObjC2 && (Flags & KEYARC)) return KS_Enabled;
   if (LangOpts.ObjC2 && (Flags & KEYOBJC2)) return KS_Enabled;
   if (LangOpts.ConceptsTS && (Flags & KEYCONCEPTS)) return KS_Enabled;
   if (LangOpts.CoroutinesTS && (Flags & KEYCOROUTINES)) return KS_Enabled;
   if (LangOpts.ModulesTS && (Flags & KEYMODULES)) return KS_Enabled;
+  if (LangOpts.ResumableFunctions && (Flags & KEYRESUMABLEFUNCS))
+    return KS_Enabled;
   if (LangOpts.CPlusPlus && (Flags & KEYALLCXX)) return KS_Future;
   return KS_Disabled;
 }
 
 /// AddKeyword - This method is used to associate a token ID with specific
 /// identifiers because they are language keywords.  This causes the lexer to
 /// automatically map matching identifiers to specialized token codes.
 static void AddKeyword(StringRef Keyword,

lib/Driver/ToolChains/Clang.cpp

     CmdArgs.push_back("-fencode-extended-block-signature");
 
   if (Args.hasFlag(options::OPT_fcoroutines_ts, options::OPT_fno_coroutines_ts,
                    false) &&
       types::isCXX(InputType)) {
     CmdArgs.push_back("-fcoroutines-ts");
   }
 
+  if (Args.hasArg(options::OPT_fresumable_functions) && types::isCXX(InputType))
+    CmdArgs.push_back("-fresumable-functions");
+
   Args.AddLastArg(CmdArgs, options::OPT_fdouble_square_bracket_attributes,
                   options::OPT_fno_double_square_bracket_attributes);
 
   bool HaveModules = false;
   RenderModulesOptions(C, D, Args, Input, Output, CmdArgs, HaveModules);
 
   // -faccess-control is default.
   if (Args.hasFlag(options::OPT_fno_access_control,

lib/Frontend/CompilerInvocation.cpp

   Opts.TraditionalCPP = Args.hasArg(OPT_traditional_cpp);
 
   Opts.RTTI = Opts.CPlusPlus && !Args.hasArg(OPT_fno_rtti);
   Opts.RTTIData = Opts.RTTI && !Args.hasArg(OPT_fno_rtti_data);
   Opts.Blocks = Args.hasArg(OPT_fblocks) || (Opts.OpenCL
     && Opts.OpenCLVersion == 200);
   Opts.BlocksRuntimeOptional = Args.hasArg(OPT_fblocks_runtime_optional);
   Opts.CoroutinesTS = Args.hasArg(OPT_fcoroutines_ts);
+  Opts.ResumableFunctions = Args.hasArg(OPT_fresumable_functions);
 
   // Enable [[]] attributes in C++11 by default.
   Opts.DoubleSquareBracketAttributes =
       Args.hasFlag(OPT_fdouble_square_bracket_attributes,
                    OPT_fno_double_square_bracket_attributes, Opts.CPlusPlus11);
 
   Opts.ModulesTS = Args.hasArg(OPT_fmodules_ts);
   Opts.Modules = Args.hasArg(OPT_fmodules) || Opts.ModulesTS;

lib/Frontend/InitPreprocessor.cpp

if (LangOpts.AlignedAllocation)
     Builder.defineMacro("__cpp_aligned_new", "201606");
 
   // TS features.
   if (LangOpts.ConceptsTS)
     Builder.defineMacro("__cpp_experimental_concepts", "1");
   if (LangOpts.CoroutinesTS)
     Builder.defineMacro("__cpp_coroutines", "201703L");
 
+  // C++ Resumable Functions proposal (N4453)
+  if (LangOpts.ResumableFunctions)
+    Builder.defineMacro("__cpp_resumable_functions", "1");
+
   // Potential future breaking changes.
   if (LangOpts.Char8)
     Builder.defineMacro("__cpp_char8_t", "201803");
 }
 
 static void InitializePredefinedMacros(const TargetInfo &TI,
                                        const LangOptions &LangOpts,
                                        const FrontendOptions &FEOpts,

lib/Parse/ParseDecl.cpp

       isInvalid = DS.setModulePrivateSpec(Loc, PrevSpec, DiagID);
       break;
 
     // constexpr
     case tok::kw_constexpr:
       isInvalid = DS.SetConstexprSpec(Loc, PrevSpec, DiagID);
       break;
 
+    // Resumable functions
+    case tok::kw_resumable:
+      isInvalid = DS.SetResumableSpec(Loc, PrevSpec, DiagID);
+      break;
+
     // type-specifier
     case tok::kw_short:
       isInvalid = DS.SetTypeSpecWidth(DeclSpec::TSW_short, Loc, PrevSpec,
                                       DiagID, Policy);
       break;
     case tok::kw_long:
       if (DS.getTypeSpecWidth() != DeclSpec::TSW_long)
         isInvalid = DS.SetTypeSpecWidth(DeclSpec::TSW_long, Loc, PrevSpec,

 
     // GNU attributes.
   case tok::kw___attribute:
 
     // C++11 decltype and constexpr.
   case tok::annot_decltype:
   case tok::kw_constexpr:
 
+    // Resumable Functions
+  case tok::kw_resumable:
+
     // C11 _Atomic
   case tok::kw__Atomic:
     return true;
 
     // GNU ObjC bizarre protocol extension: <proto1,proto2> with implicit 'id'.
   case tok::less:
     return getLangOpts().ObjC1;
 

lib/Parse/ParseDeclCXX.cpp

   case tok::kw_static:          // struct foo {...} static    x;
   case tok::kw_extern:          // struct foo {...} extern    x;
   case tok::kw_typedef:         // struct foo {...} typedef   x;
   case tok::kw_register:        // struct foo {...} register  x;
   case tok::kw_auto:            // struct foo {...} auto      x;
   case tok::kw_mutable:         // struct foo {...} mutable   x;
   case tok::kw_thread_local:    // struct foo {...} thread_local x;
   case tok::kw_constexpr:       // struct foo {...} constexpr x;
+  case tok::kw_resumable:       // struct foo {...} resumable x;
     // As shown above, type qualifiers and storage class specifiers absolutely
     // can occur after class specifiers according to the grammar.  However,
     // almost no one actually writes code like this.  If we see one of these,
     // it is much more likely that someone missed a semi colon and the
     // type/storage class specifier we're seeing is part of the *next*
     // intended declaration, as in:
     //
     //   struct foo { ... }

lib/Parse/ParseStmt.cpp

 StmtResult Parser::ParseContinueStatement() {
   SourceLocation ContinueLoc = ConsumeToken();  // eat the 'continue'.
   return Actions.ActOnContinueStmt(ContinueLoc, getCurScope());
 }
 
 /// ParseBreakStatement
 ///       jump-statement:
 ///         'break' ';'
+///         'break' 'resumable' ';'
 ///
 /// Note: this lets the caller parse the end ';'.
 ///
 StmtResult Parser::ParseBreakStatement() {
   SourceLocation BreakLoc = ConsumeToken();  // eat the 'break'.
-  return Actions.ActOnBreakStmt(BreakLoc, getCurScope());
+  SourceLocation ResumableLoc;
+  bool IsResumable = false;
+  if (Tok.is(tok::kw_resumable)) {
+    ResumableLoc = ConsumeToken();
+    IsResumable = true;
+  }
+  return Actions.ActOnBreakStmt(BreakLoc, getCurScope(), IsResumable,
+                                ResumableLoc);
 }
 
 /// ParseReturnStatement
 ///       jump-statement:
 ///         'return' expression[opt] ';'
 ///         'return' braced-init-list ';'
 ///         'co_return' expression[opt] ';'
 ///         'co_return' braced-init-list ';'

lib/Parse/ParseTentative.cpp

   case tok::kw___thread:
   case tok::kw_thread_local:
   case tok::kw__Thread_local:
     // function-specifier
   case tok::kw_inline:
   case tok::kw_virtual:
   case tok::kw_explicit:
 
+    // Resumable function support
+  case tok::kw_resumable:
+
     // Modules
   case tok::kw___module_private__:
 
     // Debugger support
   case tok::kw___unknown_anytype:
       
     // type-specifier:
     //   simple-type-specifier

lib/Sema/CMakeLists.txt

add_clang_library(clangSema
   SemaFixItUtils.cpp
   SemaInit.cpp
   SemaLambda.cpp
   SemaLookup.cpp
   SemaObjCProperty.cpp
   SemaOpenMP.cpp
   SemaOverload.cpp
   SemaPseudoObject.cpp
+  SemaResumable.cpp
   SemaStmt.cpp
   SemaStmtAsm.cpp
   SemaStmtAttr.cpp
   SemaTemplate.cpp
   SemaTemplateDeduction.cpp
   SemaTemplateInstantiate.cpp
   SemaTemplateInstantiateDecl.cpp
   SemaTemplateVariadic.cpp

lib/Sema/DeclSpec.cpp

if (Constexpr_specified) {
     PrevSpec = "constexpr";
     return true;
   }
   Constexpr_specified = true;
   ConstexprLoc = Loc;
   return false;
 }
 
+bool DeclSpec::SetResumableSpec(SourceLocation Loc, const char *&PrevSpec,
+                                unsigned &DiagID) {
+  // 'constexpr constexpr' is ok, but warn as this is likely not what the user
+  // intended.
+  if (Resumable_specified) {
+    DiagID = diag::warn_duplicate_declspec;
+    PrevSpec = "resumable";
+    return true;
+  }
+  Resumable_specified = true;
+  ResumableLoc = Loc;
+  return false;
+}
+
 void DeclSpec::SaveWrittenBuiltinSpecs() {
   writtenBS.Sign = getTypeSpecSign();
   writtenBS.Width = getTypeSpecWidth();
   writtenBS.Type = getTypeSpecType();
   // Search the list of attributes for the presence of a mode attribute.
   writtenBS.ModeAttr = false;
   AttributeList* attrs = getAttributes().getList();
   while (attrs) {

lib/Sema/ScopeInfo.cpp

void FunctionScopeInfo::Clear() {
   // Coroutine state
   FirstCoroutineStmtLoc = SourceLocation();
   CoroutinePromise = nullptr;
   CoroutineParameterMoves.clear();
   NeedsCoroutineSuspends = true;
   CoroutineSuspends.first = nullptr;
   CoroutineSuspends.second = nullptr;
 
+  // Resumable function state
+  FirstBreakResumableStmtLoc = SourceLocation();
+
   SwitchStack.clear();
   Returns.clear();
   ErrorTrap.reset();
   PossiblyUnreachableDiags.clear();
   WeakObjectUses.clear();
   ModifiedNonNullParams.clear();
 }
 

lib/Sema/SemaCoroutine.cpp

static FunctionDecl *findDeleteForPromise(Sema &S, SourceLocation Loc,
   S.MarkFunctionReferenced(Loc, OperatorDelete);
   return OperatorDelete;
 }
 
 
 void Sema::CheckCompletedCoroutineBody(FunctionDecl *FD, Stmt *&Body) {
   FunctionScopeInfo *Fn = getCurFunction();
   assert(Fn && Fn->isCoroutine() && "not a coroutine");
+
+  // Ensure explicitly resumable functions are not allowed to be coroutines
+  if (FD && FD->isResumableSpecified()) {
+    Diag(FD->getLocation(), diag::err_resumable_func_is_coroutine) << FD;
+    Diag(Fn->FirstCoroutineStmtLoc, diag::note_declared_coroutine_here)
+        << Fn->getFirstCoroutineStmtKeyword();
+    FD->setInvalidDecl(true);
+    return;
+  }
+
   if (!Body) {
     assert(FD->isInvalidDecl() &&
            "a null body is only allowed for invalid declarations");
     return;
   }
+
+  if (!Fn->hasBreakResumableStmt()) {
+    assert(FD && "cannot be null");
+    Diag(FD->getLocation(), diag::err_resumable_func_is_coroutine) << FD;
+    Diag(Fn->FirstCoroutineStmtLoc, diag::note_declared_coroutine_here)
+        << Fn->getFirstCoroutineStmtKeyword();
+    FD->setInvalidDecl(true);
+    return;
+  }
+
   // We have a function that uses coroutine keywords, but we failed to build
   // the promise type.
   if (!Fn->CoroutinePromise)
     return FD->setInvalidDecl();
 
   if (isa<CoroutineBodyStmt>(Body)) {
     // Nothing todo. the body is already a transformed coroutine body statement.
     return;

lib/Sema/SemaDecl.cpp

 #include "llvm/ADT/Triple.h"
 #include <algorithm>
 #include <cstring>
 #include <functional>
 
 using namespace clang;
 using namespace sema;
 
+enum InvalidResumableKind {
+  IRK_ParmVar,
+  IRK_Typedef,
+  IRK_NonStaticMember,
+  IRK_GlobalVar
+};
+
 Sema::DeclGroupPtrTy Sema::ConvertDeclToDeclGroup(Decl *Ptr, Decl *OwnedType) {
   if (OwnedType) {
     Decl *Group[2] = { OwnedType, Ptr };
     return DeclGroupPtrTy::make(DeclGroupRef::Create(Context, Group, 2));
   }
 
   return DeclGroupPtrTy::make(DeclGroupRef(Ptr));
 }

       Diag(DS.getConstexprSpecLoc(), diag::err_constexpr_tag)
           << GetDiagnosticTypeSpecifierID(DS.getTypeSpecType());
     else
       Diag(DS.getConstexprSpecLoc(), diag::err_constexpr_no_declarators);
     // Don't emit warnings after this error.
     return TagD;
   }
 
+  if (DS.isResumableSpecified()) {
+    // resumable can only be applied to declarations
+    // and definitions of functions and variables.
+    if (Tag)
+      Diag(DS.getResumableSpecLoc(), diag::err_resumable_tag)
+          << GetDiagnosticTypeSpecifierID(DS.getTypeSpecType());
+    else
+      Diag(DS.getResumableSpecLoc(), diag::err_resumable_no_declarators);
+    // Don't emit warnings after this error.
+    return TagD;
+  }
+
   DiagnoseFunctionSpecifiers(DS);
 
   if (DS.isFriendSpecified()) {
     // If we're dealing with a decl but not a TagDecl, assume that
     // whatever routines created it handled the friendship aspect.
     if (TagD && !Tag)
       return nullptr;
     return ActOnFriendTypeDecl(S, DS, TemplateParams);

   DiagnoseFunctionSpecifiers(D.getDeclSpec());
 
   if (D.getDeclSpec().isInlineSpecified())
     Diag(D.getDeclSpec().getInlineSpecLoc(), diag::err_inline_non_function)
         << getLangOpts().CPlusPlus17;
   if (D.getDeclSpec().isConstexprSpecified())
     Diag(D.getDeclSpec().getConstexprSpecLoc(), diag::err_invalid_constexpr)
       << 1;
+  if (D.getDeclSpec().isResumableSpecified())
+    Diag(D.getDeclSpec().getResumableSpecLoc(), diag::err_invalid_resumable)
+        << IRK_Typedef;
 
   if (D.getName().Kind != UnqualifiedIdKind::IK_Identifier) {
     if (D.getName().Kind == UnqualifiedIdKind::IK_DeductionGuideName)
       Diag(D.getName().StartLocation,
            diag::err_deduction_guide_invalid_specifier)
           << "typedef";
     else
       Diag(D.getName().StartLocation, diag::err_typedef_not_identifier)

     if (D.getDeclSpec().isConstexprSpecified()) {
       NewVD->setConstexpr(true);
       // C++1z [dcl.spec.constexpr]p1:
       //   A static data member declared with the constexpr specifier is
       //   implicitly an inline variable.
       if (NewVD->isStaticDataMember() && getLangOpts().CPlusPlus17)
         NewVD->setImplicitlyInline();
     }
+
+    if (D.getDeclSpec().isResumableSpecified()) {
+      NewVD->setResumableSpecified(true);
+      if (D.getDeclSpec().isConstexprSpecified()) {
+        Diag(D.getDeclSpec().getConstexprSpecLoc(),
+             diag::err_resumable_var_decl_constexpr)
+            << NewVD;
+        NewVD->isInvalidDecl();
+      }
+    }
   }
 
   if (D.getDeclSpec().isInlineSpecified()) {
     if (!getLangOpts().CPlusPlus) {
       Diag(D.getDeclSpec().getInlineSpecLoc(), diag::err_inline_non_function)
           << 0;
     } else if (CurContext->isFunctionOrMethod()) {
       // 'inline' is not allowed on block scope variable declaration.

 
 void Sema::CheckVariableDeclarationType(VarDecl *NewVD) {
   // If the decl is already known invalid, don't check it.
   if (NewVD->isInvalidDecl())
     return;
 
   QualType T = NewVD->getType();
 
+  if (NewVD->isResumableSpecified() && !T->getAs<AutoType>()) {
+    Diag(NewVD->getLocation(), diag::err_resumable_var_decl_type)
+        << T << NewVD->getTypeSpecStartLoc();
+    NewVD->setInvalidDecl(true);
+    return;
+  }
+
   // Defer checking an 'auto' type until its initializer is attached.
   if (T->isUndeducedType())
     return;
 
   if (NewVD->hasAttrs())
     CheckAlignasUnderalignment(NewVD);
 
   if (T->isObjCObjectType()) {

     if (D.isInvalidType())
       NewFD->setInvalidDecl();
 
     return NewFD;
   }
 
   bool isExplicit = D.getDeclSpec().isExplicitSpecified();
   bool isConstexpr = D.getDeclSpec().isConstexprSpecified();
+  bool isResumable = D.getDeclSpec().isResumableSpecified();
 
   // Check that the return type is not an abstract class type.
   // For record types, this is done by the AbstractClassUsageDiagnoser once
   // the class has been completely parsed.
   if (!DC->isRecord() &&
       SemaRef.RequireNonAbstractType(
           D.getIdentifierLoc(), R->getAs<FunctionType>()->getReturnType(),
           diag::err_abstract_type_in_decl, SemaRef.AbstractReturnType))

       return NewDD;
 
     } else {
       SemaRef.Diag(D.getIdentifierLoc(), diag::err_destructor_not_member);
       D.setInvalidType();
 
       // Create a FunctionDecl to satisfy the function definition parsing
       // code path.
-      return FunctionDecl::Create(SemaRef.Context, DC,
-                                  D.getLocStart(),
-                                  D.getIdentifierLoc(), Name, R, TInfo,
-                                  SC, isInline,
-                                  /*hasPrototype=*/true, isConstexpr);
+      return FunctionDecl::Create(
+          SemaRef.Context, DC, D.getLocStart(), D.getIdentifierLoc(), Name, R,
+          TInfo, SC, isInline,
+          /*hasPrototype=*/true, isConstexpr, isResumable);
     }
 
   } else if (Name.getNameKind() == DeclarationName::CXXConversionFunctionName) {
     if (!DC->isRecord()) {
       SemaRef.Diag(D.getIdentifierLoc(),
            diag::err_conv_function_not_member);
       return nullptr;
     }
 
     SemaRef.CheckConversionDeclarator(D, R, SC);
     IsVirtualOkay = true;
     return CXXConversionDecl::Create(SemaRef.Context, cast<CXXRecordDecl>(DC),
-                                     D.getLocStart(), NameInfo,
-                                     R, TInfo, isInline, isExplicit,
-                                     isConstexpr, SourceLocation());
+                                     D.getLocStart(), NameInfo, R, TInfo,
+                                     isInline, isExplicit, isConstexpr,
+                                     isResumable, SourceLocation());
 
   } else if (Name.getNameKind() == DeclarationName::CXXDeductionGuideName) {
     SemaRef.CheckDeductionGuideDeclarator(D, R, SC);
 
     return CXXDeductionGuideDecl::Create(SemaRef.Context, DC, D.getLocStart(),
                                          isExplicit, NameInfo, R, TInfo,
                                          D.getLocEnd());
   } else if (DC->isRecord()) {
     // If the name of the function is the same as the name of the record,
     // then this must be an invalid constructor that has a return type.
     // (The parser checks for a return type and makes the declarator a
     // constructor if it has no return type).
     if (Name.getAsIdentifierInfo() &&
         Name.getAsIdentifierInfo() == cast<CXXRecordDecl>(DC)->getIdentifier()){
       SemaRef.Diag(D.getIdentifierLoc(), diag::err_constructor_return_type)
         << SourceRange(D.getDeclSpec().getTypeSpecTypeLoc())
         << SourceRange(D.getIdentifierLoc());
       return nullptr;
     }
 
     // This is a C++ method declaration.
-    CXXMethodDecl *Ret = CXXMethodDecl::Create(SemaRef.Context,
-                                               cast<CXXRecordDecl>(DC),
-                                               D.getLocStart(), NameInfo, R,
-                                               TInfo, SC, isInline,
-                                               isConstexpr, SourceLocation());
+    CXXMethodDecl *Ret = CXXMethodDecl::Create(
+        SemaRef.Context, cast<CXXRecordDecl>(DC), D.getLocStart(), NameInfo, R,
+        TInfo, SC, isInline, isConstexpr, isResumable, SourceLocation());
     IsVirtualOkay = !Ret->isStatic();
     return Ret;
   } else {
     bool isFriend =
         SemaRef.getLangOpts().CPlusPlus && D.getDeclSpec().isFriendSpecified();
     if (!isFriend && SemaRef.CurContext->isRecord())
       return nullptr;
 
     // Determine whether the function was written with a
     // prototype. This true when:
     //   - we're in C++ (where every function has a prototype),
-    return FunctionDecl::Create(SemaRef.Context, DC,
-                                D.getLocStart(),
-                                NameInfo, R, TInfo, SC, isInline,
-                                true/*HasPrototype*/, isConstexpr);
+    return FunctionDecl::Create(SemaRef.Context, DC, D.getLocStart(), NameInfo,
+                                R, TInfo, SC, isInline, true /*HasPrototype*/,
+                                isConstexpr, isResumable);
   }
 }
 
 enum OpenCLParamType {
   ValidKernelParam,
   PtrPtrKernelParam,
   PtrKernelParam,
   InvalidAddrSpacePtrKernelParam,

   if (IsLocalExternDecl)
     NewFD->setLocalExternDecl();
 
   if (getLangOpts().CPlusPlus) {
     bool isInline = D.getDeclSpec().isInlineSpecified();
     bool isVirtual = D.getDeclSpec().isVirtualSpecified();
     bool isExplicit = D.getDeclSpec().isExplicitSpecified();
     bool isConstexpr = D.getDeclSpec().isConstexprSpecified();
+    bool isResumable = D.getDeclSpec().isResumableSpecified();
+
     isFriend = D.getDeclSpec().isFriendSpecified();
     if (isFriend && !isInline && D.isFunctionDefinition()) {
       // C++ [class.friend]p5
       //   A function can be defined in a friend declaration of a
       //   class . . . . Such a function is implicitly inline.
       NewFD->setImplicitlyInline();
     }
 

 
       // C++11 [dcl.constexpr]p3: functions declared constexpr are required to
       // be either constructors or to return a literal type. Therefore,
       // destructors cannot be declared constexpr.
       if (isa<CXXDestructorDecl>(NewFD))
         Diag(D.getDeclSpec().getConstexprSpecLoc(), diag::err_constexpr_dtor);
     }
 
+    if (isResumable) {
+      NewFD->setImplicitlyInline();
+
+      if (isa<CXXConstructorDecl>(NewFD) || isa<CXXDestructorDecl>(NewFD))
+        Diag(D.getDeclSpec().getResumableSpecLoc(),
+             diag::err_resumable_ctor_dtor)
+            << isa<CXXDestructorDecl>(NewFD);
+    }
+
     // If __module_private__ was specified, mark the function accordingly.
     if (D.getDeclSpec().isModulePrivateSpecified()) {
       if (isFunctionTemplateSpecialization) {
         SourceLocation ModulePrivateLoc
           = D.getDeclSpec().getModulePrivateSpecLoc();
         Diag(ModulePrivateLoc, diag::err_module_private_specialization)
           << 0
           << FixItHint::CreateRemoval(ModulePrivateLoc);

     DeletedFuncs = 5,
     DefaultedFuncs = 6
   };
   enum Different {
     CallingConv = 0,
     ReturnType = 1,
     ConstexprSpec = 2,
     InlineSpec = 3,
-    StorageClass = 4,
-    Linkage = 5
+    ResumableSpec = 4,
+    StorageClass = 5,
+    Linkage = 6
   };
 
   // For now, disallow all other attributes.  These should be opt-in, but
   // an analysis of all of them is a future FIXME.
   if (CausesMV && OldFD &&
       std::distance(OldFD->attr_begin(), OldFD->attr_end()) != 1) {
     S.Diag(OldFD->getLocation(), diag::err_multiversion_no_other_attrs);
     S.Diag(NewFD->getLocation(), diag::note_multiversioning_caused_here);

     if (OldFD->isConstexpr() != NewFD->isConstexpr())
       return S.Diag(NewFD->getLocation(), diag::err_multiversion_diff)
              << ConstexprSpec;
 
     if (OldFD->isInlineSpecified() != NewFD->isInlineSpecified())
       return S.Diag(NewFD->getLocation(), diag::err_multiversion_diff)
              << InlineSpec;
 
+    if (OldFD->isResumable() != NewFD->isResumable())
+      return S.Diag(NewFD->getLocation(), diag::err_multiversion_diff)
+             << ResumableSpec;
+
     if (OldFD->getStorageClass() != NewFD->getStorageClass())
       return S.Diag(NewFD->getLocation(), diag::err_multiversion_diff)
              << StorageClass;
 
     if (OldFD->isExternC() != NewFD->isExternC())
       return S.Diag(NewFD->getLocation(), diag::err_multiversion_diff)
              << Linkage;
 

     Diag(NoreturnLoc, diag::note_main_remove_noreturn)
       << FixItHint::CreateRemoval(NoreturnRange);
   }
   if (FD->isConstexpr()) {
     Diag(DS.getConstexprSpecLoc(), diag::err_constexpr_main)
       << FixItHint::CreateRemoval(DS.getConstexprSpecLoc());
     FD->setConstexpr(false);
   }
+  if (FD->isResumableSpecified()) {
+    Diag(DS.getResumableSpecLoc(), diag::err_resumable_main)
+        << FixItHint::CreateRemoval(DS.getResumableSpecLoc());
+    FD->setResumableSpecified(false);
+  }
 
   if (getLangOpts().OpenCL) {
     Diag(FD->getLocation(), diag::err_opencl_no_main)
         << FD->hasAttr<OpenCLKernelAttr>();
     FD->setInvalidDecl();
     return;
   }
 

   VarDecl *VDecl = dyn_cast<VarDecl>(RealDecl);
   if (!VDecl) {
     assert(!isa<FieldDecl>(RealDecl) && "field init shouldn't get here");
     Diag(RealDecl->getLocation(), diag::err_illegal_initializer);
     RealDecl->setInvalidDecl();
     return;
   }
 
+  bool CorrectTyposEarly =
+      VDecl->getType()->isUndeducedType() || VDecl->isResumableSpecified();
+  if (CorrectTyposEarly) {
+    // Attempt typo correction early so that the type of the init expression can
+    // be deduced based on the chosen correction if the original init contains a
+    // TypoExpr.
+    ExprResult Res = CorrectDelayedTyposInExpr(Init, VDecl);
+    if (!Res.isUsable()) {
+      RealDecl->setInvalidDecl();
+      return;
+    }
+    Init = Res.get();
+  }
+
+  if (VDecl->isResumableSpecified()) {
+    if (CheckResumableVarDecl(VDecl, Init)) {
+      RealDecl->setInvalidDecl();
+      return;
+    }
+  }
+
   // C++11 [decl.spec.auto]p6. Deduce the type which 'auto' stands in for.
   if (VDecl->getType()->isUndeducedType()) {
     // Attempt typo correction early so that the type of the init expression can
     // be deduced based on the chosen correction if the original init contains a
     // TypoExpr.
     ExprResult Res = CorrectDelayedTyposInExpr(Init, VDecl);
     if (!Res.isUsable()) {
       RealDecl->setInvalidDecl();
       return;
     }
     Init = Res.get();
 
+    // FIXME(EricWF): Correctly deduce the resumable object type if we have a
+    // resumable expression.
     if (DeduceVariableDeclarationType(VDecl, DirectInit, Init))
       return;
   }
 
   // dllimport cannot be used on variable definitions.
   if (VDecl->hasAttr<DLLImportAttr>() && !VDecl->isStaticDataMember()) {
     Diag(VDecl->getLocation(), diag::err_attribute_dllimport_data_definition);
     VDecl->setInvalidDecl();

 
     // Do nothing on dependent types.
     if (DclT->isDependentType()) {
 
     // Allow any 'static constexpr' members, whether or not they are of literal
     // type. We separately check that every constexpr variable is of literal
     // type.
     } else if (VDecl->isConstexpr()) {
+      // FIXME(EricWF): Do something here
 
       // Require constness.
     } else if (!DclT.isConstQualified()) {
       Diag(VDecl->getLocation(), diag::err_in_class_initializer_non_const)
         << Init->getSourceRange();
       VDecl->setInvalidDecl();
 
     // We allow integer constant expressions in all cases.
     } else if (DclT->isIntegralOrEnumerationType()) {
       // Check whether the expression is a constant expression.

 
     // C++1z [dcl.dcl]p1 grammar implies that an initializer is mandatory.
     if (isa<DecompositionDecl>(RealDecl)) {
       Diag(Var->getLocation(), diag::err_decomp_decl_requires_init) << Var;
       Var->setInvalidDecl();
       return;
     }
 
+    if (Var->isResumableSpecified()) {
+      Diag(Var->getLocation(), diag::err_resumable_var_decl_requires_init)
+          << Var;
+      Var->setInvalidDecl();
+      return;
+    }
+
     if (Type->isUndeducedType() &&
         DeduceVariableDeclarationType(Var, false, nullptr))
       return;
 
     // C++11 [class.static.data]p3: A static data member can be declared with
     // the constexpr specifier; if so, its declaration shall specify
     // a brace-or-equal-initializer.
     // C++11 [dcl.constexpr]p1: The constexpr specifier shall be applied only to

     Diag(DS.getThreadStorageClassSpecLoc(), diag::err_invalid_thread)
       << DeclSpec::getSpecifierName(TSCS);
   if (DS.isInlineSpecified())
     Diag(DS.getInlineSpecLoc(), diag::err_inline_non_function)
         << getLangOpts().CPlusPlus17;
   if (DS.isConstexprSpecified())
     Diag(DS.getConstexprSpecLoc(), diag::err_invalid_constexpr)
       << 0;
+  if (DS.isResumableSpecified())
+    Diag(DS.getResumableSpecLoc(), diag::err_invalid_resumable) << IRK_ParmVar;
 
   DiagnoseFunctionSpecifiers(DS);
 
   TypeSourceInfo *TInfo = GetTypeForDeclarator(D, S);
   QualType parmDeclType = TInfo->getType();
 
   if (getLangOpts().CPlusPlus) {
     // Check that there are no default arguments inside the type of this

       ActivePolicy = &WP;
     }
 
     if (!IsInstantiation && FD && FD->isConstexpr() && !FD->isInvalidDecl() &&
         (!CheckConstexprFunctionDecl(FD) ||
          !CheckConstexprFunctionBody(FD, Body)))
       FD->setInvalidDecl();
 
+    if (!IsInstantiation && FD && FD->isResumable() && !FD->isInvalidDecl() &&
+        !CheckResumableFunctionDecl(FD))
+      FD->setInvalidDecl();
+    if (FD && FD->isResumable() && !FD->isInvalidDecl())
+      CheckCompletedResumableFunctionBody(FD, Body);
+
     if (FD && FD->hasAttr<NakedAttr>()) {
       for (const Stmt *S : Body->children()) {
         // Allow local register variables without initializer as they don't
         // require prologue.
         bool RegisterVariables = false;
         if (auto *DS = dyn_cast<DeclStmt>(S)) {
           for (const auto *Decl : DS->decls()) {
             if (const auto *Var = dyn_cast<VarDecl>(Decl)) {

lib/Sema/SemaDeclCXX.cpp

 #include "clang/Sema/Template.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/StringExtras.h"
 #include <map>
 #include <set>
 
 using namespace clang;
+using namespace clang::sema;
 
 //===----------------------------------------------------------------------===//
 // CheckDefaultArgumentVisitor
 //===----------------------------------------------------------------------===//
 
 namespace {
   /// CheckDefaultArgumentVisitor - C++ [dcl.fct.default] Traverses
   /// the default argument of a parameter to determine whether it

   // C++11 [dcl.constexpr]p1: If any declaration of a function or function
   // template has a constexpr specifier then all its declarations shall
   // contain the constexpr specifier.
   if (New->isConstexpr() != Old->isConstexpr()) {
     Diag(New->getLocation(), diag::err_constexpr_redecl_mismatch)
       << New << New->isConstexpr();
     Diag(Old->getLocation(), diag::note_previous_declaration);
     Invalid = true;
+  } else if (New->isResumable() != Old->isResumable()) {
+    Diag(New->getLocation(), diag::err_resumable_redecl_mismatch)
+        << New << New->isResumable();
+    Diag(Old->getLocation(), diag::note_previous_declaration);
+    Invalid = true;
   } else if (!Old->getMostRecentDecl()->isInlined() && New->isInlined() &&
              Old->isDefined(Def) &&
              // If a friend function is inlined but does not have 'inline'
              // specifier, it is a definition. Do not report attribute conflict
              // in this case, redefinition will be diagnosed later.
              (New->isInlineSpecified() ||
               New->getFriendObjectKind() == Decl::FOK_None)) {
     // C++11 [dcl.fcn.spec]p4:

                                                      CXXCopyAssignment,
                                                      Const);
 
   //   An implicitly-declared copy assignment operator is an inline public
   //   member of its class.
   DeclarationName Name = Context.DeclarationNames.getCXXOperatorName(OO_Equal);
   SourceLocation ClassLoc = ClassDecl->getLocation();
   DeclarationNameInfo NameInfo(Name, ClassLoc);
-  CXXMethodDecl *CopyAssignment =
-      CXXMethodDecl::Create(Context, ClassDecl, ClassLoc, NameInfo, QualType(),
-                            /*TInfo=*/nullptr, /*StorageClass=*/SC_None,
-                            /*isInline=*/true, Constexpr, SourceLocation());
+  CXXMethodDecl *CopyAssignment = CXXMethodDecl::Create(
+      Context, ClassDecl, ClassLoc, NameInfo, QualType(),
+      /*isInline=*/true, Constexpr, /*isResumable=*/false, SourceLocation());
   CopyAssignment->setAccess(AS_public);
   CopyAssignment->setDefaulted();
   CopyAssignment->setImplicit();
 
   if (getLangOpts().CUDA) {
     inferCUDATargetForImplicitSpecialMember(ClassDecl, CXXCopyAssignment,
                                             CopyAssignment,
                                             /* ConstRHS */ Const,

                                                      CXXMoveAssignment,
                                                      false);
 
   //   An implicitly-declared move assignment operator is an inline public
   //   member of its class.
   DeclarationName Name = Context.DeclarationNames.getCXXOperatorName(OO_Equal);
   SourceLocation ClassLoc = ClassDecl->getLocation();
   DeclarationNameInfo NameInfo(Name, ClassLoc);
-  CXXMethodDecl *MoveAssignment =
-      CXXMethodDecl::Create(Context, ClassDecl, ClassLoc, NameInfo, QualType(),
-                            /*TInfo=*/nullptr, /*StorageClass=*/SC_None,
-                            /*isInline=*/true, Constexpr, SourceLocation());
+  CXXMethodDecl *MoveAssignment = CXXMethodDecl::Create(
+      Context, ClassDecl, ClassLoc, NameInfo, QualType(),
+      /*isInline=*/true, Constexpr, /*isResumable=*/false, SourceLocation());
   MoveAssignment->setAccess(AS_public);
   MoveAssignment->setDefaulted();
   MoveAssignment->setImplicit();
 
   if (getLangOpts().CUDA) {
     inferCUDATargetForImplicitSpecialMember(ClassDecl, CXXMoveAssignment,
                                             MoveAssignment,
                                             /* ConstRHS */ false,

lib/Sema/SemaExpr.cpp

   unsigned BuiltinID = (FDecl ? FDecl->getBuiltinID() : 0);
 
   // Functions with 'interrupt' attribute cannot be called directly.
   if (FDecl && FDecl->hasAttr<AnyX86InterruptAttr>()) {
     Diag(Fn->getExprLoc(), diag::err_anyx86_interrupt_called);
     return ExprError();
   }
 
+  if (FDecl && FDecl->isResumable())
+    SetCurFunctionImplicitlyResumable(Fn->getExprLoc());
+
   // Interrupt handlers don't save off the VFP regs automatically on ARM,
   // so there's some risk when calling out to non-interrupt handler functions
   // that the callee might not preserve them. This is easy to diagnose here,
   // but can be very challenging to debug.
   if (auto *Caller = getCurFunctionDecl())
     if (Caller->hasAttr<ARMInterruptAttr>()) {
       bool VFP = Context.getTargetInfo().hasFeature("vfp");
       if (VFP && (!FDecl || !FDecl->hasAttr<ARMInterruptAttr>()))

lib/Sema/SemaExprCXX.cpp

       return Result;
     }
     assert(TyposResolved == 0 && "Corrected typo but got same Expr back?");
   }
   return E;
 }
 
 ExprResult Sema::ActOnFinishFullExpr(Expr *FE, SourceLocation CC,
-                                     bool DiscardedValue,
-                                     bool IsConstexpr,
-                                     bool IsLambdaInitCaptureInitializer) {
+                                     bool DiscardedValue, bool IsConstexpr,
+                                     bool IsLambdaInitCaptureInitializer,
+                                     bool IsResumable) {
   ExprResult FullExpr = FE;
 
   if (!FullExpr.get())
     return ExprError();
 
   // If we are an init-expression in a lambdas init-capture, we should not
   // diagnose an unexpanded pack now (will be diagnosed once lambda-expr
   // containing full-expression is done).

lib/Sema/SemaLambda.cpp

CXXMethodDecl *Sema::startLambdaDefinition(CXXRecordDecl *Class,
   //   trailing-return-type respectively.
   DeclarationName MethodName
     = Context.DeclarationNames.getCXXOperatorName(OO_Call);
   DeclarationNameLoc MethodNameLoc;
   MethodNameLoc.CXXOperatorName.BeginOpNameLoc
     = IntroducerRange.getBegin().getRawEncoding();
   MethodNameLoc.CXXOperatorName.EndOpNameLoc
     = IntroducerRange.getEnd().getRawEncoding();
-  CXXMethodDecl *Method
-    = CXXMethodDecl::Create(Context, Class, EndLoc,
-                            DeclarationNameInfo(MethodName, 
-                                                IntroducerRange.getBegin(),
-                                                MethodNameLoc),
-                            MethodType, MethodTypeInfo,
-                            SC_None,
-                            /*isInline=*/true,
-                            IsConstexprSpecified,
-                            EndLoc);
+  CXXMethodDecl *Method = CXXMethodDecl::Create(
+      Context, Class, EndLoc,
+      DeclarationNameInfo(MethodName, IntroducerRange.getBegin(),
+      MethodType, MethodTypeInfo, SC_None,
+      /*isInline=*/true, IsConstexprSpecified,
+      /*isResumable=*/false, EndLoc);
   Method->setAccess(AS_public);
   
   // Temporarily set the lexical declaration context to the current
   // context, so that the Scope stack matches the lexical nesting.
   Method->setLexicalDeclContext(CurContext);  
   // Create a function template if we have a template parameter list
   FunctionTemplateDecl *const TemplateMethod = TemplateParams ?
             FunctionTemplateDecl::Create(Context, Class,
InvokerParams.push_back(ParmVarDecl::Create(S.Context,
                                              From->getType(),
                                              From->getTypeSourceInfo(),
                                              From->getStorageClass(),
                                              /*DefaultArg=*/nullptr));
     CallOpConvTL.setParam(I, From);
     CallOpConvNameTL.setParam(I, From);
   }
 
-  CXXConversionDecl *Conversion 
-    = CXXConversionDecl::Create(S.Context, Class, Loc, 
-                                DeclarationNameInfo(ConversionName, 
-                                  Loc, ConvNameLoc),
-                                ConvTy, 
-                                ConvTSI,
-                                /*isInline=*/true, /*isExplicit=*/false,
-                                /*isConstexpr=*/S.getLangOpts().CPlusPlus17, 
-                                CallOperator->getBody()->getLocEnd());
+  CXXConversionDecl *Conversion = CXXConversionDecl::Create(
+      S.Context, Class, Loc,
+      DeclarationNameInfo(ConversionName, Loc, ConvNameLoc), ConvTy, ConvTSI,
+      /*isConstexpr=*/S.getLangOpts().CPlusPlus17,
+      /*IsResumable=*/false, CallOperator->getBody()->getLocEnd());
   Conversion->setAccess(AS_public);
   Conversion->setImplicit(true);
 
   if (Class->isGenericLambda()) {
     // Create a template version of the conversion operator, using the template
     // parameter list of the function call operator.
     FunctionTemplateDecl *TemplateCallOperator = 
             CallOperator->getDescribedFunctionTemplate();
static void addFunctionPointerConversion(Sema &S,
   // then rewire the parameters accordingly, by hoisting up the InvokeParams
   // loop below and then use its Params to set Invoke->setParams(...) below.
   // This would avoid the 'const' qualifier of the calloperator from 
   // contaminating the type of the invoker, which is currently adjusted 
   // in SemaTemplateDeduction.cpp:DeduceTemplateArguments.  Fixing the
   // trailing return type of the invoker would require a visitor to rebuild
   // the trailing return type and adjusting all back DeclRefExpr's to refer
   // to the new static invoker parameters - not the call operator's.
-  CXXMethodDecl *Invoke
-    = CXXMethodDecl::Create(S.Context, Class, Loc, 
-                            DeclarationNameInfo(InvokerName, Loc), 
-                            InvokerFunctionTy,
-                            CallOperator->getTypeSourceInfo(), 
-                            SC_Static, /*IsInline=*/true,
-                            /*IsConstexpr=*/false, 
-                            CallOperator->getBody()->getLocEnd());
+  CXXMethodDecl *Invoke = CXXMethodDecl::Create(
+      S.Context, Class, Loc, DeclarationNameInfo(InvokerName, Loc),
+      InvokerFunctionTy, CallOperator->getTypeSourceInfo(), SC_Static,
+      /*IsInline=*/true,
+      /*IsConstexpr=*/false, /*IsResumable*/ false,
   for (unsigned I = 0, N = CallOperator->getNumParams(); I != N; ++I)
     InvokerParams[I]->setOwningFunction(Invoke);
   Invoke->setParams(InvokerParams);
   Invoke->setAccess(AS_private);
   Invoke->setImplicit(true);
   if (Class->isGenericLambda()) {
     FunctionTemplateDecl *TemplateCallOperator = 
             CallOperator->getDescribedFunctionTemplate();
static void addBlockPointerConversion(Sema &S,
   QualType ConvTy = S.Context.getFunctionType(BlockPtrTy, None, ConversionEPI);
 
   SourceLocation Loc = IntroducerRange.getBegin();
   DeclarationName Name
     = S.Context.DeclarationNames.getCXXConversionFunctionName(
         S.Context.getCanonicalType(BlockPtrTy));
   DeclarationNameLoc NameLoc;
   NameLoc.NamedType.TInfo = S.Context.getTrivialTypeSourceInfo(BlockPtrTy, Loc);
-  CXXConversionDecl *Conversion 
-    = CXXConversionDecl::Create(S.Context, Class, Loc, 
-                                DeclarationNameInfo(Name, Loc, NameLoc),
-                                ConvTy, 
-                                S.Context.getTrivialTypeSourceInfo(ConvTy, Loc),
-                                /*isInline=*/true, /*isExplicit=*/false,
-                                /*isConstexpr=*/false, 
-                                CallOperator->getBody()->getLocEnd());
+  CXXConversionDecl *Conversion = CXXConversionDecl::Create(
+      S.Context, Class, Loc, DeclarationNameInfo(Name, Loc, NameLoc), ConvTy,
+      /*isConstexpr=*/false, /*isResumable*/ false,
   Conversion->setAccess(AS_public);
   Conversion->setImplicit(true);
   Class->addDecl(Conversion);
 }
 
 static ExprResult performLambdaVarCaptureInitialization(Sema &S,
                                                         const Capture &Capture,
                                                         FieldDecl *Field) {

lib/Sema/SemaOverload.cpp

 //===--- SemaOverload.cpp - C++ Overloading -------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file provides Sema routines for C++ overloading.
 //
 //===----------------------------------------------------------------------===//
 
-#include "clang/Sema/Overload.h"
 #include "clang/AST/ASTContext.h"
 #include "clang/AST/CXXInheritance.h"
 #include "clang/AST/DeclObjC.h"
 #include "clang/AST/Expr.h"
 #include "clang/AST/ExprCXX.h"
 #include "clang/AST/ExprObjC.h"
 #include "clang/AST/TypeOrdering.h"
 #include "clang/Basic/Diagnostic.h"
 #include "clang/Basic/DiagnosticOptions.h"
 #include "clang/Basic/PartialDiagnostic.h"
 #include "clang/Basic/TargetInfo.h"
 #include "clang/Sema/Initialization.h"
 #include "clang/Sema/Lookup.h"
+#include "clang/Sema/Overload.h"
+#include "clang/Sema/ScopeInfo.h"
 #include "clang/Sema/SemaInternal.h"
 #include "clang/Sema/Template.h"
 #include "clang/Sema/TemplateDeduction.h"
 #include "llvm/ADT/DenseSet.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/SmallPtrSet.h"
 #include "llvm/ADT/SmallString.h"

         S.Diag(FD->getLocStart(),
                diag::note_addrof_ovl_candidate_disabled_by_enable_if_attr);
       else
         S.Diag(Loc, diag::err_addrof_function_disabled_by_enable_if_attr) << FD;
     }
     return false;
   }
 
+  if (FD->isResumable()) {
+    if (Complain) {
+      if (InOverloadResolution)
+        S.Diag(FD->getLocStart(), diag::note_addrof_ovl_candidate_resumable_fn);
+      else
+        S.Diag(Loc, diag::err_addrof_resumable_fn) << FD;
+    }
+    return false;
+  }
+
   auto I = llvm::find_if(FD->parameters(), [](const ParmVarDecl *P) {
     return P->hasAttr<PassObjectSizeAttr>();
   });
   if (I == FD->param_end())
     return true;
 
   if (Complain) {
     // Add one to ParamNo because it's user-facing

 
     MemExpr = cast<MemberExpr>(MemExprE->IgnoreParens());
   }
 
   QualType ResultType = Method->getReturnType();
   ExprValueKind VK = Expr::getValueKindForType(ResultType);
   ResultType = ResultType.getNonLValueExprType(Context);
 
+  if (Method->isResumable())
+    SetCurFunctionImplicitlyResumable(LParenLoc);
+
   assert(Method && "Member call to something that isn't a method?");
   CXXMemberCallExpr *TheCall =
     new (Context) CXXMemberCallExpr(Context, MemExprE, Args,
                                     ResultType, VK, RParenLoc);
 
   // Check for a valid return type.
   if (CheckCallReturnType(Method->getReturnType(), MemExpr->getMemberLoc(),
                           TheCall, Method))

                                                         nullptr);
       IsError |= Arg.isInvalid();
       TheCall->setArg(i + 1, Arg.get());
     }
   }
 
   if (IsError) return true;
 
+  if (Method->isResumable())
+    SetCurFunctionImplicitlyResumable(LParenLoc);
+
   DiagnoseSentinelCalls(Method, LParenLoc, Args);
 
   if (CheckFunctionCall(Method, TheCall, Proto))
     return true;
 
   return MaybeBindToTemporary(TheCall);
 }
 

lib/Sema/SemaResumable.cpp

+//===--- SemaResumable.cpp - Semantic Analysis for Resumable Functions ----===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+//  This file implements semantic analysis for C++ Resumable Functions
+//
+//===----------------------------------------------------------------------===//
+
+#include "clang/AST/ASTLambda.h"
+#include "clang/AST/Decl.h"
+#include "clang/AST/ExprCXX.h"
+#include "clang/AST/StmtCXX.h"
+#include "clang/Lex/Preprocessor.h"
+#include "clang/Sema/Initialization.h"
+#include "clang/Sema/Overload.h"
+#include "clang/Sema/ScopeInfo.h"
+#include "clang/Sema/Sema.h"
+#include "clang/Sema/SemaInternal.h"
+
+using namespace clang;
+using namespace sema;
+
+void Sema::CheckCompletedResumableFunctionBody(FunctionDecl *FD, Stmt *Body) {
+  if (!Body) {
+    assert(FD && FD->isInvalidDecl() && "No body for valid decl?");
+    return;
+  }
+  assert(FD && FD->isResumable() &&
+         "No function decl or non-resumable function decl?");
+  // FIXME(EricWF): Do something with this
+}
+
+void Sema::SetCurFunctionImplicitlyResumable(SourceLocation Loc,
+                                             bool IsBreakResumable) {
+  // Record the location of the resumable function call.
+  if (FunctionScopeInfo *FnScope = getCurFunction()) {
+    if (IsBreakResumable)
+      FnScope->setFirstBreakResumableStmt(Loc);
+    else
+      FnScope->setFirstResumableStmt(Loc);
+  }
+
+  // Find the callee, and mark that callee as implicitly resumable.
+  if (FunctionDecl *FD = getCurFunctionDecl()) {
+    // FIXME(EricWF): Diagnose cases where the function we're marking implicitly
+    // resumable isn't inline.
+    if (!FD->isResumableSpecified())
+      FD->setImplicitlyResumable(true);
+  } else if (LambdaScopeInfo *Lam = getCurLambda()) {
+    if (CXXMethodDecl *MD = Lam->CallOperator)
+      MD->setImplicitlyResumable(true);
+    else
+      llvm_unreachable("lambda does not yet have body?");
+  } else {
+    // Nothing to do. We should be at the global scope.
+  }
+}
+
+bool Sema::CheckResumableFunctionDecl(const FunctionDecl *FD) {
+  assert(FD->isResumable() && "Checking non-resumable function");
+  if (const auto *Method = dyn_cast<CXXMethodDecl>(FD)) {
+    if (Method->isVirtual()) {
+      Method = Method->getCanonicalDecl();
+      Diag(Method->getLocation(), diag::err_resumable_virtual);
+
+      // If it's not obvious why this function is virtual, find an overridden
+      // function which uses the 'virtual' keyword.
+      const CXXMethodDecl *WrittenVirtual = Method;
+      while (!WrittenVirtual->isVirtualAsWritten())
+        WrittenVirtual = *WrittenVirtual->begin_overridden_methods();
+      if (WrittenVirtual != Method)
+        Diag(WrittenVirtual->getLocation(),
+             diag::note_overridden_virtual_function);
+      return false;
+    }
+  }
+
+  return true;
+}
+
+bool Sema::CheckResumableVarDecl(VarDecl *VD, Expr *Init) {
+  assert(VD && Init && "cannot be null");
+  if (auto *CE = dyn_cast<CallExpr>(Init)) {
+    Decl *Callee = CE->getCalleeDecl();
+    assert(Callee && "No callee for function call?");
+    if (auto *FD = dyn_cast<FunctionDecl>(Callee)) {
+      if (!FD->isResumable()) {
+        Diag(Init->getExprLoc(),
+             diag::err_resumable_var_decl_init_not_resumable_expr)
+            << VD << Init->getSourceRange();
+        Diag(FD->getLocation(), diag::note_function_declared_here);
+        return true;
+      }
+    } else {
+      // FIXME(EricWF): Handle these cases.
+      llvm::errs() << "Unhandled Resumable var decl init case\n";
+      Callee->dumpColor();
+      assert(false);
+    }
+  } else {
+    // FIXME(EricWF): Handle these cases.
+    llvm::errs() << "Unhandled Resumable var decl init case\n";
+    Init->dumpColor();
+    Diag(Init->getExprLoc(), diag::err_resumable_var_decl_init_not_call_expr)
+        << VD << Init->getSourceRange();
+    return true;
+  }
+  return false;
+}

lib/Sema/SemaStmt.cpp

     // C99 6.8.6.2p1: A break shall appear only in or as a loop body.
     return StmtError(Diag(ContinueLoc, diag::err_continue_not_in_loop));
   }
   CheckJumpOutOfSEHFinally(*this, ContinueLoc, *S);
 
   return new (Context) ContinueStmt(ContinueLoc);
 }
 
-StmtResult
-Sema::ActOnBreakStmt(SourceLocation BreakLoc, Scope *CurScope) {
-  Scope *S = CurScope->getBreakParent();
-  if (!S) {
+StmtResult Sema::ActOnBreakStmt(SourceLocation BreakLoc, Scope *CurScope,
+                                bool IsResumable, SourceLocation ResumableLoc) {
+  Scope *BreakScope = CurScope->getBreakParent();
+  if (!BreakScope && !IsResumable) {
     // C99 6.8.6.3p1: A break shall appear only in or as a switch/loop body.
     return StmtError(Diag(BreakLoc, diag::err_break_not_in_loop_or_switch));
   }
-  if (S->isOpenMPLoopScope())
+
+  if (IsResumable)
+    SetCurFunctionImplicitlyResumable(ResumableLoc, /*IsBreakResumable*/ true);
+
+  if (BreakScope && BreakScope->isOpenMPLoopScope())
     return StmtError(Diag(BreakLoc, diag::err_omp_loop_cannot_use_stmt)
                      << "break");
-  CheckJumpOutOfSEHFinally(*this, BreakLoc, *S);
 
-  return new (Context) BreakStmt(BreakLoc);
+  // FIXME(EricWF): Is this the correct scope to check?
+  CheckJumpOutOfSEHFinally(*this, BreakLoc,
+                           *(BreakScope ? BreakScope : CurScope));
+
+  return new (Context) BreakStmt(BreakLoc, IsResumable, ResumableLoc);
 }
 
 /// Determine whether the given expression is a candidate for
 /// copy elision in either a return statement or a throw expression.
 ///
 /// \param ReturnType If we're determining the copy elision candidate for
 /// a return statement, this is the return type of the function. If we're
 /// determining the copy elision candidate for a throw expression, this will

lib/Sema/SemaTemplateInstantiateDecl.cpp

     Method->setRangeEnd(Constructor->getLocEnd());
   } else if (CXXDestructorDecl *Destructor = dyn_cast<CXXDestructorDecl>(D)) {
     Method = CXXDestructorDecl::Create(SemaRef.Context, Record,
                                        StartLoc, NameInfo, T, TInfo,
                                        Destructor->isInlineSpecified(),
                                        false);
     Method->setRangeEnd(Destructor->getLocEnd());
   } else if (CXXConversionDecl *Conversion = dyn_cast<CXXConversionDecl>(D)) {
-    Method = CXXConversionDecl::Create(SemaRef.Context, Record,
-                                       StartLoc, NameInfo, T, TInfo,
-                                       Conversion->isInlineSpecified(),
-                                       Conversion->isExplicit(),
-                                       Conversion->isConstexpr(),
-                                       Conversion->getLocEnd());
+    Method = CXXConversionDecl::Create(
+        SemaRef.Context, Record, StartLoc, NameInfo, T, TInfo,
+        Conversion->isInlineSpecified(), Conversion->isExplicit(),
+        Conversion->isConstexpr(), Conversion->isResumable(),
+        Conversion->getLocEnd());
   } else {
     StorageClass SC = D->isStatic() ? SC_Static : SC_None;
-    Method = CXXMethodDecl::Create(SemaRef.Context, Record,
-                                   StartLoc, NameInfo, T, TInfo,
-                                   SC, D->isInlineSpecified(),
-                                   D->isConstexpr(), D->getLocEnd());
+    Method = CXXMethodDecl::Create(SemaRef.Context, Record, StartLoc, NameInfo,
+                                   T, TInfo, SC, D->isInlineSpecified(),
+                                   D->isConstexpr(), D->isResumable(),
+                                   D->getLocEnd());
   }
 
   if (D->isInlined())
     Method->setImplicitlyInline();
 
   if (QualifierLoc)
     Method->setQualifierInfo(QualifierLoc);
 

lib/Serialization/ASTReaderDecl.cpp

void ASTDeclReader::VisitFunctionDecl(FunctionDecl *FD) {
   FD->HasWrittenPrototype = Record.readInt();
   FD->IsDeleted = Record.readInt();
   FD->IsTrivial = Record.readInt();
   FD->IsTrivialForCall = Record.readInt();
   FD->IsDefaulted = Record.readInt();
   FD->IsExplicitlyDefaulted = Record.readInt();
   FD->HasImplicitReturnZero = Record.readInt();
   FD->IsConstexpr = Record.readInt();
+  FD->IsResumableSpecified = Record.readInt();
+  FD->IsImplicitlyResumable = Record.readInt();
   FD->UsesSEHTry = Record.readInt();
   FD->HasSkippedBody = Record.readInt();
   FD->IsMultiVersion = Record.readInt();
   FD->IsLateTemplateParsed = Record.readInt();
   FD->setCachedLinkage(Linkage(Record.readInt()));
   FD->EndRangeLoc = ReadSourceLocation();
 
   FD->ODRHash = Record.readInt();
if (!isa<ParmVarDecl>(VD)) {
     VD->NonParmVarDeclBits.ExceptionVar = Record.readInt();
     VD->NonParmVarDeclBits.NRVOVariable = Record.readInt();
     VD->NonParmVarDeclBits.CXXForRangeDecl = Record.readInt();
     VD->NonParmVarDeclBits.ObjCForDecl = Record.readInt();
     VD->NonParmVarDeclBits.ARCPseudoStrong = Record.readInt();
     VD->NonParmVarDeclBits.IsInline = Record.readInt();
     VD->NonParmVarDeclBits.IsInlineSpecified = Record.readInt();
     VD->NonParmVarDeclBits.IsConstexpr = Record.readInt();
+    VD->NonParmVarDeclBits.IsResumable = Record.readInt();
     VD->NonParmVarDeclBits.IsInitCapture = Record.readInt();
     VD->NonParmVarDeclBits.PreviousDeclInSameBlockScope = Record.readInt();
     VD->NonParmVarDeclBits.ImplicitParamKind = Record.readInt();
   }
   auto VarLinkage = Linkage(Record.readInt());
   VD->setCachedLinkage(VarLinkage);
 
   // Reconstruct the one piece of the IdentifierNamespace that we need.

lib/Serialization/ASTReaderStmt.cpp

 void ASTStmtReader::VisitContinueStmt(ContinueStmt *S) {
   VisitStmt(S);
   S->setContinueLoc(ReadSourceLocation());
 }
 
 void ASTStmtReader::VisitBreakStmt(BreakStmt *S) {
   VisitStmt(S);
   S->setBreakLoc(ReadSourceLocation());
+  S->setResumableLoc(ReadSourceLocation());
+  if (Record.readInt())
+    S->setResumableSpecified();
 }
 
 void ASTStmtReader::VisitReturnStmt(ReturnStmt *S) {
   VisitStmt(S);
   S->setRetValue(Record.readSubExpr());
   S->setReturnLoc(ReadSourceLocation());
   S->setNRVOCandidate(ReadDeclAs<VarDecl>());
 }

lib/Serialization/ASTWriterDecl.cpp

void ASTDeclWriter::VisitFunctionDecl(FunctionDecl *D) {
   Record.push_back(D->HasWrittenPrototype);
   Record.push_back(D->IsDeleted);
   Record.push_back(D->IsTrivial);
   Record.push_back(D->IsTrivialForCall);
   Record.push_back(D->IsDefaulted);
   Record.push_back(D->IsExplicitlyDefaulted);
   Record.push_back(D->HasImplicitReturnZero);
   Record.push_back(D->IsConstexpr);
+  Record.push_back(D->IsResumableSpecified);
+  Record.push_back(D->IsImplicitlyResumable);
   Record.push_back(D->UsesSEHTry);
   Record.push_back(D->HasSkippedBody);
   Record.push_back(D->IsMultiVersion);
   Record.push_back(D->IsLateTemplateParsed);
   Record.push_back(D->getLinkageInternal());
   Record.AddSourceLocation(D->getLocEnd());
 
   Record.push_back(D->getODRHash());
if (!isa<ParmVarDecl>(D)) {
     Record.push_back(D->isExceptionVariable());
     Record.push_back(D->isNRVOVariable());
     Record.push_back(D->isCXXForRangeDecl());
     Record.push_back(D->isObjCForDecl());
     Record.push_back(D->isARCPseudoStrong());
     Record.push_back(D->isInline());
     Record.push_back(D->isInlineSpecified());
     Record.push_back(D->isConstexpr());
+    Record.push_back(D->isResumableSpecified());
     Record.push_back(D->isInitCapture());
     Record.push_back(D->isPreviousDeclInSameBlockScope());
     if (const auto *IPD = dyn_cast<ImplicitParamDecl>(D))
       Record.push_back(static_cast<unsigned>(IPD->getParameterKind()));
     else
       Record.push_back(0);
   }
   Record.push_back(D->getLinkageInternal());

lib/Serialization/ASTWriterStmt.cpp

void ASTStmtWriter::VisitContinueStmt(ContinueStmt *S) {
   VisitStmt(S);
   Record.AddSourceLocation(S->getContinueLoc());
   Code = serialization::STMT_CONTINUE;
 }
 
 void ASTStmtWriter::VisitBreakStmt(BreakStmt *S) {
   VisitStmt(S);
   Record.AddSourceLocation(S->getBreakLoc());
+  Record.AddSourceLocation(S->getResumableLoc());
+  Record.push_back(S->isResumableSpecified());
   Code = serialization::STMT_BREAK;
 }
 
 void ASTStmtWriter::VisitReturnStmt(ReturnStmt *S) {
   VisitStmt(S);
   Record.AddStmt(S->getRetValue());
   Record.AddSourceLocation(S->getReturnLoc());
   Record.AddDeclRef(S->getNRVOCandidate());

test/Parser/resumable-decl.cpp

+// RUN: %clang_cc1 -verify -fsyntax-only -std=c++11 -pedantic-errors \
+// RUN:   -triple x86_64-linux-gnu -fresumable-functions %s
+
+resumable int t1(); // OK
+
+// expected-error@+1 {{'main' is not allowed to be declared resumable}}
+resumable int main() {}
+
+void t2() {
+  break resumable;
+}

test/SemaCXX/resumable-functions.cpp

+// RUN: %clang_cc1 -std=c++11 -fsyntax-only -verify -fresumable-functions %s
+
+struct TestVirtual {
+  virtual resumable void foo();
+  resumable void bar(); // OK
+};
+
+namespace TestBreakResumableScope {
+
+void break_resumable() {
+  break resumable; // OK
+}
+
+} // end namespace TestBreakResumableScope
+
+namespace TestRedecl {
+
+resumable void p1(); // expected-note {{previous declaration is here}}
+void p1();           // expected-error {{non-resumable declaration of 'p1' follows resumable declaration}}
+
+void p2();           // expected-note {{previous declaration is here}}
+resumable void p2(); // expected-error {{resumable declaration of 'p2' follows non-resumable declaration}}
+
+} // end namespace TestRedecl
+
+struct TestDtorCtor {
+  // FIXME(EricWF): Should constructors be resumable?
+  resumable TestDtorCtor();  // expected-error{{constructor cannot be marked resumable}}
+  resumable ~TestDtorCtor(); // expected-error{{destructor cannot be marked resumable}}
+};
+
+namespace TestTagDecl {
+
+resumable class C1 {};  // expected-error {{class cannot be marked resumable}}
+resumable struct S1 {}; // expected-error {{struct cannot be marked resumable}}
+resumable union U1 {};  // expected-error {{union cannot be marked resumable}}
+resumable enum E1 {};   // expected-error {{enum cannot be marked resumable}}
+template <typename T>
+resumable class TC1 {}; // expected-error {{class cannot be marked resumable}}
+template <typename T>
+resumable struct TS1 {}; // expected-error {{struct cannot be marked resumable}}
+template <typename T>
+resumable union TU1 {}; // expected-error {{union cannot be marked resumable}}
+class C2 {
+} resumable; // expected-error {{class cannot be marked resumable}}
+struct S2 {
+} resumable; // expected-error {{struct cannot be marked resumable}}
+union U2 {
+} resumable;          // expected-error {{union cannot be marked resumable}}
+enum E2 {} resumable; // expected-error {{enum cannot be marked resumable}}
+
+resumable int; // expected-error {{resumable can only be used in variable and function declarations}}
+
+} // end namespace TestTagDecl
+
+namespace TestResumableVarDecl {
+int foo(); // expected-note {{function declared here}}
+resumable int bar();
+
+// expected-error@+1 {{initializer for resumable variable declaration 'x' calls a non-resumable function}}
+resumable auto x = foo();
+resumable auto y = bar(); // OK
+
+int implicitly_resumable() {
+  return bar();
+}
+resumable auto z = implicitly_resumable();
+
+int foo() {
+  // expected-error@+1 {{resumable variable declaration 'x' requires an initializer}}
+  resumable auto x;
+}
+
+} // namespace TestResumableVarDecl
+
+namespace TestAddrOfResumable {
+
+resumable void foo();
+void bar() { foo(); }
+void baz() { break resumable; }
+
+auto x = &foo; // expected-error {{cannot take address of resumable function 'foo'}}
+auto y = &bar; // expected-error {{cannot take address of resumable function 'bar'}}
+auto z = &baz; // expected-error {{cannot take address of resumable function 'baz'}}
+
+} // namespace TestAddrOfResumable
+
+namespace TestImplicitlyResumable {
+
+struct Class {
+  resumable int foo();
+  int bar() {
+    break resumable;
+    return 1;
+  }
+  int baz() { return bar(); }
+
+  int operator()() { return baz(); }
+  int operator()(int x) { return x; } // expected-note {{declared here}}
+};
+
+int foo() { return Class{}.foo(); }
+
+auto lam = []() { break resumable; return 42; };
+auto lam2 = []() { return 42; }; // expected-note {{function declared here}}
+
+resumable auto t1 = Class{}.foo();
+resumable auto t2 = Class{}.bar();
+resumable auto t3 = Class{}.baz();
+resumable auto t4 = foo();
+resumable auto t5 = Class{}();
+resumable auto t6 = Class{}(42); // expected-error {{initializer for resumable variable declaration 't6' calls a non-resumable function}}
+resumable auto t7 = lam();
+resumable auto t8 = lam2(); // expected-error {{initializer for resumable variable declaration 't8' calls a non-resumable function}}
+
+} // namespace TestImplicitlyResumable