adding inhritance flags and implicit inheritance

Author: NinaRanns

gcc/c-family/c.opt

@@ -1968,6 +1968,26 @@ fcontracts-nonattr-definition-check=
 C++ Joined RejectNegative Enum(on_off) Var(flag_contracts_nonattr_definition_check) Init(1)
 -fcontracts-nonattr-definition-check=[on|off]	Enable or disable contract checks on the definition side for all functions (default on).
 
+Enum
+Name(contract_inheritance) Type(int)  UnknownError(unrecognized contract inheritance mode option %qs)
+
+EnumValue
+Enum(contract_inheritance) String(none) Value(0)
+
+EnumValue
+Enum(contract_inheritance) String(P2900R13) Value(1)
+
+EnumValue
+Enum(contract_inheritance) String(Ville) Value(2)
+
+fcontracts-nonattr-inheritance-mode=
+C++ Joined RejectNegative Enum(contract_inheritance) Var(flag_contract_nonattr_inheritance_mode) Init(1)
+-fcontracts-nonattr-inheritance-mode=[none|P2900R13|Ville] Select how contracts are inherited for virtual functions
+
+Wsuggest-explicit-contract
+C++ ObjC++ Var(suggest_explicit_contract) Warning
+Warn about functions with implicitly inherited contracts.
+
 fcoroutines
 C++ LTO Var(flag_coroutines)
 Enable C++ coroutines (experimental).

gcc/cp/class.cc

@@ -3202,6 +3202,8 @@ check_for_override (tree decl, tree ctype)
 	 function.  */
       DECL_VINDEX (decl) = decl;
 
+      check_override_contracts (decl);
+
       if (warn_override
 	  && !DECL_OVERRIDE_P (decl)
 	  && !DECL_FINAL_P (decl)

gcc/cp/contracts.cc

@@ -3065,17 +3065,17 @@ maybe_apply_function_contracts (tree fndecl)
   /* The DECL_SAVED_TREE stmt list will be popped by our caller.  */
 }
 
-/* Replace any contract attributes on SOURCE with a copy where any
-   references to SOURCE's PARM_DECLs have been rewritten to the corresponding
-   PARM_DECL in DEST.  If remap_result is true, result identifier is
-   also re-mapped. C++20 version used this function to remap contracts on
-   virtual functions from base class to derived class. In such a case
-   postcondition identified wasn't remapped. Caller side wrapper functions
-   need to remap the result identifier.
-   I remap_post is false, postconditions are dropped from the destination.  */
+/* Returns a copy of SOURCE contracts where any references to SOURCE's
+   PARM_DECLs have been rewritten to the corresponding PARM_DECL in DEST. If
+   remap_result is true, result identifier is also re-mapped.
+   C++20 version used this function to remap contracts on virtual functions
+   from base class to derived class. In such a case postcondition identifier
+   wasn't remapped. Caller side wrapper functions need to remap the result
+   identifier.
+   If remap_post is false, postconditions are dropped from the destination.  */
 
-void
-copy_and_remap_contracts (tree dest, tree source, bool remap_result = true,
+tree
+remap_contracts (tree dest, tree source, bool remap_result = true,
 			  bool remap_post = true )
 {
   tree last = NULL_TREE, contract_attrs = NULL_TREE;
@@ -3111,7 +3111,7 @@ copy_and_remap_contracts (tree dest, tree source, bool remap_result = true,
 	contract_attrs = c;
     }
 
-  set_decl_contracts (dest, contract_attrs);
+  return contract_attrs;
 }
 
 /* Finish up the pre & post function definitions for a guarded FNDECL,
@@ -3407,7 +3407,10 @@ should_contract_wrap_call (bool do_pre, bool do_post, bool is_virt)
 
   /* We always wrap virtual function calls, and non-virtual calls when
      client-side checking is enabled for all contracts.  */
-  if (is_virt || (flag_contract_nonattr_client_check > 1))
+  if ((is_virt
+       && (flag_contract_nonattr_inheritance_mode
+	   == CONTRACT_INHERITANCE_P2900R13))
+      || (flag_contract_nonattr_client_check > 1))
     return true;
 
   /* Otherwise, any function with pre-conditions when selected.  */
@@ -3482,11 +3485,16 @@ define_contract_wrapper_func (const tree& fndecl, const tree& wrapdecl, void*)
   /* We check postconditions on virtual function calls or if postcondition
      checks are enabled for all clients.  We should not get here unless there
      are some checks to make.  */
-  bool check_post = (flag_contract_nonattr_client_check > 1) || is_virtual;
+  bool check_post
+    = (flag_contract_nonattr_client_check > 1)
+      || (is_virtual
+	  && (flag_contract_nonattr_inheritance_mode
+	      == CONTRACT_INHERITANCE_P2900R13));
   /* For wrappers on CDTORs we need to refer to the original contracts,
      when the wrapper is around a clone.  */
-  copy_and_remap_contracts (wrapdecl, DECL_ORIGIN (fndecl),
-			    /*remap_result*/true, check_post);
+  set_decl_contracts( wrapdecl,
+		      remap_contracts (wrapdecl, DECL_ORIGIN (fndecl),
+				       /*remap_result*/true, check_post));
 
   start_preparsed_function (wrapdecl, /*DECL_ATTRIBUTES*/NULL_TREE,
 			    SF_DEFAULT | SF_PRE_PARSED);

gcc/cp/contracts.h

@@ -55,6 +55,15 @@ enum contract_semantic
   CCS_NOEXCEPT_OBSERVE
 };
 
