From de8ba53f9a0d3b42010ab46eb76816aacc526ab1 Mon Sep 17 00:00:00 2001
From: David Malcolm <dmalcolm@redhat.com>
Date: Tue, 3 Nov 2015 12:09:49 -0500
Subject: [PATCH 21/27] FIXME: more WIP

---
 gcc/cp/cp-tree.h                                   | 125 ++++++++++++---------
 gcc/cp/name-lookup.c                               |   6 +-
 gcc/cp/name-lookup.h                               |   2 +-
 gcc/cp/parser.c                                    |  90 +++++++--------
 gcc/cp/semantics.c                                 |   4 +-
 gcc/cp/typeck.c                                    |   2 +-
 .../g++.dg/plugin/diagnostic-test-expressions-1.c  |   2 +-
 7 files changed, 123 insertions(+), 108 deletions(-)

diff --git a/gcc/cp/cp-tree.h b/gcc/cp/cp-tree.h
index 895d89c..90f6cba 100644
--- a/gcc/cp/cp-tree.h
+++ b/gcc/cp/cp-tree.h
@@ -40,6 +40,74 @@ c-common.h, not after.
 #include "c-family/c-common.h"
 #include "diagnostic.h"
 
+/* A tree node, together with a location, so that we can track locations
+   (and ranges) during parsing.
+
+   The location is redundant for node kinds that have locations,
+   but not all node kinds do (e.g. constants, and references to
+   params, locals, etc), so we stash a copy here.  */
+
+class cp_expr
+{
+public:
+  cp_expr () :
+    m_value (NULL), m_loc (UNKNOWN_LOCATION) {}
+
+  cp_expr (tree value) :
+    m_value (value), m_loc (EXPR_LOCATION (m_value))
+  {
+    if (m_value && m_value != error_mark_node)
+      {
+	if (TREE_CODE (m_value) == FUNCTION_DECL)
+	  return; // for now
+	gcc_assert (CAN_HAVE_LOCATION_P (m_value));
+	//gcc_assert (m_loc != UNKNOWN_LOCATION);
+      }
+  }
+
+  cp_expr (tree value, location_t loc):
+    m_value (value), m_loc (loc)
+  {
+    if (m_value)
+      gcc_assert (m_loc != UNKNOWN_LOCATION);
+  }
+
+  cp_expr (const cp_expr &other) :
+    m_value (other.m_value), m_loc (other.m_loc) {}
+
+  /* FIXME: should we use ctors, or have explicit conversion? */
+  static cp_expr build (tree value, location_t loc) { return cp_expr (value, loc); }
+  static cp_expr build (tree value) { return cp_expr (value); }
+
+  /* Implicit conversions to tree.  */
+  operator tree () const { return m_value; }
+  tree & operator* () { return m_value; }
+  tree & operator-> () { return m_value; }
+
+  tree get_value () const { return m_value; }
+  location_t get_location () const { return EXPR_LOCATION (m_value); }
+  location_t get_start () const
+  {
+    source_range src_range = get_range_from_loc (line_table, m_loc);
+    return src_range.m_start;
+  }
+  location_t get_finish () const
+  {
+    source_range src_range = get_range_from_loc (line_table, m_loc);
+    return src_range.m_finish;
+  }
+
+ private:
+  tree m_value;
+  location_t m_loc;
+};
+
+inline bool
+operator == (const cp_expr &lhs, tree rhs)
+{
+  return lhs.get_value () == rhs;
+}
+
 #include "name-lookup.h"
 
 /* Usage of TREE_LANG_FLAG_?:
@@ -5440,59 +5508,6 @@ extern cp_parameter_declarator *no_parameters;
 /* True if we saw "#pragma GCC java_exceptions".  */
 extern bool pragma_java_exceptions;
 
