B2-2: class templates verified in each specialization

clang/include/clang/AST/ExprContract.h

@@ -23,6 +23,19 @@ namespace clang {
 // Forward declaration for serialization friend access.
 class ASTStmtReader;
 
+/// The dependence of a quantifier or a choice: its operands', with its own
+/// type fixed. In a template, `forall(k, 0, n, p[k] > 0)` over a `T *p` is
+/// value-dependent, though it is a bool.
+inline ExprDependence binderExprDependence(const Expr *Lo, const Expr *Hi,
+                                           const Expr *Body) {
+  ExprDependence D = Body ? Body->getDependence() : ExprDependence::None;
+  if (Lo)
+    D |= Lo->getDependence();
+  if (Hi)
+    D |= Hi->getDependence();
+  return turnTypeToValueDependence(D);
+}
+
 /// ForallExpr - Represents a universal quantifier:
 ///   forall(binder, lo, hi, body)
 /// means: for all binder in [lo, hi), body holds; forall(binder, body)
@@ -46,7 +59,7 @@ class ForallExpr : public Expr {
     SubExprs[LO] = Lo;
     SubExprs[HI] = Hi;
     SubExprs[BODY] = Body;
-    setDependence(ExprDependence::None);
+    setDependence(binderExprDependence(Lo, Hi, Body));
   }
 
   explicit ForallExpr(EmptyShell Empty) : Expr(ForallExprClass, Empty) {}
@@ -101,7 +114,7 @@ class ExistsExpr : public Expr {
     SubExprs[LO] = Lo;
     SubExprs[HI] = Hi;
     SubExprs[BODY] = Body;
-    setDependence(ExprDependence::None);
+    setDependence(binderExprDependence(Lo, Hi, Body));
   }
 
   explicit ExistsExpr(EmptyShell Empty) : Expr(ExistsExprClass, Empty) {}
@@ -156,7 +169,7 @@ class ContractChooseExpr : public Expr {
     SubExprs[LO] = Lo;
     SubExprs[HI] = Hi;
     SubExprs[BODY] = Body;
-    setDependence(ExprDependence::None);
+    setDependence(binderExprDependence(Lo, Hi, Body));
   }
 
   explicit ContractChooseExpr(EmptyShell Empty) : Expr(ContractChooseExprClass, Empty) {}
@@ -202,7 +215,7 @@ class OldExpr : public Expr {
       : Expr(OldExprClass, Inner->getType(), VK_PRValue, OK_Ordinary),
         OldLoc(OldLoc), LParenLoc(LParenLoc), RParenLoc(RParenLoc),
         Inner(Inner) {
-    setDependence(ExprDependence::None);
+    setDependence(Inner->getDependence());
   }
 
   explicit OldExpr(EmptyShell Empty) : Expr(OldExprClass, Empty) {}
@@ -237,7 +250,9 @@ class ResultExpr : public Expr {
              QualType ReturnType)
       : Expr(ResultExprClass, ReturnType, VK_PRValue, OK_Ordinary),
         ResultLoc(ResultLoc), EndLoc(EndLoc) {
-    setDependence(ExprDependence::None);
+    // In a template, the return type may depend on its parameters.
+    setDependence(
+        toExprDependenceForImpliedType(ReturnType->getDependence()));
   }
 
   explicit ResultExpr(EmptyShell Empty) : Expr(ResultExprClass, Empty) {}

clang/include/clang/Basic/DiagnosticGroups.td

@@ -1216,6 +1216,8 @@ def UnusedMemberFunction : DiagGroup<"unused-member-function",
                                      [UnneededMemberFunction]>;
 def UnusedLabel : DiagGroup<"unused-label">;
 def UnusedLambdaCapture : DiagGroup<"unused-lambda-capture">;
+// Contracts of templates were ignored with a warning in this group before
+// templates were verified; it stays, so a build that names it still builds.
 def ContractUnsupported : DiagGroup<"contract-unsupported">;
 def UnusedParameter : DiagGroup<"unused-parameter">;
 def UnusedButSetParameter : DiagGroup<"unused-but-set-parameter">;

clang/include/clang/Basic/DiagnosticParseKinds.td

@@ -1987,9 +1987,5 @@ def err_cppverify_unknown : Error<
 def err_cppverify_unknown_suggest : Error<
   "no cpp-verify construct named 'cppverify::%0'; did you mean "
   "'cppverify::%1'?">;
-def warn_contract_template_unsupported : Warning<
-  "contracts in %select{function|class}0 template %1 are not yet supported "
-  "and are ignored">,
-  InGroup<ContractUnsupported>;
 
 } // end of Parser diagnostics

clang/include/clang/Sema/Sema.h

@@ -10394,8 +10394,22 @@ class Sema final : public SemaBase {
   ExprResult ActOnContractRange(Expr *Base, Expr *Lower, SourceLocation ColonLoc,
                                 Expr *Length, SourceLocation RBLoc);
 
-  /// Rewrite unqualified field names to this->field for type_invariant(expr).
-  ExprResult ActOnTypeInvariantExpr(ExprResult E, CXXRecordDecl *Record);
+  /// A component of a decreases clause, which must be an integer.
+  ExprResult ActOnContractMeasure(ExprResult E);
+
+  /// The context of a quantifier's or a choice's binder: the current one,
+  /// or, in a class (a type invariant), the nearest one around it, since a
+  /// variable of a class is a member and a binder is not.
+  DeclContext *getContractBinderContext() const;
+
+  /// forall, exists, or choose (\p Kind) over \p Binder: its bounds must be
+  /// integers and its body a condition.
+  ExprResult BuildContractBinderExpr(Stmt::StmtClass Kind,
+                                     SourceLocation KeywordLoc,
+                                     SourceLocation LParenLoc,
+                                     SourceLocation RParenLoc, VarDecl *Binder,
+                                     Expr *Lo, Expr *Hi, Expr *Body);
+
 
   /// Diagnose references to spec functions in executable code of \p FD
   /// (or in a global initializer when \p FD is null). Spec functions are
@@ -14336,6 +14350,20 @@ class Sema final : public SemaBase {
   void InstantiateExceptionSpec(SourceLocation PointOfInstantiation,
                                 FunctionDecl *Function);
 
+  /// Instantiate the contract of a function template specialization, or of
+  /// a member of a class template specialization, from its pattern's, when
+  /// it is used or defined and has none yet. (Contracts are instantiated
+  /// lazily, as exception specifications are: an unused member's contract is
+  /// never instantiated.)
+  void InstantiateFunctionContract(SourceLocation PointOfInstantiation,
+                                   FunctionDecl *Function);
+
+  /// The contract \p From of a template, with \p TemplateArgs substituted,
+  /// in \p To. Returns true on error.
+  bool SubstFunctionContract(const FunctionContractInfo &From,
+                             FunctionContractInfo &To,
+                             const MultiLevelTemplateArgumentList &TemplateArgs);
+
   /// Instantiate (or find existing instantiation of) a function template with a
   /// given set of template arguments.
   ///

clang/lib/Parse/ParseCppVerify.cpp

@@ -534,12 +534,11 @@ void Parser::ParseFunctionContractClauseList(FunctionContractClauses &Clauses) {
       // expressions. Parse each with ParseAssignmentExpression so the comma is
       // a tuple separator, not the C comma operator.
       do {
-        ExprResult E = finishCppVerifyExpression(ParseAssignmentExpression());
+        ExprResult E = ParseAssignmentExpression();
         if (E.isInvalid())
           break;
-        if (!E.get()->isTypeDependent() && !E.get()->getType()->isIntegerType())
-          Diag(E.get()->getExprLoc(), diag::err_contract_decreases_not_int);
-        else
+        E = finishCppVerifyExpression(Actions.ActOnContractMeasure(E));
+        if (E.isUsable())
           I.Decreases.push_back(E.get());
         if (Tok.is(tok::comma))
           ConsumeToken();
@@ -673,19 +672,8 @@ void Parser::attachFunctionContract(Decl *Result,
               I.MayDiverge.isInvalid() && I.Inductive.isInvalid() &&
               I.BehaviorChecks.empty() && !I.IsSpec && !I.IsProof))
     return;
-  // Templates are not verified yet: their clauses are ignored, as a member
-  // function's are.
-  if (FD->isTemplated() && !I.IsSpec && !I.IsProof) {
-    // A member of a class template is named by its class.
-    const auto *Method = dyn_cast<CXXMethodDecl>(FD);
-    if (Method && Method->getParent()->isTemplated())
-      Diag(FD->getLocation(), diag::warn_contract_template_unsupported)
-          << 1 << Method->getParent();
-    else
-      Diag(FD->getLocation(), diag::warn_contract_template_unsupported)
-          << 0 << FD;
-    return;
-  }
+  // A template's clauses are instantiated with each of its specializations,
+  // a class template's members' with the members.
   FunctionContractInfo &FCI = Ctx.getOrCreateFunctionContract(FD);
   if (FCI.ContractDecl && FCI.ContractDecl != FD) {
     Diag(FD->getLocation(), diag::err_contract_redeclaration);
@@ -835,17 +823,13 @@ void Parser::ParseLoopContractClauses(LoopContractInfo &Contract) {
       // Parse each component with ParseAssignmentExpression so the comma is a
       // tuple separator, not the C comma operator.
       while (true) {
-        ExprResult D = finishCppVerifyExpression(ParseAssignmentExpression());
+        ExprResult D = ParseAssignmentExpression();
+        if (D.isUsable())
+          D = finishCppVerifyExpression(Actions.ActOnContractMeasure(D));
         if (D.isInvalid()) {
           SkipUntil(tok::r_paren, StopAtSemi);
           return;
         }
-        if (!D.get()->isTypeDependent() &&
-            !D.get()->getType()->isIntegerType()) {
-          Diag(D.get()->getExprLoc(), diag::err_contract_decreases_not_int);
-          SkipUntil(tok::r_paren, StopAtSemi);
-          return;
-        }
         Contract.Decreases.push_back(D.get());
         if (Tok.isNot(tok::comma))
           break;
@@ -867,12 +851,6 @@ void Parser::attachLoopContract(StmtResult &Loop, LoopContractInfo &Contract) {
       (Contract.Invariants.empty() && Contract.Decreases.empty() &&
        Contract.MayDiverge.isInvalid() && Contract.Modifies.empty()))
     return;
-  if (const FunctionDecl *FD = Actions.getCurFunctionDecl();
-      FD && FD->isTemplated()) {
-    Diag(Loop.get()->getBeginLoc(), diag::warn_contract_template_unsupported)
-        << 0 << FD;
-    return;
-  }
   Actions.getASTContext().getOrCreateLoopContract(Loop.get()) =
       std::move(Contract);
 }
@@ -883,7 +861,6 @@ void Parser::ParseTypeInvariant(Decl *TagDecl) {
   auto *RD = dyn_cast_or_null<CXXRecordDecl>(TagDecl);
   if (auto *Template = dyn_cast_or_null<ClassTemplateDecl>(TagDecl))
     RD = Template->getTemplatedDecl();
-  const SourceLocation InvariantLoc = Tok.getLocation();
   ConsumeCppVerify();
   auto Finish = [&] {
     takePendingReferences(Actions.getASTContext(), RD,
@@ -919,10 +896,10 @@ void Parser::ParseTypeInvariant(Decl *TagDecl) {
     return Finish();
   }
   ConsumeParen();
-  if (!E.isInvalid() && RD->isDependentContext()) {
-    Diag(InvariantLoc, diag::warn_contract_template_unsupported) << 1 << RD;
-  } else if (!E.isInvalid()) {
-    E = Actions.ActOnTypeInvariantExpr(E, RD);
+  // With the class's `this` in scope, a field named bare is this->field. A
+  // class template's invariants are instantiated with each specialization.
+  if (!E.isInvalid()) {
+    E = Actions.ActOnContractCondition(E);
     if (!E.isInvalid())
       Actions.getASTContext().getOrCreateTypeContract(RD).Invariants.push_back(
           E.get());
@@ -1366,8 +1343,8 @@ ExprResult Parser::ParseQuantifierExpr() {
 
   // Create the bound variable and push it into scope for the body.
   VarDecl *BoundVar = VarDecl::Create(
-      Ctx, Actions.CurContext, BinderLoc, BinderLoc, BinderII, Ctx.IntTy,
-      Ctx.getTrivialTypeSourceInfo(Ctx.IntTy, BinderLoc), SC_None);
+      Ctx, Actions.getContractBinderContext(), BinderLoc, BinderLoc, BinderII,
+      Ctx.IntTy, Ctx.getTrivialTypeSourceInfo(Ctx.IntTy, BinderLoc), SC_None);
   ParseScope QuantifierScope(this, Scope::DeclScope);
   Actions.PushOnScopeChains(BoundVar, getCurScope(), /*AddToContext=*/false);
   ++QuantifierBodyDepth;
@@ -1379,40 +1356,19 @@ ExprResult Parser::ParseQuantifierExpr() {
     return ExprError();
   }
 
-  // Validate bound types: lo and hi must be integer.
-  for (const ExprResult &Bound : {Lo, Hi})
-    if (Bound.isUsable() && !Bound.get()->isTypeDependent() &&
-        !Bound.get()->getType()->isIntegerType()) {
-      Diag(Bound.get()->getExprLoc(),
-           diag::err_contract_quantifier_bound_not_int);
-      SkipUntil(tok::r_paren, StopAtSemi);
-      return ExprError();
-    }
-
-  // Validate body: must be contextually convertible to bool.
-  ExprResult BodyBool = Actions.ActOnContractCondition(Body);
-  if (BodyBool.isInvalid()) {
-    SkipUntil(tok::r_paren, StopAtSemi);
-    return ExprError();
-  }
-
   if (Tok.isNot(tok::r_paren)) {
     Diag(Tok, diag::err_contract_expected_rparen) << Keyword;
     SkipUntil(tok::r_paren, StopAtSemi);
     return ExprError();
   }
   SourceLocation RParenLoc = ConsumeParen();
 
-  Expr *LoE = Lo.isUsable() ? Lo.get() : nullptr;
-  Expr *HiE = Hi.isUsable() ? Hi.get() : nullptr;
-  if (IsChoose)
-    return new (Ctx) ContractChooseExpr(KwLoc, LParenLoc, RParenLoc, BoundVar,
-                                        LoE, HiE, BodyBool.get(), Ctx.IntTy);
-  if (IsForall)
-    return new (Ctx) ForallExpr(KwLoc, LParenLoc, RParenLoc, BoundVar, LoE, HiE,
-                                BodyBool.get(), Ctx.BoolTy);
-  return new (Ctx) ExistsExpr(KwLoc, LParenLoc, RParenLoc, BoundVar, LoE, HiE,
-                              BodyBool.get(), Ctx.BoolTy);
+  return Actions.BuildContractBinderExpr(
+      IsChoose   ? Stmt::ContractChooseExprClass
+      : IsForall ? Stmt::ForallExprClass
+                 : Stmt::ExistsExprClass,
+      KwLoc, LParenLoc, RParenLoc, BoundVar, Lo.isUsable() ? Lo.get() : nullptr,
+      Hi.isUsable() ? Hi.get() : nullptr, Body.get());
 }
 
 /// Parse cppverify::old(expr)

clang/lib/Sema/SemaContract.cpp

@@ -13,7 +13,6 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "TreeTransform.h"
 #include "clang/AST/ASTContext.h"
 #include "clang/AST/ASTLambda.h"
 #include "clang/AST/DeclCXX.h"
@@ -27,36 +26,6 @@ using namespace clang;
 
 namespace {
 
-class TypeInvariantFieldRewriter : public TreeTransform<TypeInvariantFieldRewriter> {
-  typedef TreeTransform<TypeInvariantFieldRewriter> Base;
-  CXXRecordDecl *Record;
-
-public:
-  TypeInvariantFieldRewriter(Sema &S, CXXRecordDecl *RD)
-      : Base(S), Record(RD) {}
-
-  ExprResult TransformDeclRefExpr(DeclRefExpr *E) {
-    if (FieldDecl *FD = dyn_cast<FieldDecl>(E->getDecl())) {
-      if (FD->getParent() == Record) {
-        SourceLocation Loc = E->getBeginLoc();
-        QualType ThisTy =
-            getSema().Context.getTypeDeclType(cast<TypeDecl>(Record));
-        ExprResult This =
-            getSema().BuildCXXThisExpr(Loc, ThisTy, /*IsImplicit=*/true);
-        if (This.isInvalid())
-          return ExprError();
-        DeclarationNameInfo NameInfo(FD->getDeclName(), Loc);
-        return getSema().BuildMemberExpr(
-            This.get(), /*IsArrow=*/false, Loc, NestedNameSpecifierLoc(),
-            SourceLocation(), FD, DeclAccessPair::make(FD, FD->getAccess()),
-            /*HadMultipleCandidates=*/false, NameInfo, FD->getType(),
-            VK_LValue, OK_Ordinary, /*TemplateArgs=*/nullptr);
-      }
-    }
-    return Base::TransformDeclRefExpr(E);
-  }
-};
-
 const FunctionContractInfo *contractOf(const ASTContext &Ctx,
                                        const FunctionDecl *FD) {
   for (const FunctionDecl *Redecl : FD->redecls())
@@ -309,12 +278,47 @@ ExprResult Sema::ActOnContractRange(Expr *Base, Expr *Lower,
                        OK_Ordinary, ColonLoc, RBLoc);
 }
 
-ExprResult Sema::ActOnTypeInvariantExpr(ExprResult E, CXXRecordDecl *Record) {
-  if (E.isInvalid() || !Record)
+ExprResult Sema::ActOnContractMeasure(ExprResult E) {
+  if (E.isInvalid() || E.get()->isTypeDependent() ||
+      E.get()->getType()->isIntegerType())
     return E;
-  TypeInvariantFieldRewriter Rewriter(*this, Record);
-  ExprResult Transformed = Rewriter.TransformExpr(E.get());
-  if (Transformed.isInvalid())
-    return Transformed;
-  return ActOnContractCondition(Transformed.get());
+  Diag(E.get()->getExprLoc(), diag::err_contract_decreases_not_int);
+  return ExprError();
+}
+
+DeclContext *Sema::getContractBinderContext() const {
+  DeclContext *DC = CurContext;
+  while (DC->isRecord())
+    DC = DC->getParent();
+  return DC;
+}
+
+ExprResult Sema::BuildContractBinderExpr(Stmt::StmtClass Kind,
+                                         SourceLocation KeywordLoc,
+                                         SourceLocation LParenLoc,
+                                         SourceLocation RParenLoc,
+                                         VarDecl *Binder, Expr *Lo, Expr *Hi,
+                                         Expr *Body) {
+  for (Expr *Bound : {Lo, Hi})
+    if (Bound && !Bound->isTypeDependent() &&
+        !Bound->getType()->isIntegerType()) {
+      Diag(Bound->getExprLoc(), diag::err_contract_quantifier_bound_not_int);
+      return ExprError();
+    }
+  ExprResult Condition = ActOnContractCondition(Body);
+  if (Condition.isInvalid())
+    return ExprError();
+  switch (Kind) {
+  case Stmt::ContractChooseExprClass:
+    return new (Context) ContractChooseExpr(KeywordLoc, LParenLoc, RParenLoc,
+                                            Binder, Lo, Hi, Condition.get(),
+                                            Binder->getType());
+  case Stmt::ForallExprClass:
+    return new (Context) ForallExpr(KeywordLoc, LParenLoc, RParenLoc, Binder,
+                                    Lo, Hi, Condition.get(), Context.BoolTy);
+  default:
+    assert(Kind == Stmt::ExistsExprClass && "not a quantifier or a choice");
+    return new (Context) ExistsExpr(KeywordLoc, LParenLoc, RParenLoc, Binder,
+                                    Lo, Hi, Condition.get(), Context.BoolTy);
+  }
 }

clang/lib/Sema/SemaExpr.cpp

@@ -19173,6 +19173,12 @@ void Sema::MarkFunctionReferenced(SourceLocation Loc, FunctionDecl *Func,
   if (FPT && isUnresolvedExceptionSpec(FPT->getExceptionSpecType()))
     ResolveExceptionSpec(Loc, FPT);
 
+  // A contract of a template specialization is needed where the
+  // specialization is used, as its callers rely on it, whether or not its
+  // definition is instantiated here.
+  if (OdrUse != OdrUseContext::None)
+    InstantiateFunctionContract(Loc, Func);
+
   // A callee could be called by a host function then by a device function.
   // If we only try recording once, we will miss recording the use on device
   // side. Therefore keep trying until it is recorded.