+/* Contract inheritance model.  */
+
+enum contract_inheritance
+{
+  CONTRACT_INHERITANCE_NONE = 0,
+  CONTRACT_INHERITANCE_P2900R13 = 1,
+  CONTRACT_INHERITANCE_VILLE = 2,
+};
+
 /* True if the contract is unchecked.  */
 
 inline bool
@@ -340,7 +349,7 @@ extern tree finish_contract_attribute		(tree, tree);
 extern tree invalidate_contract			(tree);
 extern tree splice_out_contracts		(tree);
 extern bool all_attributes_are_contracts_p	(tree);
-extern void copy_and_remap_contracts		(tree, tree, bool, bool);
+extern tree remap_contracts  			(tree, tree, bool, bool);
 extern void start_function_contracts		(tree);
 extern void maybe_apply_function_contracts	(tree);
 extern void finish_function_contracts		(tree);

gcc/cp/cp-tree.h

@@ -7894,6 +7894,7 @@ extern tree lookup_member			(tree, tree, int, bool,
 extern tree lookup_member_fuzzy			(tree, tree, bool);
 extern tree locate_field_accessor		(tree, tree, bool);
 extern int look_for_overrides			(tree, tree);
+extern void check_override_contracts		(tree);
 extern void get_pure_virtuals			(tree);
 extern void maybe_suppress_debug_info		(tree);
 extern void note_debug_info_needed		(tree);

gcc/cp/search.cc

@@ -2193,10 +2193,11 @@ check_final_overrider (tree overrider, tree basefn)
       {
 	/* We're inheriting basefn's contracts; create a copy of them but
 	   replace references to their parms to our parms.  */
-	copy_and_remap_contracts (overrider,
-				  basefn,
-				  /* don't remap result */ false,
-				  /* remap post conditions */ true);
+	set_decl_contracts( overrider,
+			    remap_contracts (overrider,
+					     basefn,
+					     /* don't remap result */ false,
+					     /* remap post conditions */ true));
       }
     else if (DECL_HAS_CONTRACTS_P (basefn) && DECL_HAS_CONTRACTS_P (overrider))
       {
@@ -2209,7 +2210,6 @@ check_final_overrider (tree overrider, tree basefn)
 	defer_guarded_contract_match (overrider, basefn, DECL_CONTRACTS (basefn));
       }
   }
-
   if (DECL_FINAL_P (basefn))
     {
       auto_diagnostic_group d;
@@ -2221,6 +2221,63 @@ check_final_overrider (tree overrider, tree basefn)
   return 1;
 }
 
