Merge pull request gcc-mirror#92 from NinaRanns/contracts_virtual_function2

Contracts virtual function2

Author: villevoutilainen

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(P3653) Value(2)
+
+fcontracts-nonattr-inheritance-mode=
+C++ Joined RejectNegative Enum(contract_inheritance) Var(flag_contract_nonattr_inheritance_mode) Init(0)
+-fcontracts-nonattr-inheritance-mode=[none|P2900R13|P3653] 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)
@@ -3223,6 +3225,15 @@ check_for_override (tree decl, tree ctype)
 
       if (DECL_DESTRUCTOR_P (decl))
 	TYPE_HAS_NONTRIVIAL_DESTRUCTOR (ctype) = true;
+
+      if (DECL_HAS_CONTRACTS_P(decl)
+	  && flag_contracts_nonattr
+	  && flag_contract_nonattr_inheritance_mode
+	      == CONTRACT_INHERITANCE_NONE)
+	{
+	  error_at (DECL_SOURCE_LOCATION(decl),
+		    "Contracts can not be added to virtual functions.");
+	}
     }
   else if (DECL_FINAL_P (decl))
     error ("%q+#D marked %<final%>, but is not virtual", decl);

gcc/cp/contracts.cc

@@ -1080,12 +1080,14 @@ remap_contract (tree src, tree dst, tree contract, bool duplicate_p)
   bool do_remap = false;
 
   /* Insert parameter remappings.  */
-  if (TREE_CODE (src) == FUNCTION_DECL)
-    src = DECL_ARGUMENTS (src);
-  if (TREE_CODE (dst) == FUNCTION_DECL)
-    dst = DECL_ARGUMENTS (dst);
+  gcc_assert(TREE_CODE (src) == FUNCTION_DECL);
+  gcc_assert(TREE_CODE (dst) == FUNCTION_DECL);
 
-  for (tree sp = src, dp = dst;
+  int src_num_artificial_args = num_artificial_parms_for (src);
+  int dst_num_artificial_args = num_artificial_parms_for (dst);
+
+
+  for (tree sp = DECL_ARGUMENTS (src), dp = DECL_ARGUMENTS (dst);
        sp || dp;
        sp = DECL_CHAIN (sp), dp = DECL_CHAIN (dp))
     {
@@ -1109,6 +1111,20 @@ remap_contract (tree src, tree dst, tree contract, bool duplicate_p)
 
       insert_decl_map (&id, sp, dp);
       do_remap = true;
+
+      /* First artificial arg is *this. We want to remap that. However, we
+	 want to skip _in_charge param and __vtt_parm. Do so now.  */
+      if (src_num_artificial_args > 0)
+	{
+	  while (--src_num_artificial_args,src_num_artificial_args > 0)
+	    sp = DECL_CHAIN (sp);
+	}
+      if (dst_num_artificial_args > 0)
+	{
+	  while (--dst_num_artificial_args,dst_num_artificial_args > 0)
+	    dp = DECL_CHAIN (dp);
+	}
+
     }
   if (!do_remap)
     return;
@@ -3065,17 +3081,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 +3127,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 +3423,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 +3501,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_P3653 = 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,
+					     /*remap_result*/ false,
+					     /*remap_post*/ 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,62 @@ 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_P3653)
+    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/virtualSMF-noexcept-pre.C renamed to gcc/testsuite/g++.dg/contracts/cpp26/P2900R13-virtual-func/contract_specifier_seq.C

@@ -2,7 +2,7 @@
 // behaves as if the function exited via an exception.
 // This tests the behaviour of a pre condition on a destructor
 // { dg-do run }
-// { dg-options "-std=c++2a -fcontracts -fcontracts-nonattr -fcontract-evaluation-semantic=observe " }
+// { dg-options "-std=c++2a -fcontracts -fcontracts-nonattr -fcontract-evaluation-semantic=observe -fcontracts-nonattr-inheritance-mode=P2900R13" }
 
 #include <experimental/contract>
 #include <exception>

gcc/testsuite/g++.dg/contracts/cpp26/contracts-multiple-inheritance2.C renamed to gcc/testsuite/g++.dg/contracts/cpp26/P2900R13-virtual-func/contracts-multiple-inheritance2.C

@@ -1,5 +1,5 @@
 // { dg-do compile }
-// { dg-options "-std=c++2a -fcontracts -fcontract-continuation-mode=on -fcontracts-nonattr" }
+// { dg-options "-std=c++2a -fcontracts -fcontract-continuation-mode=on -fcontracts-nonattr -fcontracts-nonattr-inheritance-mode=P2900R13" }
 
 struct BaseA {
   virtual int fun(int n) pre ( n > 0 ) { return -n; }

gcc/testsuite/g++.dg/contracts/cpp26/contracts-pre4.C renamed to gcc/testsuite/g++.dg/contracts/cpp26/P2900R13-virtual-func/contracts-pre4.C

@@ -1,6 +1,6 @@
 // test that contracts on overriding functions are found correctly
 // { dg-do run }
-// { dg-options "-std=c++2a -fcontracts -fcontract-continuation-mode=on -fcontracts-nonattr" }
+// { dg-options "-std=c++2a -fcontracts -fcontract-continuation-mode=on -fcontracts-nonattr -fcontracts-nonattr-inheritance-mode=P2900R13" }
 
 struct Base
 {

gcc/testsuite/g++.dg/contracts/cpp26/P2900R13-virtual-func/contracts-redecl.C

@@ -0,0 +1,44 @@
+// generic error tests for generalized contract redecls
+// { dg-do compile }
+// { dg-options "-std=c++2a -fcontracts -fcontracts-nonattr -fcontracts-nonattr-inheritance-mode=P2900R13" }
+
+
+struct Base
+{
+  virtual int f(int a) pre (a > 0);
+};
+
+struct Child : Base
+{
+  int f(int a) pre (a < 0); // ok, does not inherit contracts
+};
+
+struct F1
+{
+  virtual int f(int a);
+};
+
+int F1::f(int a) pre (a > 0) // { dg-error "declaration adds contracts" }
+{
+  return -a;
+}
+
+struct Foo {
+  virtual void f10 (int)  pre ( false ) {}
+};
+
+struct Bar : Foo {
+  void f10 (int n = 0) override pre ( false );
+};
+
+// we currently don't diagnose an error here if the original contract was erroneous.
+void Bar::f10(int n) pre (n >10) {}; // { dg-error "mismatched contract" }
+
+template <typename T>
+struct Base2
+{
+  virtual int f(const int a) pre( a  > 5 ) post( a > 7) { return a;};
+  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" }
+  int i(int a) pre( a  > 5 ) post( a > 7) { return a;}; // { dg-error "a value parameter used in a postcondition must be const" }
+};