Contracts nightly

.github/workflows/ericwf-contracts-nightly.yml

@@ -0,0 +1,65 @@
+name: EricWF Contracts Nightly Release flow
+
+permissions:
+  contents: write
+  actions: read
+
+on:
+  workflow_dispatch:
+  push:
+    branches:
+      - 'eric-contracts'
+      - "eric-test-contracts"
+
+
+concurrency:
+  # Skip intermediate builds: always.
+  # Cancel intermediate builds: only if it is a pull request build.
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: ${{ startsWith(github.ref, 'refs/pull/') }}
+
+jobs:
+  check_clang:
+    name: "Do it"
+    if: github.repository_owner == 'EricWF'
+    runs-on: aah
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          ref: ${{ github.ref }}
+          fetch-depth: 0
+      - name: "Setup"
+        run: |
+          mkdir build
+          mkdir install
+
+      - name: "Configure"
+        run: >
+          cmake -B build -S ./llvm/ 
+          -G Ninja 
+          -DCMAKE_BUILD_TYPE=RELWITHDEBINFO 
+          -DLLVM_ENABLE_PROJECTS="clang" 
+          "-DLLVM_ENABLE_RUNTIMES=libcxx;libcxxabi;libunwind" 
+          -DLLVM_ENABLE_ASSERTIONS=ON 
+          -DLLVM_USE_LINKER=mold
+          -DCMAKE_INSTALL_PREFIX=./install
+          -DCMAKE_C_COMPILER=clang
+          -DCMAKE_CXX_COMPILER=clang++
+          '-DLLVM_USE_SANITIZER=Address;Undefined'
+      - name: Build Clang & Libc++
+        run: |
+          cd build
+          ninja clang
+          ninja cxx
+      - name: Test Clang
+        run: |
+          cd build
+          ninja check-clang
+      - name: Check Libc++
+        run: |
+          cd build
+          ninja check-cxx
+      - name: Install
+        run: |
+          cd build
+          ninja install

CONTRACTS_TODO.txt

@@ -0,0 +1,15 @@
+* Parse result name in post contracts
+  * auto declared functions.
+  * templates.
+  * Late parsing in general
+* Diagnose
+* Test parsing failures
+* What happens when pre/post throws from a noexcept function? Can we even callee-emit contracts?
+* Start constification
+* Check 'this' access in pre/post
+* Codegen:
+  * Make it work
+
+* Required headers?
+  <contracts>
+  <source_location>

clang/include/clang/AST/ASTContext.h

