adding a constification specific VCE flag

Author: NinaRanns

gcc/cp/contracts.cc

@@ -2724,10 +2724,14 @@ 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);
+      EXPR_CONTRACT_CONST_WRAPPER_P(decl) = true;
+    }
   return decl;
 }
 

gcc/cp/cp-tree.h

@@ -3204,6 +3204,18 @@ struct GTY(()) lang_decl {
 #define CONTRACT_HELPER(NODE) \
  (LANG_DECL_FN_CHECK (NODE)->contract_helper)
 
+/* In VIEW_CONVERT_EXPR, set when this node is a const wrapper.  Used to
+   constify entities inside contract assertions.  */
+
+#define EXPR_CONTRACT_CONST_WRAPPER_P(NODE) \
+  (TREE_CHECK(NODE, VIEW_CONVERT_EXPR)->base.private_flag)
+
+/* Remove any VIEW_CONVERT_EXPR that's used to constify an entity inside a
+   contract assertion.  */
+
+#define STRIP_ANY_CONTRACT_CONST_WRAPPER(EXP) \
+  (EXP) = tree_strip_any_contract_const_wrapper (CONST_CAST_TREE (EXP))
+
 /* For a FUNCTION_DECL or a VAR_DECL, the language linkage for the
    declaration.  Some entities (like a member function in a local
    class, or a local variable) do not have linkage at all, and this
@@ -9001,6 +9013,30 @@ 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
+     EXPR_LOCATION_WRAPPER_P is set.  */
+  if (TREE_CODE (exp) == VIEW_CONVERT_EXPR
+      && EXPR_CONTRACT_CONST_WRAPPER_P (exp))
+    return true;
+  return false;
+}
+
+/* Implementation of STRIP_ANY_CONTRACT_CONST_WRAPPER.  */
+
+inline tree
+tree_strip_any_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,7 +12593,13 @@ finish_decltype_type (tree expr, bool id_expression_or_member_access_p,
       if (identifier_p (expr))
         expr = lookup_name (expr);
 
-      while (INDIRECT_REF_P (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&."  */
+      STRIP_ANY_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
            look at the underlying operand.  */

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

@@ -1,6 +1,6 @@
 // check that the return value has correct const qualification
 // { dg-do run }
-// { dg-options "-std=c++2b -fcontracts -fcontracts-nonattr -fcontract-evaluation-semantic=observe  " }
+// { dg-options "-std=c++2b -fcontracts -fcontracts-nonattr " }
 
 
 #include <type_traits>

gcc/tree-core.h

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