Add contracts representation and parsing. Much thanks to Peter for th…

clang/include/clang/AST/Decl.h

@@ -55,6 +55,7 @@ namespace clang {
 class ASTContext;
 struct ASTTemplateArgumentListInfo;
 class CompoundStmt;
+class ContractStmt;
 class DependentFunctionTemplateSpecializationInfo;
 class EnumDecl;
 class Expr;
@@ -769,11 +770,13 @@ struct QualifierInfo {
 /// Contains type source information through TypeSourceInfo.
 class DeclaratorDecl : public ValueDecl {
   // A struct representing a TInfo, a trailing requires-clause and a syntactic
-  // qualifier, to be used for the (uncommon) case of out-of-line declarations
-  // and constrained function decls.
+  // qualifier, to be used for the (uncommon) case of out-of-line declarations,
+  // constrained function decls or functions with contracts.
   struct ExtInfo : public QualifierInfo {
     TypeSourceInfo *TInfo;
     Expr *TrailingRequiresClause = nullptr;
+    SmallVector<ContractStmt *> PreContracts = {};
+    SmallVector<ContractStmt *> PostContracts = {};
   };
 
   llvm::PointerUnion<TypeSourceInfo *, ExtInfo *> DeclInfo;
@@ -853,8 +856,22 @@ class DeclaratorDecl : public ValueDecl {
                         : nullptr;
   }
 
+  SmallVector<ContractStmt *> getPreContracts() const {
+    if (hasExtInfo()) return getExtInfo()->PreContracts;
+    return {};
+  }
+
+  SmallVector<ContractStmt *> getPostContracts() const {
+    if (hasExtInfo()) return getExtInfo()->PostContracts;
+    return {};
+  }
+
   void setTrailingRequiresClause(Expr *TrailingRequiresClause);
 
+  void setPreContracts(SmallVector<ContractStmt *> PreContracts);
+
+  void setPostContracts(SmallVector<ContractStmt *> PostContracts);
+
   unsigned getNumTemplateParameterLists() const {
     return hasExtInfo() ? getExtInfo()->NumTemplParamLists : 0;
   }
@@ -2037,6 +2054,7 @@ class FunctionDecl : public DeclaratorDecl,
     LazyDeclStmtPtr Body;
     /// Information about a future defaulted function definition.
     DefaultedOrDeletedFunctionInfo *DefaultedOrDeletedInfo;
+    ///
   };
 
   unsigned ODRHash;
@@ -2126,7 +2144,9 @@ class FunctionDecl : public DeclaratorDecl,
                const DeclarationNameInfo &NameInfo, QualType T,
                TypeSourceInfo *TInfo, StorageClass S, bool UsesFPIntrin,
                bool isInlineSpecified, ConstexprSpecKind ConstexprKind,
-               Expr *TrailingRequiresClause = nullptr);
+               Expr *TrailingRequiresClause = nullptr,
+               SmallVector<ContractStmt *> PreContracts = {},
+               SmallVector<ContractStmt *> PostContracts = {});
 
   using redeclarable_base = Redeclarable<FunctionDecl>;
 
@@ -2162,20 +2182,23 @@ class FunctionDecl : public DeclaratorDecl,
          TypeSourceInfo *TInfo, StorageClass SC, bool UsesFPIntrin = false,
          bool isInlineSpecified = false, bool hasWrittenPrototype = true,
          ConstexprSpecKind ConstexprKind = ConstexprSpecKind::Unspecified,
