1 /* Definitions for C++ name lookup routines.
2 Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012
3 Free Software Foundation, Inc.
4 Contributed by Gabriel Dos Reis <gdr@integrable-solutions.net>
6 This file is part of GCC.
8 GCC is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3, or (at your option)
13 GCC is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with GCC; see the file COPYING3. If not see
20 <http://www.gnu.org/licenses/>. */
24 #include "coretypes.h"
29 #include "name-lookup.h"
31 #include "diagnostic-core.h"
34 #include "c-family/c-pragma.h"
36 #include "pointer-set.h"
38 /* The bindings for a particular name in a particular scope. */
40 struct scope_binding {
44 #define EMPTY_SCOPE_BINDING { NULL_TREE, NULL_TREE }
46 static cp_binding_level *innermost_nonclass_level (void);
47 static cxx_binding *binding_for_name (cp_binding_level *, tree);
48 static tree push_overloaded_decl (tree, int, bool);
49 static bool lookup_using_namespace (tree, struct scope_binding *, tree,
51 static bool qualified_lookup_using_namespace (tree, tree,
52 struct scope_binding *, int);
53 static tree lookup_type_current_level (tree);
54 static tree push_using_directive (tree);
55 static tree lookup_extern_c_fun_in_all_ns (tree);
56 static void diagnose_name_conflict (tree, tree);
58 /* The :: namespace. */
60 tree global_namespace;
62 /* The name of the anonymous namespace, throughout this translation
64 static GTY(()) tree anonymous_namespace_name;
66 /* Initialize anonymous_namespace_name if necessary, and return it. */
69 get_anonymous_namespace_name (void)
71 if (!anonymous_namespace_name)
73 /* The anonymous namespace has to have a unique name
74 if typeinfo objects are being compared by name. */
75 if (! flag_weak || ! SUPPORTS_ONE_ONLY)
76 anonymous_namespace_name = get_file_function_name ("N");
78 /* The demangler expects anonymous namespaces to be called
79 something starting with '_GLOBAL__N_'. */
80 anonymous_namespace_name = get_identifier ("_GLOBAL__N_1");
82 return anonymous_namespace_name;
85 /* Compute the chain index of a binding_entry given the HASH value of its
86 name and the total COUNT of chains. COUNT is assumed to be a power
89 #define ENTRY_INDEX(HASH, COUNT) (((HASH) >> 3) & ((COUNT) - 1))
91 /* A free list of "binding_entry"s awaiting for re-use. */
93 static GTY((deletable)) binding_entry free_binding_entry = NULL;
95 /* Create a binding_entry object for (NAME, TYPE). */
97 static inline binding_entry
98 binding_entry_make (tree name, tree type)
102 if (free_binding_entry)
104 entry = free_binding_entry;
105 free_binding_entry = entry->chain;
108 entry = ggc_alloc_binding_entry_s ();
117 /* Put ENTRY back on the free list. */
120 binding_entry_free (binding_entry entry)
124 entry->chain = free_binding_entry;
125 free_binding_entry = entry;
129 /* The datatype used to implement the mapping from names to types at
131 struct GTY(()) binding_table_s {
132 /* Array of chains of "binding_entry"s */
133 binding_entry * GTY((length ("%h.chain_count"))) chain;
135 /* The number of chains in this table. This is the length of the
136 member "chain" considered as an array. */
139 /* Number of "binding_entry"s in this table. */
143 /* Construct TABLE with an initial CHAIN_COUNT. */
146 binding_table_construct (binding_table table, size_t chain_count)
148 table->chain_count = chain_count;
149 table->entry_count = 0;
150 table->chain = ggc_alloc_cleared_vec_binding_entry (table->chain_count);
153 /* Make TABLE's entries ready for reuse. */
156 binding_table_free (binding_table table)
164 for (i = 0, count = table->chain_count; i < count; ++i)
166 binding_entry temp = table->chain[i];
169 binding_entry entry = temp;
171 binding_entry_free (entry);
173 table->chain[i] = NULL;
175 table->entry_count = 0;
179 /* Allocate a table with CHAIN_COUNT, assumed to be a power of two. */
181 static inline binding_table
182 binding_table_new (size_t chain_count)
184 binding_table table = ggc_alloc_binding_table_s ();
186 binding_table_construct (table, chain_count);
190 /* Expand TABLE to twice its current chain_count. */
193 binding_table_expand (binding_table table)
195 const size_t old_chain_count = table->chain_count;
196 const size_t old_entry_count = table->entry_count;
197 const size_t new_chain_count = 2 * old_chain_count;
198 binding_entry *old_chains = table->chain;
201 binding_table_construct (table, new_chain_count);
202 for (i = 0; i < old_chain_count; ++i)
204 binding_entry entry = old_chains[i];
205 for (; entry != NULL; entry = old_chains[i])
207 const unsigned int hash = IDENTIFIER_HASH_VALUE (entry->name);
208 const size_t j = ENTRY_INDEX (hash, new_chain_count);
210 old_chains[i] = entry->chain;
211 entry->chain = table->chain[j];
212 table->chain[j] = entry;
215 table->entry_count = old_entry_count;
218 /* Insert a binding for NAME to TYPE into TABLE. */
221 binding_table_insert (binding_table table, tree name, tree type)
223 const unsigned int hash = IDENTIFIER_HASH_VALUE (name);
224 const size_t i = ENTRY_INDEX (hash, table->chain_count);
225 binding_entry entry = binding_entry_make (name, type);
227 entry->chain = table->chain[i];
228 table->chain[i] = entry;
229 ++table->entry_count;
231 if (3 * table->chain_count < 5 * table->entry_count)
232 binding_table_expand (table);
235 /* Return the binding_entry, if any, that maps NAME. */
238 binding_table_find (binding_table table, tree name)
240 const unsigned int hash = IDENTIFIER_HASH_VALUE (name);
241 binding_entry entry = table->chain[ENTRY_INDEX (hash, table->chain_count)];
243 while (entry != NULL && entry->name != name)
244 entry = entry->chain;
249 /* Apply PROC -- with DATA -- to all entries in TABLE. */
252 binding_table_foreach (binding_table table, bt_foreach_proc proc, void *data)
254 const size_t chain_count = table->chain_count;
257 for (i = 0; i < chain_count; ++i)
259 binding_entry entry = table->chain[i];
260 for (; entry != NULL; entry = entry->chain)
265 #ifndef ENABLE_SCOPE_CHECKING
266 # define ENABLE_SCOPE_CHECKING 0
268 # define ENABLE_SCOPE_CHECKING 1
271 /* A free list of "cxx_binding"s, connected by their PREVIOUS. */
273 static GTY((deletable)) cxx_binding *free_bindings;
275 /* Initialize VALUE and TYPE field for BINDING, and set the PREVIOUS
279 cxx_binding_init (cxx_binding *binding, tree value, tree type)
281 binding->value = value;
282 binding->type = type;
283 binding->previous = NULL;
286 /* (GC)-allocate a binding object with VALUE and TYPE member initialized. */
289 cxx_binding_make (tree value, tree type)
291 cxx_binding *binding;
294 binding = free_bindings;
295 free_bindings = binding->previous;
298 binding = ggc_alloc_cxx_binding ();
300 cxx_binding_init (binding, value, type);
305 /* Put BINDING back on the free list. */
308 cxx_binding_free (cxx_binding *binding)
310 binding->scope = NULL;
311 binding->previous = free_bindings;
312 free_bindings = binding;
315 /* Create a new binding for NAME (with the indicated VALUE and TYPE
316 bindings) in the class scope indicated by SCOPE. */
319 new_class_binding (tree name, tree value, tree type, cp_binding_level *scope)
321 cp_class_binding *cb;
322 cxx_binding *binding;
324 cb = VEC_safe_push (cp_class_binding, gc, scope->class_shadowed, NULL);
326 cb->identifier = name;
327 cb->base = binding = cxx_binding_make (value, type);
328 binding->scope = scope;
332 /* Make DECL the innermost binding for ID. The LEVEL is the binding
333 level at which this declaration is being bound. */
336 push_binding (tree id, tree decl, cp_binding_level* level)
338 cxx_binding *binding;
340 if (level != class_binding_level)
342 binding = cxx_binding_make (decl, NULL_TREE);
343 binding->scope = level;
346 binding = new_class_binding (id, decl, /*type=*/NULL_TREE, level);
348 /* Now, fill in the binding information. */
349 binding->previous = IDENTIFIER_BINDING (id);
350 INHERITED_VALUE_BINDING_P (binding) = 0;
351 LOCAL_BINDING_P (binding) = (level != class_binding_level);
353 /* And put it on the front of the list of bindings for ID. */
354 IDENTIFIER_BINDING (id) = binding;
357 /* Remove the binding for DECL which should be the innermost binding
361 pop_binding (tree id, tree decl)
363 cxx_binding *binding;
366 /* It's easiest to write the loops that call this function without
367 checking whether or not the entities involved have names. We
368 get here for such an entity. */
371 /* Get the innermost binding for ID. */
372 binding = IDENTIFIER_BINDING (id);
374 /* The name should be bound. */
375 gcc_assert (binding != NULL);
377 /* The DECL will be either the ordinary binding or the type
378 binding for this identifier. Remove that binding. */
379 if (binding->value == decl)
380 binding->value = NULL_TREE;
383 gcc_assert (binding->type == decl);
384 binding->type = NULL_TREE;
387 if (!binding->value && !binding->type)
389 /* We're completely done with the innermost binding for this
390 identifier. Unhook it from the list of bindings. */
391 IDENTIFIER_BINDING (id) = binding->previous;
393 /* Add it to the free list. */
394 cxx_binding_free (binding);
398 /* Strip non dependent using declarations. */
401 strip_using_decl (tree decl)
403 if (decl == NULL_TREE)
406 while (TREE_CODE (decl) == USING_DECL && !DECL_DEPENDENT_P (decl))
407 decl = USING_DECL_DECLS (decl);
411 /* BINDING records an existing declaration for a name in the current scope.
412 But, DECL is another declaration for that same identifier in the
413 same scope. This is the `struct stat' hack whereby a non-typedef
414 class name or enum-name can be bound at the same level as some other
418 A class name (9.1) or enumeration name (7.2) can be hidden by the
419 name of an object, function, or enumerator declared in the same scope.
420 If a class or enumeration name and an object, function, or enumerator
421 are declared in the same scope (in any order) with the same name, the
422 class or enumeration name is hidden wherever the object, function, or
423 enumerator name is visible.
425 It's the responsibility of the caller to check that
426 inserting this name is valid here. Returns nonzero if the new binding
430 supplement_binding_1 (cxx_binding *binding, tree decl)
432 tree bval = binding->value;
434 tree target_bval = strip_using_decl (bval);
435 tree target_decl = strip_using_decl (decl);
437 if (TREE_CODE (target_decl) == TYPE_DECL && DECL_ARTIFICIAL (target_decl)
438 && target_decl != target_bval
439 && (TREE_CODE (target_bval) != TYPE_DECL
440 /* We allow pushing an enum multiple times in a class
441 template in order to handle late matching of underlying
442 type on an opaque-enum-declaration followed by an
444 || (TREE_CODE (TREE_TYPE (target_decl)) == ENUMERAL_TYPE
445 && TREE_CODE (TREE_TYPE (target_bval)) == ENUMERAL_TYPE
446 && (dependent_type_p (ENUM_UNDERLYING_TYPE
447 (TREE_TYPE (target_decl)))
448 || dependent_type_p (ENUM_UNDERLYING_TYPE
449 (TREE_TYPE (target_bval)))))))
450 /* The new name is the type name. */
451 binding->type = decl;
452 else if (/* TARGET_BVAL is null when push_class_level_binding moves
453 an inherited type-binding out of the way to make room
454 for a new value binding. */
456 /* TARGET_BVAL is error_mark_node when TARGET_DECL's name
457 has been used in a non-class scope prior declaration.
458 In that case, we should have already issued a
459 diagnostic; for graceful error recovery purpose, pretend
460 this was the intended declaration for that name. */
461 || target_bval == error_mark_node
462 /* If TARGET_BVAL is anticipated but has not yet been
463 declared, pretend it is not there at all. */
464 || (TREE_CODE (target_bval) == FUNCTION_DECL
465 && DECL_ANTICIPATED (target_bval)
466 && !DECL_HIDDEN_FRIEND_P (target_bval)))
467 binding->value = decl;
468 else if (TREE_CODE (target_bval) == TYPE_DECL
469 && DECL_ARTIFICIAL (target_bval)
470 && target_decl != target_bval
471 && (TREE_CODE (target_decl) != TYPE_DECL
472 || same_type_p (TREE_TYPE (target_decl),
473 TREE_TYPE (target_bval))))
475 /* The old binding was a type name. It was placed in
476 VALUE field because it was thought, at the point it was
477 declared, to be the only entity with such a name. Move the
478 type name into the type slot; it is now hidden by the new
480 binding->type = bval;
481 binding->value = decl;
482 binding->value_is_inherited = false;
484 else if (TREE_CODE (target_bval) == TYPE_DECL
485 && TREE_CODE (target_decl) == TYPE_DECL
486 && DECL_NAME (target_decl) == DECL_NAME (target_bval)
487 && binding->scope->kind != sk_class
488 && (same_type_p (TREE_TYPE (target_decl), TREE_TYPE (target_bval))
489 /* If either type involves template parameters, we must
490 wait until instantiation. */
491 || uses_template_parms (TREE_TYPE (target_decl))
492 || uses_template_parms (TREE_TYPE (target_bval))))
493 /* We have two typedef-names, both naming the same type to have
494 the same name. In general, this is OK because of:
498 In a given scope, a typedef specifier can be used to redefine
499 the name of any type declared in that scope to refer to the
500 type to which it already refers.
502 However, in class scopes, this rule does not apply due to the
503 stricter language in [class.mem] prohibiting redeclarations of
506 /* There can be two block-scope declarations of the same variable,
507 so long as they are `extern' declarations. However, there cannot
508 be two declarations of the same static data member:
512 A member shall not be declared twice in the
513 member-specification. */
514 else if (TREE_CODE (target_decl) == VAR_DECL
515 && TREE_CODE (target_bval) == VAR_DECL
516 && DECL_EXTERNAL (target_decl) && DECL_EXTERNAL (target_bval)
517 && !DECL_CLASS_SCOPE_P (target_decl))
519 duplicate_decls (decl, binding->value, /*newdecl_is_friend=*/false);
522 else if (TREE_CODE (decl) == NAMESPACE_DECL
523 && TREE_CODE (bval) == NAMESPACE_DECL
524 && DECL_NAMESPACE_ALIAS (decl)
525 && DECL_NAMESPACE_ALIAS (bval)
526 && ORIGINAL_NAMESPACE (bval) == ORIGINAL_NAMESPACE (decl))
529 In a declarative region, a namespace-alias-definition can be
530 used to redefine a namespace-alias declared in that declarative
531 region to refer only to the namespace to which it already
536 diagnose_name_conflict (decl, bval);
543 /* Diagnose a name conflict between DECL and BVAL. */
546 diagnose_name_conflict (tree decl, tree bval)
548 if (TREE_CODE (decl) == TREE_CODE (bval)
549 && (TREE_CODE (decl) != TYPE_DECL
550 || (DECL_ARTIFICIAL (decl) && DECL_ARTIFICIAL (bval))
551 || (!DECL_ARTIFICIAL (decl) && !DECL_ARTIFICIAL (bval)))
552 && !is_overloaded_fn (decl))
553 error ("redeclaration of %q#D", decl);
555 error ("%q#D conflicts with a previous declaration", decl);
557 inform (input_location, "previous declaration %q+#D", bval);
560 /* Wrapper for supplement_binding_1. */
563 supplement_binding (cxx_binding *binding, tree decl)
566 bool subtime = timevar_cond_start (TV_NAME_LOOKUP);
567 ret = supplement_binding_1 (binding, decl);
568 timevar_cond_stop (TV_NAME_LOOKUP, subtime);
572 /* Add DECL to the list of things declared in B. */
575 add_decl_to_level (tree decl, cp_binding_level *b)
577 /* We used to record virtual tables as if they were ordinary
578 variables, but no longer do so. */
579 gcc_assert (!(TREE_CODE (decl) == VAR_DECL && DECL_VIRTUAL_P (decl)));
581 if (TREE_CODE (decl) == NAMESPACE_DECL
582 && !DECL_NAMESPACE_ALIAS (decl))
584 DECL_CHAIN (decl) = b->namespaces;
585 b->namespaces = decl;
589 /* We build up the list in reverse order, and reverse it later if
591 TREE_CHAIN (decl) = b->names;
594 /* If appropriate, add decl to separate list of statics. We
595 include extern variables because they might turn out to be
596 static later. It's OK for this list to contain a few false
598 if (b->kind == sk_namespace)
599 if ((TREE_CODE (decl) == VAR_DECL
600 && (TREE_STATIC (decl) || DECL_EXTERNAL (decl)))
601 || (TREE_CODE (decl) == FUNCTION_DECL
602 && (!TREE_PUBLIC (decl) || DECL_DECLARED_INLINE_P (decl))))
603 VEC_safe_push (tree, gc, b->static_decls, decl);
607 /* Record a decl-node X as belonging to the current lexical scope.
608 Check for errors (such as an incompatible declaration for the same
609 name already seen in the same scope). IS_FRIEND is true if X is
610 declared as a friend.
612 Returns either X or an old decl for the same name.
613 If an old decl is returned, it may have been smashed
614 to agree with what X says. */
617 pushdecl_maybe_friend_1 (tree x, bool is_friend)
621 int need_new_binding;
623 if (x == error_mark_node)
624 return error_mark_node;
626 need_new_binding = 1;
628 if (DECL_TEMPLATE_PARM_P (x))
629 /* Template parameters have no context; they are not X::T even
630 when declared within a class or namespace. */
634 if (current_function_decl && x != current_function_decl
635 /* A local declaration for a function doesn't constitute
637 && TREE_CODE (x) != FUNCTION_DECL
638 /* A local declaration for an `extern' variable is in the
639 scope of the current namespace, not the current
641 && !(TREE_CODE (x) == VAR_DECL && DECL_EXTERNAL (x))
642 /* When parsing the parameter list of a function declarator,
643 don't set DECL_CONTEXT to an enclosing function. When we
644 push the PARM_DECLs in order to process the function body,
645 current_binding_level->this_entity will be set. */
646 && !(TREE_CODE (x) == PARM_DECL
647 && current_binding_level->kind == sk_function_parms
648 && current_binding_level->this_entity == NULL)
649 && !DECL_CONTEXT (x))
650 DECL_CONTEXT (x) = current_function_decl;
652 /* If this is the declaration for a namespace-scope function,
653 but the declaration itself is in a local scope, mark the
655 if (TREE_CODE (x) == FUNCTION_DECL
656 && DECL_NAMESPACE_SCOPE_P (x)
657 && current_function_decl
658 && x != current_function_decl)
659 DECL_LOCAL_FUNCTION_P (x) = 1;
662 name = DECL_NAME (x);
665 int different_binding_level = 0;
667 if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
668 name = TREE_OPERAND (name, 0);
670 /* In case this decl was explicitly namespace-qualified, look it
671 up in its namespace context. */
672 if (DECL_NAMESPACE_SCOPE_P (x) && namespace_bindings_p ())
673 t = namespace_binding (name, DECL_CONTEXT (x));
675 t = lookup_name_innermost_nonclass_level (name);
677 /* [basic.link] If there is a visible declaration of an entity
678 with linkage having the same name and type, ignoring entities
679 declared outside the innermost enclosing namespace scope, the
680 block scope declaration declares that same entity and
681 receives the linkage of the previous declaration. */
682 if (! t && current_function_decl && x != current_function_decl
683 && (TREE_CODE (x) == FUNCTION_DECL || TREE_CODE (x) == VAR_DECL)
684 && DECL_EXTERNAL (x))
686 /* Look in block scope. */
687 t = innermost_non_namespace_value (name);
688 /* Or in the innermost namespace. */
690 t = namespace_binding (name, DECL_CONTEXT (x));
691 /* Does it have linkage? Note that if this isn't a DECL, it's an
692 OVERLOAD, which is OK. */
693 if (t && DECL_P (t) && ! (TREE_STATIC (t) || DECL_EXTERNAL (t)))
696 different_binding_level = 1;
699 /* If we are declaring a function, and the result of name-lookup
700 was an OVERLOAD, look for an overloaded instance that is
701 actually the same as the function we are declaring. (If
702 there is one, we have to merge our declaration with the
703 previous declaration.) */
704 if (t && TREE_CODE (t) == OVERLOAD)
708 if (TREE_CODE (x) == FUNCTION_DECL)
709 for (match = t; match; match = OVL_NEXT (match))
711 if (decls_match (OVL_CURRENT (match), x))
715 /* Just choose one. */
719 t = OVL_CURRENT (match);
724 if (t && t != error_mark_node)
726 if (different_binding_level)
728 if (decls_match (x, t))
729 /* The standard only says that the local extern
730 inherits linkage from the previous decl; in
731 particular, default args are not shared. Add
732 the decl into a hash table to make sure only
733 the previous decl in this case is seen by the
736 struct cxx_int_tree_map *h;
739 TREE_PUBLIC (x) = TREE_PUBLIC (t);
741 if (cp_function_chain->extern_decl_map == NULL)
742 cp_function_chain->extern_decl_map
743 = htab_create_ggc (20, cxx_int_tree_map_hash,
744 cxx_int_tree_map_eq, NULL);
746 h = ggc_alloc_cxx_int_tree_map ();
747 h->uid = DECL_UID (x);
749 loc = htab_find_slot_with_hash
750 (cp_function_chain->extern_decl_map, h,
752 *(struct cxx_int_tree_map **) loc = h;
755 else if (TREE_CODE (t) == PARM_DECL)
757 /* Check for duplicate params. */
758 tree d = duplicate_decls (x, t, is_friend);
762 else if ((DECL_EXTERN_C_FUNCTION_P (x)
763 || DECL_FUNCTION_TEMPLATE_P (x))
764 && is_overloaded_fn (t))
765 /* Don't do anything just yet. */;
766 else if (t == wchar_decl_node)
768 if (! DECL_IN_SYSTEM_HEADER (x))
769 pedwarn (input_location, OPT_pedantic, "redeclaration of %<wchar_t%> as %qT",
772 /* Throw away the redeclaration. */
777 tree olddecl = duplicate_decls (x, t, is_friend);
779 /* If the redeclaration failed, we can stop at this
781 if (olddecl == error_mark_node)
782 return error_mark_node;
786 if (TREE_CODE (t) == TYPE_DECL)
787 SET_IDENTIFIER_TYPE_VALUE (name, TREE_TYPE (t));
791 else if (DECL_MAIN_P (x) && TREE_CODE (t) == FUNCTION_DECL)
793 /* A redeclaration of main, but not a duplicate of the
798 This function shall not be overloaded. */
799 error ("invalid redeclaration of %q+D", t);
801 /* We don't try to push this declaration since that
808 /* If x has C linkage-specification, (extern "C"),
809 lookup its binding, in case it's already bound to an object.
810 The lookup is done in all namespaces.
811 If we find an existing binding, make sure it has the same
812 exception specification as x, otherwise, bail in error [7.5, 7.6]. */
813 if ((TREE_CODE (x) == FUNCTION_DECL)
814 && DECL_EXTERN_C_P (x)
815 /* We should ignore declarations happening in system headers. */
816 && !DECL_ARTIFICIAL (x)
817 && !DECL_IN_SYSTEM_HEADER (x))
819 tree previous = lookup_extern_c_fun_in_all_ns (x);
821 && !DECL_ARTIFICIAL (previous)
822 && !DECL_IN_SYSTEM_HEADER (previous)
823 && DECL_CONTEXT (previous) != DECL_CONTEXT (x))
825 /* In case either x or previous is declared to throw an exception,
826 make sure both exception specifications are equal. */
827 if (decls_match (x, previous))
829 tree x_exception_spec = NULL_TREE;
830 tree previous_exception_spec = NULL_TREE;
833 TYPE_RAISES_EXCEPTIONS (TREE_TYPE (x));
834 previous_exception_spec =
835 TYPE_RAISES_EXCEPTIONS (TREE_TYPE (previous));
836 if (!comp_except_specs (previous_exception_spec,
840 pedwarn (input_location, 0,
841 "declaration of %q#D with C language linkage",
843 pedwarn (input_location, 0,
844 "conflicts with previous declaration %q+#D",
846 pedwarn (input_location, 0,
847 "due to different exception specifications");
848 return error_mark_node;
850 if (DECL_ASSEMBLER_NAME_SET_P (previous))
851 SET_DECL_ASSEMBLER_NAME (x,
852 DECL_ASSEMBLER_NAME (previous));
856 pedwarn (input_location, 0,
857 "declaration of %q#D with C language linkage", x);
858 pedwarn (input_location, 0,
859 "conflicts with previous declaration %q+#D",
865 check_template_shadow (x);
867 /* If this is a function conjured up by the back end, massage it
868 so it looks friendly. */
869 if (DECL_NON_THUNK_FUNCTION_P (x) && ! DECL_LANG_SPECIFIC (x))
871 retrofit_lang_decl (x);
872 SET_DECL_LANGUAGE (x, lang_c);
876 if (DECL_NON_THUNK_FUNCTION_P (x) && ! DECL_FUNCTION_MEMBER_P (x))
878 t = push_overloaded_decl (x, PUSH_LOCAL, is_friend);
879 if (!namespace_bindings_p ())
880 /* We do not need to create a binding for this name;
881 push_overloaded_decl will have already done so if
883 need_new_binding = 0;
885 else if (DECL_FUNCTION_TEMPLATE_P (x) && DECL_NAMESPACE_SCOPE_P (x))
887 t = push_overloaded_decl (x, PUSH_GLOBAL, is_friend);
889 add_decl_to_level (x, NAMESPACE_LEVEL (CP_DECL_CONTEXT (t)));
892 if (TREE_CODE (t) == FUNCTION_DECL || DECL_FUNCTION_TEMPLATE_P (t))
893 check_default_args (t);
895 if (t != x || DECL_FUNCTION_TEMPLATE_P (t))
898 /* If declaring a type as a typedef, copy the type (unless we're
899 at line 0), and install this TYPE_DECL as the new type's typedef
900 name. See the extensive comment of set_underlying_type (). */
901 if (TREE_CODE (x) == TYPE_DECL)
903 tree type = TREE_TYPE (x);
905 if (DECL_IS_BUILTIN (x)
906 || (TREE_TYPE (x) != error_mark_node
907 && TYPE_NAME (type) != x
908 /* We don't want to copy the type when all we're
909 doing is making a TYPE_DECL for the purposes of
911 && (!TYPE_NAME (type)
912 || TYPE_NAME (type) != DECL_ABSTRACT_ORIGIN (x))))
913 set_underlying_type (x);
915 if (type != error_mark_node
917 && TYPE_IDENTIFIER (type))
918 set_identifier_type_value (DECL_NAME (x), x);
920 /* If this is a locally defined typedef in a function that
921 is not a template instantation, record it to implement
922 -Wunused-local-typedefs. */
923 if (current_instantiation () == NULL
924 || (current_instantiation ()->decl != current_function_decl))
925 record_locally_defined_typedef (x);
928 /* Multiple external decls of the same identifier ought to match.
930 We get warnings about inline functions where they are defined.
931 We get warnings about other functions from push_overloaded_decl.
933 Avoid duplicate warnings where they are used. */
934 if (TREE_PUBLIC (x) && TREE_CODE (x) != FUNCTION_DECL)
938 decl = IDENTIFIER_NAMESPACE_VALUE (name);
939 if (decl && TREE_CODE (decl) == OVERLOAD)
940 decl = OVL_FUNCTION (decl);
942 if (decl && decl != error_mark_node
943 && (DECL_EXTERNAL (decl) || TREE_PUBLIC (decl))
944 /* If different sort of thing, we already gave an error. */
945 && TREE_CODE (decl) == TREE_CODE (x)
946 && !same_type_p (TREE_TYPE (x), TREE_TYPE (decl)))
948 permerror (input_location, "type mismatch with previous external decl of %q#D", x);
949 permerror (input_location, "previous external decl of %q+#D", decl);
953 if (TREE_CODE (x) == FUNCTION_DECL
955 && !flag_friend_injection)
957 /* This is a new declaration of a friend function, so hide
958 it from ordinary function lookup. */
959 DECL_ANTICIPATED (x) = 1;
960 DECL_HIDDEN_FRIEND_P (x) = 1;
963 /* This name is new in its binding level.
964 Install the new declaration and return it. */
965 if (namespace_bindings_p ())
967 /* Install a global value. */
969 /* If the first global decl has external linkage,
970 warn if we later see static one. */
971 if (IDENTIFIER_GLOBAL_VALUE (name) == NULL_TREE && TREE_PUBLIC (x))
972 TREE_PUBLIC (name) = 1;
974 /* Bind the name for the entity. */
975 if (!(TREE_CODE (x) == TYPE_DECL && DECL_ARTIFICIAL (x)
977 && (TREE_CODE (x) == TYPE_DECL
978 || TREE_CODE (x) == VAR_DECL
979 || TREE_CODE (x) == NAMESPACE_DECL
980 || TREE_CODE (x) == CONST_DECL
981 || TREE_CODE (x) == TEMPLATE_DECL))
982 SET_IDENTIFIER_NAMESPACE_VALUE (name, x);
984 /* If new decl is `static' and an `extern' was seen previously,
986 if (x != NULL_TREE && t != NULL_TREE && decls_match (x, t))
987 warn_extern_redeclared_static (x, t);
991 /* Here to install a non-global value. */
992 tree oldglobal = IDENTIFIER_NAMESPACE_VALUE (name);
993 tree oldlocal = NULL_TREE;
994 cp_binding_level *oldscope = NULL;
995 cxx_binding *oldbinding = outer_binding (name, NULL, true);
998 oldlocal = oldbinding->value;
999 oldscope = oldbinding->scope;
1002 if (need_new_binding)
1004 push_local_binding (name, x, 0);
1005 /* Because push_local_binding will hook X on to the
1006 current_binding_level's name list, we don't want to
1007 do that again below. */
1008 need_new_binding = 0;
1011 /* If this is a TYPE_DECL, push it into the type value slot. */
1012 if (TREE_CODE (x) == TYPE_DECL)
1013 set_identifier_type_value (name, x);
1015 /* Clear out any TYPE_DECL shadowed by a namespace so that
1016 we won't think this is a type. The C struct hack doesn't
1017 go through namespaces. */
1018 if (TREE_CODE (x) == NAMESPACE_DECL)
1019 set_identifier_type_value (name, NULL_TREE);
1026 && TREE_CODE (oldlocal) == VAR_DECL
1027 && DECL_DEAD_FOR_LOCAL (oldlocal))
1028 oldlocal = DECL_SHADOWED_FOR_VAR (oldlocal);
1030 if (oldlocal == NULL_TREE)
1031 oldlocal = IDENTIFIER_NAMESPACE_VALUE (DECL_NAME (d));
1034 /* If this is an extern function declaration, see if we
1035 have a global definition or declaration for the function. */
1036 if (oldlocal == NULL_TREE
1037 && DECL_EXTERNAL (x)
1038 && oldglobal != NULL_TREE
1039 && TREE_CODE (x) == FUNCTION_DECL
1040 && TREE_CODE (oldglobal) == FUNCTION_DECL)
1042 /* We have one. Their types must agree. */
1043 if (decls_match (x, oldglobal))
1047 warning (0, "extern declaration of %q#D doesn%'t match", x);
1048 warning (0, "global declaration %q+#D", oldglobal);
1051 /* If we have a local external declaration,
1052 and no file-scope declaration has yet been seen,
1053 then if we later have a file-scope decl it must not be static. */
1054 if (oldlocal == NULL_TREE
1055 && oldglobal == NULL_TREE
1056 && DECL_EXTERNAL (x)
1058 TREE_PUBLIC (name) = 1;
1060 /* Don't complain about the parms we push and then pop
1061 while tentatively parsing a function declarator. */
1062 if (TREE_CODE (x) == PARM_DECL && DECL_CONTEXT (x) == NULL_TREE)
1065 /* Warn if shadowing an argument at the top level of the body. */
1066 else if (oldlocal != NULL_TREE && !DECL_EXTERNAL (x)
1067 /* Inline decls shadow nothing. */
1068 && !DECL_FROM_INLINE (x)
1069 && (TREE_CODE (oldlocal) == PARM_DECL
1070 || TREE_CODE (oldlocal) == VAR_DECL
1071 /* If the old decl is a type decl, only warn if the
1072 old decl is an explicit typedef or if both the old
1073 and new decls are type decls. */
1074 || (TREE_CODE (oldlocal) == TYPE_DECL
1075 && (!DECL_ARTIFICIAL (oldlocal)
1076 || TREE_CODE (x) == TYPE_DECL)))
1077 /* Don't check for internally generated vars unless
1078 it's an implicit typedef (see create_implicit_typedef
1080 && (!DECL_ARTIFICIAL (x) || DECL_IMPLICIT_TYPEDEF_P (x)))
1082 bool nowarn = false;
1084 /* Don't complain if it's from an enclosing function. */
1085 if (DECL_CONTEXT (oldlocal) == current_function_decl
1086 && TREE_CODE (x) != PARM_DECL
1087 && TREE_CODE (oldlocal) == PARM_DECL)
1089 /* Go to where the parms should be and see if we find
1091 cp_binding_level *b = current_binding_level->level_chain;
1093 if (FUNCTION_NEEDS_BODY_BLOCK (current_function_decl))
1094 /* Skip the ctor/dtor cleanup level. */
1098 if (b->kind == sk_function_parms)
1100 error ("declaration of %q#D shadows a parameter", x);
1105 /* The local structure or class can't use parameters of
1106 the containing function anyway. */
1107 if (DECL_CONTEXT (oldlocal) != current_function_decl)
1109 cp_binding_level *scope = current_binding_level;
1110 tree context = DECL_CONTEXT (oldlocal);
1111 for (; scope; scope = scope->level_chain)
1113 if (scope->kind == sk_function_parms
1114 && scope->this_entity == context)
1116 if (scope->kind == sk_class
1117 && !LAMBDA_TYPE_P (scope->this_entity))
1124 /* Error if redeclaring a local declared in a
1125 for-init-statement or in the condition of an if or
1126 switch statement when the new declaration is in the
1127 outermost block of the controlled statement.
1128 Redeclaring a variable from a for or while condition is
1129 detected elsewhere. */
1130 else if (TREE_CODE (oldlocal) == VAR_DECL
1131 && oldscope == current_binding_level->level_chain
1132 && (oldscope->kind == sk_cond
1133 || oldscope->kind == sk_for))
1135 error ("redeclaration of %q#D", x);
1136 error ("%q+#D previously declared here", oldlocal);
1139 if (warn_shadow && !nowarn)
1141 if (TREE_CODE (oldlocal) == PARM_DECL)
1142 warning_at (input_location, OPT_Wshadow,
1143 "declaration of %q#D shadows a parameter", x);
1144 else if (is_capture_proxy (oldlocal))
1145 warning_at (input_location, OPT_Wshadow,
1146 "declaration of %qD shadows a lambda capture",
1149 warning_at (input_location, OPT_Wshadow,
1150 "declaration of %qD shadows a previous local",
1152 warning_at (DECL_SOURCE_LOCATION (oldlocal), OPT_Wshadow,
1153 "shadowed declaration is here");
1157 /* Maybe warn if shadowing something else. */
1158 else if (warn_shadow && !DECL_EXTERNAL (x)
1159 /* No shadow warnings for internally generated vars unless
1160 it's an implicit typedef (see create_implicit_typedef
1162 && (! DECL_ARTIFICIAL (x) || DECL_IMPLICIT_TYPEDEF_P (x))
1163 /* No shadow warnings for vars made for inlining. */
1164 && ! DECL_FROM_INLINE (x))
1168 if (current_class_ptr)
1169 member = lookup_member (current_class_type,
1172 /*want_type=*/false,
1173 tf_warning_or_error);
1177 if (member && !TREE_STATIC (member))
1179 /* Location of previous decl is not useful in this case. */
1180 warning (OPT_Wshadow, "declaration of %qD shadows a member of 'this'",
1183 else if (oldglobal != NULL_TREE
1184 && (TREE_CODE (oldglobal) == VAR_DECL
1185 /* If the old decl is a type decl, only warn if the
1186 old decl is an explicit typedef or if both the
1187 old and new decls are type decls. */
1188 || (TREE_CODE (oldglobal) == TYPE_DECL
1189 && (!DECL_ARTIFICIAL (oldglobal)
1190 || TREE_CODE (x) == TYPE_DECL))))
1191 /* XXX shadow warnings in outer-more namespaces */
1193 warning_at (input_location, OPT_Wshadow,
1194 "declaration of %qD shadows a global declaration", x);
1195 warning_at (DECL_SOURCE_LOCATION (oldglobal), OPT_Wshadow,
1196 "shadowed declaration is here");
1201 if (TREE_CODE (x) == VAR_DECL)
1202 maybe_register_incomplete_var (x);
1205 if (need_new_binding)
1206 add_decl_to_level (x,
1207 DECL_NAMESPACE_SCOPE_P (x)
1208 ? NAMESPACE_LEVEL (CP_DECL_CONTEXT (x))
1209 : current_binding_level);
1214 /* Wrapper for pushdecl_maybe_friend_1. */
1217 pushdecl_maybe_friend (tree x, bool is_friend)
1220 bool subtime = timevar_cond_start (TV_NAME_LOOKUP);
1221 ret = pushdecl_maybe_friend_1 (x, is_friend);
1222 timevar_cond_stop (TV_NAME_LOOKUP, subtime);
1226 /* Record a decl-node X as belonging to the current lexical scope. */
1231 return pushdecl_maybe_friend (x, false);
1234 /* Enter DECL into the symbol table, if that's appropriate. Returns
1235 DECL, or a modified version thereof. */
1238 maybe_push_decl (tree decl)
1240 tree type = TREE_TYPE (decl);
1242 /* Add this decl to the current binding level, but not if it comes
1243 from another scope, e.g. a static member variable. TEM may equal
1244 DECL or it may be a previous decl of the same name. */
1245 if (decl == error_mark_node
1246 || (TREE_CODE (decl) != PARM_DECL
1247 && DECL_CONTEXT (decl) != NULL_TREE
1248 /* Definitions of namespace members outside their namespace are
1250 && !DECL_NAMESPACE_SCOPE_P (decl))
1251 || (TREE_CODE (decl) == TEMPLATE_DECL && !namespace_bindings_p ())
1252 || type == unknown_type_node
1253 /* The declaration of a template specialization does not affect
1254 the functions available for overload resolution, so we do not
1256 || (TREE_CODE (decl) == FUNCTION_DECL
1257 && DECL_TEMPLATE_SPECIALIZATION (decl)))
1260 return pushdecl (decl);
1263 /* Bind DECL to ID in the current_binding_level, assumed to be a local
1264 binding level. If PUSH_USING is set in FLAGS, we know that DECL
1265 doesn't really belong to this binding level, that it got here
1266 through a using-declaration. */
1269 push_local_binding (tree id, tree decl, int flags)
1271 cp_binding_level *b;
1273 /* Skip over any local classes. This makes sense if we call
1274 push_local_binding with a friend decl of a local class. */
1275 b = innermost_nonclass_level ();
1277 if (lookup_name_innermost_nonclass_level (id))
1279 /* Supplement the existing binding. */
1280 if (!supplement_binding (IDENTIFIER_BINDING (id), decl))
1281 /* It didn't work. Something else must be bound at this
1282 level. Do not add DECL to the list of things to pop
1287 /* Create a new binding. */
1288 push_binding (id, decl, b);
1290 if (TREE_CODE (decl) == OVERLOAD || (flags & PUSH_USING))
1291 /* We must put the OVERLOAD into a TREE_LIST since the
1292 TREE_CHAIN of an OVERLOAD is already used. Similarly for
1293 decls that got here through a using-declaration. */
1294 decl = build_tree_list (NULL_TREE, decl);
1296 /* And put DECL on the list of things declared by the current
1298 add_decl_to_level (decl, b);
1301 /* Check to see whether or not DECL is a variable that would have been
1302 in scope under the ARM, but is not in scope under the ANSI/ISO
1303 standard. If so, issue an error message. If name lookup would
1304 work in both cases, but return a different result, this function
1305 returns the result of ANSI/ISO lookup. Otherwise, it returns
1309 check_for_out_of_scope_variable (tree decl)
1313 /* We only care about out of scope variables. */
1314 if (!(TREE_CODE (decl) == VAR_DECL && DECL_DEAD_FOR_LOCAL (decl)))
1317 shadowed = DECL_HAS_SHADOWED_FOR_VAR_P (decl)
1318 ? DECL_SHADOWED_FOR_VAR (decl) : NULL_TREE ;
1319 while (shadowed != NULL_TREE && TREE_CODE (shadowed) == VAR_DECL
1320 && DECL_DEAD_FOR_LOCAL (shadowed))
1321 shadowed = DECL_HAS_SHADOWED_FOR_VAR_P (shadowed)
1322 ? DECL_SHADOWED_FOR_VAR (shadowed) : NULL_TREE;
1324 shadowed = IDENTIFIER_NAMESPACE_VALUE (DECL_NAME (decl));
1327 if (!DECL_ERROR_REPORTED (decl))
1329 warning (0, "name lookup of %qD changed", DECL_NAME (decl));
1330 warning (0, " matches this %q+D under ISO standard rules",
1332 warning (0, " matches this %q+D under old rules", decl);
1333 DECL_ERROR_REPORTED (decl) = 1;
1338 /* If we have already complained about this declaration, there's no
1339 need to do it again. */
1340 if (DECL_ERROR_REPORTED (decl))
1343 DECL_ERROR_REPORTED (decl) = 1;
1345 if (TREE_TYPE (decl) == error_mark_node)
1348 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TREE_TYPE (decl)))
1350 error ("name lookup of %qD changed for ISO %<for%> scoping",
1352 error (" cannot use obsolete binding at %q+D because "
1353 "it has a destructor", decl);
1354 return error_mark_node;
1358 permerror (input_location, "name lookup of %qD changed for ISO %<for%> scoping",
1360 if (flag_permissive)
1361 permerror (input_location, " using obsolete binding at %q+D", decl);
1367 inform (input_location, "(if you use %<-fpermissive%> G++ will accept your code)");
1376 /* true means unconditionally make a BLOCK for the next level pushed. */
1378 static bool keep_next_level_flag;
1380 static int binding_depth = 0;
1387 for (i = 0; i < depth * 2; i++)
1391 /* Return a string describing the kind of SCOPE we have. */
1393 cp_binding_level_descriptor (cp_binding_level *scope)
1395 /* The order of this table must match the "scope_kind"
1397 static const char* scope_kind_names[] = {
1403 "function-parameter-scope",
1406 "template-parameter-scope",
1407 "template-explicit-spec-scope"
1409 const scope_kind kind = scope->explicit_spec_p
1410 ? sk_template_spec : scope->kind;
1412 return scope_kind_names[kind];
1415 /* Output a debugging information about SCOPE when performing
1418 cp_binding_level_debug (cp_binding_level *scope, int line, const char *action)
1420 const char *desc = cp_binding_level_descriptor (scope);
1421 if (scope->this_entity)
1422 verbatim ("%s %s(%E) %p %d\n", action, desc,
1423 scope->this_entity, (void *) scope, line);
1425 verbatim ("%s %s %p %d\n", action, desc, (void *) scope, line);
1428 /* Return the estimated initial size of the hashtable of a NAMESPACE
1431 static inline size_t
1432 namespace_scope_ht_size (tree ns)
1434 tree name = DECL_NAME (ns);
1436 return name == std_identifier
1437 ? NAMESPACE_STD_HT_SIZE
1438 : (name == global_scope_name
1439 ? GLOBAL_SCOPE_HT_SIZE
1440 : NAMESPACE_ORDINARY_HT_SIZE);
1443 /* A chain of binding_level structures awaiting reuse. */
1445 static GTY((deletable)) cp_binding_level *free_binding_level;
1447 /* Insert SCOPE as the innermost binding level. */
1450 push_binding_level (cp_binding_level *scope)
1452 /* Add it to the front of currently active scopes stack. */
1453 scope->level_chain = current_binding_level;
1454 current_binding_level = scope;
1455 keep_next_level_flag = false;
1457 if (ENABLE_SCOPE_CHECKING)
1459 scope->binding_depth = binding_depth;
1460 indent (binding_depth);
1461 cp_binding_level_debug (scope, input_line, "push");
1466 /* Create a new KIND scope and make it the top of the active scopes stack.
1467 ENTITY is the scope of the associated C++ entity (namespace, class,
1468 function, C++0x enumeration); it is NULL otherwise. */
1471 begin_scope (scope_kind kind, tree entity)
1473 cp_binding_level *scope;
1475 /* Reuse or create a struct for this binding level. */
1476 if (!ENABLE_SCOPE_CHECKING && free_binding_level)
1478 scope = free_binding_level;
1479 memset (scope, 0, sizeof (cp_binding_level));
1480 free_binding_level = scope->level_chain;
1483 scope = ggc_alloc_cleared_cp_binding_level ();
1485 scope->this_entity = entity;
1486 scope->more_cleanups_ok = true;
1493 case sk_template_spec:
1494 scope->explicit_spec_p = true;
1495 kind = sk_template_parms;
1497 case sk_template_parms:
1504 case sk_scoped_enum:
1505 case sk_function_parms:
1507 scope->keep = keep_next_level_flag;
1511 NAMESPACE_LEVEL (entity) = scope;
1512 scope->static_decls =
1513 VEC_alloc (tree, gc,
1514 DECL_NAME (entity) == std_identifier
1515 || DECL_NAME (entity) == global_scope_name
1520 /* Should not happen. */
1526 push_binding_level (scope);
1531 /* We're about to leave current scope. Pop the top of the stack of
1532 currently active scopes. Return the enclosing scope, now active. */
1537 cp_binding_level *scope = current_binding_level;
1539 if (scope->kind == sk_namespace && class_binding_level)
1540 current_binding_level = class_binding_level;
1542 /* We cannot leave a scope, if there are none left. */
1543 if (NAMESPACE_LEVEL (global_namespace))
1544 gcc_assert (!global_scope_p (scope));
1546 if (ENABLE_SCOPE_CHECKING)
1548 indent (--binding_depth);
1549 cp_binding_level_debug (scope, input_line, "leave");
1552 /* Move one nesting level up. */
1553 current_binding_level = scope->level_chain;
1555 /* Namespace-scopes are left most probably temporarily, not
1556 completely; they can be reopened later, e.g. in namespace-extension
1557 or any name binding activity that requires us to resume a
1558 namespace. For classes, we cache some binding levels. For other
1559 scopes, we just make the structure available for reuse. */
1560 if (scope->kind != sk_namespace
1561 && scope->kind != sk_class)
1563 scope->level_chain = free_binding_level;
1564 gcc_assert (!ENABLE_SCOPE_CHECKING
1565 || scope->binding_depth == binding_depth);
1566 free_binding_level = scope;
1569 /* Find the innermost enclosing class scope, and reset
1570 CLASS_BINDING_LEVEL appropriately. */
1571 if (scope->kind == sk_class)
1573 class_binding_level = NULL;
1574 for (scope = current_binding_level; scope; scope = scope->level_chain)
1575 if (scope->kind == sk_class)
1577 class_binding_level = scope;
1582 return current_binding_level;
1586 resume_scope (cp_binding_level* b)
1588 /* Resuming binding levels is meant only for namespaces,
1589 and those cannot nest into classes. */
1590 gcc_assert (!class_binding_level);
1591 /* Also, resuming a non-directly nested namespace is a no-no. */
1592 gcc_assert (b->level_chain == current_binding_level);
1593 current_binding_level = b;
1594 if (ENABLE_SCOPE_CHECKING)
1596 b->binding_depth = binding_depth;
1597 indent (binding_depth);
1598 cp_binding_level_debug (b, input_line, "resume");
1603 /* Return the innermost binding level that is not for a class scope. */
1605 static cp_binding_level *
1606 innermost_nonclass_level (void)
1608 cp_binding_level *b;
1610 b = current_binding_level;
1611 while (b->kind == sk_class)
1617 /* We're defining an object of type TYPE. If it needs a cleanup, but
1618 we're not allowed to add any more objects with cleanups to the current
1619 scope, create a new binding level. */
1622 maybe_push_cleanup_level (tree type)
1624 if (type != error_mark_node
1625 && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type)
1626 && current_binding_level->more_cleanups_ok == 0)
1628 begin_scope (sk_cleanup, NULL);
1629 current_binding_level->statement_list = push_stmt_list ();
1633 /* Return true if we are in the global binding level. */
1636 global_bindings_p (void)
1638 return global_scope_p (current_binding_level);
1641 /* True if we are currently in a toplevel binding level. This
1642 means either the global binding level or a namespace in a toplevel
1643 binding level. Since there are no non-toplevel namespace levels,
1644 this really means any namespace or template parameter level. We
1645 also include a class whose context is toplevel. */
1648 toplevel_bindings_p (void)
1650 cp_binding_level *b = innermost_nonclass_level ();
1652 return b->kind == sk_namespace || b->kind == sk_template_parms;
1655 /* True if this is a namespace scope, or if we are defining a class
1656 which is itself at namespace scope, or whose enclosing class is
1657 such a class, etc. */
1660 namespace_bindings_p (void)
1662 cp_binding_level *b = innermost_nonclass_level ();
1664 return b->kind == sk_namespace;
1667 /* True if the innermost non-class scope is a block scope. */
1670 local_bindings_p (void)
1672 cp_binding_level *b = innermost_nonclass_level ();
1673 return b->kind < sk_function_parms || b->kind == sk_omp;
1676 /* True if the current level needs to have a BLOCK made. */
1681 return (current_binding_level->blocks != NULL_TREE
1682 || current_binding_level->keep
1683 || current_binding_level->kind == sk_cleanup
1684 || current_binding_level->names != NULL_TREE
1685 || current_binding_level->using_directives);
1688 /* Returns the kind of the innermost scope. */
1691 innermost_scope_kind (void)
1693 return current_binding_level->kind;
1696 /* Returns true if this scope was created to store template parameters. */
1699 template_parm_scope_p (void)
1701 return innermost_scope_kind () == sk_template_parms;
1704 /* If KEEP is true, make a BLOCK node for the next binding level,
1705 unconditionally. Otherwise, use the normal logic to decide whether
1706 or not to create a BLOCK. */
1709 keep_next_level (bool keep)
1711 keep_next_level_flag = keep;
1714 /* Return the list of declarations of the current level.
1715 Note that this list is in reverse order unless/until
1716 you nreverse it; and when you do nreverse it, you must
1717 store the result back using `storedecls' or you will lose. */
1722 return current_binding_level->names;
1725 /* Return how many function prototypes we are currently nested inside. */
1728 function_parm_depth (void)
1731 cp_binding_level *b;
1733 for (b = current_binding_level;
1734 b->kind == sk_function_parms;
1741 /* For debugging. */
1742 static int no_print_functions = 0;
1743 static int no_print_builtins = 0;
1746 print_binding_level (cp_binding_level* lvl)
1750 fprintf (stderr, " blocks=%p", (void *) lvl->blocks);
1751 if (lvl->more_cleanups_ok)
1752 fprintf (stderr, " more-cleanups-ok");
1753 if (lvl->have_cleanups)
1754 fprintf (stderr, " have-cleanups");
1755 fprintf (stderr, "\n");
1758 fprintf (stderr, " names:\t");
1759 /* We can probably fit 3 names to a line? */
1760 for (t = lvl->names; t; t = TREE_CHAIN (t))
1762 if (no_print_functions && (TREE_CODE (t) == FUNCTION_DECL))
1764 if (no_print_builtins
1765 && (TREE_CODE (t) == TYPE_DECL)
1766 && DECL_IS_BUILTIN (t))
1769 /* Function decls tend to have longer names. */
1770 if (TREE_CODE (t) == FUNCTION_DECL)
1777 fprintf (stderr, "\n\t");
1780 print_node_brief (stderr, "", t, 0);
1781 if (t == error_mark_node)
1785 fprintf (stderr, "\n");
1787 if (VEC_length (cp_class_binding, lvl->class_shadowed))
1790 cp_class_binding *b;
1791 fprintf (stderr, " class-shadowed:");
1792 FOR_EACH_VEC_ELT (cp_class_binding, lvl->class_shadowed, i, b)
1793 fprintf (stderr, " %s ", IDENTIFIER_POINTER (b->identifier));
1794 fprintf (stderr, "\n");
1796 if (lvl->type_shadowed)
1798 fprintf (stderr, " type-shadowed:");
1799 for (t = lvl->type_shadowed; t; t = TREE_CHAIN (t))
1801 fprintf (stderr, " %s ", IDENTIFIER_POINTER (TREE_PURPOSE (t)));
1803 fprintf (stderr, "\n");
1808 print_other_binding_stack (cp_binding_level *stack)
1810 cp_binding_level *level;
1811 for (level = stack; !global_scope_p (level); level = level->level_chain)
1813 fprintf (stderr, "binding level %p\n", (void *) level);
1814 print_binding_level (level);
1819 print_binding_stack (void)
1821 cp_binding_level *b;
1822 fprintf (stderr, "current_binding_level=%p\n"
1823 "class_binding_level=%p\n"
1824 "NAMESPACE_LEVEL (global_namespace)=%p\n",
1825 (void *) current_binding_level, (void *) class_binding_level,
1826 (void *) NAMESPACE_LEVEL (global_namespace));
1827 if (class_binding_level)
1829 for (b = class_binding_level; b; b = b->level_chain)
1830 if (b == current_binding_level)
1833 b = class_binding_level;
1835 b = current_binding_level;
1838 b = current_binding_level;
1839 print_other_binding_stack (b);
1840 fprintf (stderr, "global:\n");
1841 print_binding_level (NAMESPACE_LEVEL (global_namespace));
1844 /* Return the type associated with ID. */
1847 identifier_type_value_1 (tree id)
1849 /* There is no type with that name, anywhere. */
1850 if (REAL_IDENTIFIER_TYPE_VALUE (id) == NULL_TREE)
1852 /* This is not the type marker, but the real thing. */
1853 if (REAL_IDENTIFIER_TYPE_VALUE (id) != global_type_node)
1854 return REAL_IDENTIFIER_TYPE_VALUE (id);
1855 /* Have to search for it. It must be on the global level, now.
1856 Ask lookup_name not to return non-types. */
1857 id = lookup_name_real (id, 2, 1, /*block_p=*/true, 0, LOOKUP_COMPLAIN);
1859 return TREE_TYPE (id);
1863 /* Wrapper for identifier_type_value_1. */
1866 identifier_type_value (tree id)
1869 timevar_start (TV_NAME_LOOKUP);
1870 ret = identifier_type_value_1 (id);
1871 timevar_stop (TV_NAME_LOOKUP);
1876 /* Return the IDENTIFIER_GLOBAL_VALUE of T, for use in common code, since
1877 the definition of IDENTIFIER_GLOBAL_VALUE is different for C and C++. */
1880 identifier_global_value (tree t)
1882 return IDENTIFIER_GLOBAL_VALUE (t);
1885 /* Push a definition of struct, union or enum tag named ID. into
1886 binding_level B. DECL is a TYPE_DECL for the type. We assume that
1887 the tag ID is not already defined. */
1890 set_identifier_type_value_with_scope (tree id, tree decl, cp_binding_level *b)
1894 if (b->kind != sk_namespace)
1896 /* Shadow the marker, not the real thing, so that the marker
1897 gets restored later. */
1898 tree old_type_value = REAL_IDENTIFIER_TYPE_VALUE (id);
1900 = tree_cons (id, old_type_value, b->type_shadowed);
1901 type = decl ? TREE_TYPE (decl) : NULL_TREE;
1902 TREE_TYPE (b->type_shadowed) = type;
1906 cxx_binding *binding =
1907 binding_for_name (NAMESPACE_LEVEL (current_namespace), id);
1910 supplement_binding (binding, decl);
1912 binding->value = decl;
1914 /* Store marker instead of real type. */
1915 type = global_type_node;
1917 SET_IDENTIFIER_TYPE_VALUE (id, type);
1920 /* As set_identifier_type_value_with_scope, but using
1921 current_binding_level. */
1924 set_identifier_type_value (tree id, tree decl)
1926 set_identifier_type_value_with_scope (id, decl, current_binding_level);
1929 /* Return the name for the constructor (or destructor) for the
1930 specified class TYPE. When given a template, this routine doesn't
1931 lose the specialization. */
1934 constructor_name_full (tree type)
1936 return TYPE_IDENTIFIER (TYPE_MAIN_VARIANT (type));
1939 /* Return the name for the constructor (or destructor) for the
1940 specified class. When given a template, return the plain
1941 unspecialized name. */
1944 constructor_name (tree type)
1947 name = constructor_name_full (type);
1948 if (IDENTIFIER_TEMPLATE (name))
1949 name = IDENTIFIER_TEMPLATE (name);
1953 /* Returns TRUE if NAME is the name for the constructor for TYPE,
1954 which must be a class type. */
1957 constructor_name_p (tree name, tree type)
1961 gcc_assert (MAYBE_CLASS_TYPE_P (type));
1966 if (TREE_CODE (name) != IDENTIFIER_NODE)
1969 ctor_name = constructor_name_full (type);
1970 if (name == ctor_name)
1972 if (IDENTIFIER_TEMPLATE (ctor_name)
1973 && name == IDENTIFIER_TEMPLATE (ctor_name))
1978 /* Counter used to create anonymous type names. */
1980 static GTY(()) int anon_cnt;
1982 /* Return an IDENTIFIER which can be used as a name for
1983 anonymous structs and unions. */
1986 make_anon_name (void)
1990 sprintf (buf, ANON_AGGRNAME_FORMAT, anon_cnt++);
1991 return get_identifier (buf);
1994 /* This code is practically identical to that for creating
1995 anonymous names, but is just used for lambdas instead. This is necessary
1996 because anonymous names are recognized and cannot be passed to template
1998 /* FIXME is this still necessary? */
2000 static GTY(()) int lambda_cnt = 0;
2003 make_lambda_name (void)
2007 sprintf (buf, LAMBDANAME_FORMAT, lambda_cnt++);
2008 return get_identifier (buf);
2011 /* Return (from the stack of) the BINDING, if any, established at SCOPE. */
2013 static inline cxx_binding *
2014 find_binding (cp_binding_level *scope, cxx_binding *binding)
2016 for (; binding != NULL; binding = binding->previous)
2017 if (binding->scope == scope)
2020 return (cxx_binding *)0;
2023 /* Return the binding for NAME in SCOPE, if any. Otherwise, return NULL. */
2025 static inline cxx_binding *
2026 cp_binding_level_find_binding_for_name (cp_binding_level *scope, tree name)
2028 cxx_binding *b = IDENTIFIER_NAMESPACE_BINDINGS (name);
2031 /* Fold-in case where NAME is used only once. */
2032 if (scope == b->scope && b->previous == NULL)
2034 return find_binding (scope, b);
2039 /* Always returns a binding for name in scope. If no binding is
2040 found, make a new one. */
2042 static cxx_binding *
2043 binding_for_name (cp_binding_level *scope, tree name)
2045 cxx_binding *result;
2047 result = cp_binding_level_find_binding_for_name (scope, name);
2050 /* Not found, make a new one. */
2051 result = cxx_binding_make (NULL, NULL);
2052 result->previous = IDENTIFIER_NAMESPACE_BINDINGS (name);
2053 result->scope = scope;
2054 result->is_local = false;
2055 result->value_is_inherited = false;
2056 IDENTIFIER_NAMESPACE_BINDINGS (name) = result;
2060 /* Walk through the bindings associated to the name of FUNCTION,
2061 and return the first declaration of a function with a
2062 "C" linkage specification, a.k.a 'extern "C"'.
2063 This function looks for the binding, regardless of which scope it
2064 has been defined in. It basically looks in all the known scopes.
2065 Note that this function does not lookup for bindings of builtin functions
2066 or for functions declared in system headers. */
2068 lookup_extern_c_fun_in_all_ns (tree function)
2073 gcc_assert (function && TREE_CODE (function) == FUNCTION_DECL);
2075 name = DECL_NAME (function);
2076 gcc_assert (name && TREE_CODE (name) == IDENTIFIER_NODE);
2078 for (iter = IDENTIFIER_NAMESPACE_BINDINGS (name);
2080 iter = iter->previous)
2083 for (ovl = iter->value; ovl; ovl = OVL_NEXT (ovl))
2085 tree decl = OVL_CURRENT (ovl);
2087 && TREE_CODE (decl) == FUNCTION_DECL
2088 && DECL_EXTERN_C_P (decl)
2089 && !DECL_ARTIFICIAL (decl))
2098 /* Returns a list of C-linkage decls with the name NAME. */
2101 c_linkage_bindings (tree name)
2103 tree decls = NULL_TREE;
2106 for (iter = IDENTIFIER_NAMESPACE_BINDINGS (name);
2108 iter = iter->previous)
2111 for (ovl = iter->value; ovl; ovl = OVL_NEXT (ovl))
2113 tree decl = OVL_CURRENT (ovl);
2115 && DECL_EXTERN_C_P (decl)
2116 && !DECL_ARTIFICIAL (decl))
2118 if (decls == NULL_TREE)
2121 decls = tree_cons (NULL_TREE, decl, decls);
2128 /* Insert another USING_DECL into the current binding level, returning
2129 this declaration. If this is a redeclaration, do nothing, and
2130 return NULL_TREE if this not in namespace scope (in namespace
2131 scope, a using decl might extend any previous bindings). */
2134 push_using_decl_1 (tree scope, tree name)
2138 gcc_assert (TREE_CODE (scope) == NAMESPACE_DECL);
2139 gcc_assert (TREE_CODE (name) == IDENTIFIER_NODE);
2140 for (decl = current_binding_level->usings; decl; decl = DECL_CHAIN (decl))
2141 if (USING_DECL_SCOPE (decl) == scope && DECL_NAME (decl) == name)
2144 return namespace_bindings_p () ? decl : NULL_TREE;
2145 decl = build_lang_decl (USING_DECL, name, NULL_TREE);
2146 USING_DECL_SCOPE (decl) = scope;
2147 DECL_CHAIN (decl) = current_binding_level->usings;
2148 current_binding_level->usings = decl;
2152 /* Wrapper for push_using_decl_1. */
2155 push_using_decl (tree scope, tree name)
2158 timevar_start (TV_NAME_LOOKUP);
2159 ret = push_using_decl_1 (scope, name);
2160 timevar_stop (TV_NAME_LOOKUP);
2164 /* Same as pushdecl, but define X in binding-level LEVEL. We rely on the
2165 caller to set DECL_CONTEXT properly.
2167 Note that this must only be used when X will be the new innermost
2168 binding for its name, as we tack it onto the front of IDENTIFIER_BINDING
2169 without checking to see if the current IDENTIFIER_BINDING comes from a
2170 closer binding level than LEVEL. */
2173 pushdecl_with_scope_1 (tree x, cp_binding_level *level, bool is_friend)
2175 cp_binding_level *b;
2176 tree function_decl = current_function_decl;
2178 current_function_decl = NULL_TREE;
2179 if (level->kind == sk_class)
2181 b = class_binding_level;
2182 class_binding_level = level;
2183 pushdecl_class_level (x);
2184 class_binding_level = b;
2188 b = current_binding_level;
2189 current_binding_level = level;
2190 x = pushdecl_maybe_friend (x, is_friend);
2191 current_binding_level = b;
2193 current_function_decl = function_decl;
2197 /* Wrapper for pushdecl_with_scope_1. */
2200 pushdecl_with_scope (tree x, cp_binding_level *level, bool is_friend)
2203 bool subtime = timevar_cond_start (TV_NAME_LOOKUP);
2204 ret = pushdecl_with_scope_1 (x, level, is_friend);
2205 timevar_cond_stop (TV_NAME_LOOKUP, subtime);
2210 /* DECL is a FUNCTION_DECL for a non-member function, which may have
2211 other definitions already in place. We get around this by making
2212 the value of the identifier point to a list of all the things that
2213 want to be referenced by that name. It is then up to the users of
2214 that name to decide what to do with that list.
2216 DECL may also be a TEMPLATE_DECL, with a FUNCTION_DECL in its
2217 DECL_TEMPLATE_RESULT. It is dealt with the same way.
2219 FLAGS is a bitwise-or of the following values:
2220 PUSH_LOCAL: Bind DECL in the current scope, rather than at
2222 PUSH_USING: DECL is being pushed as the result of a using
2225 IS_FRIEND is true if this is a friend declaration.
2227 The value returned may be a previous declaration if we guessed wrong
2228 about what language DECL should belong to (C or C++). Otherwise,
2229 it's always DECL (and never something that's not a _DECL). */
2232 push_overloaded_decl_1 (tree decl, int flags, bool is_friend)
2234 tree name = DECL_NAME (decl);
2237 int doing_global = (namespace_bindings_p () || !(flags & PUSH_LOCAL));
2240 old = namespace_binding (name, DECL_CONTEXT (decl));
2242 old = lookup_name_innermost_nonclass_level (name);
2246 if (TREE_CODE (old) == TYPE_DECL && DECL_ARTIFICIAL (old))
2248 tree t = TREE_TYPE (old);
2249 if (MAYBE_CLASS_TYPE_P (t) && warn_shadow
2250 && (! DECL_IN_SYSTEM_HEADER (decl)
2251 || ! DECL_IN_SYSTEM_HEADER (old)))
2252 warning (OPT_Wshadow, "%q#D hides constructor for %q#T", decl, t);
2255 else if (is_overloaded_fn (old))
2259 for (tmp = old; tmp; tmp = OVL_NEXT (tmp))
2261 tree fn = OVL_CURRENT (tmp);
2264 if (TREE_CODE (tmp) == OVERLOAD && OVL_USED (tmp)
2265 && !(flags & PUSH_USING)
2266 && compparms (TYPE_ARG_TYPES (TREE_TYPE (fn)),
2267 TYPE_ARG_TYPES (TREE_TYPE (decl)))
2268 && ! decls_match (fn, decl))
2269 error ("%q#D conflicts with previous using declaration %q#D",
2272 dup = duplicate_decls (decl, fn, is_friend);
2273 /* If DECL was a redeclaration of FN -- even an invalid
2274 one -- pass that information along to our caller. */
2275 if (dup == fn || dup == error_mark_node)
2279 /* We don't overload implicit built-ins. duplicate_decls()
2280 may fail to merge the decls if the new decl is e.g. a
2281 template function. */
2282 if (TREE_CODE (old) == FUNCTION_DECL
2283 && DECL_ANTICIPATED (old)
2284 && !DECL_HIDDEN_FRIEND_P (old))
2287 else if (old == error_mark_node)
2288 /* Ignore the undefined symbol marker. */
2292 error ("previous non-function declaration %q+#D", old);
2293 error ("conflicts with function declaration %q#D", decl);
2298 if (old || TREE_CODE (decl) == TEMPLATE_DECL
2299 /* If it's a using declaration, we always need to build an OVERLOAD,
2300 because it's the only way to remember that the declaration comes
2301 from 'using', and have the lookup behave correctly. */
2302 || (flags & PUSH_USING))
2304 if (old && TREE_CODE (old) != OVERLOAD)
2305 new_binding = ovl_cons (decl, ovl_cons (old, NULL_TREE));
2307 new_binding = ovl_cons (decl, old);
2308 if (flags & PUSH_USING)
2309 OVL_USED (new_binding) = 1;
2312 /* NAME is not ambiguous. */
2316 set_namespace_binding (name, current_namespace, new_binding);
2319 /* We only create an OVERLOAD if there was a previous binding at
2320 this level, or if decl is a template. In the former case, we
2321 need to remove the old binding and replace it with the new
2322 binding. We must also run through the NAMES on the binding
2323 level where the name was bound to update the chain. */
2325 if (TREE_CODE (new_binding) == OVERLOAD && old)
2329 for (d = &IDENTIFIER_BINDING (name)->scope->names;
2331 d = &TREE_CHAIN (*d))
2333 || (TREE_CODE (*d) == TREE_LIST
2334 && TREE_VALUE (*d) == old))
2336 if (TREE_CODE (*d) == TREE_LIST)
2337 /* Just replace the old binding with the new. */
2338 TREE_VALUE (*d) = new_binding;
2340 /* Build a TREE_LIST to wrap the OVERLOAD. */
2341 *d = tree_cons (NULL_TREE, new_binding,
2344 /* And update the cxx_binding node. */
2345 IDENTIFIER_BINDING (name)->value = new_binding;
2349 /* We should always find a previous binding in this case. */
2353 /* Install the new binding. */
2354 push_local_binding (name, new_binding, flags);
2360 /* Wrapper for push_overloaded_decl_1. */
2363 push_overloaded_decl (tree decl, int flags, bool is_friend)
2366 bool subtime = timevar_cond_start (TV_NAME_LOOKUP);
2367 ret = push_overloaded_decl_1 (decl, flags, is_friend);
2368 timevar_cond_stop (TV_NAME_LOOKUP, subtime);
2372 /* Check a non-member using-declaration. Return the name and scope
2373 being used, and the USING_DECL, or NULL_TREE on failure. */
2376 validate_nonmember_using_decl (tree decl, tree scope, tree name)
2378 /* [namespace.udecl]
2379 A using-declaration for a class member shall be a
2380 member-declaration. */
2383 error ("%qT is not a namespace", scope);
2386 else if (scope == error_mark_node)
2389 if (TREE_CODE (decl) == TEMPLATE_ID_EXPR)
2392 A using-declaration shall not name a template-id. */
2393 error ("a using-declaration cannot specify a template-id. "
2394 "Try %<using %D%>", name);
2398 if (TREE_CODE (decl) == NAMESPACE_DECL)
2400 error ("namespace %qD not allowed in using-declaration", decl);
2404 if (TREE_CODE (decl) == SCOPE_REF)
2406 /* It's a nested name with template parameter dependent scope.
2407 This can only be using-declaration for class member. */
2408 error ("%qT is not a namespace", TREE_OPERAND (decl, 0));
2412 if (is_overloaded_fn (decl))
2413 decl = get_first_fn (decl);
2415 gcc_assert (DECL_P (decl));
2417 /* Make a USING_DECL. */
2418 return push_using_decl (scope, name);
2421 /* Process local and global using-declarations. */
2424 do_nonmember_using_decl (tree scope, tree name, tree oldval, tree oldtype,
2425 tree *newval, tree *newtype)
2427 struct scope_binding decls = EMPTY_SCOPE_BINDING;
2429 *newval = *newtype = NULL_TREE;
2430 if (!qualified_lookup_using_namespace (name, scope, &decls, 0))
2434 if (!decls.value && !decls.type)
2436 error ("%qD not declared", name);
2440 /* Shift the old and new bindings around so we're comparing class and
2441 enumeration names to each other. */
2442 if (oldval && DECL_IMPLICIT_TYPEDEF_P (oldval))
2448 if (decls.value && DECL_IMPLICIT_TYPEDEF_P (decls.value))
2450 decls.type = decls.value;
2451 decls.value = NULL_TREE;
2454 /* It is impossible to overload a built-in function; any explicit
2455 declaration eliminates the built-in declaration. So, if OLDVAL
2456 is a built-in, then we can just pretend it isn't there. */
2458 && TREE_CODE (oldval) == FUNCTION_DECL
2459 && DECL_ANTICIPATED (oldval)
2460 && !DECL_HIDDEN_FRIEND_P (oldval))
2465 /* Check for using functions. */
2466 if (is_overloaded_fn (decls.value))
2470 if (oldval && !is_overloaded_fn (oldval))
2472 error ("%qD is already declared in this scope", name);
2477 for (tmp = decls.value; tmp; tmp = OVL_NEXT (tmp))
2479 tree new_fn = OVL_CURRENT (tmp);
2481 /* [namespace.udecl]
2483 If a function declaration in namespace scope or block
2484 scope has the same name and the same parameter types as a
2485 function introduced by a using declaration the program is
2487 for (tmp1 = oldval; tmp1; tmp1 = OVL_NEXT (tmp1))
2489 tree old_fn = OVL_CURRENT (tmp1);
2491 if (new_fn == old_fn)
2492 /* The function already exists in the current namespace. */
2494 else if (OVL_USED (tmp1))
2495 continue; /* this is a using decl */
2496 else if (compparms (TYPE_ARG_TYPES (TREE_TYPE (new_fn)),
2497 TYPE_ARG_TYPES (TREE_TYPE (old_fn))))
2499 gcc_assert (!DECL_ANTICIPATED (old_fn)
2500 || DECL_HIDDEN_FRIEND_P (old_fn));
2502 /* There was already a non-using declaration in
2503 this scope with the same parameter types. If both
2504 are the same extern "C" functions, that's ok. */
2505 if (decls_match (new_fn, old_fn))
2509 error ("%qD is already declared in this scope", name);
2515 /* If we broke out of the loop, there's no reason to add
2516 this function to the using declarations for this
2521 /* If we are adding to an existing OVERLOAD, then we no
2522 longer know the type of the set of functions. */
2523 if (*newval && TREE_CODE (*newval) == OVERLOAD)
2524 TREE_TYPE (*newval) = unknown_type_node;
2525 /* Add this new function to the set. */
2526 *newval = build_overload (OVL_CURRENT (tmp), *newval);
2527 /* If there is only one function, then we use its type. (A
2528 using-declaration naming a single function can be used in
2529 contexts where overload resolution cannot be
2531 if (TREE_CODE (*newval) != OVERLOAD)
2533 *newval = ovl_cons (*newval, NULL_TREE);
2534 TREE_TYPE (*newval) = TREE_TYPE (OVL_CURRENT (tmp));
2536 OVL_USED (*newval) = 1;
2541 *newval = decls.value;
2542 if (oldval && !decls_match (*newval, oldval))
2543 error ("%qD is already declared in this scope", name);
2549 if (decls.type && TREE_CODE (decls.type) == TREE_LIST)
2551 error ("reference to %qD is ambiguous", name);
2552 print_candidates (decls.type);
2556 *newtype = decls.type;
2557 if (oldtype && *newtype && !decls_match (oldtype, *newtype))
2558 error ("%qD is already declared in this scope", name);
2561 /* If *newval is empty, shift any class or enumeration name down. */
2565 *newtype = NULL_TREE;
2569 /* Process a using-declaration at function scope. */
2572 do_local_using_decl (tree decl, tree scope, tree name)
2574 tree oldval, oldtype, newval, newtype;
2575 tree orig_decl = decl;
2577 decl = validate_nonmember_using_decl (decl, scope, name);
2578 if (decl == NULL_TREE)
2581 if (building_stmt_list_p ()
2582 && at_function_scope_p ())
2583 add_decl_expr (decl);
2585 oldval = lookup_name_innermost_nonclass_level (name);
2586 oldtype = lookup_type_current_level (name);
2588 do_nonmember_using_decl (scope, name, oldval, oldtype, &newval, &newtype);
2592 if (is_overloaded_fn (newval))
2596 /* We only need to push declarations for those functions
2597 that were not already bound in the current level.
2598 The old value might be NULL_TREE, it might be a single
2599 function, or an OVERLOAD. */
2600 if (oldval && TREE_CODE (oldval) == OVERLOAD)
2601 term = OVL_FUNCTION (oldval);
2604 for (fn = newval; fn && OVL_CURRENT (fn) != term;
2606 push_overloaded_decl (OVL_CURRENT (fn),
2607 PUSH_LOCAL | PUSH_USING,
2611 push_local_binding (name, newval, PUSH_USING);
2615 push_local_binding (name, newtype, PUSH_USING);
2616 set_identifier_type_value (name, newtype);
2619 /* Emit debug info. */
2620 if (!processing_template_decl)
2621 cp_emit_debug_info_for_using (orig_decl, current_scope());
2624 /* Returns true if ROOT (a namespace, class, or function) encloses
2625 CHILD. CHILD may be either a class type or a namespace. */
2628 is_ancestor (tree root, tree child)
2630 gcc_assert ((TREE_CODE (root) == NAMESPACE_DECL
2631 || TREE_CODE (root) == FUNCTION_DECL
2632 || CLASS_TYPE_P (root)));
2633 gcc_assert ((TREE_CODE (child) == NAMESPACE_DECL
2634 || CLASS_TYPE_P (child)));
2636 /* The global namespace encloses everything. */
2637 if (root == global_namespace)
2642 /* If we've run out of scopes, stop. */
2645 /* If we've reached the ROOT, it encloses CHILD. */
2648 /* Go out one level. */
2650 child = TYPE_NAME (child);
2651 child = DECL_CONTEXT (child);
2655 /* Enter the class or namespace scope indicated by T suitable for name
2656 lookup. T can be arbitrary scope, not necessary nested inside the
2657 current scope. Returns a non-null scope to pop iff pop_scope
2658 should be called later to exit this scope. */
2663 if (TREE_CODE (t) == NAMESPACE_DECL)
2664 push_decl_namespace (t);
2665 else if (CLASS_TYPE_P (t))
2667 if (!at_class_scope_p ()
2668 || !same_type_p (current_class_type, t))
2669 push_nested_class (t);
2671 /* T is the same as the current scope. There is therefore no
2672 need to re-enter the scope. Since we are not actually
2673 pushing a new scope, our caller should not call
2681 /* Leave scope pushed by push_scope. */
2688 if (TREE_CODE (t) == NAMESPACE_DECL)
2689 pop_decl_namespace ();
2690 else if CLASS_TYPE_P (t)
2691 pop_nested_class ();
2694 /* Subroutine of push_inner_scope. */
2697 push_inner_scope_r (tree outer, tree inner)
2702 || (TREE_CODE (inner) != NAMESPACE_DECL && !CLASS_TYPE_P (inner)))
2705 prev = CP_DECL_CONTEXT (TREE_CODE (inner) == NAMESPACE_DECL ? inner : TYPE_NAME (inner));
2707 push_inner_scope_r (outer, prev);
2708 if (TREE_CODE (inner) == NAMESPACE_DECL)
2710 cp_binding_level *save_template_parm = 0;
2711 /* Temporary take out template parameter scopes. They are saved
2712 in reversed order in save_template_parm. */
2713 while (current_binding_level->kind == sk_template_parms)
2715 cp_binding_level *b = current_binding_level;
2716 current_binding_level = b->level_chain;
2717 b->level_chain = save_template_parm;
2718 save_template_parm = b;
2721 resume_scope (NAMESPACE_LEVEL (inner));
2722 current_namespace = inner;
2724 /* Restore template parameter scopes. */
2725 while (save_template_parm)
2727 cp_binding_level *b = save_template_parm;
2728 save_template_parm = b->level_chain;
2729 b->level_chain = current_binding_level;
2730 current_binding_level = b;
2737 /* Enter the scope INNER from current scope. INNER must be a scope
2738 nested inside current scope. This works with both name lookup and
2739 pushing name into scope. In case a template parameter scope is present,
2740 namespace is pushed under the template parameter scope according to
2741 name lookup rule in 14.6.1/6.
2743 Return the former current scope suitable for pop_inner_scope. */
2746 push_inner_scope (tree inner)
2748 tree outer = current_scope ();
2750 outer = current_namespace;
2752 push_inner_scope_r (outer, inner);
2756 /* Exit the current scope INNER back to scope OUTER. */
2759 pop_inner_scope (tree outer, tree inner)
2762 || (TREE_CODE (inner) != NAMESPACE_DECL && !CLASS_TYPE_P (inner)))
2765 while (outer != inner)
2767 if (TREE_CODE (inner) == NAMESPACE_DECL)
2769 cp_binding_level *save_template_parm = 0;
2770 /* Temporary take out template parameter scopes. They are saved
2771 in reversed order in save_template_parm. */
2772 while (current_binding_level->kind == sk_template_parms)
2774 cp_binding_level *b = current_binding_level;
2775 current_binding_level = b->level_chain;
2776 b->level_chain = save_template_parm;
2777 save_template_parm = b;
2782 /* Restore template parameter scopes. */
2783 while (save_template_parm)
2785 cp_binding_level *b = save_template_parm;
2786 save_template_parm = b->level_chain;
2787 b->level_chain = current_binding_level;
2788 current_binding_level = b;
2794 inner = CP_DECL_CONTEXT (TREE_CODE (inner) == NAMESPACE_DECL ? inner : TYPE_NAME (inner));
2798 /* Do a pushlevel for class declarations. */
2801 pushlevel_class (void)
2803 class_binding_level = begin_scope (sk_class, current_class_type);
2806 /* ...and a poplevel for class declarations. */
2809 poplevel_class (void)
2811 cp_binding_level *level = class_binding_level;
2812 cp_class_binding *cb;
2816 bool subtime = timevar_cond_start (TV_NAME_LOOKUP);
2817 gcc_assert (level != 0);
2819 /* If we're leaving a toplevel class, cache its binding level. */
2820 if (current_class_depth == 1)
2821 previous_class_level = level;
2822 for (shadowed = level->type_shadowed;
2824 shadowed = TREE_CHAIN (shadowed))
2825 SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (shadowed), TREE_VALUE (shadowed));
2827 /* Remove the bindings for all of the class-level declarations. */
2828 if (level->class_shadowed)
2830 FOR_EACH_VEC_ELT (cp_class_binding, level->class_shadowed, i, cb)
2832 IDENTIFIER_BINDING (cb->identifier) = cb->base->previous;
2833 cxx_binding_free (cb->base);
2835 ggc_free (level->class_shadowed);
2836 level->class_shadowed = NULL;
2839 /* Now, pop out of the binding level which we created up in the
2840 `pushlevel_class' routine. */
2841 gcc_assert (current_binding_level == level);
2843 timevar_cond_stop (TV_NAME_LOOKUP, subtime);
2846 /* Set INHERITED_VALUE_BINDING_P on BINDING to true or false, as
2847 appropriate. DECL is the value to which a name has just been
2848 bound. CLASS_TYPE is the class in which the lookup occurred. */
2851 set_inherited_value_binding_p (cxx_binding *binding, tree decl,
2854 if (binding->value == decl && TREE_CODE (decl) != TREE_LIST)
2858 if (TREE_CODE (decl) == OVERLOAD)
2859 context = ovl_scope (decl);
2862 gcc_assert (DECL_P (decl));
2863 context = context_for_name_lookup (decl);
2866 if (is_properly_derived_from (class_type, context))
2867 INHERITED_VALUE_BINDING_P (binding) = 1;
2869 INHERITED_VALUE_BINDING_P (binding) = 0;
2871 else if (binding->value == decl)
2872 /* We only encounter a TREE_LIST when there is an ambiguity in the
2873 base classes. Such an ambiguity can be overridden by a
2874 definition in this class. */
2875 INHERITED_VALUE_BINDING_P (binding) = 1;
2877 INHERITED_VALUE_BINDING_P (binding) = 0;
2880 /* Make the declaration of X appear in CLASS scope. */
2883 pushdecl_class_level (tree x)
2886 bool is_valid = true;
2889 /* Do nothing if we're adding to an outer lambda closure type,
2890 outer_binding will add it later if it's needed. */
2891 if (current_class_type != class_binding_level->this_entity)
2894 subtime = timevar_cond_start (TV_NAME_LOOKUP);
2895 /* Get the name of X. */
2896 if (TREE_CODE (x) == OVERLOAD)
2897 name = DECL_NAME (get_first_fn (x));
2899 name = DECL_NAME (x);
2903 is_valid = push_class_level_binding (name, x);
2904 if (TREE_CODE (x) == TYPE_DECL)
2905 set_identifier_type_value (name, x);
2907 else if (ANON_AGGR_TYPE_P (TREE_TYPE (x)))
2909 /* If X is an anonymous aggregate, all of its members are
2910 treated as if they were members of the class containing the
2911 aggregate, for naming purposes. */
2914 for (f = TYPE_FIELDS (TREE_TYPE (x)); f; f = DECL_CHAIN (f))
2916 location_t save_location = input_location;
2917 input_location = DECL_SOURCE_LOCATION (f);
2918 if (!pushdecl_class_level (f))
2920 input_location = save_location;
2923 timevar_cond_stop (TV_NAME_LOOKUP, subtime);
2927 /* Return the BINDING (if any) for NAME in SCOPE, which is a class
2928 scope. If the value returned is non-NULL, and the PREVIOUS field
2929 is not set, callers must set the PREVIOUS field explicitly. */
2931 static cxx_binding *
2932 get_class_binding (tree name, cp_binding_level *scope)
2937 cxx_binding *binding;
2939 class_type = scope->this_entity;
2941 /* Get the type binding. */
2942 type_binding = lookup_member (class_type, name,
2943 /*protect=*/2, /*want_type=*/true,
2944 tf_warning_or_error);
2945 /* Get the value binding. */
2946 value_binding = lookup_member (class_type, name,
2947 /*protect=*/2, /*want_type=*/false,
2948 tf_warning_or_error);
2951 && (TREE_CODE (value_binding) == TYPE_DECL
2952 || DECL_CLASS_TEMPLATE_P (value_binding)
2953 || (TREE_CODE (value_binding) == TREE_LIST
2954 && TREE_TYPE (value_binding) == error_mark_node
2955 && (TREE_CODE (TREE_VALUE (value_binding))
2957 /* We found a type binding, even when looking for a non-type
2958 binding. This means that we already processed this binding
2961 else if (value_binding)
2963 if (TREE_CODE (value_binding) == TREE_LIST
2964 && TREE_TYPE (value_binding) == error_mark_node)
2965 /* NAME is ambiguous. */
2967 else if (BASELINK_P (value_binding))
2968 /* NAME is some overloaded functions. */
2969 value_binding = BASELINK_FUNCTIONS (value_binding);
2972 /* If we found either a type binding or a value binding, create a
2973 new binding object. */
2974 if (type_binding || value_binding)
2976 binding = new_class_binding (name,
2980 /* This is a class-scope binding, not a block-scope binding. */
2981 LOCAL_BINDING_P (binding) = 0;
2982 set_inherited_value_binding_p (binding, value_binding, class_type);
2990 /* Make the declaration(s) of X appear in CLASS scope under the name
2991 NAME. Returns true if the binding is valid. */
2994 push_class_level_binding_1 (tree name, tree x)
2996 cxx_binding *binding;
3000 /* The class_binding_level will be NULL if x is a template
3001 parameter name in a member template. */
3002 if (!class_binding_level)
3005 if (name == error_mark_node)
3008 /* Check for invalid member names. */
3009 gcc_assert (TYPE_BEING_DEFINED (current_class_type));
3010 /* Check that we're pushing into the right binding level. */
3011 gcc_assert (current_class_type == class_binding_level->this_entity);
3013 /* We could have been passed a tree list if this is an ambiguous
3014 declaration. If so, pull the declaration out because
3015 check_template_shadow will not handle a TREE_LIST. */
3016 if (TREE_CODE (decl) == TREE_LIST
3017 && TREE_TYPE (decl) == error_mark_node)
3018 decl = TREE_VALUE (decl);
3020 if (!check_template_shadow (decl))
3025 If T is the name of a class, then each of the following shall
3026 have a name different from T:
3028 -- every static data member of class T;
3030 -- every member of class T that is itself a type;
3032 -- every enumerator of every member of class T that is an
3035 -- every member of every anonymous union that is a member of
3038 (Non-static data members were also forbidden to have the same
3039 name as T until TC1.) */
3040 if ((TREE_CODE (x) == VAR_DECL
3041 || TREE_CODE (x) == CONST_DECL
3042 || (TREE_CODE (x) == TYPE_DECL
3043 && !DECL_SELF_REFERENCE_P (x))
3044 /* A data member of an anonymous union. */
3045 || (TREE_CODE (x) == FIELD_DECL
3046 && DECL_CONTEXT (x) != current_class_type))
3047 && DECL_NAME (x) == constructor_name (current_class_type))
3049 tree scope = context_for_name_lookup (x);
3050 if (TYPE_P (scope) && same_type_p (scope, current_class_type))
3052 error ("%qD has the same name as the class in which it is "
3059 /* Get the current binding for NAME in this class, if any. */
3060 binding = IDENTIFIER_BINDING (name);
3061 if (!binding || binding->scope != class_binding_level)
3063 binding = get_class_binding (name, class_binding_level);
3064 /* If a new binding was created, put it at the front of the
3065 IDENTIFIER_BINDING list. */
3068 binding->previous = IDENTIFIER_BINDING (name);
3069 IDENTIFIER_BINDING (name) = binding;
3073 /* If there is already a binding, then we may need to update the
3075 if (binding && binding->value)
3077 tree bval = binding->value;
3078 tree old_decl = NULL_TREE;
3079 tree target_decl = strip_using_decl (decl);
3080 tree target_bval = strip_using_decl (bval);
3082 if (INHERITED_VALUE_BINDING_P (binding))
3084 /* If the old binding was from a base class, and was for a
3085 tag name, slide it over to make room for the new binding.
3086 The old binding is still visible if explicitly qualified
3087 with a class-key. */
3088 if (TREE_CODE (target_bval) == TYPE_DECL
3089 && DECL_ARTIFICIAL (target_bval)
3090 && !(TREE_CODE (target_decl) == TYPE_DECL
3091 && DECL_ARTIFICIAL (target_decl)))
3093 old_decl = binding->type;
3094 binding->type = bval;
3095 binding->value = NULL_TREE;
3096 INHERITED_VALUE_BINDING_P (binding) = 0;
3101 /* Any inherited type declaration is hidden by the type
3102 declaration in the derived class. */
3103 if (TREE_CODE (target_decl) == TYPE_DECL
3104 && DECL_ARTIFICIAL (target_decl))
3105 binding->type = NULL_TREE;
3108 else if (TREE_CODE (target_decl) == OVERLOAD
3109 && is_overloaded_fn (target_bval))
3111 else if (TREE_CODE (decl) == USING_DECL
3112 && TREE_CODE (bval) == USING_DECL
3113 && same_type_p (USING_DECL_SCOPE (decl),
3114 USING_DECL_SCOPE (bval)))
3115 /* This is a using redeclaration that will be diagnosed later
3116 in supplement_binding */
3118 else if (TREE_CODE (decl) == USING_DECL
3119 && TREE_CODE (bval) == USING_DECL
3120 && DECL_DEPENDENT_P (decl)
3121 && DECL_DEPENDENT_P (bval))
3123 else if (TREE_CODE (decl) == USING_DECL
3124 && is_overloaded_fn (target_bval))
3126 else if (TREE_CODE (bval) == USING_DECL
3127 && is_overloaded_fn (target_decl))
3130 if (old_decl && binding->scope == class_binding_level)
3133 /* It is always safe to clear INHERITED_VALUE_BINDING_P
3134 here. This function is only used to register bindings
3135 from with the class definition itself. */
3136 INHERITED_VALUE_BINDING_P (binding) = 0;
3141 /* Note that we declared this value so that we can issue an error if
3142 this is an invalid redeclaration of a name already used for some
3144 note_name_declared_in_class (name, decl);
3146 /* If we didn't replace an existing binding, put the binding on the
3147 stack of bindings for the identifier, and update the shadowed
3149 if (binding && binding->scope == class_binding_level)
3150 /* Supplement the existing binding. */
3151 ok = supplement_binding (binding, decl);
3154 /* Create a new binding. */
3155 push_binding (name, decl, class_binding_level);
3162 /* Wrapper for push_class_level_binding_1. */
3165 push_class_level_binding (tree name, tree x)
3168 bool subtime = timevar_cond_start (TV_NAME_LOOKUP);
3169 ret = push_class_level_binding_1 (name, x);
3170 timevar_cond_stop (TV_NAME_LOOKUP, subtime);
3174 /* Process "using SCOPE::NAME" in a class scope. Return the
3175 USING_DECL created. */
3178 do_class_using_decl (tree scope, tree name)
3180 /* The USING_DECL returned by this function. */
3182 /* The declaration (or declarations) name by this using
3183 declaration. NULL if we are in a template and cannot figure out
3184 what has been named. */
3186 /* True if SCOPE is a dependent type. */
3187 bool scope_dependent_p;
3188 /* True if SCOPE::NAME is dependent. */
3189 bool name_dependent_p;
3190 /* True if any of the bases of CURRENT_CLASS_TYPE are dependent. */
3191 bool bases_dependent_p;
3196 if (name == error_mark_node)
3199 if (!scope || !TYPE_P (scope))
3201 error ("using-declaration for non-member at class scope");
3205 /* Make sure the name is not invalid */
3206 if (TREE_CODE (name) == BIT_NOT_EXPR)
3208 error ("%<%T::%D%> names destructor", scope, name);
3211 if (MAYBE_CLASS_TYPE_P (scope) && constructor_name_p (name, scope))
3213 error ("%<%T::%D%> names constructor", scope, name);
3216 if (constructor_name_p (name, current_class_type))
3218 error ("%<%T::%D%> names constructor in %qT",
3219 scope, name, current_class_type);
3223 scope_dependent_p = dependent_scope_p (scope);
3224 name_dependent_p = (scope_dependent_p
3225 || (IDENTIFIER_TYPENAME_P (name)
3226 && dependent_type_p (TREE_TYPE (name))));
3228 bases_dependent_p = false;
3229 if (processing_template_decl)
3230 for (binfo = TYPE_BINFO (current_class_type), i = 0;
3231 BINFO_BASE_ITERATE (binfo, i, base_binfo);
3233 if (dependent_type_p (TREE_TYPE (base_binfo)))
3235 bases_dependent_p = true;
3241 /* From [namespace.udecl]:
3243 A using-declaration used as a member-declaration shall refer to a
3244 member of a base class of the class being defined.
3246 In general, we cannot check this constraint in a template because
3247 we do not know the entire set of base classes of the current
3248 class type. Morover, if SCOPE is dependent, it might match a
3249 non-dependent base. */
3251 if (!scope_dependent_p)
3254 binfo = lookup_base (current_class_type, scope, ba_any, &b_kind);
3255 if (b_kind < bk_proper_base)
3257 if (!bases_dependent_p)
3259 error_not_base_type (scope, current_class_type);
3263 else if (!name_dependent_p)
3265 decl = lookup_member (binfo, name, 0, false, tf_warning_or_error);
3268 error ("no members matching %<%T::%D%> in %q#T", scope, name,
3272 /* The binfo from which the functions came does not matter. */
3273 if (BASELINK_P (decl))
3274 decl = BASELINK_FUNCTIONS (decl);
3278 value = build_lang_decl (USING_DECL, name, NULL_TREE);
3279 USING_DECL_DECLS (value) = decl;
3280 USING_DECL_SCOPE (value) = scope;
3281 DECL_DEPENDENT_P (value) = !decl;
3287 /* Return the binding value for name in scope. */
3291 namespace_binding_1 (tree name, tree scope)
3293 cxx_binding *binding;
3295 if (SCOPE_FILE_SCOPE_P (scope))
3296 scope = global_namespace;
3298 /* Unnecessary for the global namespace because it can't be an alias. */
3299 scope = ORIGINAL_NAMESPACE (scope);
3301 binding = cp_binding_level_find_binding_for_name (NAMESPACE_LEVEL (scope), name);
3303 return binding ? binding->value : NULL_TREE;
3307 namespace_binding (tree name, tree scope)
3310 bool subtime = timevar_cond_start (TV_NAME_LOOKUP);
3311 ret = namespace_binding_1 (name, scope);
3312 timevar_cond_stop (TV_NAME_LOOKUP, subtime);
3316 /* Set the binding value for name in scope. */
3319 set_namespace_binding_1 (tree name, tree scope, tree val)
3323 if (scope == NULL_TREE)
3324 scope = global_namespace;
3325 b = binding_for_name (NAMESPACE_LEVEL (scope), name);
3326 if (!b->value || TREE_CODE (val) == OVERLOAD || val == error_mark_node)
3329 supplement_binding (b, val);
3332 /* Wrapper for set_namespace_binding_1. */
3335 set_namespace_binding (tree name, tree scope, tree val)
3337 bool subtime = timevar_cond_start (TV_NAME_LOOKUP);
3338 set_namespace_binding_1 (name, scope, val);
3339 timevar_cond_stop (TV_NAME_LOOKUP, subtime);
3342 /* Set the context of a declaration to scope. Complain if we are not
3346 set_decl_namespace (tree decl, tree scope, bool friendp)
3350 /* Get rid of namespace aliases. */
3351 scope = ORIGINAL_NAMESPACE (scope);
3353 /* It is ok for friends to be qualified in parallel space. */
3354 if (!friendp && !is_ancestor (current_namespace, scope))
3355 error ("declaration of %qD not in a namespace surrounding %qD",
3357 DECL_CONTEXT (decl) = FROB_CONTEXT (scope);
3359 /* Writing "int N::i" to declare a variable within "N" is invalid. */
3360 if (scope == current_namespace)
3362 if (at_namespace_scope_p ())
3363 error ("explicit qualification in declaration of %qD",
3368 /* See whether this has been declared in the namespace. */
3369 old = lookup_qualified_name (scope, DECL_NAME (decl), false, true);
3370 if (old == error_mark_node)
3371 /* No old declaration at all. */
3373 /* If it's a TREE_LIST, the result of the lookup was ambiguous. */
3374 if (TREE_CODE (old) == TREE_LIST)
3376 error ("reference to %qD is ambiguous", decl);
3377 print_candidates (old);
3380 if (!is_overloaded_fn (decl))
3382 /* We might have found OLD in an inline namespace inside SCOPE. */
3383 if (TREE_CODE (decl) == TREE_CODE (old))
3384 DECL_CONTEXT (decl) = DECL_CONTEXT (old);
3385 /* Don't compare non-function decls with decls_match here, since
3386 it can't check for the correct constness at this
3387 point. pushdecl will find those errors later. */
3390 /* Since decl is a function, old should contain a function decl. */
3391 if (!is_overloaded_fn (old))
3393 /* A template can be explicitly specialized in any namespace. */
3394 if (processing_explicit_instantiation)
3396 if (processing_template_decl || processing_specialization)
3397 /* We have not yet called push_template_decl to turn a
3398 FUNCTION_DECL into a TEMPLATE_DECL, so the declarations won't
3399 match. But, we'll check later, when we construct the
3402 /* Instantiations or specializations of templates may be declared as
3403 friends in any namespace. */
3404 if (friendp && DECL_USE_TEMPLATE (decl))
3406 if (is_overloaded_fn (old))
3408 tree found = NULL_TREE;
3410 for (; elt; elt = OVL_NEXT (elt))
3412 tree ofn = OVL_CURRENT (elt);
3413 /* Adjust DECL_CONTEXT first so decls_match will return true
3414 if DECL will match a declaration in an inline namespace. */
3415 DECL_CONTEXT (decl) = DECL_CONTEXT (ofn);
3416 if (decls_match (decl, ofn))
3418 if (found && !decls_match (found, ofn))
3420 DECL_CONTEXT (decl) = FROB_CONTEXT (scope);
3421 error ("reference to %qD is ambiguous", decl);
3422 print_candidates (old);
3430 if (!is_associated_namespace (scope, CP_DECL_CONTEXT (found)))
3432 DECL_CONTEXT (decl) = DECL_CONTEXT (found);
3438 DECL_CONTEXT (decl) = DECL_CONTEXT (old);
3439 if (decls_match (decl, old))
3443 /* It didn't work, go back to the explicit scope. */
3444 DECL_CONTEXT (decl) = FROB_CONTEXT (scope);
3446 error ("%qD should have been declared inside %qD", decl, scope);
3449 /* Return the namespace where the current declaration is declared. */
3452 current_decl_namespace (void)
3455 /* If we have been pushed into a different namespace, use it. */
3456 if (!VEC_empty (tree, decl_namespace_list))
3457 return VEC_last (tree, decl_namespace_list);
3459 if (current_class_type)
3460 result = decl_namespace_context (current_class_type);
3461 else if (current_function_decl)
3462 result = decl_namespace_context (current_function_decl);
3464 result = current_namespace;