get constification working for "this"

Author: EricWF

clang/include/clang/Basic/Builtins.td

@@ -2617,24 +2617,6 @@ 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 UnnamedConstant : Builtin {
-  let Spellings = ["__builtin_unnamed_constant"];
-  let Prototype = "void(...)";
-  let Attributes = [NoThrow, CustomTypeChecking, Constexpr];
-}
-
-def CurrentContractEvaluationSemantic : Builtin {
-  let Spellings = ["__builtin_contract_evaluation_semantic"];
-  let Prototype = "int()";
-  let Attributes = [NoThrow, Constexpr];
-}
 
 // C99 library functions
 // C99 stdarg.h

clang/include/clang/Basic/LangOptions.h

@@ -533,10 +533,6 @@ class LangOptions : public LangOptionsBase {
   /// A prefix map for __FILE__, __BASE_FILE__ and __builtin_FILE().
   std::map<std::string, std::string, std::greater<std::string>> MacroPrefixMap;
 
-  /// A map from a "contract group" or "contract subgroup" to the value
-  /// indicating whether the group is enabled or disabled from the command line.
-  std::unordered_map<std::string, bool> EnabledContractGroups;
-
   /// Triples of the OpenMP targets that the host code codegen should
   /// take into account in order to generate accurate offloading descriptors.
   std::vector<llvm::Triple> OMPTargetTriples;

clang/include/clang/Driver/Options.td

@@ -1681,7 +1681,7 @@ def fcontract_evaluation_semantic_EQ : Joined<["-"], "fcontract-evaluation-seman
   Visibility<[ClangOption, CC1Option]>,
   NormalizedValuesScope<"LangOptions::ContractEvaluationSemantic">,
   NormalizedValues<["Ignore", "Enforce", "Observe", "QuickEnforce"]>,
-  MarshallingInfoEnum<LangOpts<"ContractEvalSemantic">, "Enforce">;
+  MarshallingInfoEnum<LangOpts<"ContractOptions.DefaultSemantic">, "Enforce">;
 
 def fcontract_group_evaluation_semantic_EQ : CommaJoined<["-"], "fcontract-group-evaluation-semantic=">,
   Visibility<[ClangOption, CC1Option]>,

clang/include/clang/Sema/Sema.h

@@ -2741,7 +2741,16 @@ class Sema final : public SemaBase {
   StmtResult BuildContractStmt(ContractKind CK, SourceLocation KeywordLoc,
                                Expr *Cond, DeclStmt *ResultNameDecl,
                                ArrayRef<const Attr *> Attrs);
+  struct ContractScopeRAII {
+    ContractScopeRAII(Sema &S);
+    ~ContractScopeRAII();
 
+    ContractScopeRAII(ContractScopeRAII const &) = delete;
+
+    Sema *S;
+    QualType OldCXXThisType;
+    bool OldIsContractScope;
+  };
   ///@}
 
   //
@@ -6369,7 +6378,6 @@ class Sema final : public SemaBase {
       EK_Decltype,
       EK_TemplateArgument,
       EK_BoundsAttrArgument,
-      EK_ContractStmt,
       EK_Other
     } ExprContext;
 
@@ -6459,10 +6467,7 @@ class Sema final : public SemaBase {
               InDiscardedStatement);
     }
 
-    bool isContractStatementContext() const {
-
-      return InContractStatement || ExprContext == EK_ContractStmt;
-    }
+    bool isContractStatementContext() const { return InContractStatement; }
   };
 
   const ExpressionEvaluationContextRecord &currentEvaluationContext() const {
@@ -6494,10 +6499,7 @@ class Sema final : public SemaBase {
   }
 
   bool isContractStmtContext() const {
-    return ExprEvalContexts.back().ExprContext ==
-               ExpressionEvaluationContextRecord::ExpressionKind::
-                   EK_ContractStmt ||
-           ExprEvalContexts.back().InContractStatement;
+    return ExprEvalContexts.back().InContractStatement;
   }
 
   /// Increment when we find a reference; decrement when we find an ignored

clang/lib/Parse/ParseDeclCXX.cpp

@@ -4421,13 +4421,6 @@ StmtResult Parser::ParseFunctionContractSpecifier(Declarator &DeclaratorInfo) {
   ParsedAttributes CXX11Attrs(AttrFactory);
   MaybeParseCXX11Attributes(CXX11Attrs);
 
-  using ExpressionKind =
-      Sema::ExpressionEvaluationContextRecord::ExpressionKind;
-  EnterExpressionEvaluationContext EC(
-      Actions, Sema::ExpressionEvaluationContext::PotentiallyEvaluated, nullptr,
-      ExpressionKind::EK_ContractStmt);
-  Actions.currentEvaluationContext().InContractStatement = true;
-
   if (Tok.isNot(tok::l_paren)) {
     Diag(Tok, diag::err_expected_lparen_after) << CKStr;
     SkipUntil({tok::equal, tok::l_brace, tok::arrow, tok::kw_try, tok::comma,
@@ -4449,8 +4442,12 @@ StmtResult Parser::ParseFunctionContractSpecifier(Declarator &DeclaratorInfo) {
                                   Scope::FunctionPrototypeScope |
                                   Scope::ContractAssertScope);
 
+  EnterExpressionEvaluationContext EC(
+      Actions, Sema::ExpressionEvaluationContext::PotentiallyEvaluated);
+
   std::optional<Sema::CXXThisScopeRAII> ThisScope;
   InitCXXThisScopeForDeclaratorIfRelevant(DeclaratorInfo, DeclaratorInfo.getDeclSpec(), ThisScope);
+  Sema::ContractScopeRAII ContractExpressionScope(Actions);
 
   DeclaratorChunk::FunctionTypeInfo FTI = DeclaratorInfo.getFunctionTypeInfo();
 

clang/lib/Parse/ParseStmt.cpp

@@ -2440,13 +2440,7 @@ StmtResult Parser::ParseContractAssertStatement() {
   SourceLocation KeywordLoc = ConsumeToken(); // eat the 'contract_assert'.
 
   // Adjust the scope for the purposes of constification.
-  EnterContractAssertScopeRAII EnterCAS(getCurScope());
-  using ExpressionKind =
-      Sema::ExpressionEvaluationContextRecord::ExpressionKind;
-  EnterExpressionEvaluationContext EC(
-      Actions, Sema::ExpressionEvaluationContext::PotentiallyEvaluated, nullptr,
-      ExpressionKind::EK_ContractStmt);
-  Actions.currentEvaluationContext().InContractStatement = true;
+  Sema::ContractScopeRAII ContractScope(Actions);
 
   ParsedAttributes CXX11Attrs(AttrFactory);
   MaybeParseCXX11Attributes(CXX11Attrs);

clang/lib/Sema/SemaContract.cpp

@@ -201,3 +201,17 @@ StmtResult Sema::ActOnResultNameDeclarator(Scope *S, Declarator &FuncDecl,
 
   return ActOnDeclStmt(ConvertDeclToDeclGroup(New), IDLoc, IDLoc);
 }
+
+Sema::ContractScopeRAII::ContractScopeRAII(Sema &SemaRef)
+    : S(&SemaRef), OldCXXThisType(SemaRef.CXXThisTypeOverride),
+      OldIsContractScope(SemaRef.ExprEvalContexts.back().InContractStatement) {
+  QualType NewT = S->CXXThisTypeOverride;
+
+  S->CXXThisTypeOverride = NewT;
+  S->ExprEvalContexts.back().InContractStatement = true;
+}
+
+Sema::ContractScopeRAII::~ContractScopeRAII() {
+  S->CXXThisTypeOverride = OldCXXThisType;
+  S->ExprEvalContexts.back().InContractStatement = OldIsContractScope;
+}

clang/lib/Sema/SemaExprCXX.cpp

@@ -1112,6 +1112,18 @@ bool Sema::CheckCXXThrowOperand(SourceLocation ThrowLoc,
   return false;
 }
 
+static QualType adjustCVQualifiersForCXXThisWithinContract(QualType ThisTy,
+                                                           ASTContext &ASTCtx) {
+  QualType ClassType = ThisTy->getPointeeType();
+  if (not ClassType.isConstQualified()) {
+    // If the 'this' object is const-qualified, we need to remove the
+    // const-qualification for the contract check.
+    ClassType.addConst();
+    return ASTCtx.getPointerType(ClassType);
+  }
+  return ThisTy;
+}
+
 static QualType adjustCVQualifiersForCXXThisWithinLambda(
     ArrayRef<FunctionScopeInfo *> FunctionScopes, QualType ThisTy,
     DeclContext *CurSemaContext, ASTContext &ASTCtx) {
@@ -1247,6 +1259,9 @@ QualType Sema::getCurrentThisType() {
   if (!ThisTy.isNull() && isLambdaCallOperator(CurContext))
     return adjustCVQualifiersForCXXThisWithinLambda(FunctionScopes, ThisTy,
                                                     CurContext, Context);
+  if (!ThisTy.isNull() && currentEvaluationContext().InContractStatement) {
+    return adjustCVQualifiersForCXXThisWithinContract(ThisTy, Context);
+  }
   return ThisTy;
 }
 

clang/lib/Sema/TreeTransform.h

@@ -1609,11 +1609,7 @@ class TreeTransform {
   StmtResult RebuildContractStmt(ContractKind K, SourceLocation KeywordLoc,
                                  Expr *Cond, DeclStmt *ResultName,
                                  ArrayRef<const Attr *> Attrs) {
-    const bool LastVal =
-        getSema().currentEvaluationContext().InContractStatement;
-    getSema().currentEvaluationContext().InContractStatement = true;
     return getSema().BuildContractStmt(K, KeywordLoc, Cond, ResultName, Attrs);
-    getSema().currentEvaluationContext().InContractStatement = LastVal;
   }
 
   /// Build a new Objective-C \@try statement.
@@ -8589,21 +8585,10 @@ TreeTransform<Derived>::TransformCoyieldExpr(CoyieldExpr *E) {
 
 // C++ Contract Statements
 
-struct ValueGuard {
-  ValueGuard(bool *Value, bool NewValue) : Value(Value), OldVal(*Value) {
-    *Value = NewValue;
-  }
-  ~ValueGuard() { *Value = OldVal; }
-
-  bool *Value;
-  bool OldVal;
-};
-
 template <typename Derived>
 StmtResult TreeTransform<Derived>::TransformContractStmt(ContractStmt *S) {
 
-  ValueGuard InContractGuard(
-      &SemaRef.currentEvaluationContext().InContractStatement, true);
+  Sema::ContractScopeRAII ContractScope(getSema());
 
   StmtResult NewResultName;
   if (S->hasResultNameDecl()) {

clang/test/SemaCXX/ericwf.cpp

@@ -3,6 +3,31 @@
 
 void foo(int x) {
   int y = x;
-  contract_assert(++y);
+  contract_assert(++y); // expected-error {{read-only variable is not assignable}}
+  contract_assert(y++); // expected-error {{read-only variable is not assignable}}
   ++y;
 }
+
+
+template <class T>
+void bar(T v) {
+  contract_assert(v);
+  contract_assert(v++); // expected-error {{read-only variable is not assignable}}
+  contract_assert(++v); // expected-error {{read-only variable is not assignable}}
+}
+
+template void bar<int>(int); // expected-note {{requested here}}
+
+int g = 42;
+
+struct A {
+  void a(int x) {
+    contract_assert(b()); // expected-error {{this' argument to member function 'b' has type 'const A', but function is not marked const}}
+    contract_assert(z++); // expected-error {{read-only variable is not assignable}}
+    contract_assert(++g); // OK
+    contract_assert(const_cast<decltype(this)>(this)->b()); // OK
+  }
+
+  int b() {} // expected-note {{declared here}}
+  int z;
+};