-         Expr *TrailingRequiresClause = nullptr) {
+         Expr *TrailingRequiresClause = nullptr,
+         SmallVector<ContractStmt *> PreContracts = {},
+         SmallVector<ContractStmt *> PostContracts = {}) {
     DeclarationNameInfo NameInfo(N, NLoc);
     return FunctionDecl::Create(C, DC, StartLoc, NameInfo, T, TInfo, SC,
                                 UsesFPIntrin, isInlineSpecified,
                                 hasWrittenPrototype, ConstexprKind,
-                                TrailingRequiresClause);
+                                TrailingRequiresClause, PreContracts, PostContracts);
   }
 
   static FunctionDecl *
   Create(ASTContext &C, DeclContext *DC, SourceLocation StartLoc,
          const DeclarationNameInfo &NameInfo, QualType T, TypeSourceInfo *TInfo,
          StorageClass SC, bool UsesFPIntrin, bool isInlineSpecified,
          bool hasWrittenPrototype, ConstexprSpecKind ConstexprKind,
-         Expr *TrailingRequiresClause);
+         Expr *TrailingRequiresClause, SmallVector<ContractStmt *> PreContracts,
+         SmallVector<ContractStmt *> PostContracts);
 
   static FunctionDecl *CreateDeserialized(ASTContext &C, GlobalDeclID ID);
 

clang/include/clang/AST/DeclCXX.h

@@ -2066,9 +2066,12 @@ class CXXMethodDecl : public FunctionDecl {
                 QualType T, TypeSourceInfo *TInfo, StorageClass SC,
                 bool UsesFPIntrin, bool isInline,
                 ConstexprSpecKind ConstexprKind, SourceLocation EndLocation,
-                Expr *TrailingRequiresClause = nullptr)
+                Expr *TrailingRequiresClause = nullptr,
+                SmallVector<ContractStmt *> PreContracts = {},
+                SmallVector<ContractStmt *> PostContracts = {})
       : FunctionDecl(DK, C, RD, StartLoc, NameInfo, T, TInfo, SC, UsesFPIntrin,
-                     isInline, ConstexprKind, TrailingRequiresClause) {
+                     isInline, ConstexprKind, TrailingRequiresClause,
+                     PreContracts, PostContracts) {
     if (EndLocation.isValid())
       setRangeEnd(EndLocation);
   }
@@ -2079,7 +2082,9 @@ class CXXMethodDecl : public FunctionDecl {
          const DeclarationNameInfo &NameInfo, QualType T, TypeSourceInfo *TInfo,
          StorageClass SC, bool UsesFPIntrin, bool isInline,
          ConstexprSpecKind ConstexprKind, SourceLocation EndLocation,
-         Expr *TrailingRequiresClause = nullptr);
+         Expr *TrailingRequiresClause = nullptr,
+         SmallVector<ContractStmt *> PreContracts = {},
+         SmallVector<ContractStmt *> PostContracts = {});
 
   static CXXMethodDecl *CreateDeserialized(ASTContext &C, GlobalDeclID ID);
 
@@ -2547,7 +2552,9 @@ class CXXConstructorDecl final
                      bool UsesFPIntrin, bool isInline,
                      bool isImplicitlyDeclared, ConstexprSpecKind ConstexprKind,
                      InheritedConstructor Inherited,
-                     Expr *TrailingRequiresClause);
+                     Expr *TrailingRequiresClause,
+                     SmallVector<ContractStmt *> PreContracts,
+                     SmallVector<ContractStmt *> PostContracts);
 
   void anchor() override;
 
@@ -2590,7 +2597,9 @@ class CXXConstructorDecl final
          ExplicitSpecifier ES, bool UsesFPIntrin, bool isInline,
          bool isImplicitlyDeclared, ConstexprSpecKind ConstexprKind,
          InheritedConstructor Inherited = InheritedConstructor(),
