Merge pull request gcc-mirror#64 from iains/contracts-nonattr-add-contract-scope

Contracts nonattr add contract scope

Author: villevoutilainen

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,9 +1951,9 @@ 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;
   BOOL_BITFIELD x_processing_explicit_instantiation : 1;
   BOOL_BITFIELD need_pop_function_context : 1;
   BOOL_BITFIELD x_processing_omp_trait_property_expr : 1;
@@ -2031,12 +2031,14 @@ 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_condition \
+  (scope_chain->bindings->kind == sk_contract)
 
-#define processing_contract_postcondition scope_chain->x_processing_contract_postcondition
+#define processing_postcondition scope_chain->x_processing_postcondition
+#define should_constify_contract scope_chain->x_should_constify_contract
 
 #define in_discarded_stmt scope_chain->discarded_stmt
 #define in_consteval_if_p scope_chain->consteval_if_p

gcc/cp/name-lookup.cc

@@ -4630,7 +4630,8 @@ cp_binding_level_descriptor (cp_binding_level *scope)
     "template-parameter-scope",
     "template-explicit-spec-scope",
     "transaction-scope",
-    "openmp-scope"
+    "openmp-scope",
+    "contract-check-scope"
   };
   static_assert (ARRAY_SIZE (scope_kind_names) == sk_count,
 		 "must keep names aligned with scope_kind enum");
@@ -4720,6 +4721,7 @@ begin_scope (scope_kind kind, tree entity)
     case sk_scoped_enum:
     case sk_transaction:
     case sk_omp:
+    case sk_contract:
     case sk_stmt_expr:
       scope->keep = keep_next_level_flag;
       break;

gcc/cp/name-lookup.h

@@ -214,6 +214,7 @@ enum scope_kind {
 			"template <>", this scope is always empty.  */
   sk_transaction,    /* A synchronized or atomic statement.  */
   sk_omp,	     /* An OpenMP structured block.  */
+  sk_contract,	     /* A P2900 contract.  */
   sk_count	     /* Number of scope_kind enumerations.  */
 };
 
@@ -287,7 +288,7 @@ struct GTY(()) cp_binding_level {
   /* The kind of scope that this object represents.  However, a
       SK_TEMPLATE_SPEC scope is represented with KIND set to
       SK_TEMPLATE_PARMS and EXPLICIT_SPEC_P set to true.  */
-  ENUM_BITFIELD (scope_kind) kind : 4;
+  ENUM_BITFIELD (scope_kind) kind : 5;
 
   /* True if this scope is an SK_TEMPLATE_SPEC scope.  This field is
       only valid if KIND == SK_TEMPLATE_PARMS.  */
@@ -315,7 +316,7 @@ struct GTY(()) cp_binding_level {
      parent scope.  */
   unsigned artificial : 1;
 
-  /* 21 bits left to fill a 32-bit word.  */
+  /* 20 bits left to fill a 32-bit word.  */
 };
 
 /* The binding level currently in effect.  */

gcc/cp/parser.cc

@@ -11815,7 +11815,9 @@ cp_parser_lambda_introducer (cp_parser* parser, tree lambda_expr)
       cp_lexer_consume_token (parser->lexer);
       first = false;
 
-      if (!(at_function_scope_p () || parsing_nsdmi ()))
+      if (!(at_function_scope_p ()
+	    || parsing_nsdmi ()
+	    || current_binding_level->kind == sk_contract))
 	error ("non-local lambda expression cannot have a capture-default");
     }
 
@@ -13120,16 +13122,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,24 +13136,30 @@ cp_parser_statement (cp_parser* parser, tree in_statement_expr,
 		current_class_ref = view_as_const (current_class_ref_copy);
 
 	      /* Parse the condition.  */
-	      ++processing_contract_condition;
+	      tree contract = error_mark_node;
+	      begin_scope (sk_contract, current_function_decl);
+	      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
@@ -31372,19 +31376,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);
 