-/* A tree node, together with a location, so that we can track locations
-   (and ranges) during parsing.
-
-   The location is redundant for node kinds that have locations,
-   but not all node kinds do (e.g. constants, and references to
-   params, locals, etc), so we stash a copy here.  */
-
-class cp_expr
-{
-public:
-  cp_expr () :
-    m_value (NULL), m_loc (UNKNOWN_LOCATION) {}
-
-  cp_expr (tree value) :
-    m_value (value), m_loc (EXPR_LOCATION (m_value)) {}
-
-  cp_expr (tree value, location_t loc):
-    m_value (value), m_loc (loc) {}
-
-  cp_expr (const cp_expr &other) :
-    m_value (other.m_value), m_loc (other.m_loc) {}
-
-  /* FIXME: should we use ctors, or have explicit conversion? */
-  static cp_expr build (tree value, location_t loc) { return cp_expr (value, loc); }
-  static cp_expr build (tree value) { return cp_expr (value); }
-
-  /* Implicit conversion to tree.  */
-  operator tree () const { return m_value; }
-
-  tree get_value () const { return m_value; }
-  location_t get_location () const { return EXPR_LOCATION (m_value); }
-  location_t get_start () const
-  {
-    source_range src_range = get_range_from_loc (line_table, m_loc);
-    return src_range.m_start;
-  }
-  location_t get_finish () const
-  {
-    source_range src_range = get_range_from_loc (line_table, m_loc);
-    return src_range.m_finish;
-  }
-
- private:
-  tree m_value;
-  location_t m_loc;
-};
-
-inline bool
-operator == (const cp_expr &lhs, tree rhs)
-{
-  return lhs.get_value () == rhs;
-}
-
 /* in call.c */
 extern bool check_dtor_name			(tree, tree);
 bool magic_varargs_p                            (tree);
@@ -6303,7 +6318,7 @@ extern tree finish_stmt_expr_expr		(tree, tree);
 extern tree finish_stmt_expr			(tree, bool);
 extern tree stmt_expr_value_expr		(tree);
 bool empty_expr_stmt_p				(tree);
-extern tree perform_koenig_lookup		(tree, vec<tree, va_gc> *,
+extern cp_expr perform_koenig_lookup		(cp_expr, vec<tree, va_gc> *,
 						 tsubst_flags_t);
 extern tree finish_call_expr			(tree, vec<tree, va_gc> **, bool,
 						 bool, tsubst_flags_t);
@@ -6608,7 +6623,7 @@ extern tree build_reinterpret_cast		(tree, tree, tsubst_flags_t);
 extern tree build_const_cast			(tree, tree, tsubst_flags_t);
 extern tree build_c_cast			(location_t, tree, tree);
 extern tree cp_build_c_cast			(tree, tree, tsubst_flags_t);
-extern tree build_x_modify_expr			(location_t, tree,
+extern cp_expr build_x_modify_expr		(location_t, tree,
 						 enum tree_code, tree,
 						 tsubst_flags_t);
 extern tree cp_build_modify_expr		(tree, enum tree_code, tree,
diff --git a/gcc/cp/name-lookup.c b/gcc/cp/name-lookup.c
index b503012..35c27d5 100644
--- a/gcc/cp/name-lookup.c
+++ b/gcc/cp/name-lookup.c
@@ -5666,7 +5666,7 @@ arg_assoc (struct arg_lookup *k, tree n)
 /* Performs Koenig lookup depending on arguments, where fns
    are the functions found in normal lookup.  */
 
-static tree
+static cp_expr
 lookup_arg_dependent_1 (tree name, tree fns, vec<tree, va_gc> *args)
 {
   struct arg_lookup k;
@@ -5727,10 +5727,10 @@ lookup_arg_dependent_1 (tree name, tree fns, vec<tree, va_gc> *args)
 
 /* Wrapper for lookup_arg_dependent_1.  */
 
-tree
+cp_expr
 lookup_arg_dependent (tree name, tree fns, vec<tree, va_gc> *args)
 {
-  tree ret;
+  cp_expr ret;
   bool subtime;
   subtime = timevar_cond_start (TV_NAME_LOOKUP);
   ret = lookup_arg_dependent_1 (name, fns, args);
diff --git a/gcc/cp/name-lookup.h b/gcc/cp/name-lookup.h
index d430edb..d2453e9 100644
--- a/gcc/cp/name-lookup.h
+++ b/gcc/cp/name-lookup.h
@@ -347,7 +347,7 @@ extern void do_toplevel_using_decl (tree, tree, tree);
 extern void do_local_using_decl (tree, tree, tree);
 extern tree do_class_using_decl (tree, tree);
 extern void do_using_directive (tree);
-extern tree lookup_arg_dependent (tree, tree, vec<tree, va_gc> *);
+extern cp_expr lookup_arg_dependent (tree, tree, vec<tree, va_gc> *);
 extern bool is_associated_namespace (tree, tree);
 extern void parse_using_directive (tree, tree);
 extern tree innermost_non_namespace_value (tree);
diff --git a/gcc/cp/parser.c b/gcc/cp/parser.c
index 6d0a471..ca2b7f0 100644
--- a/gcc/cp/parser.c
+++ b/gcc/cp/parser.c
@@ -2003,11 +2003,11 @@ static tree cp_parser_delete_expression
   (cp_parser *);
 static cp_expr cp_parser_cast_expression
   (cp_parser *, bool, bool, bool, cp_id_kind *);
-static tree cp_parser_binary_expression
+static cp_expr cp_parser_binary_expression
   (cp_parser *, bool, bool, enum cp_parser_prec, cp_id_kind *);
 static tree cp_parser_question_colon_clause
   (cp_parser *, tree);
-static tree cp_parser_assignment_expression
+static cp_expr cp_parser_assignment_expression
   (cp_parser *, cp_id_kind * = NULL, bool = false, bool = false);
 static enum tree_code cp_parser_assignment_operator_opt
   (cp_parser *);
@@ -3158,7 +3158,7 @@ cp_parser_parse_and_diagnose_invalid_type_name (cp_parser *parser)
 				/*check_dependency_p=*/true,
 				/*template_p=*/NULL,
 				/*declarator_p=*/true,
-				/*optional_p=*/false).get_value ();
+				/*optional_p=*/false);
   /* If the next token is a (, this is a function with no explicit return
      type, i.e. constructor, destructor or conversion op.  */
   if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_PAREN)
@@ -4428,10 +4428,10 @@ cp_parser_fold_expression (cp_parser *parser, tree expr1)
         }
 
       tree expr = cp_parser_cast_expression (parser, false, false,
-					     false, &pidk).get_value ();
+					     false, &pidk);
       if (expr == error_mark_node)