-         Expr *TrailingRequiresClause = nullptr);
+         Expr *TrailingRequiresClause = nullptr,
+         SmallVector<ContractStmt *> PreContracts = {},
+         SmallVector<ContractStmt *> PostContracts = {});
 
   void setExplicitSpecifier(ExplicitSpecifier ES) {
     assert((!ES.getExpr() ||
@@ -2809,10 +2818,13 @@ class CXXDestructorDecl : public CXXMethodDecl {
                     const DeclarationNameInfo &NameInfo, QualType T,
                     TypeSourceInfo *TInfo, bool UsesFPIntrin, bool isInline,
                     bool isImplicitlyDeclared, ConstexprSpecKind ConstexprKind,
-                    Expr *TrailingRequiresClause = nullptr)
+                    Expr *TrailingRequiresClause = nullptr,
+                    SmallVector<ContractStmt *> PreContracts = {},
+                    SmallVector<ContractStmt *> PostContracts = {})
       : CXXMethodDecl(CXXDestructor, C, RD, StartLoc, NameInfo, T, TInfo,
                       SC_None, UsesFPIntrin, isInline, ConstexprKind,
-                      SourceLocation(), TrailingRequiresClause) {
+                      SourceLocation(), TrailingRequiresClause, PreContracts,
+                      PostContracts) {
     setImplicit(isImplicitlyDeclared);
   }
 
@@ -2824,7 +2836,9 @@ class CXXDestructorDecl : public CXXMethodDecl {
          const DeclarationNameInfo &NameInfo, QualType T, TypeSourceInfo *TInfo,
          bool UsesFPIntrin, bool isInline, bool isImplicitlyDeclared,
          ConstexprSpecKind ConstexprKind,
-         Expr *TrailingRequiresClause = nullptr);
+         Expr *TrailingRequiresClause = nullptr,
+         SmallVector<ContractStmt *> PreContracts = {},
+         SmallVector<ContractStmt *> PostContracts = {});
   static CXXDestructorDecl *CreateDeserialized(ASTContext &C, GlobalDeclID ID);
 
   void setOperatorDelete(FunctionDecl *OD, Expr *ThisArg);
@@ -2865,10 +2879,13 @@ class CXXConversionDecl : public CXXMethodDecl {
                     TypeSourceInfo *TInfo, bool UsesFPIntrin, bool isInline,
                     ExplicitSpecifier ES, ConstexprSpecKind ConstexprKind,
                     SourceLocation EndLocation,
-                    Expr *TrailingRequiresClause = nullptr)
+                    Expr *TrailingRequiresClause = nullptr,
+                    SmallVector<ContractStmt *> PreContracts = {},
+                    SmallVector<ContractStmt *> PostContracts = {})
       : CXXMethodDecl(CXXConversion, C, RD, StartLoc, NameInfo, T, TInfo,
                       SC_None, UsesFPIntrin, isInline, ConstexprKind,
-                      EndLocation, TrailingRequiresClause),
+                      EndLocation, TrailingRequiresClause, PreContracts,
+                      PostContracts),
         ExplicitSpec(ES) {}
   void anchor() override;
 
