c++: Yet more name-lookup api simplification

This patch deals with LOOKUP_HIDDEN, which originally meant 'find
hidden friends', but it's being pressed into service for not ignoring
lambda-relevant internals.  However these two functions are different.
(a) hidden friends can occur in block scope (very uncommon) and (b) it
had the semantics of stopping after the innermost enclosing
namepspace.  That's really suspect for the lambda case, but not
relevant there because we never get to namespace scope (I think).
Anyway, I've split the flag into two and adjusted the lambda callers
to just search block scope.  These two flags are added to the
LOOK_want enum class, which allows dropping another parameter from the
name lookup routines.

The remaining LOOKUP_$FOO flags in cp-tree.h are, I think, now all
related to features of overload resolution, conversion operators and
reference binding.  Nothing to do with /name/ lookup.

	gcc/cp/
	* cp-tree.h (LOOKUP_HIDDEN): Delete.
	(LOOKUP_PREFER_RVALUE): Adjust initializer.
	* name-lookup.h (enum class LOOK_want): Add HIDDEN_FRIEND and
	HIDDEN_LAMBDA flags.
	(lookup_name_real): Drop flags parm.
	(lookup_qualified_name): Drop find_hidden parm.
	* name-lookup.c (class name_lookup): Drop hidden field, adjust
	ctors.
	(name_lookup::add_overload): Check want for hiddenness.
	(name_lookup::process_binding): Likewise.
	(name_lookup::search_unqualified): Likewise.
	(identifier_type_value_1): Adjust lookup_name_real call.
	(set_decl_namespace): Adjust name_lookup ctor.
	(qualify_lookup): Drop flags parm, use want for hiddenness.
	(lookup_qualified_name): Drop find_hidden parm.
	(lookup_name_real_1): Drop flags parm, adjust qualify_lookup
	calls.
	(lookup_name_real): Drop flags parm.
	(lookup_name_nonclass, lookup_name): Adjust lookup_name_real
	calls.
	(lookup_type_scope_1): Adjust qualify_lookup calls.
	* call.c (build_operator_new_call): Adjust lookup_name_real call.
	(add_operator_candidates): Likewise.
	* coroutines.cc (morph_fn_to_coro): Adjust lookup_qualified_name
	call.
	* parser.c (cp_parser_lookup_name): Adjust lookup_name_real calls.
	* pt.c (check_explicit_specialization): Adjust
	lookup_qualified_name call.
	(deduction_guides_for): Likewise.
	(tsubst_friend_class): Adjust lookup_name_real call.
	(lookup_init_capture_pack): Likewise.
	(tsubst_expr): Likewise, don't look in namespaces.
	* semantics.c (capture_decltype): Adjust lookup_name_real.  Don't
	look in namespaces.
	libcc1/
	* libcp1plugin.cc (plugin_build_dependent_exp): Adjust
	lookup_name_real call.

diff --git a/gcc/cp/call.c b/gcc/cp/call.c
index 94aaf65b3f4459a62a2b22b073f3e5fc2675d11d..8c03fcaf74b3c6b81984bc71b1919fa3b924da5e 100644 (file)
--- 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 (file)
--- 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 (file)
--- 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 (file)
--- 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 (file)
--- 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 (file)
--- 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 (file)
--- 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 (file)
--- 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 (file)
--- 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);