c++, contracts: Use the saved_scope to carry state not globals.

This uses state local to the contract scopes to carry the information
on const-ification and whether the current contract is a post.

Note that if, for example, we had a lambda with a precondition in the
defintion of a post-condition, the use of increment/decrement of a
"postcondition" variable is not going to work properly.

We also use a contract scope during template substitution so that we
can check for that scope when deciding how to process.

Signed-off-by: Iain Sandoe <iain@sandoe.co.uk>

Author: iains

gcc/cp/contracts.cc

@@ -606,14 +606,16 @@ make_postcondition_variable (cp_expr id, tree type)
 {
   if (id == error_mark_node)
     return id;
+  gcc_checking_assert (scope_chain && scope_chain->bindings
+		       && scope_chain->bindings->kind == sk_contract);
 
   tree decl = build_lang_decl (PARM_DECL, id, type);
   DECL_ARTIFICIAL (decl) = true;
   DECL_SOURCE_LOCATION (decl) = id.get_location ();
 
-  // constify the postcondition variable
-  if (flag_contracts_nonattr && !flag_contracts_nonattr_noconst)
-	TREE_READONLY(decl) = true;
+  /* Maybe constify the postcondition variable.  */
+  if (flag_contracts_nonattr && should_constify_contract)
+    TREE_READONLY(decl) = true;
 
   pushdecl (decl);
   return decl;
@@ -711,16 +713,24 @@ rebuild_postconditions (tree fndecl)
 	  t = TREE_CHAIN (t))
 	register_local_identity (t);
 
+      begin_scope (sk_contract, fndecl);
+      bool old_pc = processing_postcondition;
+      bool old_const = should_constify_contract;
+      processing_postcondition = true;
+      should_constify_contract = get_contract_const (contract);
       register_local_specialization (newvar, oldvar);
 
-      ++processing_contract_condition;
       condition = tsubst_expr (condition, make_tree_vec (0),
 			       tf_warning_or_error, fndecl);
-      --processing_contract_condition;
 
       /* Update the contract condition and result.  */
       POSTCONDITION_IDENTIFIER (contract) = newvar;
       CONTRACT_CONDITION (contract) = finish_contract_condition (condition);
+      processing_postcondition = old_pc;
+      should_constify_contract = old_const;
+      gcc_checking_assert (scope_chain && scope_chain->bindings
+			   && scope_chain->bindings->kind == sk_contract);
+      pop_bindings_and_leave_scope ();
     }
 }
 
@@ -2741,14 +2751,14 @@ constify_contract_access(tree decl)
 /* Do not allow non-const by-value params being used in postconditions.  */
 
 bool
