diff mbox

[C++,Patch/RFC] cp_parser_expression vs default arguments

Message ID 53F254B8.7020805@oracle.com
State New
Headers show

Commit Message

Paolo Carlini Aug. 18, 2014, 7:32 p.m. UTC 
Hi,

recently, while having a look to c++/58614, I noticed that if we are 
going to use default arguments we can clean up quite a few functions and 
function calls, for example cp_parser_expression, per the below, which 
passes testing. Is this something we want to pursue?

Thanks,
Paolo.

///////////////////////////

Comments

Jason Merrill Aug. 18, 2014, 7:58 p.m. UTC | #1 
OK.

Jason
diff mbox

Patch

Index: parser.c
===================================================================
--- parser.c	(revision 214109)
+++ parser.c	(working copy)
@@ -1963,9 +1963,7 @@  static tree cp_parser_assignment_expression
 static enum tree_code cp_parser_assignment_operator_opt
   (cp_parser *);
 static tree cp_parser_expression
-  (cp_parser *, bool, cp_id_kind *);
-static tree cp_parser_expression
-  (cp_parser *, bool, bool, cp_id_kind *);
+  (cp_parser *, cp_id_kind * = NULL, bool = false, bool = false);
 static tree cp_parser_constant_expression
   (cp_parser *, bool, bool *);
 static tree cp_parser_builtin_offsetof
