fixing detection of non cont parameters in redeclarations. Diagnostic messages are minimum effort and can be improved

Author: NinaRanns

gcc/cp/contracts.cc

@@ -2782,30 +2782,58 @@ constify_contract_access(tree decl)
   return decl;
 }
 
-/* Do not allow non-const by-value params being used in postconditions.  */
+/* If declaration DECL is a PARM_DECL and it appears in a postcondition, then
+   check that it is not a non-const by-value param. LOCATION is where the
+   expression was found and is used for diagnostic purposes.  */
 
-bool
-maybe_reject_param_in_postcondition (tree decl)
+void
+maybe_reject_param_in_postcondition (tree decl, location_t location)
 {
   if (flag_contracts_nonattr
-      && !TREE_READONLY (decl)
       && TREE_CODE (decl) == PARM_DECL
       && should_constify_contract
       && processing_postcondition
-      && !dependent_type_p (TREE_TYPE (decl))
-      && !CP_TYPE_CONST_P (TREE_TYPE (decl))
       && !(REFERENCE_REF_P (decl)
 	   && TREE_CODE (TREE_OPERAND (decl, 0)) == PARM_DECL)
 	   /* Return value parameter has DECL_ARTIFICIAL flag set. The flag
 	    * presence of the flag should be sufficient to distinguish the
 	    * return value parameter in this context. */
 	   && !(DECL_ARTIFICIAL (decl)))
     {
-      error_at (DECL_SOURCE_LOCATION (decl),
-		"a value parameter used in a postcondition must be const");
-      return true;
+      set_parm_used_in_post (decl);
+
+      if (!CP_TYPE_CONST_P(TREE_TYPE (decl)) && !TREE_READONLY(decl))
+	{
+	  error_at (location,
+		    "a value parameter used in a postcondition must be const");
+	  inform (DECL_SOURCE_LOCATION(decl), "parameter declared here");
+	}
+    }
+}
+
+/* Check if parameters used in postconditions are const qualified on
+   a redeclaration that does not specify contracts.  */
+
+void
+check_param_in_redecl (tree olddecl, tree newdecl)
+{
+  tree t1 = FUNCTION_FIRST_USER_PARM(olddecl);
+  tree t2 = FUNCTION_FIRST_USER_PARM(newdecl);
+  for (; t1 && t1 != void_list_node;
+  t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2))
+    {
+      if (parm_used_in_post_p(t1))
+	{
+	  set_parm_used_in_post (t2);
+	  if (!CP_TYPE_CONST_P(TREE_TYPE (t2)) && !TREE_READONLY(t2))
+	    {
+	      error_at (DECL_SOURCE_LOCATION(t2),
+	      "value parameter %qE used in a postcondition must be const", t2);
+	      inform (DECL_SOURCE_LOCATION(olddecl),
+	      "previous declaration here");
+	    }
+	}
     }
-  return false;
 }
 
 void
@@ -3277,8 +3305,9 @@ p2900_duplicate_contracts (tree newdecl, tree olddecl)
 
   if (old_contracts && !new_contracts)
     /* We allow re-declarations to omit contracts declared on the initial decl.
-       In fact, this is required if the conditions contain lambdas.  */
-    ;
+       In fact, this is required if the conditions contain lambdas.  Check if
+       all the parameters are correctly const qualified. */
+    check_param_in_redecl (olddecl, newdecl);
   else if (contract_any_deferred_p (new_contracts))
     /* TODO: stash these and figure out how to process them later.  */
     ;

gcc/cp/cp-tree.h

@@ -8943,8 +8943,8 @@ extern tree grok_contract			(tree, tree, tree, cp_expr, location_t);
 extern tree finish_contract_condition		(cp_expr);
 extern void update_late_contract		(tree, tree, cp_expr);
 extern tree constify_contract_access            (tree);
-extern bool maybe_reject_param_in_postcondition (tree);
-
+extern void maybe_reject_param_in_postcondition (tree, location_t);
+extern void check_param_in_redecl 		(tree, tree);
 extern tree view_as_const                       (tree);
 extern tree maybe_contract_wrap_call	        (tree, tree);
 extern bool emit_contract_wrapper_func          (bool);
@@ -9025,6 +9025,24 @@ strip_contract_const_wrapper (tree exp)
     return exp;
 }
 