-        return cp_expr::build (error_mark_node);
-      return cp_expr::build (finish_left_unary_fold_expr (expr, op));
+        return error_mark_node;
+      return finish_left_unary_fold_expr (expr, op);
     }
 
   const cp_token* token = cp_lexer_peek_token (parser->lexer);
@@ -4439,7 +4439,7 @@ cp_parser_fold_expression (cp_parser *parser, tree expr1)
   if (op == ERROR_MARK)
     {
       cp_parser_error (parser, "expected binary operator");
-      return cp_expr::build (error_mark_node);
+      return error_mark_node;
     }
 
   if (cp_lexer_next_token_is_not (parser->lexer, CPP_ELLIPSIS))
@@ -4472,10 +4472,10 @@ cp_parser_fold_expression (cp_parser *parser, tree expr1)
 
   // Binary left or right fold.
   tree expr2 = cp_parser_cast_expression (parser, false, false, false,
-                                          &pidk).get_value ();
+                                          &pidk);
   if (expr2 == error_mark_node)
-    return cp_expr::build (error_mark_node);
-  return cp_expr::build (finish_binary_fold_expr (expr1, expr2, op));
+    return error_mark_node;
+  return finish_binary_fold_expr (expr1, expr2, op);
 }
 
 /* Parse a primary-expression.
@@ -4696,8 +4696,8 @@ cp_parser_primary_expression (cp_parser *parser,
 	token = cp_lexer_peek_token (parser->lexer);
 	if (token->type == CPP_ELLIPSIS || cp_parser_fold_operator (token))
 	  {
-	    expr = cp_parser_fold_expression (parser, expr.get_value ());
-	    if (expr.get_value () != error_mark_node
+	    expr = cp_parser_fold_expression (parser, expr);
+	    if (expr != error_mark_node
 		&& cxx_dialect < cxx1z
 		&& !in_system_header_at (input_location))
 	      pedwarn (input_location, 0, "fold-expressions only available "
@@ -4709,7 +4709,7 @@ cp_parser_primary_expression (cp_parser *parser,
 	     example, the expression is of the form `A::B', since
 	     `&A::B' might be a pointer-to-member, but `&(A::B)' is
 	     not.  */
-	  expr = finish_parenthesized_expr (expr.get_value ());
+	  expr = finish_parenthesized_expr (expr);
 
 	/* DR 705: Wrapping an unqualified name in parentheses
 	   suppresses arg-dependent lookup.  We want to pass back
@@ -4953,8 +4953,8 @@ cp_parser_primary_expression (cp_parser *parser,
 	/* If we have a template-id, then no further lookup is
 	   required.  If the template-id was for a template-class, we
 	   will sometimes have a TYPE_DECL at this point.  */