@@ -1321,6 +1321,10 @@ class ASTContext : public RefCountedBase<ASTContext> {
   // The decl is built when constructing 'BuiltinVaListDecl'.
   mutable Decl *VaListTagDecl = nullptr;
 
+  // Decl used to define the datastructure for the contract violation object
+  // used for C++ contracts
+  mutable Decl *BuiltinContractViolationRecordDecl = nullptr;
+
   // Implicitly-declared type 'struct _GUID'.
   mutable TagDecl *MSGuidTagDecl = nullptr;
 
@@ -2446,6 +2450,17 @@ class ASTContext : public RefCountedBase<ASTContext> {
     return getCanonicalTagType(MSGuidTagDecl);
   }
 
+  CanQualType getBuiltinContractViolationRecordType() const {
+    return getCanonicalTagType(
+        cast<RecordDecl>(getBuiltinContractViolationRecordDecl()));
+  }
+
+  Decl *getBuiltinContractViolationRecordDecl() const;
+  UnnamedGlobalConstantDecl *
+  BuildViolationObject(const ContractStmt *CS,
+                       const FunctionDecl *CurDecl = nullptr);
+
+
   /// Retrieve the implicitly-predeclared 'struct type_info' declaration.
   TagDecl *getMSTypeInfoTagDecl() const {
     // Lazily create this type on demand - it's only needed for MS builds.

clang/include/clang/AST/ASTNodeTraverser.h

@@ -159,7 +159,7 @@ class ASTNodeTraverser
 
       // Some statements have custom mechanisms for dumping their children.
       if (isa<DeclStmt, GenericSelectionExpr, RequiresExpr,
-              OpenACCWaitConstruct, SYCLKernelCallStmt>(S))
+              OpenACCWaitConstruct, SYCLKernelCallStmt, ContractStmt>(S))
         return;
 
       if (Traversal == TK_IgnoreUnlessSpelledInSource &&
@@ -556,6 +556,9 @@ class ASTNodeTraverser
     if (const AssociatedConstraint &TRC = D->getTrailingRequiresClause())
       Visit(TRC.ConstraintExpr);
 
+    if (const ContractSpecifierDecl *CSD = D->getContracts())
+      Visit(CSD);
+
     if (Traversal == TK_IgnoreUnlessSpelledInSource && D->isDefaulted())
       return;
 
@@ -747,6 +750,17 @@ class ASTNodeTraverser
     Visit(D->getConstraintExpr());
   }
 
+  void VisitContractSpecifierDecl(const ContractSpecifierDecl *CSD) {
+    for (auto *CS : CSD->contracts())
+      Visit(CS);
+  }
+
+  void VisitContractStmt(const ContractStmt *S) {
+    if (S->hasResultName())
+      Visit(S->getResultName());
+    Visit(S->getCond());
+  }
+
   void VisitImplicitConceptSpecializationDecl(
       const ImplicitConceptSpecializationDecl *CSD) {
     for (const TemplateArgument &Arg : CSD->getTemplateArguments())

clang/include/clang/AST/Decl.h

@@ -58,6 +58,8 @@ namespace clang {
 class ASTContext;
 struct ASTTemplateArgumentListInfo;
 class CompoundStmt;
+class ContractStmt;
+class ContractSpecifierDecl;
 class DependentFunctionTemplateSpecializationInfo;
 class EnumDecl;
 class Expr;
@@ -70,6 +72,7 @@ class Module;
 class NamespaceDecl;
 class ParmVarDecl;
 class RecordDecl;
+class ResultNameDecl;
 class Stmt;
 class StringLiteral;
 class TagDecl;
@@ -80,6 +83,7 @@ class TypeAliasTemplateDecl;
 class UnresolvedSetImpl;
 class VarTemplateDecl;
 enum class ImplicitParamKind;
+enum class ContractKind;
 
 // Holds a constraint expression along with a pack expansion index, if
 // expanded.
@@ -778,8 +782,8 @@ 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 = nullptr;
     AssociatedConstraint TrailingRequiresClause;
@@ -908,17 +912,24 @@ struct EvaluatedStmt {
   bool HasICEInit : 1;
   bool CheckedForICEInit : 1;
 
+  // The APvalue stored here may need re-evaluation under contracts, in which
+  // case we need to track if we've already regisetered this value for
+  // destruction.
+  bool RegisteredForDestruction : 1;
+
   bool HasSideEffects : 1;
   bool CheckedForSideEffects : 1;
 
+
   LazyDeclStmtPtr Value;
   APValue Evaluated;
 
   EvaluatedStmt()
       : WasEvaluated(false), IsEvaluating(false),
         HasConstantInitialization(false), HasConstantDestruction(false),
-        HasICEInit(false), CheckedForICEInit(false), HasSideEffects(false),
-        CheckedForSideEffects(false) {}
+        HasICEInit(false), CheckedForICEInit(false),
+        RegisteredForDestruction(false), HasSideEffects(false), CheckedForSideEffects(false) {}
+
 };
 
 /// Represents a variable declaration or definition.
@@ -1413,7 +1424,8 @@ class VarDecl : public DeclaratorDecl, public Redeclarable<VarDecl> {
 
 private:
   APValue *evaluateValueImpl(SmallVectorImpl<PartialDiagnosticAt> &Notes,
-                             bool IsConstantInitialization) const;
+                             bool IsConstantInitialization,
+                             bool EnableContracts) const;
 
 public:
   /// Return the already-evaluated value of this variable's
@@ -1445,8 +1457,13 @@ class VarDecl : public DeclaratorDecl, public Redeclarable<VarDecl> {
   /// Evaluate the initializer of this variable to determine whether it's a
   /// constant initializer. Should only be called once, after completing the
   /// definition of the variable.
-  bool checkForConstantInitialization(
-      SmallVectorImpl<PartialDiagnosticAt> &Notes) const;
+  bool
+  checkForConstantInitialization(SmallVectorImpl<PartialDiagnosticAt> &Notes,
+                                 bool EnableContracts = true) const;
+
+  bool
+  recheckForConstantInitialization(SmallVectorImpl<PartialDiagnosticAt> &Notes,
+                                   bool EnableContracts = true) const;
 
   void setInitStyle(InitializationStyle Style) {
     VarDeclBits.InitStyle = Style;
@@ -2058,13 +2075,18 @@ class FunctionDecl : public DeclaratorDecl,
   /// no formals.
   ParmVarDecl **ParamInfo = nullptr;
 
+  /// The contract sequence specified on this function declaration if there is
+  /// any, otherwise nullptr
+  ContractSpecifierDecl *Contracts = nullptr;
+
   /// The active member of this union is determined by
   /// FunctionDeclBits.HasDefaultedOrDeletedInfo.
   union {
     /// The body of the function.
     LazyDeclStmtPtr Body;
     /// Information about a future defaulted function definition.
     DefaultedOrDeletedFunctionInfo *DefaultedOrDeletedInfo;
+    ///
   };
 
   unsigned ODRHash;
@@ -2154,7 +2176,8 @@ class FunctionDecl : public DeclaratorDecl,
                const DeclarationNameInfo &NameInfo, QualType T,
                TypeSourceInfo *TInfo, StorageClass S, bool UsesFPIntrin,
                bool isInlineSpecified, ConstexprSpecKind ConstexprKind,
-               const AssociatedConstraint &TrailingRequiresClause);
+               const AssociatedConstraint &TrailingRequiresClause,
+               ContractSpecifierDecl *Contracts = nullptr);
 
   using redeclarable_base = Redeclarable<FunctionDecl>;
 
@@ -2190,20 +2213,23 @@ class FunctionDecl : public DeclaratorDecl,
          TypeSourceInfo *TInfo, StorageClass SC, bool UsesFPIntrin = false,
          bool isInlineSpecified = false, bool hasWrittenPrototype = true,
          ConstexprSpecKind ConstexprKind = ConstexprSpecKind::Unspecified,
-         const AssociatedConstraint &TrailingRequiresClause = {}) {
+         const AssociatedConstraint &TrailingRequiresClause = {},
+         ContractSpecifierDecl *Contracts = nullptr) {
+
     DeclarationNameInfo NameInfo(N, NLoc);
     return FunctionDecl::Create(C, DC, StartLoc, NameInfo, T, TInfo, SC,
                                 UsesFPIntrin, isInlineSpecified,
                                 hasWrittenPrototype, ConstexprKind,
-                                TrailingRequiresClause);
+                                TrailingRequiresClause, Contracts);
   }
 
   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,
-         const AssociatedConstraint &TrailingRequiresClause);
+         const AssociatedConstraint &TrailingRequiresClause, ContractSpecifierDecl *Contracts);
+
 
   static FunctionDecl *CreateDeserialized(ASTContext &C, GlobalDeclID ID);
 
