inherited in class, early draft

Author: NinaRanns

gcc/cp/parser.cc

@@ -31749,50 +31749,62 @@ void cp_parser_late_contract_condition (cp_parser *parser,
 
 /* Parse a base in inherited contract list */
 
-tree cp_parser_inherited_contract_base (cp_parser *parser,
-					tree fndecl,
-					tree_code code)
+tree
+cp_parser_inherited_contract_base (cp_parser *parser, tree fndecl,
+				   tree_code code)
 {
   tree base_contracts = NULL_TREE;
-  tree basedecl = cp_parser_class_name (parser,
-					/*typename_keyword_p=*/true,
-					/*template_keyword_p=*/false, none_type,
-					/*check_dependency_p=*/false,
-					/*class_head_p=*/false,
-					/*is_declaration=*/false);
+  tree in_decl = cp_parser_class_name (parser,
+				       /*typename_keyword_p=*/true,
+				       /*template_keyword_p=*/false, none_type,
+				       /*check_dependency_p=*/false,
+				       /*class_head_p=*/false,
+				       /*is_declaration=*/false);
 
-  if (basedecl == error_mark_node)
-      return NULL_TREE;
+  if (in_decl == error_mark_node)
+  return NULL_TREE;
 
-  tree basetype = TYPE_CANONICAL(TREE_TYPE (basedecl));
-  if (basetype == error_mark_node)
+  tree in_type = TYPE_CANONICAL(TREE_TYPE (in_decl));
+  tree base_type = NULL_TREE;
+  tree binfo = TYPE_BINFO (DECL_CONTEXT (fndecl));
+  tree base_binfo;
+  for (int i = 0; BINFO_BASE_ITERATE (binfo, i, base_binfo); ++i)
     {
-      error_at (DECL_SOURCE_LOCATION(fndecl), "contracts"
-	  " can only be inherited from a baseclass ");
-      return NULL_TREE;
+      if (same_type_p (in_type, TYPE_CANONICAL (BINFO_TYPE (base_binfo))))
+	{
+	  base_type = BINFO_TYPE (base_binfo);
+	  break;
+	}
     }
 
-  tree basefn = look_for_overrides_here (basetype, fndecl);
-  if (!basefn)
-    {
-      error_at (DECL_SOURCE_LOCATION(fndecl), "function does not "
-		" override a function in %qT ",
-		basetype);
-      return NULL_TREE;
-    }
+  if (!base_type)
+  {
+    error_at (DECL_SOURCE_LOCATION(fndecl), "contracts"
+	      " can only be inherited from a direct base class ");
+    return NULL_TREE ;
+  }
 
-  if (DECL_HAS_CONTRACTS_P(basefn))
-    {
-      contract_match_kind remap_kind = cmk_pre;
-      if (code == POSTCONDITION_STMT)
-	remap_kind = cmk_post;
-      /* We're inheriting basefn's contracts; create a copy of them but
-       * replace references to their parms to our parms.  */
+  tree base_fn = look_for_overrides_here (base_type, fndecl);
+  if (!base_fn)
+  {
+    error_at (DECL_SOURCE_LOCATION (fndecl), "function does not "
+	      "override a function in %qT ",
+	      base_type);
+    return NULL_TREE ;
+  }
 
-      base_contracts = copy_and_remap_contracts (fndecl, basefn,
-						 /* remap_result */false,
-						 remap_kind);
-    }
+  if (DECL_HAS_CONTRACTS_P(base_fn))
+  {
+    contract_match_kind remap_kind = cmk_pre;
+    if (code == POSTCONDITION_STMT)
+      remap_kind = cmk_post;
+    /* We're inheriting basefn's contracts; create a copy of them but
+     * replace references to their parms to our parms.  */
+
+    base_contracts = copy_and_remap_contracts (fndecl, base_fn,
+					       /* remap_result */false,
+					       remap_kind);
+  }
   // todo warn on empty contracts ?
   return base_contracts;
 }

gcc/testsuite/g++.dg/contracts/cpp26/P3653-virtual-func/inherited-err.C

@@ -0,0 +1,27 @@
+// check that we do not get unused warnings for contract check function parameters
+// { dg-do compile }
+// { dg-options "-std=c++2b -fcontracts -fcontracts-nonattr -fcontracts-on-virtual-functions=P3653" }
+
+
+void foo() pre inherited(Base); // { dg-error "inherited contracts are only available on member functions" }
+
+struct Base
+{
+  virtual void f() pre (true){};
+};
+
+struct Bob;
+struct Child0 : Base
+{
+  virtual void f() pre inherited(Base,); // { dg-error "expected class-name at end of input" }
+  virtual void g1() pre inherited(Base); // { dg-error "does not override" }
+  virtual void g2() pre inherited(Bob); // { dg-error "contracts can only be inherited from a direct base class" }
+  virtual void g3() pre inherited(int); // { dg-error "expected" }
+
+  void h() pre inherited(Base);// { dg-error "contracts can only appear on a virtual function" }
+};
+
+struct GChild: Child0
+{
+  virtual void f() pre inherited(Base); // { dg-error "contracts can only be inherited from a direct base class" }
+};

gcc/testsuite/g++.dg/contracts/cpp26/P3653-virtual-func/inherited.C

@@ -0,0 +1,130 @@
+// { dg-do run }
+// { dg-options "-std=c++2a -fcontracts -fcontracts-nonattr -fcontracts-on-virtual-functions=P3653 -g3" }
+#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 Base1
+{
+  virtual int f1(const int i) post (checkA()){ return 1;};
+  virtual int f2(const int i) pre (checkA()) post (checkB()){ return 1;};
+
+};
+
+
+
+struct Base2
+{
+  virtual int f1(const int i) pre (checkB()){ return 1;};
+  virtual int f2(const int i) { return 1;};
+
+};
+
+struct Base3
+{
+  virtual int f1(const int i) pre (checkB()) pre (checkC()){ return 1;};
+  virtual int f2(const int i) { return 1;};
+
+};
+
+
+struct Child0 : Base1
+{
+  virtual int f1(const int i) pre inherited (Base1) pre(checkC());
+  virtual int f2(const int i) post inherited (Base1){ return 1;}
+};
+
+struct Child1 : Base1, private Base2, protected Base3
+{
+  virtual int f1(const int i) pre inherited (Base1, Base2, Base3){ return 1;}
+  virtual int f2(const int i) post inherited (Base1, Base2, Base3){ return 1;}
+};
+
+struct GChild : Child0
+{
+  virtual int f1(const int i){ return 1;}
+  virtual int f2(const int i) post inherited (Child0){ return 1;}
+};
+
+int Child0::f1(const int i){ return 3;}
+
+int main()
+{
+
+  Child0 c0;
+
+  clear_checks ();
+  c0.f1(2);
+  assert (a.checked == 0);
+  assert (b.checked == 0);
+  assert (c.checked > 0);
+
+  clear_checks ();
+  c0.f2(2);
+  assert (a.checked == 0);
+  assert (b.checked > 0);
+  assert (c.checked == 0);
+
+
+  Child1 c1;
+
+  clear_checks ();
+  c1.f1(2);
+  assert (a.checked == 0);
+  assert (b.checked > 0);
+  assert (c.checked > 0);
+
+  clear_checks ();
+  c1.f2(2);
+  assert (a.checked == 0);
+  assert (b.checked > 0);
+  assert (c.checked == 0);
+
+  GChild g;
+
+  clear_checks ();
+  g.f1(2);
+  assert (a.checked == 0);
+  assert (b.checked == 0);
+  assert (c.checked > 0);
+
+  clear_checks ();
+  c1.f2(2);
+  assert (a.checked == 0);
+  assert (b.checked > 0);
+  assert (c.checked == 0);
+
+}

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

@@ -43,12 +43,12 @@ int f1(int a) pre ( a < 0 ); // { dg-error "mismatched contract" }
 
 struct Base
 {
-  virtual int f(int a) pre (a > 0); // { dg-error "Contracts can not be added to virtual functions" }
+  virtual int f(int a) pre (a > 0); // { dg-error "Contracts cannot be added to virtual functions" }
 };
 
 struct Child : Base
 {
-  int f(int a) pre (a < 0); // { dg-error "Contracts can not be added to virtual functions" }
+  int f(int a) pre (a < 0); // { dg-error "Contracts cannot be added to virtual functions" }
 };
 
 struct F1
@@ -75,11 +75,11 @@ void T1::vfun(int m, double n)
 void T1::vfun(int m, double n) pre(true); // { dg-error "declaration adds contracts" }
 
 struct Foo {
-  virtual void f10 (int)  pre ( false ) {} // { dg-error "Contracts can not be added to virtual functions" }
+  virtual void f10 (int)  pre ( false ) {} // { dg-error "Contracts cannot be added to virtual functions" }
 };
 
 struct Bar : Foo {
-  void f10 (int n = 0) override pre ( false ); // { dg-error "Contracts can not be added to virtual functions" }
+  void f10 (int n = 0) override pre ( false ); // { dg-error "Contracts cannot be added to virtual functions" }
 };
 
 // we currently don't diagnose an error here if the original contract was erroneous.

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

@@ -24,17 +24,17 @@ namespace parsing_trailing_return_type_test {
 
 namespace parsing_virtual_test {
   struct A {
-    virtual void f(int i) // { dg-error "Contracts can not be added to virtual functions" }
+    virtual void f(int i) // { dg-error "Contracts cannot be added to virtual functions" }
       pre(i >= 0);
   };
 
   struct B : A {
-    void f(int i) override final // { dg-error "Contracts can not be added to virtual functions" }
+    void f(int i) override final // { dg-error "Contracts cannot be added to virtual functions" }
       pre(i >= 0);
   };
 
   struct C : A {
-    void f(int i) override // { dg-error "Contracts can not be added to virtual functions" }
+    void f(int i) override // { dg-error "Contracts cannot be added to virtual functions" }
       pre(i >= 0) = 0;
   };
 }
@@ -45,7 +45,7 @@ namespace parsing_default_delete_pure_test {
   struct X {
     X() pre(a) = default;
     X(const X&) pre(b) = delete;
-    virtual void f() pre(c) = 0; // { dg-error "Contracts can not be added to virtual functions" }
+    virtual void f() pre(c) = 0; // { dg-error "Contracts cannot be added to virtual functions" }
   };
 }
 

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

@@ -3,13 +3,13 @@
 
 struct Base
 {
-  virtual int f1() pre(true); // { dg-error "Contracts can not be added to virtual functions" }
+  virtual int f1() pre(true); // { dg-error "Contracts cannot be added to virtual functions" }
   virtual int f2();
 
 };
 struct Child : Base
 {
-  int f2() pre(true); // { dg-error "Contracts can not be added to virtual functions" }
+  int f2() pre(true); // { dg-error "Contracts cannot be added to virtual functions" }
 
 };