@@ -2883,7 +2900,9 @@ class CXXConversionDecl : public CXXMethodDecl {
          const DeclarationNameInfo &NameInfo, QualType T, TypeSourceInfo *TInfo,
          bool UsesFPIntrin, bool isInline, ExplicitSpecifier ES,
          ConstexprSpecKind ConstexprKind, SourceLocation EndLocation,
-         Expr *TrailingRequiresClause = nullptr);
+         Expr *TrailingRequiresClause = nullptr,
+         SmallVector<ContractStmt *> PreContracts = {},
+         SmallVector<ContractStmt *> PostContracts = {});
   static CXXConversionDecl *CreateDeserialized(ASTContext &C, GlobalDeclID ID);
 
   ExplicitSpecifier getExplicitSpecifier() {

clang/include/clang/AST/RecursiveASTVisitor.h

@@ -2443,6 +2443,9 @@ DEF_TRAVERSE_STMT(ObjCAtThrowStmt, {})
 DEF_TRAVERSE_STMT(ObjCAtTryStmt, {})
 DEF_TRAVERSE_STMT(ObjCForCollectionStmt, {})
 DEF_TRAVERSE_STMT(ObjCAutoreleasePoolStmt, {})
+// FIXME(EricWF): This may have a declaration with a body eventually.
+// Will that need a different implementation.
+DEF_TRAVERSE_STMT(ContractStmt, {})
 
 DEF_TRAVERSE_STMT(CXXForRangeStmt, {
   if (!getDerived().shouldVisitImplicitCode()) {

clang/include/clang/AST/Stmt.h

@@ -74,6 +74,7 @@ enum class CXXNewInitializationStyle;
 enum class PredefinedIdentKind;
 enum class SourceLocIdentKind;
 enum class StringLiteralKind;
+enum class ContractKind;
 
 //===----------------------------------------------------------------------===//
 // AST classes for statements.
@@ -849,6 +850,21 @@ class alignas(void *) Stmt {
     SourceLocation RParenLoc;
   };
 
+  class ContractAssertBitfields {
+    friend class ASTStmtReader;
+    friend class ASTStmtWriter;
+    friend class ContractStmt;
+
+    LLVM_PREFERRED_TYPE(StmtBitfields)
+    unsigned : NumStmtBits;
+
+    LLVM_PREFERRED_TYPE(bool)
+    unsigned HasResultName : 1;
+
+    LLVM_PREFERRED_TYPE(ContractKind)
+    unsigned ContractKind : 2;
+  };
+
   class CXXNewExprBitfields {
     friend class ASTStmtReader;
     friend class ASTStmtWriter;
@@ -1266,6 +1282,9 @@ class alignas(void *) Stmt {
     // C++ Coroutines expressions
     CoawaitExprBitfields CoawaitBits;
 
+    // C++ contracts
+    ContractAssertBitfields ContractAssertBits;
+
     // Obj-C Expressions
     ObjCIndirectCopyRestoreExprBitfields ObjCIndirectCopyRestoreExprBits;
 

clang/include/clang/AST/StmtCXX.h

@@ -524,6 +524,105 @@ class CoreturnStmt : public Stmt {
   }
 };
 
+enum class ContractKind { Pre, Post, Assert };
+
+class ContractStmt final : public Stmt,
+                           private llvm::TrailingObjects<ContractStmt, Stmt *> {
+  friend class ASTStmtReader;
+  friend TrailingObjects;
+
+  enum { ResultNameDeclOffset = 0, ConditionOffset = 1, Count = 2 };
+
+public:
+  // These types correspond to the three C++ 'await_suspend' return variants
+
+private:
+  unsigned condOffset() const {
+    return ResultNameDeclOffset + ContractAssertBits.HasResultName;
+  }
+
+  Stmt **getSubStmts() { return getTrailingObjects<Stmt *>(); }
+
+  Stmt *const *getSubStmts() const { return getTrailingObjects<Stmt *>(); }
+
+  SourceLocation KeywordLoc;
+
+public:
+  ContractStmt(ContractKind CK, SourceLocation KeywordLoc, Expr *Condition)
+      : Stmt(ContractStmtClass), KeywordLoc(KeywordLoc) {
+    ContractAssertBits.ContractKind = static_cast<unsigned>(CK);
+    ContractAssertBits.HasResultName = false;
+  }
+
+  ContractStmt(EmptyShell Empty, ContractKind Kind, bool HasResultName = false)
+      : Stmt(ContractStmtClass, Empty) {
+    ContractAssertBits.ContractKind = static_cast<unsigned>(Kind);
+    ContractAssertBits.HasResultName = HasResultName;
+  }
+
+  static ContractStmt *Create(const ASTContext &C, ContractKind Kind,
+                              SourceLocation KeywordLoc, Expr *Condition,
+                              DeclStmt *ResultNameDecl = nullptr);
+
+  static ContractStmt *CreateEmpty(const ASTContext &C, ContractKind Kind,
+                                   bool HasResultName = false);
+
+  ContractKind getContractKind() const {
+    return static_cast<ContractKind>(ContractAssertBits.ContractKind);
+  }
+  void setContractKind(ContractKind CK) {
+    ContractAssertBits.ContractKind = static_cast<unsigned>(CK);
+  }
+
+  bool hasResultNameDecl() const { return ContractAssertBits.HasResultName; }
+
+  DeclStmt *getResultNameDecl() const {
+    return hasResultNameDecl()
+               ? static_cast<DeclStmt *>(
+                     getTrailingObjects<Stmt *>()[ResultNameDeclOffset])
+               : nullptr;
+  }
+
+  void setResultNameDecl(DeclStmt *D) {
+    assert(hasResultNameDecl() && "no result name decl");
+    getTrailingObjects<Stmt *>()[ResultNameDeclOffset] = D;
+  }
+
+  void setCondition(Expr *E) {
+    getTrailingObjects<Stmt *>()[ConditionOffset] = E;
+  }
+
+  Expr *getCond() {
+    return reinterpret_cast<Expr *>(getTrailingObjects<Stmt *>()[condOffset()]);
+  }
+
+  const Expr *getCond() const {
+    return reinterpret_cast<Expr *>(getTrailingObjects<Stmt *>()[condOffset()]);
+  }
+
+  void setCond(Expr *Cond) {
+    getTrailingObjects<Stmt *>()[condOffset()] = reinterpret_cast<Stmt *>(Cond);
+  }
+
+  SourceLocation getKeywordLoc() const { return KeywordLoc; }
+  SourceLocation getBeginLoc() const LLVM_READONLY { return KeywordLoc; }
+  SourceLocation getEndLoc() const LLVM_READONLY {
+    return getCond()->getEndLoc();
+  }
+
+  child_range children() {
+    return child_range(getSubStmts(), getSubStmts() + condOffset() + 1);
+  }
+
+  const_child_range children() const {
+    return const_child_range(getSubStmts(), getSubStmts() + condOffset() + 1);
+  }
+
+  static bool classof(const Stmt *T) {
+    return T->getStmtClass() == ContractStmtClass;
+  }
+};
+
 }  // end namespace clang
 
 #endif

clang/include/clang/Basic/Builtins.td

@@ -2575,6 +2575,20 @@ def SetJmpEx : MSLibBuiltin<"setjmpex.h"> {
   let Prototype = "int(jmp_buf)";
 }
 
+// C++ contracts
+def ContractViolation : Builtin {
+  let Spellings = ["handle_contract_violation"];
+  let Prototype = "void()";
+  let Attributes = [NoThrow, NoReturn, Constexpr];
+}
+
+def ContractAssert : Builtin {
+  let Spellings = ["__builtin_contract_assert"];
+  let Attributes = [NoThrow, Constexpr];
+
+  let Prototype = "void(bool)";
+}
+
 // C99 library functions
 // C99 stdarg.h
 def VaStart : LibBuiltin<"stdarg.h"> {

clang/include/clang/Basic/DiagnosticASTKinds.td

@@ -403,6 +403,8 @@ def note_constexpr_assumption_failed : Note<
   "assumption evaluated to false">;
 def err_experimental_clang_interp_failed : Error<
   "the experimental clang interpreter failed to evaluate an expression">;
+def note_constexpr_contract_failure : Error<
+  "contract failed during execution of constexpr function">;
 
 def warn_integer_constant_overflow : Warning<
   "overflow in expression; result is %0 with type %1">,

clang/include/clang/Basic/LangOptions.def

@@ -156,6 +156,7 @@ LANGOPT(NoBuiltin         , 1, 0, "disable builtin functions")
 LANGOPT(NoMathBuiltin     , 1, 0, "disable math builtin functions")
 LANGOPT(GNUAsm            , 1, 1, "GNU-style inline assembly")
 LANGOPT(Coroutines        , 1, 0, "C++20 coroutines")
+LANGOPT(Contracts         , 1, 1, "C++2c contracts")
 LANGOPT(CoroAlignedAllocation, 1, 0, "prefer Aligned Allocation according to P2014 Option 2")
 LANGOPT(DllExportInlines  , 1, 1, "dllexported classes dllexport inline methods")
 LANGOPT(RelaxedTemplateTemplateArgs, 1, 1, "C++17 relaxed matching of template template arguments")