+/* Indicate if PARM_DECL DECL is ODR used in a postcondition.  */
+
+inline void
+set_parm_used_in_post (tree decl, bool constify = true)
+{
+  gcc_checking_assert (TREE_CODE (decl) == PARM_DECL);
+  decl->base.public_flag = constify;
+}
+
+/* Test if PARM_DECL is ODR used in a postcondition.  */
+
+inline bool
+parm_used_in_post_p (const_tree decl)
+{
+  /* Check if this parameter is odr used within a function's postcondition  */
+  return ((TREE_CODE (decl) == PARM_DECL) && decl->base.public_flag);
+}
+
 /* Inline bodies.  */
 
 inline tree

gcc/cp/decl.cc

@@ -2273,6 +2273,7 @@ duplicate_decls (tree newdecl, tree olddecl, bool hiding, bool was_hidden)
 		 declaration of the function or function template in the
 		 translation unit."  */
 	      check_no_redeclaration_friend_default_args (olddecl, newdecl);
+
 	    }
 	}
     }

gcc/cp/pt.cc

@@ -22373,7 +22373,7 @@ tsubst_expr (tree t, tree args, tsubst_flags_t complain, tree in_decl)
 	  /* force_paren_expr can also create a VIEW_CONVERT_EXPR.  */
 	  RETURN (finish_parenthesized_expr (op));
 
-	maybe_reject_param_in_postcondition (op);
+	maybe_reject_param_in_postcondition (op, EXPR_LOCATION (t));
 
 	if (flag_contracts_nonattr && should_constify_contract
 	    && processing_contract_condition)

gcc/cp/search.cc

@@ -2273,6 +2273,8 @@ check_override_contracts (tree fndecl)
 	      inform (DECL_SOURCE_LOCATION (basefn),
 		      "overridden function is %qD", basefn);
 	    }
+
+	  check_param_in_redecl (basefn, fndecl);
 	}
     }
 }

gcc/cp/semantics.cc

@@ -5019,7 +5019,7 @@ finish_id_expression_1 (tree id_expression,
 	}
     }
 
-  maybe_reject_param_in_postcondition (decl);
+  maybe_reject_param_in_postcondition (decl, location);
   if (flag_contracts_nonattr && should_constify_contract
 	&& processing_contract_condition)
     decl = constify_contract_access(decl);

gcc/testsuite/g++.dg/contracts/cpp26/P3653-virtual-func/postcondition-const-check.C