-	if (TREE_CODE (id_expression.get_value ()) == TEMPLATE_ID_EXPR
-            || TREE_CODE (id_expression.get_value ()) == TYPE_DECL)
+	if (TREE_CODE (id_expression) == TEMPLATE_ID_EXPR
+            || TREE_CODE (id_expression) == TYPE_DECL)
 	  decl = id_expression;
 	/* Look up the name.  */
 	else
@@ -4971,7 +4971,7 @@ cp_parser_primary_expression (cp_parser *parser,
 		return error_mark_node;
 	      }
 
-	    decl = cp_parser_lookup_name (parser, id_expression.get_value (),
+	    decl = cp_parser_lookup_name (parser, id_expression,
 					  none_type,
 					  template_p,
 					  /*is_namespace=*/false,
@@ -4987,12 +4987,12 @@ cp_parser_primary_expression (cp_parser *parser,
 	       dot-syntax for classes here.  */
 	    if (c_dialect_objc ()
 		&& cp_lexer_peek_token (parser->lexer)->type == CPP_DOT
-		&& TREE_CODE (decl.get_value ()) == TYPE_DECL
-		&& objc_is_class_name (decl.get_value ()))
+		&& TREE_CODE (decl) == TYPE_DECL
+		&& objc_is_class_name (decl))
 	      {
 		tree component;
 		cp_lexer_consume_token (parser->lexer);
-		component = cp_parser_identifier (parser).get_value ();
+		component = cp_parser_identifier (parser);
 		if (component == error_mark_node)
 		  return error_mark_node;
 
@@ -5009,7 +5009,7 @@ cp_parser_primary_expression (cp_parser *parser,
 
 	    /* If name lookup gives us a SCOPE_REF, then the
 	       qualifying scope was dependent.  */
-	    if (TREE_CODE (decl.get_value ()) == SCOPE_REF)
+	    if (TREE_CODE (decl) == SCOPE_REF)
 	      {
 		/* At this point, we do not know if DECL is a valid
 		   integral constant expression.  We assume that it is
@@ -7531,7 +7531,7 @@ cp_parser_unary_expression (cp_parser *parser, cp_id_kind * pidk,
 	    /* Save away the PEDANTIC flag.  */
 	    cp_parser_extension_opt (parser, &saved_pedantic);
 	    /* Parse the cast-expression.  */
-	    expr = cp_parser_simple_cast_expression (parser).get_value ();
+	    expr = cp_parser_simple_cast_expression (parser);
 	    /* Restore the PEDANTIC flag.  */
 	    pedantic = saved_pedantic;
 
@@ -7546,7 +7546,7 @@ cp_parser_unary_expression (cp_parser *parser, cp_id_kind * pidk,
 	    /* Consume the `__real__' or `__imag__' token.  */
 	    cp_lexer_consume_token (parser->lexer);
 	    /* Parse the cast-expression.  */
-	    expression = cp_parser_simple_cast_expression (parser).get_value ();
+	    expression = cp_parser_simple_cast_expression (parser);
 	    /* Create the complete representation.  */
 	    return build_x_unary_op (token->location,
 				     (keyword == RID_REALPART
@@ -7677,7 +7677,7 @@ cp_parser_unary_expression (cp_parser *parser, cp_id_kind * pidk,
 				     unary_operator == ADDR_EXPR,
 				     /*cast_p=*/false,
 				     /*decltype*/false,
-				     pidk).get_value ();
+				     pidk);
       /* Now, build an appropriate representation.  */
       switch (unary_operator)
 	{
@@ -8138,7 +8138,7 @@ cp_parser_delete_expression (cp_parser* parser)
     array_p = false;
 
   /* Parse the cast-expression.  */
-  expression = cp_parser_simple_cast_expression (parser).get_value ();
+  expression = cp_parser_simple_cast_expression (parser);
 
   /* A delete-expression may not appear in an integral constant
      expression.  */
@@ -8346,7 +8346,7 @@ cp_parser_cast_expression (cp_parser *parser, bool address_p, bool cast_p,
 					    /*address_p=*/false,
 					    /*cast_p=*/true,
 					    /*decltype_p=*/false,
-					    pidk).get_value ();
+					    pidk);
 
 	  if (cp_parser_parse_definitely (parser))
 	    {
@@ -8458,7 +8458,7 @@ cp_parser_cast_expression (cp_parser *parser, bool address_p, bool cast_p,
  ? PREC_NOT_OPERATOR					     \
  : binops_by_token[token->type].prec)
 
-static tree
+static cp_expr
 cp_parser_binary_expression (cp_parser* parser, bool cast_p,
 			     bool no_toplevel_fold_p,
 			     bool decltype_p,
@@ -8533,10 +8533,10 @@ cp_parser_binary_expression (cp_parser* parser, bool cast_p,
 	 disable warnings while evaluating it.  */
       if (current.tree_type == TRUTH_ANDIF_EXPR)
 	c_inhibit_evaluation_warnings +=
-          current.lhs.get_value () == truthvalue_false_node;
+          current.lhs == truthvalue_false_node;
       else if (current.tree_type == TRUTH_ORIF_EXPR)
 	c_inhibit_evaluation_warnings +=
-          current.lhs.get_value () == truthvalue_true_node;
+          current.lhs == truthvalue_true_node;
 
       /* Extract another operand.  It may be the RHS of this expression
 	 or the LHS of a new, higher priority expression.  */
@@ -8584,12 +8584,12 @@ cp_parser_binary_expression (cp_parser* parser, bool cast_p,
       /* Undo the disabling of warnings done above.  */
       if (current.tree_type == TRUTH_ANDIF_EXPR)
 	c_inhibit_evaluation_warnings -=
-          current.lhs.get_value () == truthvalue_false_node;
+          current.lhs == truthvalue_false_node;
       else if (current.tree_type == TRUTH_ORIF_EXPR)
 	c_inhibit_evaluation_warnings -=
-          current.lhs.get_value () == truthvalue_true_node;
+          current.lhs == truthvalue_true_node;
 
-      tree current_lhs = current.lhs.get_value ();
+      tree current_lhs = current.lhs;
       if (warn_logical_not_paren
 	  && TREE_CODE_CLASS (current.tree_type) == tcc_comparison
 	  && current.lhs_type == TRUTH_NOT_EXPR
@@ -8607,7 +8607,7 @@ cp_parser_binary_expression (cp_parser* parser, bool cast_p,
 	      || TREE_TYPE (current_lhs) == NULL_TREE
 	      || TREE_CODE (TREE_TYPE (current_lhs)) != BOOLEAN_TYPE))
 	warn_logical_not_parentheses (current.loc, current.tree_type,
-				      maybe_constant_value (rhs.get_value ()));
+				      maybe_constant_value (rhs));
 
       overload = NULL;
 
@@ -8636,14 +8636,14 @@ cp_parser_binary_expression (cp_parser* parser, bool cast_p,
                                   current.tree_type,
                                   TREE_CODE_CLASS (current.tree_type)
                                   == tcc_comparison
-                                  ? boolean_type_node : TREE_TYPE (current.lhs.get_value ()),
-                                  current.lhs.get_value (), rhs.get_value ());
+                                  ? boolean_type_node : TREE_TYPE (current.lhs),
+                                  current.lhs, rhs);
       else
         current.lhs = build_x_binary_op (combined_loc,
                                          current.tree_type,
-                                         current.lhs.get_value (),
+                                         current.lhs,
                                          current.lhs_type,
-                                         rhs.get_value (),
+                                         rhs,
                                          rhs_type, &overload,
                                          complain_flags (decltype_p));
       current.lhs_type = current.tree_type;
@@ -8662,10 +8662,10 @@ cp_parser_binary_expression (cp_parser* parser, bool cast_p,
 	return error_mark_node;
     }
 
-  return current.lhs.get_value ();
+  return current.lhs;
 }
 
-static tree
+static cp_expr
 cp_parser_binary_expression (cp_parser* parser, bool cast_p,
 			     bool no_toplevel_fold_p,
 			     enum cp_parser_prec prec,
@@ -8747,11 +8747,11 @@ cp_parser_question_colon_clause (cp_parser* parser, tree logical_or_expr)
 
    Returns a representation for the expression.  */
 
-static tree
+static cp_expr
 cp_parser_assignment_expression (cp_parser* parser, cp_id_kind * pidk,
 				 bool cast_p, bool decltype_p)
 {
-  tree expr;
+  cp_expr expr;
 
   /* If the next token is the `throw' keyword, then we're looking at
      a throw-expression.  */
@@ -8914,12 +8914,12 @@ static cp_expr
 cp_parser_expression (cp_parser* parser, cp_id_kind * pidk,
 		      bool cast_p, bool decltype_p)
 {
-  tree expression = NULL_TREE;
+  cp_expr expression = NULL_TREE;
   location_t loc = UNKNOWN_LOCATION;
 
   while (true)
     {
-      tree assignment_expression;
+      cp_expr assignment_expression;
 
       /* Parse the next assignment-expression.  */
       assignment_expression
@@ -26008,7 +26008,7 @@ cp_parser_sizeof_operand (cp_parser* parser, enum rid keyword)
   /* If the type-id production did not work out, then we must be
      looking at the unary-expression production.  */
   if (!expr)
-    expr = cp_parser_unary_expression (parser).get_value ();
+    expr = cp_parser_unary_expression (parser);
 
   /* Go back to evaluating expressions.  */
   --cp_unevaluated_operand;
@@ -31362,7 +31362,7 @@ restart:
 	  cp_token *token;
 	  cp_lexer_consume_token (parser->lexer);
 	  cp_parser_parse_tentatively (parser);
-	  rhs1 = cp_parser_simple_cast_expression (parser).get_value ();
+	  rhs1 = cp_parser_simple_cast_expression (parser);
 	  if (rhs1 == error_mark_node)
 	    {
 	      cp_parser_abort_tentative_parse (parser);
@@ -31659,7 +31659,7 @@ cp_parser_omp_for_incr (cp_parser *parser, tree decl)
       op = (token->type == CPP_PLUS_PLUS
 	    ? PREINCREMENT_EXPR : PREDECREMENT_EXPR);
       cp_lexer_consume_token (parser->lexer);
-      lhs = cp_parser_simple_cast_expression (parser).get_value ();
+      lhs = cp_parser_simple_cast_expression (parser);
       if (lhs != decl)
 	return error_mark_node;
       return build2 (op, TREE_TYPE (decl), decl, NULL_TREE);
diff --git a/gcc/cp/semantics.c b/gcc/cp/semantics.c
index 602f01c..2e38e10 100644
--- a/gcc/cp/semantics.c
+++ b/gcc/cp/semantics.c
@@ -2159,8 +2159,8 @@ empty_expr_stmt_p (tree expr_stmt)
    the function (or functions) to call; ARGS are the arguments to the
    call.  Returns the functions to be considered by overload resolution.  */
 
-tree
-perform_koenig_lookup (tree fn, vec<tree, va_gc> *args,
+cp_expr
+perform_koenig_lookup (cp_expr fn, vec<tree, va_gc> *args,
 		       tsubst_flags_t complain)
 {
   tree identifier = NULL_TREE;
diff --git a/gcc/cp/typeck.c b/gcc/cp/typeck.c
index 7c948c6..483f493 100644
--- a/gcc/cp/typeck.c
+++ b/gcc/cp/typeck.c
@@ -7756,7 +7756,7 @@ cp_build_modify_expr (tree lhs, enum tree_code modifycode, tree rhs,
   return result;
 }
 
-tree
+cp_expr
 build_x_modify_expr (location_t loc, tree lhs, enum tree_code modifycode,
 		     tree rhs, tsubst_flags_t complain)
 {
diff --git a/gcc/testsuite/g++.dg/plugin/diagnostic-test-expressions-1.c b/gcc/testsuite/g++.dg/plugin/diagnostic-test-expressions-1.c
index aef7d29..70651f6 100644
--- a/gcc/testsuite/g++.dg/plugin/diagnostic-test-expressions-1.c
+++ b/gcc/testsuite/g++.dg/plugin/diagnostic-test-expressions-1.c
@@ -423,7 +423,7 @@ void test_quadratic (double a, double b, double c)
 #endif
 
 /* FIXME: C++-specific expresssions. */
-void test_literal_keyworkds (int a, int b)
+void test_cp_literal_keywords (int a, int b)
 {
   __emit_expression_range (0, true ); /* { dg-warning "range" } */
   __emit_expression_range (0, false ); /* { dg-warning "range" } */
-- 
1.8.5.3