@@ -2765,6 +2791,10 @@ class FunctionDecl : public DeclaratorDecl,
     return const_cast<FunctionDecl*>(this)->getCanonicalDecl();
   }
 
+
+  FunctionDecl *getDeclForContracts();
+  const FunctionDecl *getDeclForContracts() const;
+
   unsigned getBuiltinID(bool ConsiderWrapperFunctions = false) const;
 
   // ArrayRef interface to parameters.
@@ -3138,6 +3168,22 @@ class FunctionDecl : public DeclaratorDecl,
     return {};
   }
 
+  /// Set the function level contracts for this function. Update the specifier
+  /// decl and it's children to have this declaration as a declaration context.
+  void setContracts(ContractSpecifierDecl *CSD);
+
+  bool hasContracts() const { return Contracts != nullptr; }
+
+  ContractSpecifierDecl *getContracts() const { return Contracts; }
+
+  using ContractRange = llvm::iterator_range<llvm::filter_iterator<
+      ArrayRef<ContractStmt *>::iterator, bool (*)(const ContractStmt *)>>;
+
+  // Convenience functions to get the preconditions and postconditions.
+  ArrayRef<ContractStmt *> contracts() const;
+  ContractRange preconditions() const;
+  ContractRange postconditions() const;
+
   // Implement isa/cast/dyncast/etc.
   static bool classof(const Decl *D) { return classofKind(D->getKind()); }
   static bool classofKind(Kind K) {
@@ -3184,6 +3230,9 @@ class FieldDecl : public DeclaratorDecl, public Mergeable<FieldDecl> {
   unsigned Mutable : 1;
   LLVM_PREFERRED_TYPE(InitStorageKind)
   unsigned StorageKind : 2;
+  LLVM_PREFERRED_TYPE(bool)
+  unsigned IsConstifiedCapture : 1;
+
   mutable unsigned CachedFieldIndex : 28;
 
   /// If this is a bitfield with a default member initializer, this
@@ -3223,6 +3272,7 @@ class FieldDecl : public DeclaratorDecl, public Mergeable<FieldDecl> {
         CachedFieldIndex(0), Init() {
     if (BW)
       setBitWidth(BW);
+    IsConstifiedCapture = false;
   }
 
 public:
@@ -3385,6 +3435,11 @@ class FieldDecl : public DeclaratorDecl, public Mergeable<FieldDecl> {
   /// Set the captured variable length array type for this field.
   void setCapturedVLAType(const VariableArrayType *VLAType);
 
+  bool isConstifiedCapture() const { return IsConstifiedCapture; }
+  void setIsConstifiedCapture(bool Value = true) {
+    IsConstifiedCapture = Value;
+  }
+
   /// Returns the parent of this field declaration, which
   /// is the struct in which this field is defined.
   ///