diff --git a/gcc/cp/call.c b/gcc/cp/call.c
index 94aaf65b3f4459a62a2b22b073f3e5fc2675d11d..8c03fcaf74b3c6b81984bc71b1919fa3b924da5e 100644
--- a/gcc/cp/call.c
+++ b/gcc/cp/call.c
@@ -4704,7 +4704,7 @@ build_operator_new_call (tree fnname, vec<tree, va_gc> **args,
up in the global scope.
we disregard block-scope declarations of "operator new". */
- fns = lookup_name_real (fnname, LOOK_where::NAMESPACE, LOOK_want::NORMAL, 0);
+ fns = lookup_name_real (fnname, LOOK_where::NAMESPACE, LOOK_want::NORMAL);
fns = lookup_arg_dependent (fnname, fns, *args);
if (align_arg)
@@ -5983,7 +5983,7 @@ add_operator_candidates (z_candidate **candidates,
if (!memonly)
{
tree fns = lookup_name_real (fnname, LOOK_where::BLOCK_NAMESPACE,
- LOOK_want::NORMAL, 0);
+ LOOK_want::NORMAL);
fns = lookup_arg_dependent (fnname, fns, arglist);
add_candidates (fns, NULL_TREE, arglist, NULL_TREE,
NULL_TREE, false, NULL_TREE, NULL_TREE,
diff --git a/gcc/cp/coroutines.cc b/gcc/cp/coroutines.cc
index 22ba81c802524ae956975b63270126cc8c8a833a..898b88b70756402217c6e66b12beb7b05d41f7c7 100644
--- a/gcc/cp/coroutines.cc
+++ b/gcc/cp/coroutines.cc
@@ -4311,7 +4311,7 @@ morph_fn_to_coro (tree orig, tree *resumer, tree *destroyer)
tree std_nt = lookup_qualified_name (std_node,
get_identifier ("nothrow"),
LOOK_want::NORMAL,
- /*complain=*/true, false);
+ /*complain=*/true);
if (!std_nt || std_nt == error_mark_node)
error_at (fn_start, "%qE is provided by %qT but %<std::nothrow%> "
"cannot be found", grooaf, promise_type);
diff --git a/gcc/cp/cp-tree.h b/gcc/cp/cp-tree.h
index 59ab2309d18c6c6e3c91984b3d99e2475cf58551..047585740191a9ab62d54f300918b69e480c6978 100644
--- a/gcc/cp/cp-tree.h
+++ b/gcc/cp/cp-tree.h
@@ -5567,14 +5567,10 @@ enum overload_flags { NO_SPECIAL = 0, DTOR_FLAG, TYPENAME_FLAG };
#define LOOKUP_DESTRUCTOR (1 << 5)
/* Do not permit references to bind to temporaries. */
#define LOOKUP_NO_TEMP_BIND (1 << 6)
-/* Return friend declarations and un-declared builtin functions.
- (Normally, these entities are registered in the symbol table, but
- not found by lookup.) */
-#define LOOKUP_HIDDEN (1 << 7)
/* We're trying to treat an lvalue as an rvalue. */
/* FIXME remove when we extend the P1825 semantics to all standard modes, the
C++20 approach uses IMPLICIT_RVALUE_P instead. */
-#define LOOKUP_PREFER_RVALUE (LOOKUP_HIDDEN << 1)
+#define LOOKUP_PREFER_RVALUE (LOOKUP_NO_TEMP_BIND << 1)
/* We're inside an init-list, so narrowing conversions are ill-formed. */
#define LOOKUP_NO_NARROWING (LOOKUP_PREFER_RVALUE << 1)
/* We're looking up a constructor for list-initialization. */
diff --git a/gcc/cp/name-lookup.c b/gcc/cp/name-lookup.c
index 51de6fb4c36e4ff4a29897187b6df799d81ba2c2..4753dc529e62d28c59604af7429a7285febc232b 100644
--- a/gcc/cp/name-lookup.c
+++ b/gcc/cp/name-lookup.c
@@ -165,7 +165,6 @@ public:
tree value; /* A (possibly ambiguous) set of things found. */
tree type; /* A type that has been found. */
LOOK_want want; /* What kind of entity we want. */
- bool hidden; /* Allow hidden */
bool deduping; /* Full deduping is needed because using declarations
are in play. */
@@ -179,9 +178,9 @@ protected:
static name_lookup *active;
public:
- name_lookup (tree n, LOOK_want w = LOOK_want::NORMAL, bool h = false)
+ name_lookup (tree n, LOOK_want w = LOOK_want::NORMAL)
: name (n), value (NULL_TREE), type (NULL_TREE),
- want (w), hidden (h),
+ want (w),
deduping (false), scopes (NULL), previous (NULL)
{
preserve_state ();
@@ -420,7 +419,7 @@ name_lookup::add_overload (tree fns)
if (!deduping && TREE_CODE (fns) == OVERLOAD)
{
tree probe = fns;
- if (!hidden)
+ if (!bool (want & LOOK_want::HIDDEN_FRIEND))
probe = ovl_skip_hidden (probe);
if (probe && TREE_CODE (probe) == OVERLOAD
&& OVL_DEDUP_P (probe))
@@ -489,12 +488,12 @@ name_lookup::process_binding (tree new_val, tree new_type)
/* Did we really see a type? */
if (new_type
&& ((want & LOOK_want::TYPE_NAMESPACE) == LOOK_want::NAMESPACE
- || (!hidden
+ || (!bool (want & LOOK_want::HIDDEN_FRIEND)
&& DECL_LANG_SPECIFIC (new_type)
&& DECL_ANTICIPATED (new_type))))
new_type = NULL_TREE;
- if (new_val && !hidden)
+ if (new_val && !bool (want & LOOK_want::HIDDEN_FRIEND))
new_val = ovl_skip_hidden (new_val);
/* Do we really see a value? */
@@ -718,13 +717,13 @@ name_lookup::search_unqualified (tree scope, cp_binding_level *level)
if (scope == global_namespace)
break;
- /* If looking for hidden names, we only look in the innermost
+ /* If looking for hidden friends, we only look in the innermost
namespace scope. [namespace.memdef]/3 If a friend
declaration in a non-local class first declares a class,
function, class template or function template the friend is a
member of the innermost enclosing namespace. See also
[basic.lookup.unqual]/7 */
- if (hidden)
+ if (bool (want & LOOK_want::HIDDEN_FRIEND))
break;
}
@@ -3744,7 +3743,7 @@ identifier_type_value_1 (tree id)
return REAL_IDENTIFIER_TYPE_VALUE (id);
/* Have to search for it. It must be on the global level, now.
Ask lookup_name not to return non-types. */
- id = lookup_name_real (id, LOOK_where::BLOCK_NAMESPACE, LOOK_want::TYPE, 0);
+ id = lookup_name_real (id, LOOK_where::BLOCK_NAMESPACE, LOOK_want::TYPE);
if (id)
return TREE_TYPE (id);
return NULL_TREE;
@@ -4818,7 +4817,8 @@ set_decl_namespace (tree decl, tree scope, bool friendp)
children. */
tree old = NULL_TREE;
{
- name_lookup lookup (DECL_NAME (decl), LOOK_want::NORMAL, true);
+ name_lookup lookup (DECL_NAME (decl),
+ LOOK_want::NORMAL | LOOK_want::HIDDEN_FRIEND);
if (!lookup.search_qualified (scope, /*usings=*/false))
/* No old declaration at all. */
goto not_found;
@@ -5217,7 +5217,7 @@ cp_namespace_decls (tree ns)
lookup_type_scope. */
static bool
-qualify_lookup (tree val, LOOK_want want, int flags)
+qualify_lookup (tree val, LOOK_want want)
{
if (val == NULL_TREE)
return false;
@@ -5238,7 +5238,7 @@ qualify_lookup (tree val, LOOK_want want, int flags)
return false;
/* Look through lambda things that we shouldn't be able to see. */
- if (!(flags & LOOKUP_HIDDEN) && is_lambda_ignored_entity (val))
+ if (!bool (want & LOOK_want::HIDDEN_LAMBDA) && is_lambda_ignored_entity (val))
return false;
return true;
@@ -5995,14 +5995,13 @@ suggest_alternative_in_scoped_enum (tree name, tree scoped_enum)
neither a class-type nor a namespace a diagnostic is issued. */
tree
-lookup_qualified_name (tree scope, tree name, LOOK_want want, bool complain,
- bool find_hidden /*=false*/)
+lookup_qualified_name (tree scope, tree name, LOOK_want want, bool complain)
{
tree t = NULL_TREE;
if (TREE_CODE (scope) == NAMESPACE_DECL)
{
- name_lookup lookup (name, want, find_hidden);
+ name_lookup lookup (name, want);
if (qualified_namespace_lookup (scope, &lookup))
t = lookup.value;
@@ -6021,9 +6020,9 @@ lookup_qualified_name (tree scope, tree name, LOOK_want want, bool complain,
/* Wrapper for the above that takes a string argument. The function name is
not at the beginning of the line to keep this wrapper out of etags. */
-tree lookup_qualified_name (tree t, const char *p, LOOK_want w, bool c, bool fh)
+tree lookup_qualified_name (tree t, const char *p, LOOK_want w, bool c)
{
- return lookup_qualified_name (t, get_identifier (p), w, c, fh);
+ return lookup_qualified_name (t, get_identifier (p), w, c);
}
/* [namespace.qual]
@@ -6424,7 +6423,7 @@ innermost_non_namespace_value (tree name)
namespace or type. */
static tree
-lookup_name_real_1 (tree name, LOOK_where where, LOOK_want want, int flags)
+lookup_name_real_1 (tree name, LOOK_where where, LOOK_want want)
{
tree val = NULL_TREE;
@@ -6480,10 +6479,10 @@ lookup_name_real_1 (tree name, LOOK_where where, LOOK_want want, int flags)
continue;
/* If this is the kind of thing we're looking for, we're done. */
- if (qualify_lookup (iter->value, want, flags))
+ if (qualify_lookup (iter->value, want))
binding = iter->value;
else if (bool (want & LOOK_want::TYPE)
- && qualify_lookup (iter->type, want, flags))
+ && qualify_lookup (iter->type, want))
binding = iter->type;
else
binding = NULL_TREE;
@@ -6548,7 +6547,7 @@ lookup_name_real_1 (tree name, LOOK_where where, LOOK_want want, int flags)
/* Now lookup in namespace scopes. */
if (!val && bool (where & LOOK_where::NAMESPACE))
{
- name_lookup lookup (name, want, flags & LOOKUP_HIDDEN);
+ name_lookup lookup (name, want);
if (lookup.search_unqualified
(current_decl_namespace (), current_binding_level))
val = lookup.value;
@@ -6564,11 +6563,10 @@ lookup_name_real_1 (tree name, LOOK_where where, LOOK_want want, int flags)
/* Wrapper for lookup_name_real_1. */
tree
-lookup_name_real (tree name, LOOK_where where, LOOK_want want, int flags)
+lookup_name_real (tree name, LOOK_where where, LOOK_want want)
{
- tree ret;
bool subtime = timevar_cond_start (TV_NAME_LOOKUP);
- ret = lookup_name_real_1 (name, where, want, flags);
+ tree ret = lookup_name_real_1 (name, where, want);
timevar_cond_stop (TV_NAME_LOOKUP, subtime);
return ret;
}
@@ -6576,20 +6574,19 @@ lookup_name_real (tree name, LOOK_where where, LOOK_want want, int flags)
tree
lookup_name_nonclass (tree name)
{
- return lookup_name_real (name, LOOK_where::BLOCK_NAMESPACE,
- LOOK_want::NORMAL, 0);
+ return lookup_name_real (name, LOOK_where::BLOCK_NAMESPACE, LOOK_want::NORMAL);
}
tree
lookup_name (tree name)
{
- return lookup_name_real (name, LOOK_where::ALL, LOOK_want::NORMAL, 0);
+ return lookup_name_real (name, LOOK_where::ALL, LOOK_want::NORMAL);
}
tree
lookup_name (tree name, LOOK_want want)
{
- return lookup_name_real (name, LOOK_where::ALL, want, 0);
+ return lookup_name_real (name, LOOK_where::ALL, want);
}
/* Look up NAME for type used in elaborated name specifier in
@@ -6637,13 +6634,13 @@ lookup_type_scope_1 (tree name, tag_scope scope)
typedef struct C {} C;
correctly. */
if (tree type = iter->type)
- if (qualify_lookup (type, LOOK_want::TYPE, false)
+ if (qualify_lookup (type, LOOK_want::TYPE)
&& (scope != ts_current
|| LOCAL_BINDING_P (iter)
|| DECL_CONTEXT (type) == iter->scope->this_entity))
return type;
- if (qualify_lookup (iter->value, LOOK_want::TYPE, false)
+ if (qualify_lookup (iter->value, LOOK_want::TYPE)
&& (scope != ts_current
|| !INHERITED_VALUE_BINDING_P (iter)))
return iter->value;
@@ -6664,11 +6661,11 @@ lookup_type_scope_1 (tree name, tag_scope scope)
{
/* If this is the kind of thing we're looking for, we're done. */
if (tree type = MAYBE_STAT_TYPE (*slot))
- if (qualify_lookup (type, LOOK_want::TYPE, false))
+ if (qualify_lookup (type, LOOK_want::TYPE))
return type;
if (tree decl = MAYBE_STAT_DECL (*slot))
- if (qualify_lookup (decl, LOOK_want::TYPE, false))
+ if (qualify_lookup (decl, LOOK_want::TYPE))
return decl;
}
diff --git a/gcc/cp/name-lookup.h b/gcc/cp/name-lookup.h
index 79b7a590915f2fd496bf4a884dcb29483a64076c..e43a04c1d6ea1152887b7645d0350c7238a41d90 100644
--- a/gcc/cp/name-lookup.h
+++ b/gcc/cp/name-lookup.h
@@ -306,6 +306,9 @@ enum class LOOK_want
TYPE = 1 << 1, /* We only want TYPE_DECLS. */
NAMESPACE = 1 << 2, /* We only want NAMESPACE_DECLS. */
+ HIDDEN_FRIEND = 1 << 3, /* See hidden friends. */
+ HIDDEN_LAMBDA = 1 << 4, /* See lambda-ignored entities. */
+
TYPE_NAMESPACE = TYPE | NAMESPACE, /* Either NAMESPACE or TYPE. */
};
constexpr LOOK_want operator| (LOOK_want a, LOOK_want b)
@@ -317,7 +320,7 @@ constexpr LOOK_want operator& (LOOK_want a, LOOK_want b)
return LOOK_want (unsigned (a) & unsigned (b));
}
-extern tree lookup_name_real (tree, LOOK_where, LOOK_want, int flags);
+extern tree lookup_name_real (tree, LOOK_where, LOOK_want);
extern tree lookup_type_scope (tree, tag_scope);
extern tree get_namespace_binding (tree ns, tree id);
extern void set_global_binding (tree decl);
@@ -330,10 +333,10 @@ extern tree lookup_name (tree name);
extern tree lookup_name (tree name, LOOK_want);
extern tree lookup_qualified_name (tree scope, tree name,
LOOK_want = LOOK_want::NORMAL,
- bool = true, /*hidden*/bool = false);
+ bool = true);
extern tree lookup_qualified_name (tree scope, const char *name,
LOOK_want = LOOK_want::NORMAL,
- bool = true, bool = false);
+ bool = true);
extern tree lookup_name_nonclass (tree);
extern bool is_local_extern (tree);
extern bool pushdecl_class_level (tree);
diff --git a/gcc/cp/parser.c b/gcc/cp/parser.c
index 2e12a5997278d8df6a3cbacea1c3862213fcae6e..641cedbe3f87370c23df817debd11c52ccd55769 100644
--- a/gcc/cp/parser.c
+++ b/gcc/cp/parser.c
@@ -28462,7 +28462,7 @@ cp_parser_lookup_name (cp_parser *parser, tree name,
template-name after -> or ., only
consider class templates. */
: is_template ? LOOK_want::TYPE
- : prefer_type_arg (tag_type), 0);
+ : prefer_type_arg (tag_type));
parser->object_scope = object_type;
parser->qualifying_scope = NULL_TREE;
}
@@ -28470,8 +28470,7 @@ cp_parser_lookup_name (cp_parser *parser, tree name,
{
decl = lookup_name_real (name, LOOK_where::ALL,
is_namespace ? LOOK_want::NAMESPACE
- : prefer_type_arg (tag_type),
- 0);
+ : prefer_type_arg (tag_type));
parser->qualifying_scope = NULL_TREE;
parser->object_scope = NULL_TREE;
}
diff --git a/gcc/cp/pt.c b/gcc/cp/pt.c
index fe7f71dc05b717e7ab94ce4582056a8ada46b313..74c745a2c5dadd92981bcbf90b349284e96669f7 100644
--- a/gcc/cp/pt.c
+++ b/gcc/cp/pt.c
@@ -2999,9 +2999,10 @@ check_explicit_specialization (tree declarator,
if (fns == error_mark_node)
/* If lookup fails, look for a friend declaration so we can
give a better diagnostic. */
- fns = lookup_qualified_name (CP_DECL_CONTEXT (decl), dname,
- LOOK_want::NORMAL, /*complain*/true,
- /*hidden*/true);
+ fns = (lookup_qualified_name
+ (CP_DECL_CONTEXT (decl), dname,
+ LOOK_want::NORMAL | LOOK_want::HIDDEN_FRIEND,
+ /*complain*/true));
if (fns == error_mark_node || !is_overloaded_fn (fns))
{
@@ -11184,7 +11185,7 @@ tsubst_friend_class (tree friend_tmpl, tree args)
}
tmpl = lookup_name_real (DECL_NAME (friend_tmpl), LOOK_where::CLASS_NAMESPACE,
- LOOK_want::NORMAL, LOOKUP_HIDDEN);
+ LOOK_want::NORMAL | LOOK_want::HIDDEN_FRIEND);
if (tmpl && DECL_CLASS_TEMPLATE_P (tmpl))
{
@@ -17834,8 +17835,7 @@ lookup_init_capture_pack (tree decl)
for (int i = 0; i < len; ++i)
{
tree ename = vec ? make_ith_pack_parameter_name (cname, i) : cname;
- tree elt = lookup_name_real (ename, LOOK_where::ALL, LOOK_want::NORMAL,
- LOOKUP_NORMAL);
+ tree elt = lookup_name_real (ename, LOOK_where::ALL, LOOK_want::NORMAL);
if (vec)
TREE_VEC_ELT (vec, i) = elt;
else
@@ -17940,10 +17940,9 @@ tsubst_expr (tree t, tree args, tsubst_flags_t complain, tree in_decl,
tree inst;
if (!DECL_PACK_P (decl))
{
- inst = lookup_name_real (DECL_NAME (decl),
- LOOK_where::BLOCK_NAMESPACE,
- LOOK_want::NORMAL,
- LOOKUP_HIDDEN);
+ inst = (lookup_name_real
+ (DECL_NAME (decl), LOOK_where::BLOCK,
+ LOOK_want::NORMAL | LOOK_want::HIDDEN_LAMBDA));
gcc_assert (inst != decl && is_capture_proxy (inst));
}
else if (is_normal_capture_proxy (decl))
@@ -28726,8 +28725,7 @@ deduction_guides_for (tree tmpl, tsubst_flags_t complain)
{
guides = lookup_qualified_name (CP_DECL_CONTEXT (tmpl),
dguide_name (tmpl),
- LOOK_want::NORMAL, /*complain*/false,
- /*hidden*/false);
+ LOOK_want::NORMAL, /*complain*/false);
if (guides == error_mark_node)
guides = NULL_TREE;
}
diff --git a/gcc/cp/semantics.c b/gcc/cp/semantics.c
index a7b8eb84b7e23fde31abadea25433f7a5aee6cc9..da452c58daaf7e74a908e190eeca6b7aa427d08b 100644
--- a/gcc/cp/semantics.c
+++ b/gcc/cp/semantics.c
@@ -10322,8 +10322,8 @@ static tree
capture_decltype (tree decl)
{
tree lam = CLASSTYPE_LAMBDA_EXPR (DECL_CONTEXT (current_function_decl));
- tree cap = lookup_name_real (DECL_NAME (decl), LOOK_where::BLOCK_NAMESPACE,
- LOOK_want::NORMAL, LOOKUP_HIDDEN);
+ tree cap = lookup_name_real (DECL_NAME (decl), LOOK_where::BLOCK,
+ LOOK_want::NORMAL | LOOK_want::HIDDEN_LAMBDA);
tree type;
if (cap && is_capture_proxy (cap))
diff --git a/libcc1/libcp1plugin.cc b/libcc1/libcp1plugin.cc
index ddff74522263a5abe6cd3374e8e77c4bf7d6a8c4..e30cb8c024bafcf5ac8e735d0e1aa522fca776b3 100644
--- a/libcc1/libcp1plugin.cc
+++ b/libcc1/libcp1plugin.cc
@@ -2653,7 +2653,7 @@ plugin_build_dependent_expr (cc1_plugin::connection *self,
tree res = identifier;
if (!scope)
res = lookup_name_real (res, LOOK_where::BLOCK_NAMESPACE,
- LOOK_want::NORMAL, 0);
+ LOOK_want::NORMAL);
else if (!TYPE_P (scope) || !dependent_scope_p (scope))
{
res = lookup_qualified_name (scope, res, LOOK_want::NORMAL, true);