@@ -0,0 +1,139 @@
+// { dg-do compile }
+// { dg-options "-std=c++23 -fcontracts -fcontracts-nonattr -fcontracts-nonattr-inheritance-mode=P3653 " }
+
+struct NTClass {
+  //TODO, make non trivial when https://github.com/NinaRanns/gcc/issues/21 is solved
+//  NTClass(){};
+//  ~NTClass(){};
+};
+
+template <typename... ARGS>
+bool check(ARGS... args){ return true;}
+
+
+struct Base
+{
+  virtual void f (const NTClass i)  post (check (i));
+  virtual void f (const int i)  post (check (i));
+
+
+}  ;
+
+struct Derived : Base
+{
+  void f (NTClass i); // { dg-error "used in a postcondition must be const" }
+};
+
+struct DerivedV : virtual Base
+{
+  void f (NTClass i); // { dg-error "used in a postcondition must be const" }
+};
+
+template<typename T>
+struct DerivedT : Base
+{
+  void f (NTClass i) {};
+
+  void f (T i) {};
+};
+
+template<typename T>
+  struct DerivedTV : virtual Base
+  {
+    void f (NTClass i) {};
+
+    void f (T i) {};
+  };
+
+template<typename T>
+struct BaseT
+{
+  virtual void f (const NTClass i) post (check (i));
+
+  virtual void f (const T i) post (check (i));
+};
+
+template<typename T>
+struct DerivedTT : BaseT<T>
+{
+  void f (NTClass i) {};
+
+  void f (T i) {};
+};
+
+template <typename T>
+struct DerivedTVT : virtual BaseT<T>
+{
+  void f (NTClass i) {};
+
+  void f (T i) {};
+};
+
+// adding DerivedT2 for diagnostic disambiguation purposes
+template<typename T>
+struct DerivedT2 : Base
+{
+  void f (NTClass i) {};
+
+  void f (T i) {};
+};
+
+// adding DerivedTV2 for diagnostic disambiguation purposes
+template<typename T>
+struct DerivedTV2 : virtual Base
+{
+  void f (NTClass i) {};
+
+  void f (T i) {};
+};
+
+template<typename T>
+struct DerivedTT2 : BaseT<T>
+{
+  void f (NTClass i) {};
+
+  void f (int i) {};
+};
+
+template <typename T>
+struct DerivedTVT2 : virtual BaseT<T>
+{
+  void f (NTClass i) {};
+
+  void f (int i) {};
+};
+
+
+int main()
+{
+  DerivedT<int>  dt;
+  // { dg-error {used in a postcondition must be const} "" { target *-*-* } 35 }
+  // { dg-error {used in a postcondition must be const} "" { target *-*-* } 37 }
+
+  DerivedTV<int>  dvt;
+  // { dg-error {used in a postcondition must be const} "" { target *-*-* } 43 }
+  // { dg-error {used in a postcondition must be const} "" { target *-*-* } 45 }
+
+
+  DerivedTT<int>  dt2;
+  // { dg-error {used in a postcondition must be const} "" { target *-*-* } 59 }
+  // { dg-error {used in a postcondition must be const} "" { target *-*-* } 61 }
+
+  DerivedTVT<int>  dvt2;
+  // { dg-error {used in a postcondition must be const} "" { target *-*-* } 67 }
+  // { dg-error {used in a postcondition must be const} "" { target *-*-* } 69 }
+
+
+  DerivedT2<char>  dtc;
+  // { dg-error {used in a postcondition must be const} "" { target *-*-* } 76 }
+
+  DerivedTV2<char>  dvtc;
+  // { dg-error {used in a postcondition must be const} "" { target *-*-* } 85 }
+
+  DerivedTT2<char>  dtc2;
+  // { dg-error {used in a postcondition must be const} "" { target *-*-* } 93 }
+
+  DerivedTVT2<char>  dvtc2;
+  // { dg-error {used in a postcondition must be const} "" { target *-*-* } 101 }
+
+}

gcc/testsuite/g++.dg/contracts/cpp26/contracts1.C

@@ -45,54 +45,3 @@ struct Baz
   void i(const int x) post(x, x); // { dg-error "expected conditional-expression" }
 };
 
-void postcond(int x) post(x >= 0); // { dg-error "a value parameter used in a postcondition must be const" }
-
-struct PostCond {
-  void postcond(int x) post(x >= 0); // { dg-error "a value parameter used in a postcondition must be const" }
-  template<class T> void postcond2(T x) post(x >= 0);
-};
-
-template <class T> void
-postcond3(T x) post(x >= 0);
-
-void postcond4(const int y, int x) post(x >= 0); // { dg-error "a value parameter used in a postcondition must be const" }
-
-void postcond5(int y, const int x) post(x >= 0);
-
-template <typename T>
-struct Base
-{
-  virtual int f(const int a) pre( a  > 5 ) post( a > 7) { return a;}; // { dg-error "Contracts can not be added to virtual functions" }
-  int g(const int a) pre( a  > 5 ) post( a > 7) { return a;};
-  virtual int h(int a) pre( a  > 5 ) post( a > 7) { return a;}; // { dg-error "a value parameter used in a postcondition must be const" }
-  // { dg-error {Contracts can not be added to virtual functions} "" { target *-*-* } .-1 }
-  int i(int a) pre( a  > 5 ) post( a > 7) { return a;}; // { dg-error "a value parameter used in a postcondition must be const" }
-};
-
-
-void postcond6()
-{
-  Base<int> b;
-  b.f(6);
-  b.g(6);
-  b.h(6);
-  b.i(6);
-}
-		  
-template<class T>
-void
-PostCond::postcond2(T x) post (x >= 0)  // { dg-error "a value parameter used in a postcondition must be const" }
-{ x; }
-
-template <class T>
-void
-postcond3(T x) post(x >= 0)
-{ } 
-
-void postcond7()
-{
-  PostCond p;
-  p.postcond2 (2);
-  postcond3 (4); // { dg-error "a value parameter used in a postcondition must be const" "" {target *-*-* } 56 }
-
-}