+/* Given a class TYPE, and a virtual function decl FNDECL, check the direct
+   base classes for contracts.
+  */
+
+void
+check_override_contracts (tree fndecl)
+{
+
+  if (!flag_contracts || !flag_contracts_nonattr
+      || flag_contract_nonattr_inheritance_mode != CONTRACT_INHERITANCE_VILLE )
+    return;
+
+  /* A constructor for a class T does not override a function T
+     in a base class.  */
+  if (DECL_CONSTRUCTOR_P (fndecl))
+    return;
+
+  bool explicit_contracts = DECL_HAS_CONTRACTS_P(fndecl);
+  tree binfo = TYPE_BINFO (DECL_CONTEXT (fndecl));
+  tree base_binfo;
+
+  for (int i = 0; BINFO_BASE_ITERATE (binfo, i, base_binfo); ++i)
+    {
+      tree basetype = BINFO_TYPE (base_binfo);
+
+      if (!TYPE_POLYMORPHIC_P (basetype))
+  	continue;
+
+      tree basefn = look_for_overrides_here (basetype, fndecl);
+      if (!basefn)
+	continue;
+
+      if (!explicit_contracts && DECL_HAS_CONTRACTS_P(basefn))
+	{
+	  /* We're inheriting basefn's contracts; create a copy of them but
+	   * replace references to their parms to our parms.  */
+	  tree base_contracts = remap_contracts (
+	      fndecl, basefn,
+	      /* don't remap result */false,
+	      /* remap post conditions */true);
+	  tree contracts = chainon (DECL_CONTRACTS (fndecl), base_contracts);
+
+	  set_decl_contracts(fndecl, contracts);
+
+	  if (suggest_explicit_contract)
+	    {
+	      warning_at (DECL_SOURCE_LOCATION(fndecl),
+			  suggest_explicit_contract,
+			  "Function implicitly inherits a contract");
+	      inform (DECL_SOURCE_LOCATION(basefn),
+		      "overridden function is %qD", basefn);
+	    }
+	}
+    }
+
+}
+
 /* Given a class TYPE, and a function decl FNDECL, look for
    virtual functions in TYPE's hierarchy which FNDECL overrides.
    We do not look in TYPE itself, only its bases.

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

@@ -0,0 +1,132 @@
+// test that contracts on overriding functions are found correctly
+// { dg-do run }
+// { dg-options "-std=c++2a -fcontracts -fcontract-continuation-mode=off -fcontracts-nonattr -fcontracts-nonattr-inheritance-mode=none " }
+#include <cassert>
+
+struct contract{
+  int checked = 0;
+};
+
+
+contract a,b,c;
+
+bool checkA(){
+    a.checked++;
+    return true;
+}
+
+bool checkB(){
+    b.checked++;
+    return true;
+}
+
+bool checkC(){
+    c.checked++;
+    return true;
+}
+
+void clear_checks(){
+  a.checked = b.checked = c.checked = 0;
+
+}
+
+struct Base
+{
+  virtual void f() pre (checkA()){};
+};
+
+
+struct Child0 : Base
+{
+  virtual void f() {};  //no contract
+};
+
+struct Child1 : Base
+{
+  virtual void f() pre (checkB()){};
+};
+
+
+struct GChild1 : Child0
+{
+  virtual void f() pre (checkC()){};
+};
+
+struct GChild2 : Child1
+{
+  virtual void f() {};
+};
+
+
+void fooBase(Base* b)
+{
+    b->f();
+}
+
+int main(int, char**)
+{
+  Base b0;
+  Child0 c0;
+  Child1 c1;
+  GChild1 g1;
+  GChild2 g2;
+
+
+  clear_checks();
+  fooBase(&b0);
+  assert(a.checked > 0);
+
+  clear_checks();
+  fooBase(&c0);
+  assert(a.checked == 0);
+
+  clear_checks();
+  fooBase(&c1);
+  assert(a.checked == 0);
+  assert(b.checked > 0);
+
+
+  clear_checks();
+  fooBase(&g1);
+  assert(a.checked == 0);
+  assert(b.checked == 0);
+  assert(c.checked > 0);
+
+
+  clear_checks();
+  fooBase(&g2);
+  assert(a.checked == 0);
+  assert(b.checked == 0);
+  assert(c.checked == 0);
+
+  clear_checks();
+  b0.f();
+  assert(a.checked > 0);
+
+  clear_checks();
+  c0.f();
+  assert(a.checked == 0);
+
+  clear_checks();
+  c1.f();
+  assert(a.checked == 0);
+  assert(b.checked > 0);
+
+
+  clear_checks();
+  g1.f();;
+  assert(a.checked == 0);
+  assert(b.checked == 0);
+  assert(c.checked > 0);
+
+
+  clear_checks();
+  g2.f();
+  assert(a.checked == 0);
+  assert(b.checked == 0);
+  assert(c.checked == 0);
+
+  return 0;
+}
+
+