Merge pull request gcc-mirror#85 from NinaRanns/contracts_return_value_const

addressing return value constness

Author: villevoutilainen

gcc/cp/contracts.cc

@@ -613,10 +613,6 @@ make_postcondition_variable (cp_expr id, tree type)
   DECL_ARTIFICIAL (decl) = true;
   DECL_SOURCE_LOCATION (decl) = id.get_location ();
 
-  /* Maybe constify the postcondition variable.  */
-  if (flag_contracts_nonattr && should_constify_contract)
-    TREE_READONLY(decl) = true;
-
   pushdecl (decl);
   return decl;
 }
@@ -2734,10 +2730,15 @@ finish_contract_condition (cp_expr condition)
 
 tree view_as_const(tree decl)
 {
-  tree ctype = TREE_TYPE (decl);
-  ctype = cp_build_qualified_type (ctype, (cp_type_quals (ctype)
-						     | TYPE_QUAL_CONST));
-  decl = build1 (VIEW_CONVERT_EXPR, ctype, decl);
+  if (!contract_const_wrapper_p (decl))
+    {
+      tree ctype = TREE_TYPE (decl);
+      ctype = cp_build_qualified_type (ctype, (cp_type_quals (ctype)
+					       | TYPE_QUAL_CONST));
+      decl = build1 (VIEW_CONVERT_EXPR, ctype, decl);
+      /* Mark the VCE as contract const wrapper.  */
+      decl->base.private_flag = true;
+    }
   return decl;
 }
 
@@ -2746,14 +2747,9 @@ tree view_as_const(tree decl)
 tree
 constify_contract_access(tree decl)
 {
-  /* only constifies the automatic storage variables for now.
-   * The postcondition variable is created const. Parameters need to be
-   * checked separately, and we also need to make references and *this const
-   */
 
-  /* We check if we have a variable of automatic storage duration, a parameter,
-   * a variable of automatic storage duration of reference type, or a
-   * parameter of reference type
+  /* We check if we have a variable, a parameter, a variable of reference type,
+   * or a parameter of reference type
    */
   if (!TREE_READONLY (decl)
       && (VAR_P (decl)
@@ -2783,7 +2779,11 @@ maybe_reject_param_in_postcondition (tree decl)
       && !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))
+	   && 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");

gcc/cp/cp-tree.h

@@ -9001,6 +9001,29 @@ set_contract_const (tree t, bool constify)
   TREE_LANG_FLAG_4 (CONTRACT_CHECK (t)) = constify;
 }
 
+/* Test if EXP is a contract const wrapper node.  */
+
+inline bool
+contract_const_wrapper_p (const_tree exp)
+{
+  /* A wrapper node has code VIEW_CONVERT_EXPR, and the flag base.private_flag
+     is set. The wrapper node is used to Used to constify entities inside
+     contract assertions.  */
+  return ((TREE_CODE (exp) == VIEW_CONVERT_EXPR) && exp->base.private_flag);
+}
+
+/* If EXP is a contract_const_wrapper_p, return the wrapped expression.
+   Otherwise, do nothing. */
+
+inline tree
+strip_contract_const_wrapper (tree exp)
+{
+  if (contract_const_wrapper_p (exp))
+    return TREE_OPERAND (exp, 0);
+  else
+    return exp;
+}
+
 /* Inline bodies.  */
 
 inline tree

gcc/cp/semantics.cc

@@ -12593,6 +12593,12 @@ finish_decltype_type (tree expr, bool id_expression_or_member_access_p,
       if (identifier_p (expr))
         expr = lookup_name (expr);
 
+      /* If e is a constified expression inside a contract assertion,
+	 strip the const wrapper. Per P2900R14, "For a function f with the
+	 return type T , the result name is an lvalue of type const T , decltype(r)
+	 is T , and decltype((r)) is const T&."  */
+      expr = strip_contract_const_wrapper (expr);
+
       if (INDIRECT_REF_P (expr)
 	  || TREE_CODE (expr) == VIEW_CONVERT_EXPR)
         /* This can happen when the expression is, e.g., "a.b". Just

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

@@ -0,0 +1,59 @@
+// check that the return value has correct const qualification
+// { dg-do run }
+// { dg-options "-std=c++2b -fcontracts -fcontracts-nonattr " }
+
+
+#include <type_traits>
+
+bool is_constified(int &){ return false;}
+
+bool is_constified(const int &){ return true;}
+
+
+int f1(int i)
+     pre (is_constified(i))
+     pre (std::is_same<decltype(i), int>::value)
+     pre (std::is_same<decltype((i)), const int&>::value)
+
+     post (r: is_constified(r))
+     post (r: std::is_same<decltype(r), int>::value)
+     post (r: std::is_same<decltype((r)), const int&>::value)
+     { return i; };
+
+int& f2(int& i)
+    pre (is_constified(i))
+    pre (std::is_same<decltype(i), int&>::value)
+    pre (std::is_same<decltype((i)), const int&>::value)
+
+    post (r: is_constified(r))
+    post (r: std::is_same<decltype(r), int&>::value)
+    post (r: std::is_same<decltype((r)), const int&>::value)
+    {
+      static_assert(std::is_same<decltype(i), int&>::value);
+      return i;
+    }
+
+int* f2(int* i)
+    pre (std::is_same<decltype(i), int*>::value)
+    pre (std::is_same<decltype((i)),int * const>::value)
+
+    post (r: std::is_same<decltype(r), int *>::value)
+    post (r: std::is_same<decltype((r)),int * const>::value)
+    { return i;}
+
+int const * f2(int const * i)
+    pre (std::is_same<decltype(i), int const *>::value)
+    pre (std::is_same<decltype((i)),int const * const>::value)
+
+    post (r: std::is_same<decltype(r), int const *>::value)
+    post (r: std::is_same<decltype((r)),int const * const>::value)
+    { return i;}
+
+int main()
+{
+
+  int i = 4;
+  f1(i);
+  f2(i);
+
+}

gcc/tree-core.h

@@ -1364,6 +1364,9 @@ struct GTY(()) tree_base {
        ENUM_IS_OPAQUE in
 	   ENUMERAL_TYPE
 
+      contract_const_wrapper_p in
+	   VIEW_CONVERT_EXPR
+
    protected_flag:
 
        TREE_PROTECTED in