@@ -4314,7 +4312,7 @@  cp_parser_primary_expression (cp_parser *parser,
 	else
 	  {
 	    /* Parse the parenthesized expression.  */
-	    expr = cp_parser_expression (parser, cast_p, decltype_p, idk);
+	    expr = cp_parser_expression (parser, idk, cast_p, decltype_p);
 	    /* Let the front end know that this expression was
 	       enclosed in parentheses. This matters in case, for
 	       example, the expression is of the form `A::B', since
@@ -5736,7 +5734,7 @@  cp_parser_postfix_expression (cp_parser *parser, b
 
 	/* And the expression which is being cast.  */
 	cp_parser_require (parser, CPP_OPEN_PAREN, RT_OPEN_PAREN);
-	expression = cp_parser_expression (parser, /*cast_p=*/true, & idk);
+	expression = cp_parser_expression (parser, & idk, /*cast_p=*/true);
 	cp_parser_require (parser, CPP_CLOSE_PAREN, RT_CLOSE_PAREN);
 
 	parser->greater_than_is_operator_p
@@ -5808,7 +5806,7 @@  cp_parser_postfix_expression (cp_parser *parser, b
 	    tree expression;
 
 	    /* Look for an expression.  */
-	    expression = cp_parser_expression (parser, /*cast_p=*/false, & idk);
+	    expression = cp_parser_expression (parser, & idk);
 	    /* Compute its typeid.  */
 	    postfix_expression = build_typeid (expression, tf_warning_or_error);
 	    /* Look for the `)' token.  */
@@ -6350,7 +6348,7 @@  cp_parser_array_notation (location_t loc, cp_parse
 	 2. ARRAY [ EXP : EXP ]
 	 3. ARRAY [ EXP : EXP : EXP ]  */
 
-      *init_index = cp_parser_expression (parser, false, NULL);	
+      *init_index = cp_parser_expression (parser);	
       if (cp_lexer_peek_token (parser->lexer)->type != CPP_COLON)
 	{  
 	  /* This indicates that we have a normal array expression.  */
@@ -6360,11 +6358,11 @@  cp_parser_array_notation (location_t loc, cp_parse
       
       /* Consume the ':'.  */
       cp_lexer_consume_token (parser->lexer);
-      length_index = cp_parser_expression (parser, false, NULL);
+      length_index = cp_parser_expression (parser);
       if (cp_lexer_peek_token (parser->lexer)->type == CPP_COLON)
 	{
 	  cp_lexer_consume_token (parser->lexer);
-	  stride = cp_parser_expression (parser, false, NULL);
+	  stride = cp_parser_expression (parser);
 	}
     }
   parser->colon_corrects_to_scope_p = saved_colon_corrects;
@@ -6449,7 +6447,7 @@  cp_parser_postfix_open_square_expression (cp_parse
 	    return an_exp;
 	}
       else
-	index = cp_parser_expression (parser, /*cast_p=*/false, NULL);
+	index = cp_parser_expression (parser);
     }
 
   parser->greater_than_is_operator_p = saved_greater_than_is_operator_p;
@@ -7149,7 +7147,7 @@  cp_parser_unary_expression (cp_parser *parser, boo
 
 	    ++cp_unevaluated_operand;
 	    ++c_inhibit_evaluation_warnings;
-	    expr = cp_parser_expression (parser, false, NULL);
+	    expr = cp_parser_expression (parser);
 	    --c_inhibit_evaluation_warnings;
 	    --cp_unevaluated_operand;
 
@@ -7582,7 +7580,7 @@  cp_parser_direct_new_declarator (cp_parser* parser
       cp_parser_require (parser, CPP_OPEN_SQUARE, RT_OPEN_SQUARE);
 
       token = cp_lexer_peek_token (parser->lexer);
-      expression = cp_parser_expression (parser, /*cast_p=*/false, NULL);
+      expression = cp_parser_expression (parser);
       /* The standard requires that the expression have integral
 	 type.  DR 74 adds enumeration types.  We believe that the
 	 real intent is that these expressions be handled like the
@@ -8221,7 +8219,7 @@  cp_parser_question_colon_clause (cp_parser* parser
       parser->colon_corrects_to_scope_p = false;
       /* Parse the expression.  */
       c_inhibit_evaluation_warnings += logical_or_expr == truthvalue_false_node;
-      expr = cp_parser_expression (parser, /*cast_p=*/false, NULL);
+      expr = cp_parser_expression (parser);
       c_inhibit_evaluation_warnings +=
 	((logical_or_expr == truthvalue_true_node)
 	 - (logical_or_expr == truthvalue_false_node));
@@ -8420,8 +8418,8 @@  cp_parser_assignment_operator_opt (cp_parser* pars
    Returns a representation of the expression.  */
 
 static tree
-cp_parser_expression (cp_parser* parser, bool cast_p, bool decltype_p,
-		      cp_id_kind * pidk)
+cp_parser_expression (cp_parser* parser, cp_id_kind * pidk,
+		      bool cast_p, bool decltype_p)
 {
   tree expression = NULL_TREE;
   location_t loc = UNKNOWN_LOCATION;
@@ -8468,12 +8466,6 @@  static tree
   return expression;
 }
 
-static inline tree
-cp_parser_expression (cp_parser* parser, bool cast_p, cp_id_kind * pidk)
-{
-  return cp_parser_expression (parser, cast_p, /*decltype*/false, pidk);
-}
-
 /* Parse a constant-expression.
 
    constant-expression:
@@ -9398,7 +9390,7 @@  cp_parser_lambda_body (cp_parser* parser, tree lam
 
 	cp_parser_require_keyword (parser, RID_RETURN, RT_RETURN);
 
-	expr = cp_parser_expression (parser, /*cast_p=*/false, &idk);
+	expr = cp_parser_expression (parser, &idk);
 
 	cp_parser_require (parser, CPP_SEMICOLON, RT_SEMICOLON);
 	cp_parser_require (parser, CPP_CLOSE_BRACE, RT_CLOSE_BRACE);
@@ -9810,7 +9802,7 @@  cp_parser_expression_statement (cp_parser* parser,
      statement.  */
   if (cp_lexer_next_token_is_not (parser->lexer, CPP_SEMICOLON))
     {
-      statement = cp_parser_expression (parser, /*cast_p=*/false, NULL);
+      statement = cp_parser_expression (parser);
       if (statement == error_mark_node
 	  && !cp_parser_uncommitted_to_tentative_parse_p (parser))
 	{
@@ -10211,7 +10203,7 @@  cp_parser_condition (cp_parser* parser)
     cp_parser_abort_tentative_parse (parser);
 
   /* Otherwise, we are looking at an expression.  */
-  return cp_parser_expression (parser, /*cast_p=*/false, NULL);
+  return cp_parser_expression (parser);
 }
 
 /* Parses a for-statement or range-for-statement until the closing ')',
@@ -10263,7 +10255,7 @@  cp_parser_c_for (cp_parser *parser, tree scope, tr
 
   /* If there's an expression, process it.  */
   if (cp_lexer_next_token_is_not (parser->lexer, CPP_CLOSE_PAREN))
-    expression = cp_parser_expression (parser, /*cast_p=*/false, NULL);
+    expression = cp_parser_expression (parser);
   finish_for_expr (expression, stmt);
 
   return stmt;
@@ -10291,7 +10283,7 @@  cp_parser_range_for (cp_parser *parser, tree scope
       range_expr = cp_parser_braced_list (parser, &expr_non_constant_p);
     }
   else
-    range_expr = cp_parser_expression (parser, /*cast_p=*/false, NULL);
+    range_expr = cp_parser_expression (parser);
 
   /* If in template, STMT is converted to a normal for-statement
      at instantiation. If not, it is done just ahead. */
@@ -10679,7 +10671,7 @@  cp_parser_iteration_statement (cp_parser* parser,
 	/* Look for the `('.  */
 	cp_parser_require (parser, CPP_OPEN_PAREN, RT_OPEN_PAREN);
 	/* Parse the expression.  */
-	expression = cp_parser_expression (parser, /*cast_p=*/false, NULL);
+	expression = cp_parser_expression (parser);
 	/* We're done with the do-statement.  */
 	finish_do_stmt (expression, statement, ivdep);
 	/* Look for the `)'.  */
@@ -10889,7 +10881,7 @@  cp_parser_jump_statement (cp_parser* parser)
 	    expr = cp_parser_braced_list (parser, &expr_non_constant_p);
 	  }
 	else if (cp_lexer_next_token_is_not (parser->lexer, CPP_SEMICOLON))
-	  expr = cp_parser_expression (parser, /*cast_p=*/false, NULL);
+	  expr = cp_parser_expression (parser);
 	else
 	  /* If the next token is a `;', then there is no
 	     expression.  */
@@ -10910,7 +10902,7 @@  cp_parser_jump_statement (cp_parser* parser)
 	  /* Consume the '*' token.  */
 	  cp_lexer_consume_token (parser->lexer);
 	  /* Parse the dependent expression.  */
-	  finish_goto_stmt (cp_parser_expression (parser, /*cast_p=*/false, NULL));
+	  finish_goto_stmt (cp_parser_expression (parser));
 	}
       else
 	finish_goto_stmt (cp_parser_identifier (parser));
@@ -12130,8 +12122,8 @@  cp_parser_decltype_expr (cp_parser *parser,
       cp_parser_abort_tentative_parse (parser);
 
       /* Parse a full expression.  */
-      expr = cp_parser_expression (parser, /*cast_p=*/false,
-				   /*decltype*/true, NULL);
+      expr = cp_parser_expression (parser, /*pidk=*/NULL, /*cast_p=*/false,
+				   /*decltype_p=*/true);
     }
 
   return expr;
@@ -21215,7 +21207,7 @@  cp_parser_noexcept_specification_opt (cp_parser* p
 	    }
 	  else
 	    {
-	      expr = cp_parser_expression (parser, false, NULL);
+	      expr = cp_parser_expression (parser);
 	      *consumed_expr = true;
 	    }
 
@@ -21612,7 +21604,7 @@  cp_parser_asm_operand_list (cp_parser* parser)
       /* Look for the `('.  */
       cp_parser_require (parser, CPP_OPEN_PAREN, RT_OPEN_PAREN);
       /* Parse the expression.  */
-      expression = cp_parser_expression (parser, /*cast_p=*/false, NULL);
+      expression = cp_parser_expression (parser);
       /* Look for the `)'.  */
       cp_parser_require (parser, CPP_CLOSE_PAREN, RT_CLOSE_PAREN);
 
@@ -25386,7 +25378,7 @@  cp_parser_objc_message_receiver (cp_parser* parser
   /* An Objective-C message receiver may be either (1) a type
      or (2) an expression.  */
   cp_parser_parse_tentatively (parser);
-  rcv = cp_parser_expression (parser, false, NULL);
+  rcv = cp_parser_expression (parser);
 
   if (cp_parser_parse_definitely (parser))
     return rcv;
@@ -26740,7 +26732,7 @@  cp_parser_objc_synchronized_statement (cp_parser *
   location = cp_lexer_peek_token (parser->lexer)->location;
   objc_maybe_warn_exceptions (location);
   cp_parser_require (parser, CPP_OPEN_PAREN, RT_OPEN_PAREN);
-  lock = cp_parser_expression (parser, false, NULL);
+  lock = cp_parser_expression (parser);
   cp_parser_require (parser, CPP_CLOSE_PAREN, RT_CLOSE_PAREN);
 
   /* NB: The @synchronized block needs to be wrapped in its own STATEMENT_LIST
@@ -26767,7 +26759,7 @@  cp_parser_objc_throw_statement (cp_parser *parser)
   cp_parser_require_keyword (parser, RID_AT_THROW, RT_AT_THROW);
 
   if (cp_lexer_next_token_is_not (parser->lexer, CPP_SEMICOLON))
-    expr = cp_parser_expression (parser, /*cast_p=*/false, NULL);
+    expr = cp_parser_expression (parser);
 
   cp_parser_consume_semicolon_at_end_of_statement (parser);
 
@@ -27424,8 +27416,7 @@  cp_parser_omp_var_list_no_open (cp_parser *parser,
 		  parser->colon_corrects_to_scope_p = false;
 		  cp_lexer_consume_token (parser->lexer);
 		  if (!cp_lexer_next_token_is (parser->lexer, CPP_COLON))
-		    low_bound = cp_parser_expression (parser, /*cast_p=*/false,
-						      NULL);
+		    low_bound = cp_parser_expression (parser);
 		  if (!colon)
 		    parser->colon_corrects_to_scope_p
 		      = saved_colon_corrects_to_scope_p;
@@ -27438,9 +27429,7 @@  cp_parser_omp_var_list_no_open (cp_parser *parser,
 			goto skip_comma;
 		      if (!cp_lexer_next_token_is (parser->lexer,
 						   CPP_CLOSE_SQUARE))
-			length = cp_parser_expression (parser,
-						       /*cast_p=*/false,
-						       NULL);
+			length = cp_parser_expression (parser);
 		    }
 		  /* Look for the closing `]'.  */
 		  if (!cp_parser_require (parser, CPP_CLOSE_SQUARE,
@@ -27708,7 +27697,7 @@  cp_parser_omp_clause_num_threads (cp_parser *parse
   if (!cp_parser_require (parser, CPP_OPEN_PAREN, RT_OPEN_PAREN))
     return list;
 
-  t = cp_parser_expression (parser, false, NULL);
+  t = cp_parser_expression (parser);
 
   if (t == error_mark_node
       || !cp_parser_require (parser, CPP_CLOSE_PAREN, RT_CLOSE_PAREN))
@@ -28002,7 +27991,7 @@  cp_parser_omp_clause_num_teams (cp_parser *parser,
   if (!cp_parser_require (parser, CPP_OPEN_PAREN, RT_OPEN_PAREN))
     return list;
 
-  t = cp_parser_expression (parser, false, NULL);
+  t = cp_parser_expression (parser);
 
   if (t == error_mark_node
       || !cp_parser_require (parser, CPP_CLOSE_PAREN, RT_CLOSE_PAREN))
@@ -28032,7 +28021,7 @@  cp_parser_omp_clause_thread_limit (cp_parser *pars
   if (!cp_parser_require (parser, CPP_OPEN_PAREN, RT_OPEN_PAREN))
     return list;
 
-  t = cp_parser_expression (parser, false, NULL);
+  t = cp_parser_expression (parser);
 
   if (t == error_mark_node
       || !cp_parser_require (parser, CPP_CLOSE_PAREN, RT_CLOSE_PAREN))
@@ -28104,7 +28093,7 @@  cp_parser_omp_clause_linear (cp_parser *parser, tr
 
   if (colon)
     {
-      step = cp_parser_expression (parser, false, NULL);
+      step = cp_parser_expression (parser);
 
       if (is_cilk_simd_fn && TREE_CODE (step) == PARM_DECL)
 	{
@@ -28300,7 +28289,7 @@  cp_parser_omp_clause_device (cp_parser *parser, tr
   if (!cp_parser_require (parser, CPP_OPEN_PAREN, RT_OPEN_PAREN))
     return list;
 
-  t = cp_parser_expression (parser, false, NULL);
+  t = cp_parser_expression (parser);
 
   if (t == error_mark_node
       || !cp_parser_require (parser, CPP_CLOSE_PAREN, RT_CLOSE_PAREN))
@@ -28839,7 +28828,7 @@  cp_parser_omp_atomic (cp_parser *parser, cp_token
       if (!cp_parser_require (parser, CPP_EQ, RT_EQ))
 	goto saw_error;
       if (code == NOP_EXPR)
-	lhs = cp_parser_expression (parser, /*cast_p=*/false, NULL);
+	lhs = cp_parser_expression (parser);
       else
 	lhs = cp_parser_unary_expression (parser, /*address_p=*/false,
 					  /*cast_p=*/false, NULL);
@@ -29019,7 +29008,7 @@  restart:
 	      cp_parser_abort_tentative_parse (parser);
 	      if (structured_block && code == OMP_ATOMIC_CAPTURE_OLD)
 		{
-		  rhs = cp_parser_expression (parser, /*cast_p=*/false, NULL);
+		  rhs = cp_parser_expression (parser);
 		  if (rhs == error_mark_node)
 		    goto saw_error;
 		  opcode = NOP_EXPR;
@@ -29105,7 +29094,7 @@  restart:
 	}
       cp_lexer_consume_token (parser->lexer);
 
-      rhs = cp_parser_expression (parser, false, NULL);
+      rhs = cp_parser_expression (parser);
       if (rhs == error_mark_node)
 	goto saw_error;
       break;
@@ -29511,7 +29500,7 @@  cp_parser_omp_for_loop_init (cp_parser *parser,
 	{
 	  decl = NULL;
 	  cp_parser_abort_tentative_parse (parser);
-	  init = cp_parser_expression (parser, false, NULL);
+	  init = cp_parser_expression (parser);
 	  if (init)
 	    {
 	      if (TREE_CODE (init) == MODIFY_EXPR
@@ -29685,7 +29674,7 @@  cp_parser_omp_for_loop (cp_parser *parser, enum tr
 		  || CLASS_TYPE_P (TREE_TYPE (real_decl))))
 	    incr = cp_parser_omp_for_incr (parser, real_decl);
 	  else
-	    incr = cp_parser_expression (parser, false, NULL);
+	    incr = cp_parser_expression (parser);
 	  if (CAN_HAVE_LOCATION_P (incr) && !EXPR_HAS_LOCATION (incr))
 	    SET_EXPR_LOCATION (incr, input_location);
 	}
@@ -30895,7 +30884,7 @@  cp_parser_omp_declare_reduction_exprs (tree fndecl
 
   keep_next_level (true);
   tree block = begin_omp_structured_block ();
-  combiner = cp_parser_expression (parser, false, NULL);
+  combiner = cp_parser_expression (parser);
   finish_expr_stmt (combiner);
   block = finish_omp_structured_block (block);
   add_stmt (block);
@@ -31512,7 +31501,7 @@  cp_parser_transaction_expression (cp_parser *parse
     {
       cp_parser_require (parser, CPP_OPEN_PAREN, RT_OPEN_PAREN);
 
-      expr = cp_parser_expression (parser, /*cast_p=*/false, NULL);
+      expr = cp_parser_expression (parser);
       expr = finish_parenthesized_expr (expr);
 
       cp_parser_require (parser, CPP_CLOSE_PAREN, RT_CLOSE_PAREN);