-      /* Build a fake variable for the result identifier.  */
-      tree result = NULL_TREE;
-      if (identifier)
-	{
-	  begin_scope (sk_block, NULL_TREE);
-	  result = make_postcondition_variable (identifier);
-	  ++processing_template_decl;
-	}
-
-      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;
@@ -31393,16 +31384,31 @@ 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.  */
-      ++processing_contract_condition;
-      if (postcondition_p)
-	++processing_contract_postcondition;
+      begin_scope (sk_contract, current_function_decl);
+      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;
+	}
       cp_expr condition = cp_parser_conditional_expression (parser);
-      if (postcondition_p)
-	--processing_contract_postcondition;
+      /* Build the contract.  */
+      contract = grok_contract (attribute, mode, result, condition, loc);
+      if (identifier)
+	--processing_template_decl;
+      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;
-      --processing_contract_condition;
 
 	/* 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. */
@@ -31413,15 +31419,6 @@ cp_parser_contract_attribute_spec (cp_parser *parser, tree attribute,
 	 we need to search the condition for errors.  */
       else if (contains_error_p (condition))
 	cp_parser_skip_up_to_closing_square_bracket (parser);
-
-      /* Build the contract.  */
-      contract = grok_contract (attribute, mode, result, condition, loc);
-      /* Leave our temporary scope for the postcondition result.  */
-      if (result)
-	{
-	  --processing_template_decl;
-	  pop_bindings_and_leave_scope ();
-	}
     }
 
   if (!flag_contracts)
@@ -31455,22 +31452,16 @@ void cp_parser_late_contract_condition (cp_parser *parser,
   if (TREE_CODE (contract) == POSTCONDITION_STMT)
     identifier = POSTCONDITION_IDENTIFIER (contract);
 
-  /* Build a fake variable for the result identifier.  */
-  tree result = NULL_TREE;
+  tree type = TREE_TYPE (TREE_TYPE (fn));
   if (identifier)
     {
       /* TODO: Can we guarantee that the identifier has a location? */
       location_t loc = cp_expr_location (contract);
-      tree type = TREE_TYPE (TREE_TYPE (fn));
       if (!check_postcondition_result (fn, type, loc))
 	{
 	  invalidate_contract (contract);
 	  return;
 	}
-
-      begin_scope (sk_block, NULL_TREE);
-      result = make_postcondition_variable (identifier, type);
-      ++processing_template_decl;
     }
 
   /* In C++20 contracts, 'this' is not allowed in preconditions of
@@ -31502,7 +31493,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.  */
@@ -31512,17 +31502,32 @@ 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.  */
-  ++processing_contract_condition;
-  if (POSTCONDITION_P (contract))
-    ++processing_contract_postcondition;
+  begin_scope (sk_contract, fn);
+  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)
+    {
+      result = make_postcondition_variable (identifier, type);
+      ++processing_template_decl;
+    }
   condition = cp_parser_conditional_expression (parser);
-  if (POSTCONDITION_P (contract))
-    --processing_contract_postcondition;
-  --processing_contract_condition;
+  /* Commit to changes.  */
+  update_late_contract (contract, result, condition);
+  /* Leave our temporary scope for the postcondition result.  */
+  if (identifier)
+    --processing_template_decl;
+  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 ();
 
   if (cp_lexer_next_token_is_not (parser->lexer, CPP_EOF))
-      error_at (input_location,
-		"expected conditional-expression");
+    error_at (input_location, "expected conditional-expression");
 
   /* Revert to the main lexer.  */
   cp_parser_pop_lexer (parser);
@@ -31533,17 +31538,6 @@ void cp_parser_late_contract_condition (cp_parser *parser,
   current_class_ref = saved_ccr;
   current_class_ptr = saved_ccp;
   contract_class_ptr = saved_contract_ccp;
-
-  /* Commit to changes.  */
-  update_late_contract (contract, result, condition);
-  flag_contracts_nonattr_noconst = old_flag_contracts_nonattr_noconst;
-
-  /* Leave our temporary scope for the postcondition result.  */
-  if (result)
-    {
-      --processing_template_decl;
-      pop_bindings_and_leave_scope ();
-    }
 }
 
 static contract_modifier