-maybe_reject_param_in_postcondition(tree decl)
+maybe_reject_param_in_postcondition (tree decl)
 {
   if (flag_contracts_nonattr
-      && processing_contract_postcondition
-      && !dependent_type_p (TREE_TYPE (decl))
       && !TREE_READONLY (decl)
-      && !CP_TYPE_CONST_P (TREE_TYPE (decl))
       && TREE_CODE (decl) == PARM_DECL
+      && processing_postcondition
+      && !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))
     {

gcc/cp/cp-tree.h

@@ -1951,8 +1951,6 @@ struct GTY(()) saved_scope {
   int x_processing_template_decl;
   int x_processing_specialization;
   int x_processing_constraint;
-  int x_processing_contract_condition;
-  int x_processing_contract_postcondition;
   int suppress_location_wrappers;
   BOOL_BITFIELD x_processing_postcondition : 1;
   BOOL_BITFIELD x_should_constify_contract : 1;
@@ -2033,12 +2031,11 @@ extern GTY(()) struct saved_scope *scope_chain;
 #define processing_omp_trait_property_expr scope_chain->x_processing_omp_trait_property_expr
 
 /* Nonzero if we are parsing the conditional expression of a contract
-   condition. These expressions appear outside the paramter list (like a
+   condition. These expressions appear outside the parameter list (like a
    trailing return type), but are potentially evaluated.  */
 
-#define processing_contract_condition scope_chain->x_processing_contract_condition
-
-#define processing_contract_postcondition scope_chain->x_processing_contract_postcondition
+#define processing_contract_condition \
+  (scope_chain->bindings->kind == sk_contract)
 
 #define processing_postcondition scope_chain->x_processing_postcondition
 #define should_constify_contract scope_chain->x_should_constify_contract

gcc/cp/parser.cc

@@ -13120,16 +13120,12 @@ cp_parser_statement (cp_parser* parser, tree in_statement_expr,
 						     0);
 
 	      /* Do we have an override for const-ification?  */
-	      bool old_flag_contracts_nonattr_noconst
-		= flag_contracts_nonattr_noconst;
-
 	      bool should_constify = !flag_contracts_nonattr_noconst;
 	      if (!modifier.error_p
 		  && (modifier.mutable_p
 		      || (flag_contracts_nonattr_const_keyword
 			  && !modifier.const_p)))
 		should_constify = false;
-	      flag_contracts_nonattr_noconst = !should_constify;
 
 	      /* If we have a current class object, see if we need to consider
 		 it const when processing the contract condition.  */
@@ -13138,28 +13134,30 @@ cp_parser_statement (cp_parser* parser, tree in_statement_expr,
 		current_class_ref = view_as_const (current_class_ref_copy);
 
 	      /* Parse the condition.  */
+	      tree contract = error_mark_node;
 	      begin_scope (sk_contract, current_function_decl);
-	      ++processing_contract_condition;
+	      bool old_pc = processing_postcondition;
+	      bool old_const = should_constify_contract;
 	      processing_postcondition = false;
 	      should_constify_contract = should_constify;
 	      cp_expr condition = cp_parser_conditional_expression (parser);
-	      --processing_contract_condition;
+	      gcc_checking_assert (scope_chain && scope_chain->bindings
+				  && scope_chain->bindings->kind == sk_contract);
+	      /* Build the contract.  */
+	      contract
+		= grok_contract (cont_assert, /*mode*/NULL_TREE,
+				 /*result*/NULL_TREE, condition, loc);
+	      processing_postcondition = old_pc;
+	      should_constify_contract = old_const;
 	      pop_bindings_and_leave_scope ();
 
 	      /* Revert (any) constification of the current class object.  */
 	      current_class_ref = current_class_ref_copy;
 
-	      flag_contracts_nonattr_noconst
-		= old_flag_contracts_nonattr_noconst;
-
 	      parens.require_close (parser);
-	      /* Build the contract.  */
-	      tree contract
-		= grok_contract (cont_assert, /*mode*/NULL_TREE,
-				 /*result*/NULL_TREE, condition, loc);
+
 	      if (contract != error_mark_node)
 		set_contract_const (contract, should_constify);
-
 	      std_attrs = finish_contract_attribute (cont_assert, contract);
 
 	      /* If there are errors in the contract, we do not create the
@@ -31376,10 +31374,6 @@ cp_parser_contract_attribute_spec (cp_parser *parser, tree attribute,
       /* Enable location wrappers when parsing contracts.  */
       auto suppression = make_temp_override (suppress_location_wrappers, 0);
 
-      bool old_flag_contracts_nonattr_noconst = flag_contracts_nonattr_noconst;
-      /* The should_constify value should account for all the mixed flags.  */
-      flag_contracts_nonattr_noconst = !should_constify;
-
       /* If we have a current class object, see if we need to consider
 	 it const when processing the contract condition.  */
       tree current_class_ref_copy = current_class_ref;
@@ -31389,31 +31383,30 @@ cp_parser_contract_attribute_spec (cp_parser *parser, tree attribute,
       /* Parse the condition, ensuring that parameters or the return variable
 	 aren't flagged for use outside the body of a function.  */
       begin_scope (sk_contract, current_function_decl);
-      ++processing_contract_condition;
-      if (postcondition_p)
-	++processing_contract_postcondition;
+      bool old_pc = processing_postcondition;
+      bool old_const = should_constify_contract;
+      processing_postcondition = postcondition_p;
+      should_constify_contract = should_constify;
       tree result = NULL_TREE;
       if (identifier)
 	{
 	  /* Build a fake variable for the result identifier.  */
 	  result = make_postcondition_variable (identifier);
 	  ++processing_template_decl;
 	}
-      processing_postcondition = postcondition_p;
-      should_constify_contract = should_constify;
       cp_expr condition = cp_parser_conditional_expression (parser);
       /* Build the contract.  */
       contract = grok_contract (attribute, mode, result, condition, loc);
       if (identifier)
 	--processing_template_decl;
-      if (postcondition_p)
-	--processing_contract_postcondition;
-      --processing_contract_condition;
+      processing_postcondition = old_pc;
+      should_constify_contract = old_const;
+      gcc_checking_assert (scope_chain && scope_chain->bindings
+			   && scope_chain->bindings->kind == sk_contract);
       pop_bindings_and_leave_scope ();
 
       /* Revert (any) constification of the current class object.  */
       current_class_ref = current_class_ref_copy;
-      flag_contracts_nonattr_noconst = old_flag_contracts_nonattr_noconst;
 
 	/* For natural syntax, we eat the parens here. For the attribute
 	syntax, it will be done one level up, we just need to skip to it. */
@@ -31498,7 +31491,6 @@ void cp_parser_late_contract_condition (cp_parser *parser,
   cp_token_cache *tokens = DEFPARSE_TOKENS (condition);
   cp_parser_push_lexer_for_tokens (parser, tokens);
 
-  bool old_flag_contracts_nonattr_noconst = flag_contracts_nonattr_noconst;
   bool should_constify = get_contract_const (contract);
   /* If we have a current class object, see if we need to consider
      it const when processing the contract condition.  */
@@ -31509,9 +31501,10 @@ void cp_parser_late_contract_condition (cp_parser *parser,
   /* Parse the condition, ensuring that parameters or the return variable
      aren't flagged for use outside the body of a function.  */
   begin_scope (sk_contract, fn);
-  ++processing_contract_condition;
-  if (POSTCONDITION_P (contract))
-    ++processing_contract_postcondition;
+  bool old_pc = processing_postcondition;
+  bool old_const = should_constify_contract;
+  processing_postcondition = POSTCONDITION_P (contract);
+  should_constify_contract = should_constify;
   /* Build a fake variable for the result identifier.  */
   tree result = NULL_TREE;
   if (identifier)
@@ -31523,15 +31516,14 @@ void cp_parser_late_contract_condition (cp_parser *parser,
   /* Commit to changes.  */
   update_late_contract (contract, result, condition);
   /* Leave our temporary scope for the postcondition result.  */
-  if (result)
+  if (identifier)
     --processing_template_decl;
-  if (POSTCONDITION_P (contract))
-    --processing_contract_postcondition;
-  --processing_contract_condition;
+  processing_postcondition = old_pc;
+  should_constify_contract = old_const;
+  gcc_checking_assert (scope_chain && scope_chain->bindings
+		       && scope_chain->bindings->kind == sk_contract);
   pop_bindings_and_leave_scope ();
 
-  flag_contracts_nonattr_noconst = old_flag_contracts_nonattr_noconst;
-
   if (cp_lexer_next_token_is_not (parser->lexer, CPP_EOF))
     error_at (input_location, "expected conditional-expression");
 

gcc/cp/pt.cc

@@ -12043,19 +12043,16 @@ tsubst_contract (tree decl, tree t, tree args, tsubst_flags_t complain,
 	  return invalidate_contract (r);
     }
 
-  /* Should we const-ify this condition?  */
-  bool old_flag_contracts_nonattr_noconst = flag_contracts_nonattr_noconst;
-  bool const_p = get_contract_const (t);
-  flag_contracts_nonattr_noconst = !const_p;
-
   /* Instantiate the condition.  If the return type is undeduced, process
      the expression as if inside a template to avoid spurious type errors.  */
   begin_scope (sk_contract, decl);
-  ++processing_contract_condition;
+  bool old_pc = processing_postcondition;
+  bool old_const = should_constify_contract;
+  processing_postcondition = POSTCONDITION_P (t);
+  /* Should we const-ify this condition?  */
+  should_constify_contract =  get_contract_const (t);
   if (auto_p)
     ++processing_template_decl;
-  if (POSTCONDITION_P (t))
-    ++processing_contract_postcondition;
   if (newvar)
     /* Make the variable available for lookup.  */
     register_local_specialization (newvar, oldvar);
@@ -12067,13 +12064,13 @@ tsubst_contract (tree decl, tree t, tree args, tsubst_flags_t complain,
   CONTRACT_COMMENT (r)
       = tsubst_expr (CONTRACT_COMMENT (r), args, complain, in_decl);
 
-  if (POSTCONDITION_P (t))
-    --processing_contract_postcondition;
   if (auto_p)
     --processing_template_decl;
-  --processing_contract_condition;
+  processing_postcondition = old_pc;
+  should_constify_contract = old_const;
+  gcc_checking_assert (scope_chain && scope_chain->bindings
+		       && scope_chain->bindings->kind == sk_contract);
   pop_bindings_and_leave_scope ();
-  flag_contracts_nonattr_noconst = old_flag_contracts_nonattr_noconst;
 
   return r;
 }
@@ -21957,7 +21954,7 @@ tsubst_expr (tree t, tree args, tsubst_flags_t complain, tree in_decl)
 		 declaration (such as in a late-specified return type).  Just
 		 make a dummy decl, since it's only used for its type.  */
 	      gcc_assert (cp_unevaluated_operand
-			  || processing_contract_postcondition);
+			  || processing_postcondition);
 	      r = tsubst_decl (t, args, complain);
 	      /* Give it the template pattern as its context; its true context
 		 hasn't been instantiated yet and this is good enough for
@@ -22362,7 +22359,7 @@ tsubst_expr (tree t, tree args, tsubst_flags_t complain, tree in_decl)
 
 	maybe_reject_param_in_postcondition (op);
 
-	if (flag_contracts_nonattr && !flag_contracts_nonattr_noconst
+	if (flag_contracts_nonattr && should_constify_contract
 	    && processing_contract_condition)
 	    op = constify_contract_access(op);
 

gcc/cp/semantics.cc

@@ -4932,12 +4932,10 @@ finish_id_expression_1 (tree id_expression,
     }
 
   maybe_reject_param_in_postcondition (decl);
-
-  if (flag_contracts_nonattr && !flag_contracts_nonattr_noconst
+  if (flag_contracts_nonattr && should_constify_contract
 	&& processing_contract_condition)
-    {
-       decl = constify_contract_access(decl);
-    }
+    decl = constify_contract_access(decl);
+
   return cp_expr (decl, location);
 }