Hi,
another straightforward one sitting in my tree... Sanity checked on
x86_64-linux.
Thanks, Paolo.
///////////////////
2019-05-14 Paolo Carlini <paolo.carl...@oracle.com>
* call.c (perform_overload_resolution, build_new_method_call_1):
Use OVL_P.
* decl.c (grokfndecl): Likewise.
* mangle.c (write_expression): Likewise.
* parser.c (cp_parser_template_id): Likewise.
* pt.c (resolve_overloaded_unification, type_dependent_expression_p):
Likewise.
* search.c (build_baselink): Likewise.
* tree.c (is_overloaded_fn, dependent_name, maybe_get_fns): Likewise.
Index: call.c
===================================================================
--- call.c (revision 271166)
+++ call.c (working copy)
@@ -4383,9 +4383,8 @@ perform_overload_resolution (tree fn,
*any_viable_p = true;
/* Check FN. */
- gcc_assert (TREE_CODE (fn) == FUNCTION_DECL
+ gcc_assert (OVL_P (fn)
|| TREE_CODE (fn) == TEMPLATE_DECL
- || TREE_CODE (fn) == OVERLOAD
|| TREE_CODE (fn) == TEMPLATE_ID_EXPR);
if (TREE_CODE (fn) == TEMPLATE_ID_EXPR)
@@ -9605,9 +9604,8 @@ build_new_method_call_1 (tree instance, tree fns,
fns = TREE_OPERAND (fns, 0);
template_only = 1;
}
- gcc_assert (TREE_CODE (fns) == FUNCTION_DECL
- || TREE_CODE (fns) == TEMPLATE_DECL
- || TREE_CODE (fns) == OVERLOAD);
+ gcc_assert (OVL_P (fns)
+ || TREE_CODE (fns) == TEMPLATE_DECL);
fn = OVL_FIRST (fns);
name = DECL_NAME (fn);
Index: decl.c
===================================================================
--- decl.c (revision 271166)
+++ decl.c (working copy)
@@ -8918,9 +8918,7 @@ grokfndecl (tree ctype,
the information in the TEMPLATE_ID_EXPR. */
SET_DECL_IMPLICIT_INSTANTIATION (decl);
- gcc_assert (identifier_p (fns)
- || TREE_CODE (fns) == OVERLOAD
- || TREE_CODE (fns) == FUNCTION_DECL);
+ gcc_assert (identifier_p (fns) || OVL_P (fns));
DECL_TEMPLATE_INFO (decl) = build_template_info (fns, args);
for (t = TYPE_ARG_TYPES (TREE_TYPE (decl)); t; t = TREE_CHAIN (t))
Index: mangle.c
===================================================================
--- mangle.c (revision 271166)
+++ mangle.c (working copy)
@@ -3278,8 +3278,7 @@ write_expression (tree expr)
/* Mangle a dependent name as the name, not whatever happens to
be the first function in the overload set. */
- if ((TREE_CODE (fn) == FUNCTION_DECL
- || TREE_CODE (fn) == OVERLOAD)
+ if (OVL_P (fn)
&& type_dependent_expression_p_push (expr))
fn = OVL_NAME (fn);
Index: parser.c
===================================================================
--- parser.c (revision 271166)
+++ parser.c (working copy)
@@ -16479,10 +16479,9 @@ cp_parser_template_id (cp_parser *parser,
{
/* If it's not a class-template or a template-template, it should be
a function-template. */
- gcc_assert ((DECL_FUNCTION_TEMPLATE_P (templ)
- || TREE_CODE (templ) == OVERLOAD
- || TREE_CODE (templ) == FUNCTION_DECL
- || BASELINK_P (templ)));
+ gcc_assert (DECL_FUNCTION_TEMPLATE_P (templ)
+ || OVL_P (templ)
+ || BASELINK_P (templ));
template_id = lookup_template_function (templ, arguments);
if (TREE_CODE (template_id) == TEMPLATE_ID_EXPR)
Index: pt.c
===================================================================
--- pt.c (revision 271166)
+++ pt.c (working copy)
@@ -21193,8 +21193,7 @@ resolve_overloaded_unification (tree tparms,
if (good != 1)
good = ok;
}
- else if (TREE_CODE (arg) != OVERLOAD
- && TREE_CODE (arg) != FUNCTION_DECL)
+ else if (!OVL_P (arg))
/* If ARG is, for example, "(0, &f)" then its type will be unknown
-- but the deduction does not succeed because the expression is
not just the function on its own. */
@@ -25950,8 +25949,7 @@ type_dependent_expression_p (tree expression)
return true;
}
- gcc_assert (TREE_CODE (expression) == OVERLOAD
- || TREE_CODE (expression) == FUNCTION_DECL);
+ gcc_assert (OVL_P (expression));
for (lkp_iterator iter (expression); iter; ++iter)
if (type_dependent_expression_p (*iter))
Index: search.c
===================================================================
--- search.c (revision 271166)
+++ search.c (working copy)
@@ -1058,10 +1058,9 @@ build_baselink (tree binfo, tree access_binfo, tre
{
tree baselink;
- gcc_assert (TREE_CODE (functions) == FUNCTION_DECL
+ gcc_assert (OVL_P (functions)
|| TREE_CODE (functions) == TEMPLATE_DECL
- || TREE_CODE (functions) == TEMPLATE_ID_EXPR
- || TREE_CODE (functions) == OVERLOAD);
+ || TREE_CODE (functions) == TEMPLATE_ID_EXPR);
gcc_assert (!optype || TYPE_P (optype));
gcc_assert (TREE_TYPE (functions));
Index: tree.c
===================================================================
--- tree.c (revision 271166)
+++ tree.c (working copy)
@@ -2381,8 +2381,7 @@ is_overloaded_fn (tree x)
|| (TREE_CODE (x) == OVERLOAD && !OVL_SINGLE_P (x)))
return 2;
- return (TREE_CODE (x) == FUNCTION_DECL
- || TREE_CODE (x) == OVERLOAD);
+ return OVL_P (x);
}
/* X is the CALL_EXPR_FN of a CALL_EXPR. If X represents a dependent name
@@ -2396,7 +2395,7 @@ dependent_name (tree x)
return x;
if (TREE_CODE (x) == TEMPLATE_ID_EXPR)
x = TREE_OPERAND (x, 0);
- if (TREE_CODE (x) == OVERLOAD || TREE_CODE (x) == FUNCTION_DECL)
+ if (OVL_P (x))
return OVL_NAME (x);
return NULL_TREE;
}
@@ -2428,8 +2427,7 @@ maybe_get_fns (tree from)
if (TREE_CODE (from) == TEMPLATE_ID_EXPR)
from = TREE_OPERAND (from, 0);
- if (TREE_CODE (from) == OVERLOAD
- || TREE_CODE (from) == FUNCTION_DECL)
+ if (OVL_P (from))
return from;
return NULL;
