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 || (processing_template_decl
445 && TREE_CODE (TREE_TYPE (target_decl
)) == ENUMERAL_TYPE
446 && TREE_CODE (TREE_TYPE (target_bval
)) == ENUMERAL_TYPE
447 && (dependent_type_p (ENUM_UNDERLYING_TYPE
448 (TREE_TYPE (target_decl
)))
449 || dependent_type_p (ENUM_UNDERLYING_TYPE
450 (TREE_TYPE (target_bval
)))))))
451 /* The new name is the type name. */
452 binding
->type
= decl
;
453 else if (/* TARGET_BVAL is null when push_class_level_binding moves
454 an inherited type-binding out of the way to make room
455 for a new value binding. */
457 /* TARGET_BVAL is error_mark_node when TARGET_DECL's name
458 has been used in a non-class scope prior declaration.
459 In that case, we should have already issued a
460 diagnostic; for graceful error recovery purpose, pretend
461 this was the intended declaration for that name. */
462 || target_bval
== error_mark_node
463 /* If TARGET_BVAL is anticipated but has not yet been
464 declared, pretend it is not there at all. */
465 || (TREE_CODE (target_bval
) == FUNCTION_DECL
466 && DECL_ANTICIPATED (target_bval
)
467 && !DECL_HIDDEN_FRIEND_P (target_bval
)))
468 binding
->value
= decl
;
469 else if (TREE_CODE (target_bval
) == TYPE_DECL
470 && DECL_ARTIFICIAL (target_bval
)
471 && target_decl
!= target_bval
472 && (TREE_CODE (target_decl
) != TYPE_DECL
473 || same_type_p (TREE_TYPE (target_decl
),
474 TREE_TYPE (target_bval
))))
476 /* The old binding was a type name. It was placed in
477 VALUE field because it was thought, at the point it was
478 declared, to be the only entity with such a name. Move the
479 type name into the type slot; it is now hidden by the new
481 binding
->type
= bval
;
482 binding
->value
= decl
;
483 binding
->value_is_inherited
= false;
485 else if (TREE_CODE (target_bval
) == TYPE_DECL
486 && TREE_CODE (target_decl
) == TYPE_DECL
487 && DECL_NAME (target_decl
) == DECL_NAME (target_bval
)
488 && binding
->scope
->kind
!= sk_class
489 && (same_type_p (TREE_TYPE (target_decl
), TREE_TYPE (target_bval
))
490 /* If either type involves template parameters, we must
491 wait until instantiation. */
492 || uses_template_parms (TREE_TYPE (target_decl
))
493 || uses_template_parms (TREE_TYPE (target_bval
))))
494 /* We have two typedef-names, both naming the same type to have
495 the same name. In general, this is OK because of:
499 In a given scope, a typedef specifier can be used to redefine
500 the name of any type declared in that scope to refer to the
501 type to which it already refers.
503 However, in class scopes, this rule does not apply due to the
504 stricter language in [class.mem] prohibiting redeclarations of
507 /* There can be two block-scope declarations of the same variable,
508 so long as they are `extern' declarations. However, there cannot
509 be two declarations of the same static data member:
513 A member shall not be declared twice in the
514 member-specification. */
515 else if (TREE_CODE (target_decl
) == VAR_DECL
516 && TREE_CODE (target_bval
) == VAR_DECL
517 && DECL_EXTERNAL (target_decl
) && DECL_EXTERNAL (target_bval
)
518 && !DECL_CLASS_SCOPE_P (target_decl
))
520 duplicate_decls (decl
, binding
->value
, /*newdecl_is_friend=*/false);
523 else if (TREE_CODE (decl
) == NAMESPACE_DECL
524 && TREE_CODE (bval
) == NAMESPACE_DECL
525 && DECL_NAMESPACE_ALIAS (decl
)
526 && DECL_NAMESPACE_ALIAS (bval
)
527 && ORIGINAL_NAMESPACE (bval
) == ORIGINAL_NAMESPACE (decl
))
530 In a declarative region, a namespace-alias-definition can be
531 used to redefine a namespace-alias declared in that declarative
532 region to refer only to the namespace to which it already
537 diagnose_name_conflict (decl
, bval
);
544 /* Diagnose a name conflict between DECL and BVAL. */
547 diagnose_name_conflict (tree decl
, tree bval
)
549 if (TREE_CODE (decl
) == TREE_CODE (bval
)
550 && (TREE_CODE (decl
) != TYPE_DECL
551 || (DECL_ARTIFICIAL (decl
) && DECL_ARTIFICIAL (bval
))
552 || (!DECL_ARTIFICIAL (decl
) && !DECL_ARTIFICIAL (bval
)))
553 && !is_overloaded_fn (decl
))
554 error ("redeclaration of %q#D", decl
);
556 error ("%q#D conflicts with a previous declaration", decl
);
558 inform (input_location
, "previous declaration %q+#D", bval
);
561 /* Wrapper for supplement_binding_1. */
564 supplement_binding (cxx_binding
*binding
, tree decl
)
567 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
568 ret
= supplement_binding_1 (binding
, decl
);
569 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
573 /* Add DECL to the list of things declared in B. */
576 add_decl_to_level (tree decl
, cp_binding_level
*b
)
578 /* We used to record virtual tables as if they were ordinary
579 variables, but no longer do so. */
580 gcc_assert (!(TREE_CODE (decl
) == VAR_DECL
&& DECL_VIRTUAL_P (decl
)));
582 if (TREE_CODE (decl
) == NAMESPACE_DECL
583 && !DECL_NAMESPACE_ALIAS (decl
))
585 DECL_CHAIN (decl
) = b
->namespaces
;
586 b
->namespaces
= decl
;
590 /* We build up the list in reverse order, and reverse it later if
592 TREE_CHAIN (decl
) = b
->names
;
595 /* If appropriate, add decl to separate list of statics. We
596 include extern variables because they might turn out to be
597 static later. It's OK for this list to contain a few false
599 if (b
->kind
== sk_namespace
)
600 if ((TREE_CODE (decl
) == VAR_DECL
601 && (TREE_STATIC (decl
) || DECL_EXTERNAL (decl
)))
602 || (TREE_CODE (decl
) == FUNCTION_DECL
603 && (!TREE_PUBLIC (decl
) || DECL_DECLARED_INLINE_P (decl
))))
604 VEC_safe_push (tree
, gc
, b
->static_decls
, decl
);
608 /* Record a decl-node X as belonging to the current lexical scope.
609 Check for errors (such as an incompatible declaration for the same
610 name already seen in the same scope). IS_FRIEND is true if X is
611 declared as a friend.
613 Returns either X or an old decl for the same name.
614 If an old decl is returned, it may have been smashed
615 to agree with what X says. */
618 pushdecl_maybe_friend_1 (tree x
, bool is_friend
)
622 int need_new_binding
;
624 if (x
== error_mark_node
)
625 return error_mark_node
;
627 need_new_binding
= 1;
629 if (DECL_TEMPLATE_PARM_P (x
))
630 /* Template parameters have no context; they are not X::T even
631 when declared within a class or namespace. */
635 if (current_function_decl
&& x
!= current_function_decl
636 /* A local declaration for a function doesn't constitute
638 && TREE_CODE (x
) != FUNCTION_DECL
639 /* A local declaration for an `extern' variable is in the
640 scope of the current namespace, not the current
642 && !(TREE_CODE (x
) == VAR_DECL
&& DECL_EXTERNAL (x
))
643 /* When parsing the parameter list of a function declarator,
644 don't set DECL_CONTEXT to an enclosing function. When we
645 push the PARM_DECLs in order to process the function body,
646 current_binding_level->this_entity will be set. */
647 && !(TREE_CODE (x
) == PARM_DECL
648 && current_binding_level
->kind
== sk_function_parms
649 && current_binding_level
->this_entity
== NULL
)
650 && !DECL_CONTEXT (x
))
651 DECL_CONTEXT (x
) = current_function_decl
;
653 /* If this is the declaration for a namespace-scope function,
654 but the declaration itself is in a local scope, mark the
656 if (TREE_CODE (x
) == FUNCTION_DECL
657 && DECL_NAMESPACE_SCOPE_P (x
)
658 && current_function_decl
659 && x
!= current_function_decl
)
660 DECL_LOCAL_FUNCTION_P (x
) = 1;
663 name
= DECL_NAME (x
);
666 int different_binding_level
= 0;
668 if (TREE_CODE (name
) == TEMPLATE_ID_EXPR
)
669 name
= TREE_OPERAND (name
, 0);
671 /* In case this decl was explicitly namespace-qualified, look it
672 up in its namespace context. */
673 if (DECL_NAMESPACE_SCOPE_P (x
) && namespace_bindings_p ())
674 t
= namespace_binding (name
, DECL_CONTEXT (x
));
676 t
= lookup_name_innermost_nonclass_level (name
);
678 /* [basic.link] If there is a visible declaration of an entity
679 with linkage having the same name and type, ignoring entities
680 declared outside the innermost enclosing namespace scope, the
681 block scope declaration declares that same entity and
682 receives the linkage of the previous declaration. */
683 if (! t
&& current_function_decl
&& x
!= current_function_decl
684 && (TREE_CODE (x
) == FUNCTION_DECL
|| TREE_CODE (x
) == VAR_DECL
)
685 && DECL_EXTERNAL (x
))
687 /* Look in block scope. */
688 t
= innermost_non_namespace_value (name
);
689 /* Or in the innermost namespace. */
691 t
= namespace_binding (name
, DECL_CONTEXT (x
));
692 /* Does it have linkage? Note that if this isn't a DECL, it's an
693 OVERLOAD, which is OK. */
694 if (t
&& DECL_P (t
) && ! (TREE_STATIC (t
) || DECL_EXTERNAL (t
)))
697 different_binding_level
= 1;
700 /* If we are declaring a function, and the result of name-lookup
701 was an OVERLOAD, look for an overloaded instance that is
702 actually the same as the function we are declaring. (If
703 there is one, we have to merge our declaration with the
704 previous declaration.) */
705 if (t
&& TREE_CODE (t
) == OVERLOAD
)
709 if (TREE_CODE (x
) == FUNCTION_DECL
)
710 for (match
= t
; match
; match
= OVL_NEXT (match
))
712 if (decls_match (OVL_CURRENT (match
), x
))
716 /* Just choose one. */
720 t
= OVL_CURRENT (match
);
725 if (t
&& t
!= error_mark_node
)
727 if (different_binding_level
)
729 if (decls_match (x
, t
))
730 /* The standard only says that the local extern
731 inherits linkage from the previous decl; in
732 particular, default args are not shared. Add
733 the decl into a hash table to make sure only
734 the previous decl in this case is seen by the
737 struct cxx_int_tree_map
*h
;
740 TREE_PUBLIC (x
) = TREE_PUBLIC (t
);
742 if (cp_function_chain
->extern_decl_map
== NULL
)
743 cp_function_chain
->extern_decl_map
744 = htab_create_ggc (20, cxx_int_tree_map_hash
,
745 cxx_int_tree_map_eq
, NULL
);
747 h
= ggc_alloc_cxx_int_tree_map ();
748 h
->uid
= DECL_UID (x
);
750 loc
= htab_find_slot_with_hash
751 (cp_function_chain
->extern_decl_map
, h
,
753 *(struct cxx_int_tree_map
**) loc
= h
;
756 else if (TREE_CODE (t
) == PARM_DECL
)
758 /* Check for duplicate params. */
759 tree d
= duplicate_decls (x
, t
, is_friend
);
763 else if ((DECL_EXTERN_C_FUNCTION_P (x
)
764 || DECL_FUNCTION_TEMPLATE_P (x
))
765 && is_overloaded_fn (t
))
766 /* Don't do anything just yet. */;
767 else if (t
== wchar_decl_node
)
769 if (! DECL_IN_SYSTEM_HEADER (x
))
770 pedwarn (input_location
, OPT_Wpedantic
, "redeclaration of %<wchar_t%> as %qT",
773 /* Throw away the redeclaration. */
778 tree olddecl
= duplicate_decls (x
, t
, is_friend
);
780 /* If the redeclaration failed, we can stop at this
782 if (olddecl
== error_mark_node
)
783 return error_mark_node
;
787 if (TREE_CODE (t
) == TYPE_DECL
)
788 SET_IDENTIFIER_TYPE_VALUE (name
, TREE_TYPE (t
));
792 else if (DECL_MAIN_P (x
) && TREE_CODE (t
) == FUNCTION_DECL
)
794 /* A redeclaration of main, but not a duplicate of the
799 This function shall not be overloaded. */
800 error ("invalid redeclaration of %q+D", t
);
802 /* We don't try to push this declaration since that
809 /* If x has C linkage-specification, (extern "C"),
810 lookup its binding, in case it's already bound to an object.
811 The lookup is done in all namespaces.
812 If we find an existing binding, make sure it has the same
813 exception specification as x, otherwise, bail in error [7.5, 7.6]. */
814 if ((TREE_CODE (x
) == FUNCTION_DECL
)
815 && DECL_EXTERN_C_P (x
)
816 /* We should ignore declarations happening in system headers. */
817 && !DECL_ARTIFICIAL (x
)
818 && !DECL_IN_SYSTEM_HEADER (x
))
820 tree previous
= lookup_extern_c_fun_in_all_ns (x
);
822 && !DECL_ARTIFICIAL (previous
)
823 && !DECL_IN_SYSTEM_HEADER (previous
)
824 && DECL_CONTEXT (previous
) != DECL_CONTEXT (x
))
826 /* In case either x or previous is declared to throw an exception,
827 make sure both exception specifications are equal. */
828 if (decls_match (x
, previous
))
830 tree x_exception_spec
= NULL_TREE
;
831 tree previous_exception_spec
= NULL_TREE
;
834 TYPE_RAISES_EXCEPTIONS (TREE_TYPE (x
));
835 previous_exception_spec
=
836 TYPE_RAISES_EXCEPTIONS (TREE_TYPE (previous
));
837 if (!comp_except_specs (previous_exception_spec
,
841 pedwarn (input_location
, 0,
842 "declaration of %q#D with C language linkage",
844 pedwarn (input_location
, 0,
845 "conflicts with previous declaration %q+#D",
847 pedwarn (input_location
, 0,
848 "due to different exception specifications");
849 return error_mark_node
;
851 if (DECL_ASSEMBLER_NAME_SET_P (previous
))
852 SET_DECL_ASSEMBLER_NAME (x
,
853 DECL_ASSEMBLER_NAME (previous
));
857 pedwarn (input_location
, 0,
858 "declaration of %q#D with C language linkage", x
);
859 pedwarn (input_location
, 0,
860 "conflicts with previous declaration %q+#D",
866 check_template_shadow (x
);
868 /* If this is a function conjured up by the back end, massage it
869 so it looks friendly. */
870 if (DECL_NON_THUNK_FUNCTION_P (x
) && ! DECL_LANG_SPECIFIC (x
))
872 retrofit_lang_decl (x
);
873 SET_DECL_LANGUAGE (x
, lang_c
);
877 if (DECL_NON_THUNK_FUNCTION_P (x
) && ! DECL_FUNCTION_MEMBER_P (x
))
879 t
= push_overloaded_decl (x
, PUSH_LOCAL
, is_friend
);
880 if (!namespace_bindings_p ())
881 /* We do not need to create a binding for this name;
882 push_overloaded_decl will have already done so if
884 need_new_binding
= 0;
886 else if (DECL_FUNCTION_TEMPLATE_P (x
) && DECL_NAMESPACE_SCOPE_P (x
))
888 t
= push_overloaded_decl (x
, PUSH_GLOBAL
, is_friend
);
890 add_decl_to_level (x
, NAMESPACE_LEVEL (CP_DECL_CONTEXT (t
)));
893 if (TREE_CODE (t
) == FUNCTION_DECL
|| DECL_FUNCTION_TEMPLATE_P (t
))
894 check_default_args (t
);
896 if (t
!= x
|| DECL_FUNCTION_TEMPLATE_P (t
))
899 /* If declaring a type as a typedef, copy the type (unless we're
900 at line 0), and install this TYPE_DECL as the new type's typedef
901 name. See the extensive comment of set_underlying_type (). */
902 if (TREE_CODE (x
) == TYPE_DECL
)
904 tree type
= TREE_TYPE (x
);
906 if (DECL_IS_BUILTIN (x
)
907 || (TREE_TYPE (x
) != error_mark_node
908 && TYPE_NAME (type
) != x
909 /* We don't want to copy the type when all we're
910 doing is making a TYPE_DECL for the purposes of
912 && (!TYPE_NAME (type
)
913 || TYPE_NAME (type
) != DECL_ABSTRACT_ORIGIN (x
))))
914 set_underlying_type (x
);
916 if (type
!= error_mark_node
918 && TYPE_IDENTIFIER (type
))
919 set_identifier_type_value (DECL_NAME (x
), x
);
921 /* If this is a locally defined typedef in a function that
922 is not a template instantation, record it to implement
923 -Wunused-local-typedefs. */
924 if (current_instantiation () == NULL
925 || (current_instantiation ()->decl
!= current_function_decl
))
926 record_locally_defined_typedef (x
);
929 /* Multiple external decls of the same identifier ought to match.
931 We get warnings about inline functions where they are defined.
932 We get warnings about other functions from push_overloaded_decl.
934 Avoid duplicate warnings where they are used. */
935 if (TREE_PUBLIC (x
) && TREE_CODE (x
) != FUNCTION_DECL
)
939 decl
= IDENTIFIER_NAMESPACE_VALUE (name
);
940 if (decl
&& TREE_CODE (decl
) == OVERLOAD
)
941 decl
= OVL_FUNCTION (decl
);
943 if (decl
&& decl
!= error_mark_node
944 && (DECL_EXTERNAL (decl
) || TREE_PUBLIC (decl
))
945 /* If different sort of thing, we already gave an error. */
946 && TREE_CODE (decl
) == TREE_CODE (x
)
947 && !same_type_p (TREE_TYPE (x
), TREE_TYPE (decl
)))
949 permerror (input_location
, "type mismatch with previous external decl of %q#D", x
);
950 permerror (input_location
, "previous external decl of %q+#D", decl
);
954 if (TREE_CODE (x
) == FUNCTION_DECL
956 && !flag_friend_injection
)
958 /* This is a new declaration of a friend function, so hide
959 it from ordinary function lookup. */
960 DECL_ANTICIPATED (x
) = 1;
961 DECL_HIDDEN_FRIEND_P (x
) = 1;
964 /* This name is new in its binding level.
965 Install the new declaration and return it. */
966 if (namespace_bindings_p ())
968 /* Install a global value. */
970 /* If the first global decl has external linkage,
971 warn if we later see static one. */
972 if (IDENTIFIER_GLOBAL_VALUE (name
) == NULL_TREE
&& TREE_PUBLIC (x
))
973 TREE_PUBLIC (name
) = 1;
975 /* Bind the name for the entity. */
976 if (!(TREE_CODE (x
) == TYPE_DECL
&& DECL_ARTIFICIAL (x
)
978 && (TREE_CODE (x
) == TYPE_DECL
979 || TREE_CODE (x
) == VAR_DECL
980 || TREE_CODE (x
) == NAMESPACE_DECL
981 || TREE_CODE (x
) == CONST_DECL
982 || TREE_CODE (x
) == TEMPLATE_DECL
))
983 SET_IDENTIFIER_NAMESPACE_VALUE (name
, x
);
985 /* If new decl is `static' and an `extern' was seen previously,
987 if (x
!= NULL_TREE
&& t
!= NULL_TREE
&& decls_match (x
, t
))
988 warn_extern_redeclared_static (x
, t
);
992 /* Here to install a non-global value. */
993 tree oldglobal
= IDENTIFIER_NAMESPACE_VALUE (name
);
994 tree oldlocal
= NULL_TREE
;
995 cp_binding_level
*oldscope
= NULL
;
996 cxx_binding
*oldbinding
= outer_binding (name
, NULL
, true);
999 oldlocal
= oldbinding
->value
;
1000 oldscope
= oldbinding
->scope
;
1003 if (need_new_binding
)
1005 push_local_binding (name
, x
, 0);
1006 /* Because push_local_binding will hook X on to the
1007 current_binding_level's name list, we don't want to
1008 do that again below. */
1009 need_new_binding
= 0;
1012 /* If this is a TYPE_DECL, push it into the type value slot. */
1013 if (TREE_CODE (x
) == TYPE_DECL
)
1014 set_identifier_type_value (name
, x
);
1016 /* Clear out any TYPE_DECL shadowed by a namespace so that
1017 we won't think this is a type. The C struct hack doesn't
1018 go through namespaces. */
1019 if (TREE_CODE (x
) == NAMESPACE_DECL
)
1020 set_identifier_type_value (name
, NULL_TREE
);
1027 && TREE_CODE (oldlocal
) == VAR_DECL
1028 && DECL_DEAD_FOR_LOCAL (oldlocal
))
1029 oldlocal
= DECL_SHADOWED_FOR_VAR (oldlocal
);
1031 if (oldlocal
== NULL_TREE
)
1032 oldlocal
= IDENTIFIER_NAMESPACE_VALUE (DECL_NAME (d
));
1035 /* If this is an extern function declaration, see if we
1036 have a global definition or declaration for the function. */
1037 if (oldlocal
== NULL_TREE
1038 && DECL_EXTERNAL (x
)
1039 && oldglobal
!= NULL_TREE
1040 && TREE_CODE (x
) == FUNCTION_DECL
1041 && TREE_CODE (oldglobal
) == FUNCTION_DECL
)
1043 /* We have one. Their types must agree. */
1044 if (decls_match (x
, oldglobal
))
1048 warning (0, "extern declaration of %q#D doesn%'t match", x
);
1049 warning (0, "global declaration %q+#D", oldglobal
);
1052 /* If we have a local external declaration,
1053 and no file-scope declaration has yet been seen,
1054 then if we later have a file-scope decl it must not be static. */
1055 if (oldlocal
== NULL_TREE
1056 && oldglobal
== NULL_TREE
1057 && DECL_EXTERNAL (x
)
1059 TREE_PUBLIC (name
) = 1;
1061 /* Don't complain about the parms we push and then pop
1062 while tentatively parsing a function declarator. */
1063 if (TREE_CODE (x
) == PARM_DECL
&& DECL_CONTEXT (x
) == NULL_TREE
)
1066 /* Warn if shadowing an argument at the top level of the body. */
1067 else if (oldlocal
!= NULL_TREE
&& !DECL_EXTERNAL (x
)
1068 /* Inline decls shadow nothing. */
1069 && !DECL_FROM_INLINE (x
)
1070 && (TREE_CODE (oldlocal
) == PARM_DECL
1071 || TREE_CODE (oldlocal
) == VAR_DECL
1072 /* If the old decl is a type decl, only warn if the
1073 old decl is an explicit typedef or if both the old
1074 and new decls are type decls. */
1075 || (TREE_CODE (oldlocal
) == TYPE_DECL
1076 && (!DECL_ARTIFICIAL (oldlocal
)
1077 || TREE_CODE (x
) == TYPE_DECL
)))
1078 /* Don't check for internally generated vars unless
1079 it's an implicit typedef (see create_implicit_typedef
1081 && (!DECL_ARTIFICIAL (x
) || DECL_IMPLICIT_TYPEDEF_P (x
)))
1083 bool nowarn
= false;
1085 /* Don't complain if it's from an enclosing function. */
1086 if (DECL_CONTEXT (oldlocal
) == current_function_decl
1087 && TREE_CODE (x
) != PARM_DECL
1088 && TREE_CODE (oldlocal
) == PARM_DECL
)
1090 /* Go to where the parms should be and see if we find
1092 cp_binding_level
*b
= current_binding_level
->level_chain
;
1094 if (FUNCTION_NEEDS_BODY_BLOCK (current_function_decl
))
1095 /* Skip the ctor/dtor cleanup level. */
1099 if (b
->kind
== sk_function_parms
)
1101 error ("declaration of %q#D shadows a parameter", x
);
1106 /* The local structure or class can't use parameters of
1107 the containing function anyway. */
1108 if (DECL_CONTEXT (oldlocal
) != current_function_decl
)
1110 cp_binding_level
*scope
= current_binding_level
;
1111 tree context
= DECL_CONTEXT (oldlocal
);
1112 for (; scope
; scope
= scope
->level_chain
)
1114 if (scope
->kind
== sk_function_parms
1115 && scope
->this_entity
== context
)
1117 if (scope
->kind
== sk_class
1118 && !LAMBDA_TYPE_P (scope
->this_entity
))
1125 /* Error if redeclaring a local declared in a
1126 for-init-statement or in the condition of an if or
1127 switch statement when the new declaration is in the
1128 outermost block of the controlled statement.
1129 Redeclaring a variable from a for or while condition is
1130 detected elsewhere. */
1131 else if (TREE_CODE (oldlocal
) == VAR_DECL
1132 && oldscope
== current_binding_level
->level_chain
1133 && (oldscope
->kind
== sk_cond
1134 || oldscope
->kind
== sk_for
))
1136 error ("redeclaration of %q#D", x
);
1137 error ("%q+#D previously declared here", oldlocal
);
1140 if (warn_shadow
&& !nowarn
)
1142 if (TREE_CODE (oldlocal
) == PARM_DECL
)
1143 warning_at (input_location
, OPT_Wshadow
,
1144 "declaration of %q#D shadows a parameter", x
);
1145 else if (is_capture_proxy (oldlocal
))
1146 warning_at (input_location
, OPT_Wshadow
,
1147 "declaration of %qD shadows a lambda capture",
1150 warning_at (input_location
, OPT_Wshadow
,
1151 "declaration of %qD shadows a previous local",
1153 warning_at (DECL_SOURCE_LOCATION (oldlocal
), OPT_Wshadow
,
1154 "shadowed declaration is here");
1158 /* Maybe warn if shadowing something else. */
1159 else if (warn_shadow
&& !DECL_EXTERNAL (x
)
1160 /* No shadow warnings for internally generated vars unless
1161 it's an implicit typedef (see create_implicit_typedef
1163 && (! DECL_ARTIFICIAL (x
) || DECL_IMPLICIT_TYPEDEF_P (x
))
1164 /* No shadow warnings for vars made for inlining. */
1165 && ! DECL_FROM_INLINE (x
))
1169 if (current_class_ptr
)
1170 member
= lookup_member (current_class_type
,
1173 /*want_type=*/false,
1174 tf_warning_or_error
);
1178 if (member
&& !TREE_STATIC (member
))
1180 /* Location of previous decl is not useful in this case. */
1181 warning (OPT_Wshadow
, "declaration of %qD shadows a member of 'this'",
1184 else if (oldglobal
!= NULL_TREE
1185 && (TREE_CODE (oldglobal
) == VAR_DECL
1186 /* If the old decl is a type decl, only warn if the
1187 old decl is an explicit typedef or if both the
1188 old and new decls are type decls. */
1189 || (TREE_CODE (oldglobal
) == TYPE_DECL
1190 && (!DECL_ARTIFICIAL (oldglobal
)
1191 || TREE_CODE (x
) == TYPE_DECL
))))
1192 /* XXX shadow warnings in outer-more namespaces */
1194 warning_at (input_location
, OPT_Wshadow
,
1195 "declaration of %qD shadows a global declaration", x
);
1196 warning_at (DECL_SOURCE_LOCATION (oldglobal
), OPT_Wshadow
,
1197 "shadowed declaration is here");
1202 if (TREE_CODE (x
) == VAR_DECL
)
1203 maybe_register_incomplete_var (x
);
1206 if (need_new_binding
)
1207 add_decl_to_level (x
,
1208 DECL_NAMESPACE_SCOPE_P (x
)
1209 ? NAMESPACE_LEVEL (CP_DECL_CONTEXT (x
))
1210 : current_binding_level
);
1215 /* Wrapper for pushdecl_maybe_friend_1. */
1218 pushdecl_maybe_friend (tree x
, bool is_friend
)
1221 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
1222 ret
= pushdecl_maybe_friend_1 (x
, is_friend
);
1223 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
1227 /* Record a decl-node X as belonging to the current lexical scope. */
1232 return pushdecl_maybe_friend (x
, false);
1235 /* Enter DECL into the symbol table, if that's appropriate. Returns
1236 DECL, or a modified version thereof. */
1239 maybe_push_decl (tree decl
)
1241 tree type
= TREE_TYPE (decl
);
1243 /* Add this decl to the current binding level, but not if it comes
1244 from another scope, e.g. a static member variable. TEM may equal
1245 DECL or it may be a previous decl of the same name. */
1246 if (decl
== error_mark_node
1247 || (TREE_CODE (decl
) != PARM_DECL
1248 && DECL_CONTEXT (decl
) != NULL_TREE
1249 /* Definitions of namespace members outside their namespace are
1251 && !DECL_NAMESPACE_SCOPE_P (decl
))
1252 || (TREE_CODE (decl
) == TEMPLATE_DECL
&& !namespace_bindings_p ())
1253 || type
== unknown_type_node
1254 /* The declaration of a template specialization does not affect
1255 the functions available for overload resolution, so we do not
1257 || (TREE_CODE (decl
) == FUNCTION_DECL
1258 && DECL_TEMPLATE_SPECIALIZATION (decl
)))
1261 return pushdecl (decl
);
1264 /* Bind DECL to ID in the current_binding_level, assumed to be a local
1265 binding level. If PUSH_USING is set in FLAGS, we know that DECL
1266 doesn't really belong to this binding level, that it got here
1267 through a using-declaration. */
1270 push_local_binding (tree id
, tree decl
, int flags
)
1272 cp_binding_level
*b
;
1274 /* Skip over any local classes. This makes sense if we call
1275 push_local_binding with a friend decl of a local class. */
1276 b
= innermost_nonclass_level ();
1278 if (lookup_name_innermost_nonclass_level (id
))
1280 /* Supplement the existing binding. */
1281 if (!supplement_binding (IDENTIFIER_BINDING (id
), decl
))
1282 /* It didn't work. Something else must be bound at this
1283 level. Do not add DECL to the list of things to pop
1288 /* Create a new binding. */
1289 push_binding (id
, decl
, b
);
1291 if (TREE_CODE (decl
) == OVERLOAD
|| (flags
& PUSH_USING
))
1292 /* We must put the OVERLOAD into a TREE_LIST since the
1293 TREE_CHAIN of an OVERLOAD is already used. Similarly for
1294 decls that got here through a using-declaration. */
1295 decl
= build_tree_list (NULL_TREE
, decl
);
1297 /* And put DECL on the list of things declared by the current
1299 add_decl_to_level (decl
, b
);
1302 /* Check to see whether or not DECL is a variable that would have been
1303 in scope under the ARM, but is not in scope under the ANSI/ISO
1304 standard. If so, issue an error message. If name lookup would
1305 work in both cases, but return a different result, this function
1306 returns the result of ANSI/ISO lookup. Otherwise, it returns
1310 check_for_out_of_scope_variable (tree decl
)
1314 /* We only care about out of scope variables. */
1315 if (!(TREE_CODE (decl
) == VAR_DECL
&& DECL_DEAD_FOR_LOCAL (decl
)))
1318 shadowed
= DECL_HAS_SHADOWED_FOR_VAR_P (decl
)
1319 ? DECL_SHADOWED_FOR_VAR (decl
) : NULL_TREE
;
1320 while (shadowed
!= NULL_TREE
&& TREE_CODE (shadowed
) == VAR_DECL
1321 && DECL_DEAD_FOR_LOCAL (shadowed
))
1322 shadowed
= DECL_HAS_SHADOWED_FOR_VAR_P (shadowed
)
1323 ? DECL_SHADOWED_FOR_VAR (shadowed
) : NULL_TREE
;
1325 shadowed
= IDENTIFIER_NAMESPACE_VALUE (DECL_NAME (decl
));
1328 if (!DECL_ERROR_REPORTED (decl
))
1330 warning (0, "name lookup of %qD changed", DECL_NAME (decl
));
1331 warning (0, " matches this %q+D under ISO standard rules",
1333 warning (0, " matches this %q+D under old rules", decl
);
1334 DECL_ERROR_REPORTED (decl
) = 1;
1339 /* If we have already complained about this declaration, there's no
1340 need to do it again. */
1341 if (DECL_ERROR_REPORTED (decl
))
1344 DECL_ERROR_REPORTED (decl
) = 1;
1346 if (TREE_TYPE (decl
) == error_mark_node
)
1349 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TREE_TYPE (decl
)))
1351 error ("name lookup of %qD changed for ISO %<for%> scoping",
1353 error (" cannot use obsolete binding at %q+D because "
1354 "it has a destructor", decl
);
1355 return error_mark_node
;
1359 permerror (input_location
, "name lookup of %qD changed for ISO %<for%> scoping",
1361 if (flag_permissive
)
1362 permerror (input_location
, " using obsolete binding at %q+D", decl
);
1368 inform (input_location
, "(if you use %<-fpermissive%> G++ will accept your code)");
1377 /* true means unconditionally make a BLOCK for the next level pushed. */
1379 static bool keep_next_level_flag
;
1381 static int binding_depth
= 0;
1388 for (i
= 0; i
< depth
* 2; i
++)
1392 /* Return a string describing the kind of SCOPE we have. */
1394 cp_binding_level_descriptor (cp_binding_level
*scope
)
1396 /* The order of this table must match the "scope_kind"
1398 static const char* scope_kind_names
[] = {
1404 "function-parameter-scope",
1407 "template-parameter-scope",
1408 "template-explicit-spec-scope"
1410 const scope_kind kind
= scope
->explicit_spec_p
1411 ? sk_template_spec
: scope
->kind
;
1413 return scope_kind_names
[kind
];
1416 /* Output a debugging information about SCOPE when performing
1419 cp_binding_level_debug (cp_binding_level
*scope
, int line
, const char *action
)
1421 const char *desc
= cp_binding_level_descriptor (scope
);
1422 if (scope
->this_entity
)
1423 verbatim ("%s %s(%E) %p %d\n", action
, desc
,
1424 scope
->this_entity
, (void *) scope
, line
);
1426 verbatim ("%s %s %p %d\n", action
, desc
, (void *) scope
, line
);
1429 /* Return the estimated initial size of the hashtable of a NAMESPACE
1432 static inline size_t
1433 namespace_scope_ht_size (tree ns
)
1435 tree name
= DECL_NAME (ns
);
1437 return name
== std_identifier
1438 ? NAMESPACE_STD_HT_SIZE
1439 : (name
== global_scope_name
1440 ? GLOBAL_SCOPE_HT_SIZE
1441 : NAMESPACE_ORDINARY_HT_SIZE
);
1444 /* A chain of binding_level structures awaiting reuse. */
1446 static GTY((deletable
)) cp_binding_level
*free_binding_level
;
1448 /* Insert SCOPE as the innermost binding level. */
1451 push_binding_level (cp_binding_level
*scope
)
1453 /* Add it to the front of currently active scopes stack. */
1454 scope
->level_chain
= current_binding_level
;
1455 current_binding_level
= scope
;
1456 keep_next_level_flag
= false;
1458 if (ENABLE_SCOPE_CHECKING
)
1460 scope
->binding_depth
= binding_depth
;
1461 indent (binding_depth
);
1462 cp_binding_level_debug (scope
, input_line
, "push");
1467 /* Create a new KIND scope and make it the top of the active scopes stack.
1468 ENTITY is the scope of the associated C++ entity (namespace, class,
1469 function, C++0x enumeration); it is NULL otherwise. */
1472 begin_scope (scope_kind kind
, tree entity
)
1474 cp_binding_level
*scope
;
1476 /* Reuse or create a struct for this binding level. */
1477 if (!ENABLE_SCOPE_CHECKING
&& free_binding_level
)
1479 scope
= free_binding_level
;
1480 memset (scope
, 0, sizeof (cp_binding_level
));
1481 free_binding_level
= scope
->level_chain
;
1484 scope
= ggc_alloc_cleared_cp_binding_level ();
1486 scope
->this_entity
= entity
;
1487 scope
->more_cleanups_ok
= true;
1494 case sk_template_spec
:
1495 scope
->explicit_spec_p
= true;
1496 kind
= sk_template_parms
;
1498 case sk_template_parms
:
1505 case sk_scoped_enum
:
1506 case sk_function_parms
:
1508 scope
->keep
= keep_next_level_flag
;
1512 NAMESPACE_LEVEL (entity
) = scope
;
1513 scope
->static_decls
=
1514 VEC_alloc (tree
, gc
,
1515 DECL_NAME (entity
) == std_identifier
1516 || DECL_NAME (entity
) == global_scope_name
1521 /* Should not happen. */
1527 push_binding_level (scope
);
1532 /* We're about to leave current scope. Pop the top of the stack of
1533 currently active scopes. Return the enclosing scope, now active. */
1538 cp_binding_level
*scope
= current_binding_level
;
1540 if (scope
->kind
== sk_namespace
&& class_binding_level
)
1541 current_binding_level
= class_binding_level
;
1543 /* We cannot leave a scope, if there are none left. */
1544 if (NAMESPACE_LEVEL (global_namespace
))
1545 gcc_assert (!global_scope_p (scope
));
1547 if (ENABLE_SCOPE_CHECKING
)
1549 indent (--binding_depth
);
1550 cp_binding_level_debug (scope
, input_line
, "leave");
1553 /* Move one nesting level up. */
1554 current_binding_level
= scope
->level_chain
;
1556 /* Namespace-scopes are left most probably temporarily, not
1557 completely; they can be reopened later, e.g. in namespace-extension
1558 or any name binding activity that requires us to resume a
1559 namespace. For classes, we cache some binding levels. For other
1560 scopes, we just make the structure available for reuse. */
1561 if (scope
->kind
!= sk_namespace
1562 && scope
->kind
!= sk_class
)
1564 scope
->level_chain
= free_binding_level
;
1565 gcc_assert (!ENABLE_SCOPE_CHECKING
1566 || scope
->binding_depth
== binding_depth
);
1567 free_binding_level
= scope
;
1570 /* Find the innermost enclosing class scope, and reset
1571 CLASS_BINDING_LEVEL appropriately. */
1572 if (scope
->kind
== sk_class
)
1574 class_binding_level
= NULL
;
1575 for (scope
= current_binding_level
; scope
; scope
= scope
->level_chain
)
1576 if (scope
->kind
== sk_class
)
1578 class_binding_level
= scope
;
1583 return current_binding_level
;
1587 resume_scope (cp_binding_level
* b
)
1589 /* Resuming binding levels is meant only for namespaces,
1590 and those cannot nest into classes. */
1591 gcc_assert (!class_binding_level
);
1592 /* Also, resuming a non-directly nested namespace is a no-no. */
1593 gcc_assert (b
->level_chain
== current_binding_level
);
1594 current_binding_level
= b
;
1595 if (ENABLE_SCOPE_CHECKING
)
1597 b
->binding_depth
= binding_depth
;
1598 indent (binding_depth
);
1599 cp_binding_level_debug (b
, input_line
, "resume");
1604 /* Return the innermost binding level that is not for a class scope. */
1606 static cp_binding_level
*
1607 innermost_nonclass_level (void)
1609 cp_binding_level
*b
;
1611 b
= current_binding_level
;
1612 while (b
->kind
== sk_class
)
1618 /* We're defining an object of type TYPE. If it needs a cleanup, but
1619 we're not allowed to add any more objects with cleanups to the current
1620 scope, create a new binding level. */
1623 maybe_push_cleanup_level (tree type
)
1625 if (type
!= error_mark_node
1626 && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
)
1627 && current_binding_level
->more_cleanups_ok
== 0)
1629 begin_scope (sk_cleanup
, NULL
);
1630 current_binding_level
->statement_list
= push_stmt_list ();
1634 /* Return true if we are in the global binding level. */
1637 global_bindings_p (void)
1639 return global_scope_p (current_binding_level
);
1642 /* True if we are currently in a toplevel binding level. This
1643 means either the global binding level or a namespace in a toplevel
1644 binding level. Since there are no non-toplevel namespace levels,
1645 this really means any namespace or template parameter level. We
1646 also include a class whose context is toplevel. */
1649 toplevel_bindings_p (void)
1651 cp_binding_level
*b
= innermost_nonclass_level ();
1653 return b
->kind
== sk_namespace
|| b
->kind
== sk_template_parms
;
1656 /* True if this is a namespace scope, or if we are defining a class
1657 which is itself at namespace scope, or whose enclosing class is
1658 such a class, etc. */
1661 namespace_bindings_p (void)
1663 cp_binding_level
*b
= innermost_nonclass_level ();
1665 return b
->kind
== sk_namespace
;
1668 /* True if the innermost non-class scope is a block scope. */
1671 local_bindings_p (void)
1673 cp_binding_level
*b
= innermost_nonclass_level ();
1674 return b
->kind
< sk_function_parms
|| b
->kind
== sk_omp
;
1677 /* True if the current level needs to have a BLOCK made. */
1682 return (current_binding_level
->blocks
!= NULL_TREE
1683 || current_binding_level
->keep
1684 || current_binding_level
->kind
== sk_cleanup
1685 || current_binding_level
->names
!= NULL_TREE
1686 || current_binding_level
->using_directives
);
1689 /* Returns the kind of the innermost scope. */
1692 innermost_scope_kind (void)
1694 return current_binding_level
->kind
;
1697 /* Returns true if this scope was created to store template parameters. */
1700 template_parm_scope_p (void)
1702 return innermost_scope_kind () == sk_template_parms
;
1705 /* If KEEP is true, make a BLOCK node for the next binding level,
1706 unconditionally. Otherwise, use the normal logic to decide whether
1707 or not to create a BLOCK. */
1710 keep_next_level (bool keep
)
1712 keep_next_level_flag
= keep
;
1715 /* Return the list of declarations of the current level.
1716 Note that this list is in reverse order unless/until
1717 you nreverse it; and when you do nreverse it, you must
1718 store the result back using `storedecls' or you will lose. */
1723 return current_binding_level
->names
;
1726 /* Return how many function prototypes we are currently nested inside. */
1729 function_parm_depth (void)
1732 cp_binding_level
*b
;
1734 for (b
= current_binding_level
;
1735 b
->kind
== sk_function_parms
;
1742 /* For debugging. */
1743 static int no_print_functions
= 0;
1744 static int no_print_builtins
= 0;
1747 print_binding_level (cp_binding_level
* lvl
)
1751 fprintf (stderr
, " blocks=%p", (void *) lvl
->blocks
);
1752 if (lvl
->more_cleanups_ok
)
1753 fprintf (stderr
, " more-cleanups-ok");
1754 if (lvl
->have_cleanups
)
1755 fprintf (stderr
, " have-cleanups");
1756 fprintf (stderr
, "\n");
1759 fprintf (stderr
, " names:\t");
1760 /* We can probably fit 3 names to a line? */
1761 for (t
= lvl
->names
; t
; t
= TREE_CHAIN (t
))
1763 if (no_print_functions
&& (TREE_CODE (t
) == FUNCTION_DECL
))
1765 if (no_print_builtins
1766 && (TREE_CODE (t
) == TYPE_DECL
)
1767 && DECL_IS_BUILTIN (t
))
1770 /* Function decls tend to have longer names. */
1771 if (TREE_CODE (t
) == FUNCTION_DECL
)
1778 fprintf (stderr
, "\n\t");
1781 print_node_brief (stderr
, "", t
, 0);
1782 if (t
== error_mark_node
)
1786 fprintf (stderr
, "\n");
1788 if (VEC_length (cp_class_binding
, lvl
->class_shadowed
))
1791 cp_class_binding
*b
;
1792 fprintf (stderr
, " class-shadowed:");
1793 FOR_EACH_VEC_ELT (cp_class_binding
, lvl
->class_shadowed
, i
, b
)
1794 fprintf (stderr
, " %s ", IDENTIFIER_POINTER (b
->identifier
));
1795 fprintf (stderr
, "\n");
1797 if (lvl
->type_shadowed
)
1799 fprintf (stderr
, " type-shadowed:");
1800 for (t
= lvl
->type_shadowed
; t
; t
= TREE_CHAIN (t
))
1802 fprintf (stderr
, " %s ", IDENTIFIER_POINTER (TREE_PURPOSE (t
)));
1804 fprintf (stderr
, "\n");
1809 print_other_binding_stack (cp_binding_level
*stack
)
1811 cp_binding_level
*level
;
1812 for (level
= stack
; !global_scope_p (level
); level
= level
->level_chain
)
1814 fprintf (stderr
, "binding level %p\n", (void *) level
);
1815 print_binding_level (level
);
1820 print_binding_stack (void)
1822 cp_binding_level
*b
;
1823 fprintf (stderr
, "current_binding_level=%p\n"
1824 "class_binding_level=%p\n"
1825 "NAMESPACE_LEVEL (global_namespace)=%p\n",
1826 (void *) current_binding_level
, (void *) class_binding_level
,
1827 (void *) NAMESPACE_LEVEL (global_namespace
));
1828 if (class_binding_level
)
1830 for (b
= class_binding_level
; b
; b
= b
->level_chain
)
1831 if (b
== current_binding_level
)
1834 b
= class_binding_level
;
1836 b
= current_binding_level
;
1839 b
= current_binding_level
;
1840 print_other_binding_stack (b
);
1841 fprintf (stderr
, "global:\n");
1842 print_binding_level (NAMESPACE_LEVEL (global_namespace
));
1845 /* Return the type associated with ID. */
1848 identifier_type_value_1 (tree id
)
1850 /* There is no type with that name, anywhere. */
1851 if (REAL_IDENTIFIER_TYPE_VALUE (id
) == NULL_TREE
)
1853 /* This is not the type marker, but the real thing. */
1854 if (REAL_IDENTIFIER_TYPE_VALUE (id
) != global_type_node
)
1855 return REAL_IDENTIFIER_TYPE_VALUE (id
);
1856 /* Have to search for it. It must be on the global level, now.
1857 Ask lookup_name not to return non-types. */
1858 id
= lookup_name_real (id
, 2, 1, /*block_p=*/true, 0, 0);
1860 return TREE_TYPE (id
);
1864 /* Wrapper for identifier_type_value_1. */
1867 identifier_type_value (tree id
)
1870 timevar_start (TV_NAME_LOOKUP
);
1871 ret
= identifier_type_value_1 (id
);
1872 timevar_stop (TV_NAME_LOOKUP
);
1877 /* Return the IDENTIFIER_GLOBAL_VALUE of T, for use in common code, since
1878 the definition of IDENTIFIER_GLOBAL_VALUE is different for C and C++. */
1881 identifier_global_value (tree t
)
1883 return IDENTIFIER_GLOBAL_VALUE (t
);
1886 /* Push a definition of struct, union or enum tag named ID. into
1887 binding_level B. DECL is a TYPE_DECL for the type. We assume that
1888 the tag ID is not already defined. */
1891 set_identifier_type_value_with_scope (tree id
, tree decl
, cp_binding_level
*b
)
1895 if (b
->kind
!= sk_namespace
)
1897 /* Shadow the marker, not the real thing, so that the marker
1898 gets restored later. */
1899 tree old_type_value
= REAL_IDENTIFIER_TYPE_VALUE (id
);
1901 = tree_cons (id
, old_type_value
, b
->type_shadowed
);
1902 type
= decl
? TREE_TYPE (decl
) : NULL_TREE
;
1903 TREE_TYPE (b
->type_shadowed
) = type
;
1907 cxx_binding
*binding
=
1908 binding_for_name (NAMESPACE_LEVEL (current_namespace
), id
);
1911 supplement_binding (binding
, decl
);
1913 binding
->value
= decl
;
1915 /* Store marker instead of real type. */
1916 type
= global_type_node
;
1918 SET_IDENTIFIER_TYPE_VALUE (id
, type
);
1921 /* As set_identifier_type_value_with_scope, but using
1922 current_binding_level. */
1925 set_identifier_type_value (tree id
, tree decl
)
1927 set_identifier_type_value_with_scope (id
, decl
, current_binding_level
);
1930 /* Return the name for the constructor (or destructor) for the
1931 specified class TYPE. When given a template, this routine doesn't
1932 lose the specialization. */
1935 constructor_name_full (tree type
)
1937 return TYPE_IDENTIFIER (TYPE_MAIN_VARIANT (type
));
1940 /* Return the name for the constructor (or destructor) for the
1941 specified class. When given a template, return the plain
1942 unspecialized name. */
1945 constructor_name (tree type
)
1948 name
= constructor_name_full (type
);
1949 if (IDENTIFIER_TEMPLATE (name
))
1950 name
= IDENTIFIER_TEMPLATE (name
);
1954 /* Returns TRUE if NAME is the name for the constructor for TYPE,
1955 which must be a class type. */
1958 constructor_name_p (tree name
, tree type
)
1962 gcc_assert (MAYBE_CLASS_TYPE_P (type
));
1967 if (TREE_CODE (name
) != IDENTIFIER_NODE
)
1970 /* These don't have names. */
1971 if (TREE_CODE (type
) == DECLTYPE_TYPE
1972 || TREE_CODE (type
) == TYPEOF_TYPE
)
1975 ctor_name
= constructor_name_full (type
);
1976 if (name
== ctor_name
)
1978 if (IDENTIFIER_TEMPLATE (ctor_name
)
1979 && name
== IDENTIFIER_TEMPLATE (ctor_name
))
1984 /* Counter used to create anonymous type names. */
1986 static GTY(()) int anon_cnt
;
1988 /* Return an IDENTIFIER which can be used as a name for
1989 anonymous structs and unions. */
1992 make_anon_name (void)
1996 sprintf (buf
, ANON_AGGRNAME_FORMAT
, anon_cnt
++);
1997 return get_identifier (buf
);
2000 /* This code is practically identical to that for creating
2001 anonymous names, but is just used for lambdas instead. This isn't really
2002 necessary, but it's convenient to avoid treating lambdas like other
2005 static GTY(()) int lambda_cnt
= 0;
2008 make_lambda_name (void)
2012 sprintf (buf
, LAMBDANAME_FORMAT
, lambda_cnt
++);
2013 return get_identifier (buf
);
2016 /* Return (from the stack of) the BINDING, if any, established at SCOPE. */
2018 static inline cxx_binding
*
2019 find_binding (cp_binding_level
*scope
, cxx_binding
*binding
)
2021 for (; binding
!= NULL
; binding
= binding
->previous
)
2022 if (binding
->scope
== scope
)
2025 return (cxx_binding
*)0;
2028 /* Return the binding for NAME in SCOPE, if any. Otherwise, return NULL. */
2030 static inline cxx_binding
*
2031 cp_binding_level_find_binding_for_name (cp_binding_level
*scope
, tree name
)
2033 cxx_binding
*b
= IDENTIFIER_NAMESPACE_BINDINGS (name
);
2036 /* Fold-in case where NAME is used only once. */
2037 if (scope
== b
->scope
&& b
->previous
== NULL
)
2039 return find_binding (scope
, b
);
2044 /* Always returns a binding for name in scope. If no binding is
2045 found, make a new one. */
2047 static cxx_binding
*
2048 binding_for_name (cp_binding_level
*scope
, tree name
)
2050 cxx_binding
*result
;
2052 result
= cp_binding_level_find_binding_for_name (scope
, name
);
2055 /* Not found, make a new one. */
2056 result
= cxx_binding_make (NULL
, NULL
);
2057 result
->previous
= IDENTIFIER_NAMESPACE_BINDINGS (name
);
2058 result
->scope
= scope
;
2059 result
->is_local
= false;
2060 result
->value_is_inherited
= false;
2061 IDENTIFIER_NAMESPACE_BINDINGS (name
) = result
;
2065 /* Walk through the bindings associated to the name of FUNCTION,
2066 and return the first declaration of a function with a
2067 "C" linkage specification, a.k.a 'extern "C"'.
2068 This function looks for the binding, regardless of which scope it
2069 has been defined in. It basically looks in all the known scopes.
2070 Note that this function does not lookup for bindings of builtin functions
2071 or for functions declared in system headers. */
2073 lookup_extern_c_fun_in_all_ns (tree function
)
2078 gcc_assert (function
&& TREE_CODE (function
) == FUNCTION_DECL
);
2080 name
= DECL_NAME (function
);
2081 gcc_assert (name
&& TREE_CODE (name
) == IDENTIFIER_NODE
);
2083 for (iter
= IDENTIFIER_NAMESPACE_BINDINGS (name
);
2085 iter
= iter
->previous
)
2088 for (ovl
= iter
->value
; ovl
; ovl
= OVL_NEXT (ovl
))
2090 tree decl
= OVL_CURRENT (ovl
);
2092 && TREE_CODE (decl
) == FUNCTION_DECL
2093 && DECL_EXTERN_C_P (decl
)
2094 && !DECL_ARTIFICIAL (decl
))
2103 /* Returns a list of C-linkage decls with the name NAME. */
2106 c_linkage_bindings (tree name
)
2108 tree decls
= NULL_TREE
;
2111 for (iter
= IDENTIFIER_NAMESPACE_BINDINGS (name
);
2113 iter
= iter
->previous
)
2116 for (ovl
= iter
->value
; ovl
; ovl
= OVL_NEXT (ovl
))
2118 tree decl
= OVL_CURRENT (ovl
);
2120 && DECL_EXTERN_C_P (decl
)
2121 && !DECL_ARTIFICIAL (decl
))
2123 if (decls
== NULL_TREE
)
2126 decls
= tree_cons (NULL_TREE
, decl
, decls
);
2133 /* Insert another USING_DECL into the current binding level, returning
2134 this declaration. If this is a redeclaration, do nothing, and
2135 return NULL_TREE if this not in namespace scope (in namespace
2136 scope, a using decl might extend any previous bindings). */
2139 push_using_decl_1 (tree scope
, tree name
)
2143 gcc_assert (TREE_CODE (scope
) == NAMESPACE_DECL
);
2144 gcc_assert (TREE_CODE (name
) == IDENTIFIER_NODE
);
2145 for (decl
= current_binding_level
->usings
; decl
; decl
= DECL_CHAIN (decl
))
2146 if (USING_DECL_SCOPE (decl
) == scope
&& DECL_NAME (decl
) == name
)
2149 return namespace_bindings_p () ? decl
: NULL_TREE
;
2150 decl
= build_lang_decl (USING_DECL
, name
, NULL_TREE
);
2151 USING_DECL_SCOPE (decl
) = scope
;
2152 DECL_CHAIN (decl
) = current_binding_level
->usings
;
2153 current_binding_level
->usings
= decl
;
2157 /* Wrapper for push_using_decl_1. */
2160 push_using_decl (tree scope
, tree name
)
2163 timevar_start (TV_NAME_LOOKUP
);
2164 ret
= push_using_decl_1 (scope
, name
);
2165 timevar_stop (TV_NAME_LOOKUP
);
2169 /* Same as pushdecl, but define X in binding-level LEVEL. We rely on the
2170 caller to set DECL_CONTEXT properly.
2172 Note that this must only be used when X will be the new innermost
2173 binding for its name, as we tack it onto the front of IDENTIFIER_BINDING
2174 without checking to see if the current IDENTIFIER_BINDING comes from a
2175 closer binding level than LEVEL. */
2178 pushdecl_with_scope_1 (tree x
, cp_binding_level
*level
, bool is_friend
)
2180 cp_binding_level
*b
;
2181 tree function_decl
= current_function_decl
;
2183 current_function_decl
= NULL_TREE
;
2184 if (level
->kind
== sk_class
)
2186 b
= class_binding_level
;
2187 class_binding_level
= level
;
2188 pushdecl_class_level (x
);
2189 class_binding_level
= b
;
2193 b
= current_binding_level
;
2194 current_binding_level
= level
;
2195 x
= pushdecl_maybe_friend (x
, is_friend
);
2196 current_binding_level
= b
;
2198 current_function_decl
= function_decl
;
2202 /* Wrapper for pushdecl_with_scope_1. */
2205 pushdecl_with_scope (tree x
, cp_binding_level
*level
, bool is_friend
)
2208 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
2209 ret
= pushdecl_with_scope_1 (x
, level
, is_friend
);
2210 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
2215 /* DECL is a FUNCTION_DECL for a non-member function, which may have
2216 other definitions already in place. We get around this by making
2217 the value of the identifier point to a list of all the things that
2218 want to be referenced by that name. It is then up to the users of
2219 that name to decide what to do with that list.
2221 DECL may also be a TEMPLATE_DECL, with a FUNCTION_DECL in its
2222 DECL_TEMPLATE_RESULT. It is dealt with the same way.
2224 FLAGS is a bitwise-or of the following values:
2225 PUSH_LOCAL: Bind DECL in the current scope, rather than at
2227 PUSH_USING: DECL is being pushed as the result of a using
2230 IS_FRIEND is true if this is a friend declaration.
2232 The value returned may be a previous declaration if we guessed wrong
2233 about what language DECL should belong to (C or C++). Otherwise,
2234 it's always DECL (and never something that's not a _DECL). */
2237 push_overloaded_decl_1 (tree decl
, int flags
, bool is_friend
)
2239 tree name
= DECL_NAME (decl
);
2242 int doing_global
= (namespace_bindings_p () || !(flags
& PUSH_LOCAL
));
2245 old
= namespace_binding (name
, DECL_CONTEXT (decl
));
2247 old
= lookup_name_innermost_nonclass_level (name
);
2251 if (TREE_CODE (old
) == TYPE_DECL
&& DECL_ARTIFICIAL (old
))
2253 tree t
= TREE_TYPE (old
);
2254 if (MAYBE_CLASS_TYPE_P (t
) && warn_shadow
2255 && (! DECL_IN_SYSTEM_HEADER (decl
)
2256 || ! DECL_IN_SYSTEM_HEADER (old
)))
2257 warning (OPT_Wshadow
, "%q#D hides constructor for %q#T", decl
, t
);
2260 else if (is_overloaded_fn (old
))
2264 for (tmp
= old
; tmp
; tmp
= OVL_NEXT (tmp
))
2266 tree fn
= OVL_CURRENT (tmp
);
2269 if (TREE_CODE (tmp
) == OVERLOAD
&& OVL_USED (tmp
)
2270 && !(flags
& PUSH_USING
)
2271 && compparms (TYPE_ARG_TYPES (TREE_TYPE (fn
)),
2272 TYPE_ARG_TYPES (TREE_TYPE (decl
)))
2273 && ! decls_match (fn
, decl
))
2274 error ("%q#D conflicts with previous using declaration %q#D",
2277 dup
= duplicate_decls (decl
, fn
, is_friend
);
2278 /* If DECL was a redeclaration of FN -- even an invalid
2279 one -- pass that information along to our caller. */
2280 if (dup
== fn
|| dup
== error_mark_node
)
2284 /* We don't overload implicit built-ins. duplicate_decls()
2285 may fail to merge the decls if the new decl is e.g. a
2286 template function. */
2287 if (TREE_CODE (old
) == FUNCTION_DECL
2288 && DECL_ANTICIPATED (old
)
2289 && !DECL_HIDDEN_FRIEND_P (old
))
2292 else if (old
== error_mark_node
)
2293 /* Ignore the undefined symbol marker. */
2297 error ("previous non-function declaration %q+#D", old
);
2298 error ("conflicts with function declaration %q#D", decl
);
2303 if (old
|| TREE_CODE (decl
) == TEMPLATE_DECL
2304 /* If it's a using declaration, we always need to build an OVERLOAD,
2305 because it's the only way to remember that the declaration comes
2306 from 'using', and have the lookup behave correctly. */
2307 || (flags
& PUSH_USING
))
2309 if (old
&& TREE_CODE (old
) != OVERLOAD
)
2310 new_binding
= ovl_cons (decl
, ovl_cons (old
, NULL_TREE
));
2312 new_binding
= ovl_cons (decl
, old
);
2313 if (flags
& PUSH_USING
)
2314 OVL_USED (new_binding
) = 1;
2317 /* NAME is not ambiguous. */
2321 set_namespace_binding (name
, current_namespace
, new_binding
);
2324 /* We only create an OVERLOAD if there was a previous binding at
2325 this level, or if decl is a template. In the former case, we
2326 need to remove the old binding and replace it with the new
2327 binding. We must also run through the NAMES on the binding
2328 level where the name was bound to update the chain. */
2330 if (TREE_CODE (new_binding
) == OVERLOAD
&& old
)
2334 for (d
= &IDENTIFIER_BINDING (name
)->scope
->names
;
2336 d
= &TREE_CHAIN (*d
))
2338 || (TREE_CODE (*d
) == TREE_LIST
2339 && TREE_VALUE (*d
) == old
))
2341 if (TREE_CODE (*d
) == TREE_LIST
)
2342 /* Just replace the old binding with the new. */
2343 TREE_VALUE (*d
) = new_binding
;
2345 /* Build a TREE_LIST to wrap the OVERLOAD. */
2346 *d
= tree_cons (NULL_TREE
, new_binding
,
2349 /* And update the cxx_binding node. */
2350 IDENTIFIER_BINDING (name
)->value
= new_binding
;
2354 /* We should always find a previous binding in this case. */
2358 /* Install the new binding. */
2359 push_local_binding (name
, new_binding
, flags
);
2365 /* Wrapper for push_overloaded_decl_1. */
2368 push_overloaded_decl (tree decl
, int flags
, bool is_friend
)
2371 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
2372 ret
= push_overloaded_decl_1 (decl
, flags
, is_friend
);
2373 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
2377 /* Check a non-member using-declaration. Return the name and scope
2378 being used, and the USING_DECL, or NULL_TREE on failure. */
2381 validate_nonmember_using_decl (tree decl
, tree scope
, tree name
)
2383 /* [namespace.udecl]
2384 A using-declaration for a class member shall be a
2385 member-declaration. */
2388 error ("%qT is not a namespace", scope
);
2391 else if (scope
== error_mark_node
)
2394 if (TREE_CODE (decl
) == TEMPLATE_ID_EXPR
)
2397 A using-declaration shall not name a template-id. */
2398 error ("a using-declaration cannot specify a template-id. "
2399 "Try %<using %D%>", name
);
2403 if (TREE_CODE (decl
) == NAMESPACE_DECL
)
2405 error ("namespace %qD not allowed in using-declaration", decl
);
2409 if (TREE_CODE (decl
) == SCOPE_REF
)
2411 /* It's a nested name with template parameter dependent scope.
2412 This can only be using-declaration for class member. */
2413 error ("%qT is not a namespace", TREE_OPERAND (decl
, 0));
2417 if (is_overloaded_fn (decl
))
2418 decl
= get_first_fn (decl
);
2420 gcc_assert (DECL_P (decl
));
2422 /* Make a USING_DECL. */
2423 tree using_decl
= push_using_decl (scope
, name
);
2425 if (using_decl
== NULL_TREE
2426 && at_function_scope_p ()
2427 && TREE_CODE (decl
) == VAR_DECL
)
2428 /* C++11 7.3.3/10. */
2429 error ("%qD is already declared in this scope", name
);
2434 /* Process local and global using-declarations. */
2437 do_nonmember_using_decl (tree scope
, tree name
, tree oldval
, tree oldtype
,
2438 tree
*newval
, tree
*newtype
)
2440 struct scope_binding decls
= EMPTY_SCOPE_BINDING
;
2442 *newval
= *newtype
= NULL_TREE
;
2443 if (!qualified_lookup_using_namespace (name
, scope
, &decls
, 0))
2447 if (!decls
.value
&& !decls
.type
)
2449 error ("%qD not declared", name
);
2453 /* Shift the old and new bindings around so we're comparing class and
2454 enumeration names to each other. */
2455 if (oldval
&& DECL_IMPLICIT_TYPEDEF_P (oldval
))
2461 if (decls
.value
&& DECL_IMPLICIT_TYPEDEF_P (decls
.value
))
2463 decls
.type
= decls
.value
;
2464 decls
.value
= NULL_TREE
;
2467 /* It is impossible to overload a built-in function; any explicit
2468 declaration eliminates the built-in declaration. So, if OLDVAL
2469 is a built-in, then we can just pretend it isn't there. */
2471 && TREE_CODE (oldval
) == FUNCTION_DECL
2472 && DECL_ANTICIPATED (oldval
)
2473 && !DECL_HIDDEN_FRIEND_P (oldval
))
2478 /* Check for using functions. */
2479 if (is_overloaded_fn (decls
.value
))
2483 if (oldval
&& !is_overloaded_fn (oldval
))
2485 error ("%qD is already declared in this scope", name
);
2490 for (tmp
= decls
.value
; tmp
; tmp
= OVL_NEXT (tmp
))
2492 tree new_fn
= OVL_CURRENT (tmp
);
2494 /* [namespace.udecl]
2496 If a function declaration in namespace scope or block
2497 scope has the same name and the same parameter types as a
2498 function introduced by a using declaration the program is
2500 for (tmp1
= oldval
; tmp1
; tmp1
= OVL_NEXT (tmp1
))
2502 tree old_fn
= OVL_CURRENT (tmp1
);
2504 if (new_fn
== old_fn
)
2505 /* The function already exists in the current namespace. */
2507 else if (OVL_USED (tmp1
))
2508 continue; /* this is a using decl */
2509 else if (compparms (TYPE_ARG_TYPES (TREE_TYPE (new_fn
)),
2510 TYPE_ARG_TYPES (TREE_TYPE (old_fn
))))
2512 gcc_assert (!DECL_ANTICIPATED (old_fn
)
2513 || DECL_HIDDEN_FRIEND_P (old_fn
));
2515 /* There was already a non-using declaration in
2516 this scope with the same parameter types. If both
2517 are the same extern "C" functions, that's ok. */
2518 if (decls_match (new_fn
, old_fn
))
2522 error ("%qD is already declared in this scope", name
);
2528 /* If we broke out of the loop, there's no reason to add
2529 this function to the using declarations for this
2534 /* If we are adding to an existing OVERLOAD, then we no
2535 longer know the type of the set of functions. */
2536 if (*newval
&& TREE_CODE (*newval
) == OVERLOAD
)
2537 TREE_TYPE (*newval
) = unknown_type_node
;
2538 /* Add this new function to the set. */
2539 *newval
= build_overload (OVL_CURRENT (tmp
), *newval
);
2540 /* If there is only one function, then we use its type. (A
2541 using-declaration naming a single function can be used in
2542 contexts where overload resolution cannot be
2544 if (TREE_CODE (*newval
) != OVERLOAD
)
2546 *newval
= ovl_cons (*newval
, NULL_TREE
);
2547 TREE_TYPE (*newval
) = TREE_TYPE (OVL_CURRENT (tmp
));
2549 OVL_USED (*newval
) = 1;
2554 *newval
= decls
.value
;
2555 if (oldval
&& !decls_match (*newval
, oldval
))
2556 error ("%qD is already declared in this scope", name
);
2562 if (decls
.type
&& TREE_CODE (decls
.type
) == TREE_LIST
)
2564 error ("reference to %qD is ambiguous", name
);
2565 print_candidates (decls
.type
);
2569 *newtype
= decls
.type
;
2570 if (oldtype
&& *newtype
&& !decls_match (oldtype
, *newtype
))
2571 error ("%qD is already declared in this scope", name
);
2574 /* If *newval is empty, shift any class or enumeration name down. */
2578 *newtype
= NULL_TREE
;
2582 /* Process a using-declaration at function scope. */
2585 do_local_using_decl (tree decl
, tree scope
, tree name
)
2587 tree oldval
, oldtype
, newval
, newtype
;
2588 tree orig_decl
= decl
;
2590 decl
= validate_nonmember_using_decl (decl
, scope
, name
);
2591 if (decl
== NULL_TREE
)
2594 if (building_stmt_list_p ()
2595 && at_function_scope_p ())
2596 add_decl_expr (decl
);
2598 oldval
= lookup_name_innermost_nonclass_level (name
);
2599 oldtype
= lookup_type_current_level (name
);
2601 do_nonmember_using_decl (scope
, name
, oldval
, oldtype
, &newval
, &newtype
);
2605 if (is_overloaded_fn (newval
))
2609 /* We only need to push declarations for those functions
2610 that were not already bound in the current level.
2611 The old value might be NULL_TREE, it might be a single
2612 function, or an OVERLOAD. */
2613 if (oldval
&& TREE_CODE (oldval
) == OVERLOAD
)
2614 term
= OVL_FUNCTION (oldval
);
2617 for (fn
= newval
; fn
&& OVL_CURRENT (fn
) != term
;
2619 push_overloaded_decl (OVL_CURRENT (fn
),
2620 PUSH_LOCAL
| PUSH_USING
,
2624 push_local_binding (name
, newval
, PUSH_USING
);
2628 push_local_binding (name
, newtype
, PUSH_USING
);
2629 set_identifier_type_value (name
, newtype
);
2632 /* Emit debug info. */
2633 if (!processing_template_decl
)
2634 cp_emit_debug_info_for_using (orig_decl
, current_scope());
2637 /* Returns true if ROOT (a namespace, class, or function) encloses
2638 CHILD. CHILD may be either a class type or a namespace. */
2641 is_ancestor (tree root
, tree child
)
2643 gcc_assert ((TREE_CODE (root
) == NAMESPACE_DECL
2644 || TREE_CODE (root
) == FUNCTION_DECL
2645 || CLASS_TYPE_P (root
)));
2646 gcc_assert ((TREE_CODE (child
) == NAMESPACE_DECL
2647 || CLASS_TYPE_P (child
)));
2649 /* The global namespace encloses everything. */
2650 if (root
== global_namespace
)
2655 /* If we've run out of scopes, stop. */
2658 /* If we've reached the ROOT, it encloses CHILD. */
2661 /* Go out one level. */
2663 child
= TYPE_NAME (child
);
2664 child
= DECL_CONTEXT (child
);
2668 /* Enter the class or namespace scope indicated by T suitable for name
2669 lookup. T can be arbitrary scope, not necessary nested inside the
2670 current scope. Returns a non-null scope to pop iff pop_scope
2671 should be called later to exit this scope. */
2676 if (TREE_CODE (t
) == NAMESPACE_DECL
)
2677 push_decl_namespace (t
);
2678 else if (CLASS_TYPE_P (t
))
2680 if (!at_class_scope_p ()
2681 || !same_type_p (current_class_type
, t
))
2682 push_nested_class (t
);
2684 /* T is the same as the current scope. There is therefore no
2685 need to re-enter the scope. Since we are not actually
2686 pushing a new scope, our caller should not call
2694 /* Leave scope pushed by push_scope. */
2701 if (TREE_CODE (t
) == NAMESPACE_DECL
)
2702 pop_decl_namespace ();
2703 else if CLASS_TYPE_P (t
)
2704 pop_nested_class ();
2707 /* Subroutine of push_inner_scope. */
2710 push_inner_scope_r (tree outer
, tree inner
)
2715 || (TREE_CODE (inner
) != NAMESPACE_DECL
&& !CLASS_TYPE_P (inner
)))
2718 prev
= CP_DECL_CONTEXT (TREE_CODE (inner
) == NAMESPACE_DECL
? inner
: TYPE_NAME (inner
));
2720 push_inner_scope_r (outer
, prev
);
2721 if (TREE_CODE (inner
) == NAMESPACE_DECL
)
2723 cp_binding_level
*save_template_parm
= 0;
2724 /* Temporary take out template parameter scopes. They are saved
2725 in reversed order in save_template_parm. */
2726 while (current_binding_level
->kind
== sk_template_parms
)
2728 cp_binding_level
*b
= current_binding_level
;
2729 current_binding_level
= b
->level_chain
;
2730 b
->level_chain
= save_template_parm
;
2731 save_template_parm
= b
;
2734 resume_scope (NAMESPACE_LEVEL (inner
));
2735 current_namespace
= inner
;
2737 /* Restore template parameter scopes. */
2738 while (save_template_parm
)
2740 cp_binding_level
*b
= save_template_parm
;
2741 save_template_parm
= b
->level_chain
;
2742 b
->level_chain
= current_binding_level
;
2743 current_binding_level
= b
;
2750 /* Enter the scope INNER from current scope. INNER must be a scope
2751 nested inside current scope. This works with both name lookup and
2752 pushing name into scope. In case a template parameter scope is present,
2753 namespace is pushed under the template parameter scope according to
2754 name lookup rule in 14.6.1/6.
2756 Return the former current scope suitable for pop_inner_scope. */
2759 push_inner_scope (tree inner
)
2761 tree outer
= current_scope ();
2763 outer
= current_namespace
;
2765 push_inner_scope_r (outer
, inner
);
2769 /* Exit the current scope INNER back to scope OUTER. */
2772 pop_inner_scope (tree outer
, tree inner
)
2775 || (TREE_CODE (inner
) != NAMESPACE_DECL
&& !CLASS_TYPE_P (inner
)))
2778 while (outer
!= inner
)
2780 if (TREE_CODE (inner
) == NAMESPACE_DECL
)
2782 cp_binding_level
*save_template_parm
= 0;
2783 /* Temporary take out template parameter scopes. They are saved
2784 in reversed order in save_template_parm. */
2785 while (current_binding_level
->kind
== sk_template_parms
)
2787 cp_binding_level
*b
= current_binding_level
;
2788 current_binding_level
= b
->level_chain
;
2789 b
->level_chain
= save_template_parm
;
2790 save_template_parm
= b
;
2795 /* Restore template parameter scopes. */
2796 while (save_template_parm
)
2798 cp_binding_level
*b
= save_template_parm
;
2799 save_template_parm
= b
->level_chain
;
2800 b
->level_chain
= current_binding_level
;
2801 current_binding_level
= b
;
2807 inner
= CP_DECL_CONTEXT (TREE_CODE (inner
) == NAMESPACE_DECL
? inner
: TYPE_NAME (inner
));
2811 /* Do a pushlevel for class declarations. */
2814 pushlevel_class (void)
2816 class_binding_level
= begin_scope (sk_class
, current_class_type
);
2819 /* ...and a poplevel for class declarations. */
2822 poplevel_class (void)
2824 cp_binding_level
*level
= class_binding_level
;
2825 cp_class_binding
*cb
;
2829 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
2830 gcc_assert (level
!= 0);
2832 /* If we're leaving a toplevel class, cache its binding level. */
2833 if (current_class_depth
== 1)
2834 previous_class_level
= level
;
2835 for (shadowed
= level
->type_shadowed
;
2837 shadowed
= TREE_CHAIN (shadowed
))
2838 SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (shadowed
), TREE_VALUE (shadowed
));
2840 /* Remove the bindings for all of the class-level declarations. */
2841 if (level
->class_shadowed
)
2843 FOR_EACH_VEC_ELT (cp_class_binding
, level
->class_shadowed
, i
, cb
)
2845 IDENTIFIER_BINDING (cb
->identifier
) = cb
->base
->previous
;
2846 cxx_binding_free (cb
->base
);
2848 ggc_free (level
->class_shadowed
);
2849 level
->class_shadowed
= NULL
;
2852 /* Now, pop out of the binding level which we created up in the
2853 `pushlevel_class' routine. */
2854 gcc_assert (current_binding_level
== level
);
2856 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
2859 /* Set INHERITED_VALUE_BINDING_P on BINDING to true or false, as
2860 appropriate. DECL is the value to which a name has just been
2861 bound. CLASS_TYPE is the class in which the lookup occurred. */
2864 set_inherited_value_binding_p (cxx_binding
*binding
, tree decl
,
2867 if (binding
->value
== decl
&& TREE_CODE (decl
) != TREE_LIST
)
2871 if (TREE_CODE (decl
) == OVERLOAD
)
2872 context
= ovl_scope (decl
);
2875 gcc_assert (DECL_P (decl
));
2876 context
= context_for_name_lookup (decl
);
2879 if (is_properly_derived_from (class_type
, context
))
2880 INHERITED_VALUE_BINDING_P (binding
) = 1;
2882 INHERITED_VALUE_BINDING_P (binding
) = 0;
2884 else if (binding
->value
== decl
)
2885 /* We only encounter a TREE_LIST when there is an ambiguity in the
2886 base classes. Such an ambiguity can be overridden by a
2887 definition in this class. */
2888 INHERITED_VALUE_BINDING_P (binding
) = 1;
2890 INHERITED_VALUE_BINDING_P (binding
) = 0;
2893 /* Make the declaration of X appear in CLASS scope. */
2896 pushdecl_class_level (tree x
)
2899 bool is_valid
= true;
2902 /* Do nothing if we're adding to an outer lambda closure type,
2903 outer_binding will add it later if it's needed. */
2904 if (current_class_type
!= class_binding_level
->this_entity
)
2907 subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
2908 /* Get the name of X. */
2909 if (TREE_CODE (x
) == OVERLOAD
)
2910 name
= DECL_NAME (get_first_fn (x
));
2912 name
= DECL_NAME (x
);
2916 is_valid
= push_class_level_binding (name
, x
);
2917 if (TREE_CODE (x
) == TYPE_DECL
)
2918 set_identifier_type_value (name
, x
);
2920 else if (ANON_AGGR_TYPE_P (TREE_TYPE (x
)))
2922 /* If X is an anonymous aggregate, all of its members are
2923 treated as if they were members of the class containing the
2924 aggregate, for naming purposes. */
2927 for (f
= TYPE_FIELDS (TREE_TYPE (x
)); f
; f
= DECL_CHAIN (f
))
2929 location_t save_location
= input_location
;
2930 input_location
= DECL_SOURCE_LOCATION (f
);
2931 if (!pushdecl_class_level (f
))
2933 input_location
= save_location
;
2936 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
2940 /* Return the BINDING (if any) for NAME in SCOPE, which is a class
2941 scope. If the value returned is non-NULL, and the PREVIOUS field
2942 is not set, callers must set the PREVIOUS field explicitly. */
2944 static cxx_binding
*
2945 get_class_binding (tree name
, cp_binding_level
*scope
)
2950 cxx_binding
*binding
;
2952 class_type
= scope
->this_entity
;
2954 /* Get the type binding. */
2955 type_binding
= lookup_member (class_type
, name
,
2956 /*protect=*/2, /*want_type=*/true,
2957 tf_warning_or_error
);
2958 /* Get the value binding. */
2959 value_binding
= lookup_member (class_type
, name
,
2960 /*protect=*/2, /*want_type=*/false,
2961 tf_warning_or_error
);
2964 && (TREE_CODE (value_binding
) == TYPE_DECL
2965 || DECL_CLASS_TEMPLATE_P (value_binding
)
2966 || (TREE_CODE (value_binding
) == TREE_LIST
2967 && TREE_TYPE (value_binding
) == error_mark_node
2968 && (TREE_CODE (TREE_VALUE (value_binding
))
2970 /* We found a type binding, even when looking for a non-type
2971 binding. This means that we already processed this binding
2974 else if (value_binding
)
2976 if (TREE_CODE (value_binding
) == TREE_LIST
2977 && TREE_TYPE (value_binding
) == error_mark_node
)
2978 /* NAME is ambiguous. */
2980 else if (BASELINK_P (value_binding
))
2981 /* NAME is some overloaded functions. */
2982 value_binding
= BASELINK_FUNCTIONS (value_binding
);
2985 /* If we found either a type binding or a value binding, create a
2986 new binding object. */
2987 if (type_binding
|| value_binding
)
2989 binding
= new_class_binding (name
,
2993 /* This is a class-scope binding, not a block-scope binding. */
2994 LOCAL_BINDING_P (binding
) = 0;
2995 set_inherited_value_binding_p (binding
, value_binding
, class_type
);
3003 /* Make the declaration(s) of X appear in CLASS scope under the name
3004 NAME. Returns true if the binding is valid. */
3007 push_class_level_binding_1 (tree name
, tree x
)
3009 cxx_binding
*binding
;
3013 /* The class_binding_level will be NULL if x is a template
3014 parameter name in a member template. */
3015 if (!class_binding_level
)
3018 if (name
== error_mark_node
)
3021 /* Check for invalid member names. */
3022 gcc_assert (TYPE_BEING_DEFINED (current_class_type
));
3023 /* Check that we're pushing into the right binding level. */
3024 gcc_assert (current_class_type
== class_binding_level
->this_entity
);
3026 /* We could have been passed a tree list if this is an ambiguous
3027 declaration. If so, pull the declaration out because
3028 check_template_shadow will not handle a TREE_LIST. */
3029 if (TREE_CODE (decl
) == TREE_LIST
3030 && TREE_TYPE (decl
) == error_mark_node
)
3031 decl
= TREE_VALUE (decl
);
3033 if (!check_template_shadow (decl
))
3038 If T is the name of a class, then each of the following shall
3039 have a name different from T:
3041 -- every static data member of class T;
3043 -- every member of class T that is itself a type;
3045 -- every enumerator of every member of class T that is an
3048 -- every member of every anonymous union that is a member of
3051 (Non-static data members were also forbidden to have the same
3052 name as T until TC1.) */
3053 if ((TREE_CODE (x
) == VAR_DECL
3054 || TREE_CODE (x
) == CONST_DECL
3055 || (TREE_CODE (x
) == TYPE_DECL
3056 && !DECL_SELF_REFERENCE_P (x
))
3057 /* A data member of an anonymous union. */
3058 || (TREE_CODE (x
) == FIELD_DECL
3059 && DECL_CONTEXT (x
) != current_class_type
))
3060 && DECL_NAME (x
) == constructor_name (current_class_type
))
3062 tree scope
= context_for_name_lookup (x
);
3063 if (TYPE_P (scope
) && same_type_p (scope
, current_class_type
))
3065 error ("%qD has the same name as the class in which it is "
3072 /* Get the current binding for NAME in this class, if any. */
3073 binding
= IDENTIFIER_BINDING (name
);
3074 if (!binding
|| binding
->scope
!= class_binding_level
)
3076 binding
= get_class_binding (name
, class_binding_level
);
3077 /* If a new binding was created, put it at the front of the
3078 IDENTIFIER_BINDING list. */
3081 binding
->previous
= IDENTIFIER_BINDING (name
);
3082 IDENTIFIER_BINDING (name
) = binding
;
3086 /* If there is already a binding, then we may need to update the
3088 if (binding
&& binding
->value
)
3090 tree bval
= binding
->value
;
3091 tree old_decl
= NULL_TREE
;
3092 tree target_decl
= strip_using_decl (decl
);
3093 tree target_bval
= strip_using_decl (bval
);
3095 if (INHERITED_VALUE_BINDING_P (binding
))
3097 /* If the old binding was from a base class, and was for a
3098 tag name, slide it over to make room for the new binding.
3099 The old binding is still visible if explicitly qualified
3100 with a class-key. */
3101 if (TREE_CODE (target_bval
) == TYPE_DECL
3102 && DECL_ARTIFICIAL (target_bval
)
3103 && !(TREE_CODE (target_decl
) == TYPE_DECL
3104 && DECL_ARTIFICIAL (target_decl
)))
3106 old_decl
= binding
->type
;
3107 binding
->type
= bval
;
3108 binding
->value
= NULL_TREE
;
3109 INHERITED_VALUE_BINDING_P (binding
) = 0;
3114 /* Any inherited type declaration is hidden by the type
3115 declaration in the derived class. */
3116 if (TREE_CODE (target_decl
) == TYPE_DECL
3117 && DECL_ARTIFICIAL (target_decl
))
3118 binding
->type
= NULL_TREE
;
3121 else if (TREE_CODE (target_decl
) == OVERLOAD
3122 && is_overloaded_fn (target_bval
))
3124 else if (TREE_CODE (decl
) == USING_DECL
3125 && TREE_CODE (bval
) == USING_DECL
3126 && same_type_p (USING_DECL_SCOPE (decl
),
3127 USING_DECL_SCOPE (bval
)))
3128 /* This is a using redeclaration that will be diagnosed later
3129 in supplement_binding */
3131 else if (TREE_CODE (decl
) == USING_DECL
3132 && TREE_CODE (bval
) == USING_DECL
3133 && DECL_DEPENDENT_P (decl
)
3134 && DECL_DEPENDENT_P (bval
))
3136 else if (TREE_CODE (decl
) == USING_DECL
3137 && is_overloaded_fn (target_bval
))
3139 else if (TREE_CODE (bval
) == USING_DECL
3140 && is_overloaded_fn (target_decl
))
3143 if (old_decl
&& binding
->scope
== class_binding_level
)
3146 /* It is always safe to clear INHERITED_VALUE_BINDING_P
3147 here. This function is only used to register bindings
3148 from with the class definition itself. */
3149 INHERITED_VALUE_BINDING_P (binding
) = 0;
3154 /* Note that we declared this value so that we can issue an error if
3155 this is an invalid redeclaration of a name already used for some
3157 note_name_declared_in_class (name
, decl
);
3159 /* If we didn't replace an existing binding, put the binding on the
3160 stack of bindings for the identifier, and update the shadowed
3162 if (binding
&& binding
->scope
== class_binding_level
)
3163 /* Supplement the existing binding. */
3164 ok
= supplement_binding (binding
, decl
);
3167 /* Create a new binding. */
3168 push_binding (name
, decl
, class_binding_level
);
3175 /* Wrapper for push_class_level_binding_1. */
3178 push_class_level_binding (tree name
, tree x
)
3181 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
3182 ret
= push_class_level_binding_1 (name
, x
);
3183 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
3187 /* Process "using SCOPE::NAME" in a class scope. Return the
3188 USING_DECL created. */
3191 do_class_using_decl (tree scope
, tree name
)
3193 /* The USING_DECL returned by this function. */
3195 /* The declaration (or declarations) name by this using
3196 declaration. NULL if we are in a template and cannot figure out
3197 what has been named. */
3199 /* True if SCOPE is a dependent type. */
3200 bool scope_dependent_p
;
3201 /* True if SCOPE::NAME is dependent. */
3202 bool name_dependent_p
;
3203 /* True if any of the bases of CURRENT_CLASS_TYPE are dependent. */
3204 bool bases_dependent_p
;
3209 if (name
== error_mark_node
)
3212 if (!scope
|| !TYPE_P (scope
))
3214 error ("using-declaration for non-member at class scope");
3218 /* Make sure the name is not invalid */
3219 if (TREE_CODE (name
) == BIT_NOT_EXPR
)
3221 error ("%<%T::%D%> names destructor", scope
, name
);
3224 if (MAYBE_CLASS_TYPE_P (scope
) && constructor_name_p (name
, scope
))
3226 error ("%<%T::%D%> names constructor", scope
, name
);
3229 if (constructor_name_p (name
, current_class_type
))
3231 error ("%<%T::%D%> names constructor in %qT",
3232 scope
, name
, current_class_type
);
3236 scope_dependent_p
= dependent_scope_p (scope
);
3237 name_dependent_p
= (scope_dependent_p
3238 || (IDENTIFIER_TYPENAME_P (name
)
3239 && dependent_type_p (TREE_TYPE (name
))));
3241 bases_dependent_p
= false;
3242 if (processing_template_decl
)
3243 for (binfo
= TYPE_BINFO (current_class_type
), i
= 0;
3244 BINFO_BASE_ITERATE (binfo
, i
, base_binfo
);
3246 if (dependent_type_p (TREE_TYPE (base_binfo
)))
3248 bases_dependent_p
= true;
3254 /* From [namespace.udecl]:
3256 A using-declaration used as a member-declaration shall refer to a
3257 member of a base class of the class being defined.
3259 In general, we cannot check this constraint in a template because
3260 we do not know the entire set of base classes of the current
3261 class type. Morover, if SCOPE is dependent, it might match a
3262 non-dependent base. */
3264 if (!scope_dependent_p
)
3267 binfo
= lookup_base (current_class_type
, scope
, ba_any
, &b_kind
);
3268 if (b_kind
< bk_proper_base
)
3270 if (!bases_dependent_p
)
3272 error_not_base_type (scope
, current_class_type
);
3276 else if (!name_dependent_p
)
3278 decl
= lookup_member (binfo
, name
, 0, false, tf_warning_or_error
);
3281 error ("no members matching %<%T::%D%> in %q#T", scope
, name
,
3285 /* The binfo from which the functions came does not matter. */
3286 if (BASELINK_P (decl
))
3287 decl
= BASELINK_FUNCTIONS (decl
);
3291 value
= build_lang_decl (USING_DECL
, name
, NULL_TREE
);
3292 USING_DECL_DECLS (value
) = decl
;
3293 USING_DECL_SCOPE (value
) = scope
;
3294 DECL_DEPENDENT_P (value
) = !decl
;
3300 /* Return the binding value for name in scope. */
3304 namespace_binding_1 (tree name
, tree scope
)
3306 cxx_binding
*binding
;
3308 if (SCOPE_FILE_SCOPE_P (scope
))
3309 scope
= global_namespace
;
3311 /* Unnecessary for the global namespace because it can't be an alias. */
3312 scope
= ORIGINAL_NAMESPACE (scope
);
3314 binding
= cp_binding_level_find_binding_for_name (NAMESPACE_LEVEL (scope
), name
);
3316 return binding
? binding
->value
: NULL_TREE
;
3320 namespace_binding (tree name
, tree scope
)
3323 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
3324 ret
= namespace_binding_1 (name
, scope
);
3325 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
3329 /* Set the binding value for name in scope. */
3332 set_namespace_binding_1 (tree name
, tree scope
, tree val
)
3336 if (scope
== NULL_TREE
)
3337 scope
= global_namespace
;
3338 b
= binding_for_name (NAMESPACE_LEVEL (scope
), name
);
3339 if (!b
->value
|| TREE_CODE (val
) == OVERLOAD
|| val
== error_mark_node
)
3342 supplement_binding (b
, val
);
3345 /* Wrapper for set_namespace_binding_1. */
3348 set_namespace_binding (tree name
, tree scope
, tree val
)
3350 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
3351 set_namespace_binding_1 (name
, scope
, val
);
3352 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
3355 /* Set the context of a declaration to scope. Complain if we are not
3359 set_decl_namespace (tree decl
, tree scope
, bool friendp
)
3363 /* Get rid of namespace aliases. */
3364 scope
= ORIGINAL_NAMESPACE (scope
);
3366 /* It is ok for friends to be qualified in parallel space. */
3367 if (!friendp
&& !is_ancestor (current_namespace
, scope
))
3368 error ("declaration of %qD not in a namespace surrounding %qD",
3370 DECL_CONTEXT (decl
) = FROB_CONTEXT (scope
);
3372 /* Writing "int N::i" to declare a variable within "N" is invalid. */
3373 if (scope
== current_namespace
)
3375 if (at_namespace_scope_p ())
3376 error ("explicit qualification in declaration of %qD",
3381 /* See whether this has been declared in the namespace. */
3382 old
= lookup_qualified_name (scope
, DECL_NAME (decl
), false, true);
3383 if (old
== error_mark_node
)
3384 /* No old declaration at all. */
3386 /* If it's a TREE_LIST, the result of the lookup was ambiguous. */
3387 if (TREE_CODE (old
) == TREE_LIST
)
3389 error ("reference to %qD is ambiguous", decl
);
3390 print_candidates (old
);
3393 if (!is_overloaded_fn (decl
))
3395 /* We might have found OLD in an inline namespace inside SCOPE. */
3396 if (TREE_CODE (decl
) == TREE_CODE (old
))
3397 DECL_CONTEXT (decl
) = DECL_CONTEXT (old
);
3398 /* Don't compare non-function decls with decls_match here, since
3399 it can't check for the correct constness at this
3400 point. pushdecl will find those errors later. */
3403 /* Since decl is a function, old should contain a function decl. */
3404 if (!is_overloaded_fn (old
))
3406 /* A template can be explicitly specialized in any namespace. */
3407 if (processing_explicit_instantiation
)
3409 if (processing_template_decl
|| processing_specialization
)
3410 /* We have not yet called push_template_decl to turn a
3411 FUNCTION_DECL into a TEMPLATE_DECL, so the declarations won't
3412 match. But, we'll check later, when we construct the
3415 /* Instantiations or specializations of templates may be declared as
3416 friends in any namespace. */
3417 if (friendp
&& DECL_USE_TEMPLATE (decl
))
3419 if (is_overloaded_fn (old
))
3421 tree found
= NULL_TREE
;
3423 for (; elt
; elt
= OVL_NEXT (elt
))
3425 tree ofn
= OVL_CURRENT (elt
);
3426 /* Adjust DECL_CONTEXT first so decls_match will return true
3427 if DECL will match a declaration in an inline namespace. */
3428 DECL_CONTEXT (decl
) = DECL_CONTEXT (ofn
);
3429 if (decls_match (decl
, ofn
))
3431 if (found
&& !decls_match (found
, ofn
))
3433 DECL_CONTEXT (decl
) = FROB_CONTEXT (scope
);
3434 error ("reference to %qD is ambiguous", decl
);
3435 print_candidates (old
);
3443 if (!is_associated_namespace (scope
, CP_DECL_CONTEXT (found
)))
3445 DECL_CONTEXT (decl
) = DECL_CONTEXT (found
);
3451 DECL_CONTEXT (decl
) = DECL_CONTEXT (old
);
3452 if (decls_match (decl
, old
))
3456 /* It didn't work, go back to the explicit scope. */
3457 DECL_CONTEXT (decl
) = FROB_CONTEXT (scope
);
3459 error ("%qD should have been declared inside %qD", decl
, scope
);
3462 /* Return the namespace where the current declaration is declared. */
3465 current_decl_namespace (void)
3468 /* If we have been pushed into a different namespace, use it. */
3469 if (!VEC_empty (tree
, decl_namespace_list
))
3470 return VEC_last (tree
, decl_namespace_list
);
3472 if (current_class_type
)
3473 result
= decl_namespace_context (current_class_type
);
3474 else if (current_function_decl
)
3475 result
= decl_namespace_context (current_function_decl
);
3477 result
= current_namespace
;
3481 /* Process any ATTRIBUTES on a namespace definition. Currently only
3482 attribute visibility is meaningful, which is a property of the syntactic
3483 block rather than the namespace as a whole, so we don't touch the
3484 NAMESPACE_DECL at all. Returns true if attribute visibility is seen. */
3487 handle_namespace_attrs (tree ns
, tree attributes
)
3490 bool saw_vis
= false;
3492 for (d
= attributes
; d
; d
= TREE_CHAIN (d
))
3494 tree name
= TREE_PURPOSE (d
);
3495 tree args
= TREE_VALUE (d
);
3497 if (is_attribute_p ("visibility", name
))
3499 tree x
= args
? TREE_VALUE (args
) : NULL_TREE
;
3500 if (x
== NULL_TREE
|| TREE_CODE (x
) != STRING_CST
|| TREE_CHAIN (args
))
3502 warning (OPT_Wattributes
,
3503 "%qD attribute requires a single NTBS argument",
3508 if (!TREE_PUBLIC (ns
))
3509 warning (OPT_Wattributes
,
3510 "%qD attribute is meaningless since members of the "
3511 "anonymous namespace get local symbols", name
);
3513 push_visibility (TREE_STRING_POINTER (x
), 1);
3518 warning (OPT_Wattributes
, "%qD attribute directive ignored",
3527 /* Push into the scope of the NAME namespace. If NAME is NULL_TREE, then we
3528 select a name that is unique to this compilation unit. */
3531 push_namespace (tree name
)
3534 bool need_new
= true;
3535 bool implicit_use
= false;
3538 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
3540 /* We should not get here if the global_namespace is not yet constructed
3541 nor if NAME designates the global namespace: The global scope is
3542 constructed elsewhere. */
3543 gcc_assert (global_namespace
!= NULL
&& name
!= global_scope_name
);
3547 name
= get_anonymous_namespace_name();
3548 d
= IDENTIFIER_NAMESPACE_VALUE (name
);
3550 /* Reopening anonymous namespace. */
3552 implicit_use
= true;
3556 /* Check whether this is an extended namespace definition. */
3557 d
= IDENTIFIER_NAMESPACE_VALUE (name
);
3558 if (d
!= NULL_TREE
&& TREE_CODE (d
) == NAMESPACE_DECL
)
3560 tree dna
= DECL_NAMESPACE_ALIAS (d
);
3563 /* We do some error recovery for, eg, the redeclaration
3570 However, in nasty cases like:
3578 we just error out below, in duplicate_decls. */
3579 if (NAMESPACE_LEVEL (dna
)->level_chain
3580 == current_binding_level
)
3582 error ("namespace alias %qD not allowed here, "
3583 "assuming %qD", d
, dna
);
3595 /* Make a new namespace, binding the name to it. */
3596 d
= build_lang_decl (NAMESPACE_DECL
, name
, void_type_node
);
3597 DECL_CONTEXT (d
) = FROB_CONTEXT (current_namespace
);
3598 /* The name of this namespace is not visible to other translation
3599 units if it is an anonymous namespace or member thereof. */
3600 if (anon
|| decl_anon_ns_mem_p (current_namespace
))
3601 TREE_PUBLIC (d
) = 0;
3603 TREE_PUBLIC (d
) = 1;
3607 /* Clear DECL_NAME for the benefit of debugging back ends. */
3608 SET_DECL_ASSEMBLER_NAME (d
, name
);
3609 DECL_NAME (d
) = NULL_TREE
;
3611 begin_scope (sk_namespace
, d
);
3614 resume_scope (NAMESPACE_LEVEL (d
));
3617 do_using_directive (d
);
3618 /* Enter the name space. */
3619 current_namespace
= d
;
3621 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
3624 /* Pop from the scope of the current namespace. */
3627 pop_namespace (void)
3629 gcc_assert (current_namespace
!= global_namespace
);
3630 current_namespace
= CP_DECL_CONTEXT (current_namespace
);
3631 /* The binding level is not popped, as it might be re-opened later. */
3635 /* Push into the scope of the namespace NS, even if it is deeply
3636 nested within another namespace. */
3639 push_nested_namespace (tree ns
)
3641 if (ns
== global_namespace
)
3642 push_to_top_level ();
3645 push_nested_namespace (CP_DECL_CONTEXT (ns
));
3646 push_namespace (DECL_NAME (ns
));
3650 /* Pop back from the scope of the namespace NS, which was previously
3651 entered with push_nested_namespace. */
3654 pop_nested_namespace (tree ns
)
3656 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
3657 gcc_assert (current_namespace
== ns
);
3658 while (ns
!= global_namespace
)
3661 ns
= CP_DECL_CONTEXT (ns
);
3664 pop_from_top_level ();
3665 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
3668 /* Temporarily set the namespace for the current declaration. */
3671 push_decl_namespace (tree decl
)
3673 if (TREE_CODE (decl
) != NAMESPACE_DECL
)
3674 decl
= decl_namespace_context (decl
);
3675 VEC_safe_push (tree
, gc
, decl_namespace_list
, ORIGINAL_NAMESPACE (decl
));
3678 /* [namespace.memdef]/2 */
3681 pop_decl_namespace (void)
3683 VEC_pop (tree
, decl_namespace_list
);
3686 /* Return the namespace that is the common ancestor
3687 of two given namespaces. */
3690 namespace_ancestor_1 (tree ns1
, tree ns2
)
3693 if (is_ancestor (ns1
, ns2
))
3696 nsr
= namespace_ancestor_1 (CP_DECL_CONTEXT (ns1
), ns2
);
3700 /* Wrapper for namespace_ancestor_1. */
3703 namespace_ancestor (tree ns1
, tree ns2
)
3706 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
3707 nsr
= namespace_ancestor_1 (ns1
, ns2
);
3708 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
3712 /* Process a namespace-alias declaration. */
3715 do_namespace_alias (tree alias
, tree name_space
)
3717 if (name_space
== error_mark_node
)
3720 gcc_assert (TREE_CODE (name_space
) == NAMESPACE_DECL
);
3722 name_space
= ORIGINAL_NAMESPACE (name_space
);
3724 /* Build the alias. */
3725 alias
= build_lang_decl (NAMESPACE_DECL
, alias
, void_type_node
);
3726 DECL_NAMESPACE_ALIAS (alias
) = name_space
;
3727 DECL_EXTERNAL (alias
) = 1;
3728 DECL_CONTEXT (alias
) = FROB_CONTEXT (current_scope ());
3731 /* Emit debug info for namespace alias. */
3732 if (!building_stmt_list_p ())
3733 (*debug_hooks
->global_decl
) (alias
);
3736 /* Like pushdecl, only it places X in the current namespace,
3740 pushdecl_namespace_level (tree x
, bool is_friend
)
3742 cp_binding_level
*b
= current_binding_level
;
3745 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
3746 t
= pushdecl_with_scope (x
, NAMESPACE_LEVEL (current_namespace
), is_friend
);
3748 /* Now, the type_shadowed stack may screw us. Munge it so it does
3750 if (TREE_CODE (t
) == TYPE_DECL
)
3752 tree name
= DECL_NAME (t
);
3754 tree
*ptr
= (tree
*)0;
3755 for (; !global_scope_p (b
); b
= b
->level_chain
)
3757 tree shadowed
= b
->type_shadowed
;
3758 for (; shadowed
; shadowed
= TREE_CHAIN (shadowed
))
3759 if (TREE_PURPOSE (shadowed
) == name
)
3761 ptr
= &TREE_VALUE (shadowed
);
3762 /* Can't break out of the loop here because sometimes
3763 a binding level will have duplicate bindings for
3764 PT names. It's gross, but I haven't time to fix it. */
3767 newval
= TREE_TYPE (t
);
3768 if (ptr
== (tree
*)0)
3770 /* @@ This shouldn't be needed. My test case "zstring.cc" trips
3771 up here if this is changed to an assertion. --KR */
3772 SET_IDENTIFIER_TYPE_VALUE (name
, t
);
3779 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
3783 /* Insert USED into the using list of USER. Set INDIRECT_flag if this
3784 directive is not directly from the source. Also find the common
3785 ancestor and let our users know about the new namespace */
3788 add_using_namespace_1 (tree user
, tree used
, bool indirect
)
3791 /* Using oneself is a no-op. */
3794 gcc_assert (TREE_CODE (user
) == NAMESPACE_DECL
);
3795 gcc_assert (TREE_CODE (used
) == NAMESPACE_DECL
);
3796 /* Check if we already have this. */
3797 t
= purpose_member (used
, DECL_NAMESPACE_USING (user
));
3801 /* Promote to direct usage. */
3802 TREE_INDIRECT_USING (t
) = 0;
3806 /* Add used to the user's using list. */
3807 DECL_NAMESPACE_USING (user
)
3808 = tree_cons (used
, namespace_ancestor (user
, used
),
3809 DECL_NAMESPACE_USING (user
));
3811 TREE_INDIRECT_USING (DECL_NAMESPACE_USING (user
)) = indirect
;
3813 /* Add user to the used's users list. */
3814 DECL_NAMESPACE_USERS (used
)
3815 = tree_cons (user
, 0, DECL_NAMESPACE_USERS (used
));
3817 /* Recursively add all namespaces used. */
3818 for (t
= DECL_NAMESPACE_USING (used
); t
; t
= TREE_CHAIN (t
))
3819 /* indirect usage */
3820 add_using_namespace_1 (user
, TREE_PURPOSE (t
), 1);
3822 /* Tell everyone using us about the new used namespaces. */
3823 for (t
= DECL_NAMESPACE_USERS (user
); t
; t
= TREE_CHAIN (t
))
3824 add_using_namespace_1 (TREE_PURPOSE (t
), used
, 1);
3827 /* Wrapper for add_using_namespace_1. */
3830 add_using_namespace (tree user
, tree used
, bool indirect
)
3832 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
3833 add_using_namespace_1 (user
, used
, indirect
);
3834 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
3837 /* Process a using-declaration not appearing in class or local scope. */
3840 do_toplevel_using_decl (tree decl
, tree scope
, tree name
)
3842 tree oldval
, oldtype
, newval
, newtype
;
3843 tree orig_decl
= decl
;
3844 cxx_binding
*binding
;
3846 decl
= validate_nonmember_using_decl (decl
, scope
, name
);
3847 if (decl
== NULL_TREE
)
3850 binding
= binding_for_name (NAMESPACE_LEVEL (current_namespace
), name
);
3852 oldval
= binding
->value
;
3853 oldtype
= binding
->type
;
3855 do_nonmember_using_decl (scope
, name
, oldval
, oldtype
, &newval
, &newtype
);
3857 /* Emit debug info. */
3858 if (!processing_template_decl
)
3859 cp_emit_debug_info_for_using (orig_decl
, current_namespace
);
3861 /* Copy declarations found. */
3863 binding
->value
= newval
;
3865 binding
->type
= newtype
;
3868 /* Process a using-directive. */
3871 do_using_directive (tree name_space
)
3873 tree context
= NULL_TREE
;
3875 if (name_space
== error_mark_node
)
3878 gcc_assert (TREE_CODE (name_space
) == NAMESPACE_DECL
);
3880 if (building_stmt_list_p ())
3881 add_stmt (build_stmt (input_location
, USING_STMT
, name_space
));
3882 name_space
= ORIGINAL_NAMESPACE (name_space
);
3884 if (!toplevel_bindings_p ())
3886 push_using_directive (name_space
);
3891 add_using_namespace (current_namespace
, name_space
, 0);
3892 if (current_namespace
!= global_namespace
)
3893 context
= current_namespace
;
3895 /* Emit debugging info. */
3896 if (!processing_template_decl
)
3897 (*debug_hooks
->imported_module_or_decl
) (name_space
, NULL_TREE
,
3902 /* Deal with a using-directive seen by the parser. Currently we only
3903 handle attributes here, since they cannot appear inside a template. */
3906 parse_using_directive (tree name_space
, tree attribs
)
3910 do_using_directive (name_space
);
3912 for (a
= attribs
; a
; a
= TREE_CHAIN (a
))
3914 tree name
= TREE_PURPOSE (a
);
3915 if (is_attribute_p ("strong", name
))
3917 if (!toplevel_bindings_p ())
3918 error ("strong using only meaningful at namespace scope");
3919 else if (name_space
!= error_mark_node
)
3921 if (!is_ancestor (current_namespace
, name_space
))
3922 error ("current namespace %qD does not enclose strongly used namespace %qD",
3923 current_namespace
, name_space
);
3924 DECL_NAMESPACE_ASSOCIATIONS (name_space
)
3925 = tree_cons (current_namespace
, 0,
3926 DECL_NAMESPACE_ASSOCIATIONS (name_space
));
3930 warning (OPT_Wattributes
, "%qD attribute directive ignored", name
);
3934 /* Like pushdecl, only it places X in the global scope if appropriate.
3935 Calls cp_finish_decl to register the variable, initializing it with
3936 *INIT, if INIT is non-NULL. */
3939 pushdecl_top_level_1 (tree x
, tree
*init
, bool is_friend
)
3941 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
3942 push_to_top_level ();
3943 x
= pushdecl_namespace_level (x
, is_friend
);
3945 cp_finish_decl (x
, *init
, false, NULL_TREE
, 0);
3946 pop_from_top_level ();
3947 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
3951 /* Like pushdecl, only it places X in the global scope if appropriate. */
3954 pushdecl_top_level (tree x
)
3956 return pushdecl_top_level_1 (x
, NULL
, false);
3959 /* Like pushdecl_top_level, but adding the IS_FRIEND parameter. */
3962 pushdecl_top_level_maybe_friend (tree x
, bool is_friend
)
3964 return pushdecl_top_level_1 (x
, NULL
, is_friend
);
3967 /* Like pushdecl, only it places X in the global scope if
3968 appropriate. Calls cp_finish_decl to register the variable,
3969 initializing it with INIT. */
3972 pushdecl_top_level_and_finish (tree x
, tree init
)
3974 return pushdecl_top_level_1 (x
, &init
, false);
3977 /* Combines two sets of overloaded functions into an OVERLOAD chain, removing
3978 duplicates. The first list becomes the tail of the result.
3980 The algorithm is O(n^2). We could get this down to O(n log n) by
3981 doing a sort on the addresses of the functions, if that becomes
3985 merge_functions (tree s1
, tree s2
)
3987 for (; s2
; s2
= OVL_NEXT (s2
))
3989 tree fn2
= OVL_CURRENT (s2
);
3992 for (fns1
= s1
; fns1
; fns1
= OVL_NEXT (fns1
))
3994 tree fn1
= OVL_CURRENT (fns1
);
3996 /* If the function from S2 is already in S1, there is no
3997 need to add it again. For `extern "C"' functions, we
3998 might have two FUNCTION_DECLs for the same function, in
3999 different namespaces, but let's leave them in in case
4000 they have different default arguments. */
4005 /* If we exhausted all of the functions in S1, FN2 is new. */
4007 s1
= build_overload (fn2
, s1
);
4012 /* Returns TRUE iff OLD and NEW are the same entity.
4014 3 [basic]/3: An entity is a value, object, reference, function,
4015 enumerator, type, class member, template, template specialization,
4016 namespace, parameter pack, or this.
4018 7.3.4 [namespace.udir]/4: If name lookup finds a declaration for a name
4019 in two different namespaces, and the declarations do not declare the
4020 same entity and do not declare functions, the use of the name is
4024 same_entity_p (tree one
, tree two
)
4030 if (TREE_CODE (one
) == TYPE_DECL
4031 && TREE_CODE (two
) == TYPE_DECL
4032 && same_type_p (TREE_TYPE (one
), TREE_TYPE (two
)))
4037 /* This should return an error not all definitions define functions.
4038 It is not an error if we find two functions with exactly the
4039 same signature, only if these are selected in overload resolution.
4040 old is the current set of bindings, new_binding the freshly-found binding.
4041 XXX Do we want to give *all* candidates in case of ambiguity?
4042 XXX In what way should I treat extern declarations?
4043 XXX I don't want to repeat the entire duplicate_decls here */
4046 ambiguous_decl (struct scope_binding
*old
, cxx_binding
*new_binding
, int flags
)
4049 gcc_assert (old
!= NULL
);
4051 /* Copy the type. */
4052 type
= new_binding
->type
;
4053 if (LOOKUP_NAMESPACES_ONLY (flags
)
4054 || (type
&& hidden_name_p (type
) && !(flags
& LOOKUP_HIDDEN
)))
4057 /* Copy the value. */
4058 val
= new_binding
->value
;
4061 if (hidden_name_p (val
) && !(flags
& LOOKUP_HIDDEN
))
4064 switch (TREE_CODE (val
))
4067 /* If we expect types or namespaces, and not templates,
4068 or this is not a template class. */
4069 if ((LOOKUP_QUALIFIERS_ONLY (flags
)
4070 && !DECL_TYPE_TEMPLATE_P (val
)))
4074 if (LOOKUP_NAMESPACES_ONLY (flags
)
4075 || (type
&& (flags
& LOOKUP_PREFER_TYPES
)))
4078 case NAMESPACE_DECL
:
4079 if (LOOKUP_TYPES_ONLY (flags
))
4083 /* Ignore built-in functions that are still anticipated. */
4084 if (LOOKUP_QUALIFIERS_ONLY (flags
))
4088 if (LOOKUP_QUALIFIERS_ONLY (flags
))
4093 /* If val is hidden, shift down any class or enumeration name. */
4102 else if (val
&& !same_entity_p (val
, old
->value
))
4104 if (is_overloaded_fn (old
->value
) && is_overloaded_fn (val
))
4105 old
->value
= merge_functions (old
->value
, val
);
4108 old
->value
= tree_cons (NULL_TREE
, old
->value
,
4109 build_tree_list (NULL_TREE
, val
));
4110 TREE_TYPE (old
->value
) = error_mark_node
;
4116 else if (type
&& old
->type
!= type
)
4118 old
->type
= tree_cons (NULL_TREE
, old
->type
,
4119 build_tree_list (NULL_TREE
, type
));
4120 TREE_TYPE (old
->type
) = error_mark_node
;
4124 /* Return the declarations that are members of the namespace NS. */
4127 cp_namespace_decls (tree ns
)
4129 return NAMESPACE_LEVEL (ns
)->names
;
4132 /* Combine prefer_type and namespaces_only into flags. */
4135 lookup_flags (int prefer_type
, int namespaces_only
)
4137 if (namespaces_only
)
4138 return LOOKUP_PREFER_NAMESPACES
;
4139 if (prefer_type
> 1)
4140 return LOOKUP_PREFER_TYPES
;
4141 if (prefer_type
> 0)
4142 return LOOKUP_PREFER_BOTH
;
4146 /* Given a lookup that returned VAL, use FLAGS to decide if we want to
4147 ignore it or not. Subroutine of lookup_name_real and
4148 lookup_type_scope. */
4151 qualify_lookup (tree val
, int flags
)
4153 if (val
== NULL_TREE
)
4155 if ((flags
& LOOKUP_PREFER_NAMESPACES
) && TREE_CODE (val
) == NAMESPACE_DECL
)
4157 if (flags
& LOOKUP_PREFER_TYPES
)
4159 tree target_val
= strip_using_decl (val
);
4160 if (TREE_CODE (target_val
) == TYPE_DECL
4161 || TREE_CODE (target_val
) == TEMPLATE_DECL
)
4164 if (flags
& (LOOKUP_PREFER_NAMESPACES
| LOOKUP_PREFER_TYPES
))
4166 /* Look through lambda things that we shouldn't be able to see. */
4167 if (is_lambda_ignored_entity (val
))
4172 /* Given a lookup that returned VAL, decide if we want to ignore it or
4173 not based on DECL_ANTICIPATED. */
4176 hidden_name_p (tree val
)
4179 && DECL_LANG_SPECIFIC (val
)
4180 && DECL_ANTICIPATED (val
))
4185 /* Remove any hidden friend functions from a possibly overloaded set
4189 remove_hidden_names (tree fns
)
4194 if (TREE_CODE (fns
) == FUNCTION_DECL
&& hidden_name_p (fns
))
4196 else if (TREE_CODE (fns
) == OVERLOAD
)
4200 for (o
= fns
; o
; o
= OVL_NEXT (o
))
4201 if (hidden_name_p (OVL_CURRENT (o
)))
4207 for (o
= fns
; o
; o
= OVL_NEXT (o
))
4208 if (!hidden_name_p (OVL_CURRENT (o
)))
4209 n
= build_overload (OVL_CURRENT (o
), n
);
4217 /* Suggest alternatives for NAME, an IDENTIFIER_NODE for which name
4218 lookup failed. Search through all available namespaces and print out
4219 possible candidates. */
4222 suggest_alternatives_for (location_t location
, tree name
)
4224 VEC(tree
,heap
) *candidates
= NULL
;
4225 VEC(tree
,heap
) *namespaces_to_search
= NULL
;
4226 int max_to_search
= PARAM_VALUE (CXX_MAX_NAMESPACES_FOR_DIAGNOSTIC_HELP
);
4231 VEC_safe_push (tree
, heap
, namespaces_to_search
, global_namespace
);
4233 while (!VEC_empty (tree
, namespaces_to_search
)
4234 && n_searched
< max_to_search
)
4236 tree scope
= VEC_pop (tree
, namespaces_to_search
);
4237 struct scope_binding binding
= EMPTY_SCOPE_BINDING
;
4238 cp_binding_level
*level
= NAMESPACE_LEVEL (scope
);
4240 /* Look in this namespace. */
4241 qualified_lookup_using_namespace (name
, scope
, &binding
, 0);
4246 VEC_safe_push (tree
, heap
, candidates
, binding
.value
);
4248 /* Add child namespaces. */
4249 for (t
= level
->namespaces
; t
; t
= DECL_CHAIN (t
))
4250 VEC_safe_push (tree
, heap
, namespaces_to_search
, t
);
4253 /* If we stopped before we could examine all namespaces, inform the
4254 user. Do this even if we don't have any candidates, since there
4255 might be more candidates further down that we weren't able to
4257 if (n_searched
>= max_to_search
4258 && !VEC_empty (tree
, namespaces_to_search
))
4260 "maximum limit of %d namespaces searched for %qE",
4261 max_to_search
, name
);
4263 VEC_free (tree
, heap
, namespaces_to_search
);
4265 /* Nothing useful to report. */
4266 if (VEC_empty (tree
, candidates
))
4269 inform_n (location
, VEC_length (tree
, candidates
),
4270 "suggested alternative:",
4271 "suggested alternatives:");
4273 FOR_EACH_VEC_ELT (tree
, candidates
, ix
, t
)
4274 inform (location_of (t
), " %qE", t
);
4276 VEC_free (tree
, heap
, candidates
);
4279 /* Unscoped lookup of a global: iterate over current namespaces,
4280 considering using-directives. */
4283 unqualified_namespace_lookup_1 (tree name
, int flags
)
4285 tree initial
= current_decl_namespace ();
4286 tree scope
= initial
;
4288 cp_binding_level
*level
;
4289 tree val
= NULL_TREE
;
4291 for (; !val
; scope
= CP_DECL_CONTEXT (scope
))
4293 struct scope_binding binding
= EMPTY_SCOPE_BINDING
;
4295 cp_binding_level_find_binding_for_name (NAMESPACE_LEVEL (scope
), name
);
4298 ambiguous_decl (&binding
, b
, flags
);
4300 /* Add all _DECLs seen through local using-directives. */
4301 for (level
= current_binding_level
;
4302 level
->kind
!= sk_namespace
;
4303 level
= level
->level_chain
)
4304 if (!lookup_using_namespace (name
, &binding
, level
->using_directives
,
4306 /* Give up because of error. */
4307 return error_mark_node
;
4309 /* Add all _DECLs seen through global using-directives. */
4310 /* XXX local and global using lists should work equally. */
4314 if (!lookup_using_namespace (name
, &binding
,
4315 DECL_NAMESPACE_USING (siter
),
4317 /* Give up because of error. */
4318 return error_mark_node
;
4319 if (siter
== scope
) break;
4320 siter
= CP_DECL_CONTEXT (siter
);
4323 val
= binding
.value
;
4324 if (scope
== global_namespace
)
4330 /* Wrapper for unqualified_namespace_lookup_1. */
4333 unqualified_namespace_lookup (tree name
, int flags
)
4336 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
4337 ret
= unqualified_namespace_lookup_1 (name
, flags
);
4338 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
4342 /* Look up NAME (an IDENTIFIER_NODE) in SCOPE (either a NAMESPACE_DECL
4343 or a class TYPE). If IS_TYPE_P is TRUE, then ignore non-type
4346 Returns a DECL (or OVERLOAD, or BASELINK) representing the
4347 declaration found. If no suitable declaration can be found,
4348 ERROR_MARK_NODE is returned. If COMPLAIN is true and SCOPE is
4349 neither a class-type nor a namespace a diagnostic is issued. */
4352 lookup_qualified_name (tree scope
, tree name
, bool is_type_p
, bool complain
)
4357 if (TREE_CODE (scope
) == NAMESPACE_DECL
)
4359 struct scope_binding binding
= EMPTY_SCOPE_BINDING
;
4362 flags
|= LOOKUP_PREFER_TYPES
;
4363 if (qualified_lookup_using_namespace (name
, scope
, &binding
, flags
))
4366 else if (cxx_dialect
!= cxx98
&& TREE_CODE (scope
) == ENUMERAL_TYPE
)
4367 t
= lookup_enumerator (scope
, name
);
4368 else if (is_class_type (scope
, complain
))
4369 t
= lookup_member (scope
, name
, 2, is_type_p
, tf_warning_or_error
);
4372 return error_mark_node
;
4376 /* Subroutine of unqualified_namespace_lookup:
4377 Add the bindings of NAME in used namespaces to VAL.
4378 We are currently looking for names in namespace SCOPE, so we
4379 look through USINGS for using-directives of namespaces
4380 which have SCOPE as a common ancestor with the current scope.
4381 Returns false on errors. */
4384 lookup_using_namespace (tree name
, struct scope_binding
*val
,
4385 tree usings
, tree scope
, int flags
)
4388 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
4389 /* Iterate over all used namespaces in current, searching for using
4390 directives of scope. */
4391 for (iter
= usings
; iter
; iter
= TREE_CHAIN (iter
))
4392 if (TREE_VALUE (iter
) == scope
)
4394 tree used
= ORIGINAL_NAMESPACE (TREE_PURPOSE (iter
));
4396 cp_binding_level_find_binding_for_name (NAMESPACE_LEVEL (used
), name
);
4397 /* Resolve ambiguities. */
4399 ambiguous_decl (val
, val1
, flags
);
4401 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
4402 return val
->value
!= error_mark_node
;
4405 /* Returns true iff VEC contains TARGET. */
4408 tree_vec_contains (VEC(tree
,gc
)* vec
, tree target
)
4412 FOR_EACH_VEC_ELT (tree
,vec
,i
,elt
)
4419 Accepts the NAME to lookup and its qualifying SCOPE.
4420 Returns the name/type pair found into the cxx_binding *RESULT,
4421 or false on error. */
4424 qualified_lookup_using_namespace (tree name
, tree scope
,
4425 struct scope_binding
*result
, int flags
)
4427 /* Maintain a list of namespaces visited... */
4428 VEC(tree
,gc
) *seen
= NULL
;
4429 VEC(tree
,gc
) *seen_inline
= NULL
;
4430 /* ... and a list of namespace yet to see. */
4431 VEC(tree
,gc
) *todo
= NULL
;
4432 VEC(tree
,gc
) *todo_maybe
= NULL
;
4433 VEC(tree
,gc
) *todo_inline
= NULL
;
4435 timevar_start (TV_NAME_LOOKUP
);
4436 /* Look through namespace aliases. */
4437 scope
= ORIGINAL_NAMESPACE (scope
);
4439 /* Algorithm: Starting with SCOPE, walk through the set of used
4440 namespaces. For each used namespace, look through its inline
4441 namespace set for any bindings and usings. If no bindings are
4442 found, add any usings seen to the set of used namespaces. */
4443 VEC_safe_push (tree
, gc
, todo
, scope
);
4445 while (VEC_length (tree
, todo
))
4448 scope
= VEC_pop (tree
, todo
);
4449 if (tree_vec_contains (seen
, scope
))
4451 VEC_safe_push (tree
, gc
, seen
, scope
);
4452 VEC_safe_push (tree
, gc
, todo_inline
, scope
);
4455 while (VEC_length (tree
, todo_inline
))
4457 cxx_binding
*binding
;
4459 scope
= VEC_pop (tree
, todo_inline
);
4460 if (tree_vec_contains (seen_inline
, scope
))
4462 VEC_safe_push (tree
, gc
, seen_inline
, scope
);
4465 cp_binding_level_find_binding_for_name (NAMESPACE_LEVEL (scope
), name
);
4469 ambiguous_decl (result
, binding
, flags
);
4472 for (usings
= DECL_NAMESPACE_USING (scope
); usings
;
4473 usings
= TREE_CHAIN (usings
))
4474 if (!TREE_INDIRECT_USING (usings
))
4476 if (is_associated_namespace (scope
, TREE_PURPOSE (usings
)))
4477 VEC_safe_push (tree
, gc
, todo_inline
, TREE_PURPOSE (usings
));
4479 VEC_safe_push (tree
, gc
, todo_maybe
, TREE_PURPOSE (usings
));
4484 VEC_truncate (tree
, todo_maybe
, 0);
4486 while (VEC_length (tree
, todo_maybe
))
4487 VEC_safe_push (tree
, gc
, todo
, VEC_pop (tree
, todo_maybe
));
4489 VEC_free (tree
,gc
,todo
);
4490 VEC_free (tree
,gc
,todo_maybe
);
4491 VEC_free (tree
,gc
,todo_inline
);
4492 VEC_free (tree
,gc
,seen
);
4493 VEC_free (tree
,gc
,seen_inline
);
4494 timevar_stop (TV_NAME_LOOKUP
);
4495 return result
->value
!= error_mark_node
;
4498 /* Subroutine of outer_binding.
4500 Returns TRUE if BINDING is a binding to a template parameter of
4501 SCOPE. In that case SCOPE is the scope of a primary template
4502 parameter -- in the sense of G++, i.e, a template that has its own
4505 Returns FALSE otherwise. */
4508 binding_to_template_parms_of_scope_p (cxx_binding
*binding
,
4509 cp_binding_level
*scope
)
4511 tree binding_value
, tmpl
, tinfo
;
4514 if (!binding
|| !scope
|| !scope
->this_entity
)
4517 binding_value
= binding
->value
? binding
->value
: binding
->type
;
4518 tinfo
= get_template_info (scope
->this_entity
);
4520 /* BINDING_VALUE must be a template parm. */
4521 if (binding_value
== NULL_TREE
4522 || (!DECL_P (binding_value
)
4523 || !DECL_TEMPLATE_PARM_P (binding_value
)))
4526 /* The level of BINDING_VALUE. */
4528 template_type_parameter_p (binding_value
)
4529 ? TEMPLATE_PARM_LEVEL (TEMPLATE_TYPE_PARM_INDEX
4530 (TREE_TYPE (binding_value
)))
4531 : TEMPLATE_PARM_LEVEL (DECL_INITIAL (binding_value
));
4533 /* The template of the current scope, iff said scope is a primary
4536 && PRIMARY_TEMPLATE_P (TI_TEMPLATE (tinfo
))
4537 ? TI_TEMPLATE (tinfo
)
4540 /* If the level of the parm BINDING_VALUE equals the depth of TMPL,
4541 then BINDING_VALUE is a parameter of TMPL. */
4542 return (tmpl
&& level
== TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (tmpl
)));
4545 /* Return the innermost non-namespace binding for NAME from a scope
4546 containing BINDING, or, if BINDING is NULL, the current scope.
4547 Please note that for a given template, the template parameters are
4548 considered to be in the scope containing the current scope.
4549 If CLASS_P is false, then class bindings are ignored. */
4552 outer_binding (tree name
,
4553 cxx_binding
*binding
,
4557 cp_binding_level
*scope
;
4558 cp_binding_level
*outer_scope
;
4562 scope
= binding
->scope
->level_chain
;
4563 outer
= binding
->previous
;
4567 scope
= current_binding_level
;
4568 outer
= IDENTIFIER_BINDING (name
);
4570 outer_scope
= outer
? outer
->scope
: NULL
;
4572 /* Because we create class bindings lazily, we might be missing a
4573 class binding for NAME. If there are any class binding levels
4574 between the LAST_BINDING_LEVEL and the scope in which OUTER was
4575 declared, we must lookup NAME in those class scopes. */
4577 while (scope
&& scope
!= outer_scope
&& scope
->kind
!= sk_namespace
)
4579 if (scope
->kind
== sk_class
)
4581 cxx_binding
*class_binding
;
4583 class_binding
= get_class_binding (name
, scope
);
4586 /* Thread this new class-scope binding onto the
4587 IDENTIFIER_BINDING list so that future lookups
4589 class_binding
->previous
= outer
;
4591 binding
->previous
= class_binding
;
4593 IDENTIFIER_BINDING (name
) = class_binding
;
4594 return class_binding
;
4597 /* If we are in a member template, the template parms of the member
4598 template are considered to be inside the scope of the containing
4599 class, but within G++ the class bindings are all pushed between the
4600 template parms and the function body. So if the outer binding is
4601 a template parm for the current scope, return it now rather than
4602 look for a class binding. */
4603 if (outer_scope
&& outer_scope
->kind
== sk_template_parms
4604 && binding_to_template_parms_of_scope_p (outer
, scope
))
4607 scope
= scope
->level_chain
;
4613 /* Return the innermost block-scope or class-scope value binding for
4614 NAME, or NULL_TREE if there is no such binding. */
4617 innermost_non_namespace_value (tree name
)
4619 cxx_binding
*binding
;
4620 binding
= outer_binding (name
, /*binding=*/NULL
, /*class_p=*/true);
4621 return binding
? binding
->value
: NULL_TREE
;
4624 /* Look up NAME in the current binding level and its superiors in the
4625 namespace of variables, functions and typedefs. Return a ..._DECL
4626 node of some kind representing its definition if there is only one
4627 such declaration, or return a TREE_LIST with all the overloaded
4628 definitions if there are many, or return 0 if it is undefined.
4629 Hidden name, either friend declaration or built-in function, are
4632 If PREFER_TYPE is > 0, we prefer TYPE_DECLs or namespaces.
4633 If PREFER_TYPE is > 1, we reject non-type decls (e.g. namespaces).
4634 Otherwise we prefer non-TYPE_DECLs.
4636 If NONCLASS is nonzero, bindings in class scopes are ignored. If
4637 BLOCK_P is false, bindings in block scopes are ignored. */
4640 lookup_name_real_1 (tree name
, int prefer_type
, int nonclass
, bool block_p
,
4641 int namespaces_only
, int flags
)
4644 tree val
= NULL_TREE
;
4646 /* Conversion operators are handled specially because ordinary
4647 unqualified name lookup will not find template conversion
4649 if (IDENTIFIER_TYPENAME_P (name
))
4651 cp_binding_level
*level
;
4653 for (level
= current_binding_level
;
4654 level
&& level
->kind
!= sk_namespace
;
4655 level
= level
->level_chain
)
4660 /* A conversion operator can only be declared in a class
4662 if (level
->kind
!= sk_class
)
4665 /* Lookup the conversion operator in the class. */
4666 class_type
= level
->this_entity
;
4667 operators
= lookup_fnfields (class_type
, name
, /*protect=*/0);
4675 flags
|= lookup_flags (prefer_type
, namespaces_only
);
4677 /* First, look in non-namespace scopes. */
4679 if (current_class_type
== NULL_TREE
)
4682 if (block_p
|| !nonclass
)
4683 for (iter
= outer_binding (name
, NULL
, !nonclass
);
4685 iter
= outer_binding (name
, iter
, !nonclass
))
4689 /* Skip entities we don't want. */
4690 if (LOCAL_BINDING_P (iter
) ? !block_p
: nonclass
)
4693 /* If this is the kind of thing we're looking for, we're done. */
4694 if (qualify_lookup (iter
->value
, flags
))
4695 binding
= iter
->value
;
4696 else if ((flags
& LOOKUP_PREFER_TYPES
)
4697 && qualify_lookup (iter
->type
, flags
))
4698 binding
= iter
->type
;
4700 binding
= NULL_TREE
;
4704 if (hidden_name_p (binding
))
4706 /* A non namespace-scope binding can only be hidden in the
4707 presence of a local class, due to friend declarations.
4709 In particular, consider:
4717 B* b; // error: B is hidden
4718 C* c; // OK, finds ::C
4721 B *b; // error: B is hidden
4722 C *c; // OK, finds ::C
4727 The standard says that "B" is a local class in "f"
4728 (but not nested within "A") -- but that name lookup
4729 for "B" does not find this declaration until it is
4730 declared directly with "f".
4736 If a friend declaration appears in a local class and
4737 the name specified is an unqualified name, a prior
4738 declaration is looked up without considering scopes
4739 that are outside the innermost enclosing non-class
4740 scope. For a friend function declaration, if there is
4741 no prior declaration, the program is ill-formed. For a
4742 friend class declaration, if there is no prior
4743 declaration, the class that is specified belongs to the
4744 innermost enclosing non-class scope, but if it is
4745 subsequently referenced, its name is not found by name
4746 lookup until a matching declaration is provided in the
4747 innermost enclosing nonclass scope.
4749 So just keep looking for a non-hidden binding.
4751 gcc_assert (TREE_CODE (binding
) == TYPE_DECL
);
4759 /* Now lookup in namespace scopes. */
4761 val
= unqualified_namespace_lookup (name
, flags
);
4763 /* If we have a single function from a using decl, pull it out. */
4764 if (val
&& TREE_CODE (val
) == OVERLOAD
&& !really_overloaded_fn (val
))
4765 val
= OVL_FUNCTION (val
);
4770 /* Wrapper for lookup_name_real_1. */
4773 lookup_name_real (tree name
, int prefer_type
, int nonclass
, bool block_p
,
4774 int namespaces_only
, int flags
)
4777 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
4778 ret
= lookup_name_real_1 (name
, prefer_type
, nonclass
, block_p
,
4779 namespaces_only
, flags
);
4780 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
4785 lookup_name_nonclass (tree name
)
4787 return lookup_name_real (name
, 0, 1, /*block_p=*/true, 0, 0);
4791 lookup_function_nonclass (tree name
, VEC(tree
,gc
) *args
, bool block_p
)
4794 lookup_arg_dependent (name
,
4795 lookup_name_real (name
, 0, 1, block_p
, 0, 0),
4800 lookup_name (tree name
)
4802 return lookup_name_real (name
, 0, 0, /*block_p=*/true, 0, 0);
4806 lookup_name_prefer_type (tree name
, int prefer_type
)
4808 return lookup_name_real (name
, prefer_type
, 0, /*block_p=*/true, 0, 0);
4811 /* Look up NAME for type used in elaborated name specifier in
4812 the scopes given by SCOPE. SCOPE can be either TS_CURRENT or
4813 TS_WITHIN_ENCLOSING_NON_CLASS. Although not implied by the
4814 name, more scopes are checked if cleanup or template parameter
4815 scope is encountered.
4817 Unlike lookup_name_real, we make sure that NAME is actually
4818 declared in the desired scope, not from inheritance, nor using
4819 directive. For using declaration, there is DR138 still waiting
4820 to be resolved. Hidden name coming from an earlier friend
4821 declaration is also returned.
4823 A TYPE_DECL best matching the NAME is returned. Catching error
4824 and issuing diagnostics are caller's responsibility. */
4827 lookup_type_scope_1 (tree name
, tag_scope scope
)
4829 cxx_binding
*iter
= NULL
;
4830 tree val
= NULL_TREE
;
4832 /* Look in non-namespace scope first. */
4833 if (current_binding_level
->kind
!= sk_namespace
)
4834 iter
= outer_binding (name
, NULL
, /*class_p=*/ true);
4835 for (; iter
; iter
= outer_binding (name
, iter
, /*class_p=*/ true))
4837 /* Check if this is the kind of thing we're looking for.
4838 If SCOPE is TS_CURRENT, also make sure it doesn't come from
4839 base class. For ITER->VALUE, we can simply use
4840 INHERITED_VALUE_BINDING_P. For ITER->TYPE, we have to use
4843 We check ITER->TYPE before ITER->VALUE in order to handle
4844 typedef struct C {} C;
4847 if (qualify_lookup (iter
->type
, LOOKUP_PREFER_TYPES
)
4848 && (scope
!= ts_current
4849 || LOCAL_BINDING_P (iter
)
4850 || DECL_CONTEXT (iter
->type
) == iter
->scope
->this_entity
))
4852 else if ((scope
!= ts_current
4853 || !INHERITED_VALUE_BINDING_P (iter
))
4854 && qualify_lookup (iter
->value
, LOOKUP_PREFER_TYPES
))
4861 /* Look in namespace scope. */
4864 iter
= cp_binding_level_find_binding_for_name
4865 (NAMESPACE_LEVEL (current_decl_namespace ()), name
);
4869 /* If this is the kind of thing we're looking for, we're done. */
4870 if (qualify_lookup (iter
->type
, LOOKUP_PREFER_TYPES
))
4872 else if (qualify_lookup (iter
->value
, LOOKUP_PREFER_TYPES
))
4878 /* Type found, check if it is in the allowed scopes, ignoring cleanup
4879 and template parameter scopes. */
4882 cp_binding_level
*b
= current_binding_level
;
4885 if (iter
->scope
== b
)
4888 if (b
->kind
== sk_cleanup
|| b
->kind
== sk_template_parms
4889 || b
->kind
== sk_function_parms
)
4891 else if (b
->kind
== sk_class
4892 && scope
== ts_within_enclosing_non_class
)
4902 /* Wrapper for lookup_type_scope_1. */
4905 lookup_type_scope (tree name
, tag_scope scope
)
4908 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
4909 ret
= lookup_type_scope_1 (name
, scope
);
4910 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
4915 /* Similar to `lookup_name' but look only in the innermost non-class
4919 lookup_name_innermost_nonclass_level_1 (tree name
)
4921 cp_binding_level
*b
;
4924 b
= innermost_nonclass_level ();
4926 if (b
->kind
== sk_namespace
)
4928 t
= IDENTIFIER_NAMESPACE_VALUE (name
);
4930 /* extern "C" function() */
4931 if (t
!= NULL_TREE
&& TREE_CODE (t
) == TREE_LIST
)
4934 else if (IDENTIFIER_BINDING (name
)
4935 && LOCAL_BINDING_P (IDENTIFIER_BINDING (name
)))
4937 cxx_binding
*binding
;
4938 binding
= IDENTIFIER_BINDING (name
);
4941 if (binding
->scope
== b
4942 && !(TREE_CODE (binding
->value
) == VAR_DECL
4943 && DECL_DEAD_FOR_LOCAL (binding
->value
)))
4944 return binding
->value
;
4946 if (b
->kind
== sk_cleanup
)
4956 /* Wrapper for lookup_name_innermost_nonclass_level_1. */
4959 lookup_name_innermost_nonclass_level (tree name
)
4962 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
4963 ret
= lookup_name_innermost_nonclass_level_1 (name
);
4964 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
4969 /* Returns true iff DECL is a block-scope extern declaration of a function
4973 is_local_extern (tree decl
)
4975 cxx_binding
*binding
;
4977 /* For functions, this is easy. */
4978 if (TREE_CODE (decl
) == FUNCTION_DECL
)
4979 return DECL_LOCAL_FUNCTION_P (decl
);
4981 if (TREE_CODE (decl
) != VAR_DECL
)
4983 if (!current_function_decl
)
4986 /* For variables, this is not easy. We need to look at the binding stack
4987 for the identifier to see whether the decl we have is a local. */
4988 for (binding
= IDENTIFIER_BINDING (DECL_NAME (decl
));
4989 binding
&& binding
->scope
->kind
!= sk_namespace
;
4990 binding
= binding
->previous
)
4991 if (binding
->value
== decl
)
4992 return LOCAL_BINDING_P (binding
);
4997 /* Like lookup_name_innermost_nonclass_level, but for types. */
5000 lookup_type_current_level (tree name
)
5004 timevar_start (TV_NAME_LOOKUP
);
5005 gcc_assert (current_binding_level
->kind
!= sk_namespace
);
5007 if (REAL_IDENTIFIER_TYPE_VALUE (name
) != NULL_TREE
5008 && REAL_IDENTIFIER_TYPE_VALUE (name
) != global_type_node
)
5010 cp_binding_level
*b
= current_binding_level
;
5013 if (purpose_member (name
, b
->type_shadowed
))
5015 t
= REAL_IDENTIFIER_TYPE_VALUE (name
);
5018 if (b
->kind
== sk_cleanup
)
5025 timevar_stop (TV_NAME_LOOKUP
);
5029 /* [basic.lookup.koenig] */
5030 /* A nonzero return value in the functions below indicates an error. */
5036 VEC(tree
,gc
) *namespaces
;
5037 VEC(tree
,gc
) *classes
;
5039 struct pointer_set_t
*fn_set
;
5042 static bool arg_assoc (struct arg_lookup
*, tree
);
5043 static bool arg_assoc_args (struct arg_lookup
*, tree
);
5044 static bool arg_assoc_args_vec (struct arg_lookup
*, VEC(tree
,gc
) *);
5045 static bool arg_assoc_type (struct arg_lookup
*, tree
);
5046 static bool add_function (struct arg_lookup
*, tree
);
5047 static bool arg_assoc_namespace (struct arg_lookup
*, tree
);
5048 static bool arg_assoc_class_only (struct arg_lookup
*, tree
);
5049 static bool arg_assoc_bases (struct arg_lookup
*, tree
);
5050 static bool arg_assoc_class (struct arg_lookup
*, tree
);
5051 static bool arg_assoc_template_arg (struct arg_lookup
*, tree
);
5053 /* Add a function to the lookup structure.
5054 Returns true on error. */
5057 add_function (struct arg_lookup
*k
, tree fn
)
5059 if (!is_overloaded_fn (fn
))
5060 /* All names except those of (possibly overloaded) functions and
5061 function templates are ignored. */;
5062 else if (k
->fn_set
&& pointer_set_insert (k
->fn_set
, fn
))
5063 /* It's already in the list. */;
5064 else if (!k
->functions
)
5066 else if (fn
== k
->functions
)
5070 k
->functions
= build_overload (fn
, k
->functions
);
5071 if (TREE_CODE (k
->functions
) == OVERLOAD
)
5072 OVL_ARG_DEPENDENT (k
->functions
) = true;
5078 /* Returns true iff CURRENT has declared itself to be an associated
5079 namespace of SCOPE via a strong using-directive (or transitive chain
5080 thereof). Both are namespaces. */
5083 is_associated_namespace (tree current
, tree scope
)
5085 VEC(tree
,gc
) *seen
= make_tree_vector ();
5086 VEC(tree
,gc
) *todo
= make_tree_vector ();
5092 if (scope
== current
)
5097 VEC_safe_push (tree
, gc
, seen
, scope
);
5098 for (t
= DECL_NAMESPACE_ASSOCIATIONS (scope
); t
; t
= TREE_CHAIN (t
))
5099 if (!vec_member (TREE_PURPOSE (t
), seen
))
5100 VEC_safe_push (tree
, gc
, todo
, TREE_PURPOSE (t
));
5101 if (!VEC_empty (tree
, todo
))
5103 scope
= VEC_last (tree
, todo
);
5104 VEC_pop (tree
, todo
);
5113 release_tree_vector (seen
);
5114 release_tree_vector (todo
);
5119 /* Add functions of a namespace to the lookup structure.
5120 Returns true on error. */
5123 arg_assoc_namespace (struct arg_lookup
*k
, tree scope
)
5127 if (vec_member (scope
, k
->namespaces
))
5129 VEC_safe_push (tree
, gc
, k
->namespaces
, scope
);
5131 /* Check out our super-users. */
5132 for (value
= DECL_NAMESPACE_ASSOCIATIONS (scope
); value
;
5133 value
= TREE_CHAIN (value
))
5134 if (arg_assoc_namespace (k
, TREE_PURPOSE (value
)))
5137 /* Also look down into inline namespaces. */
5138 for (value
= DECL_NAMESPACE_USING (scope
); value
;
5139 value
= TREE_CHAIN (value
))
5140 if (is_associated_namespace (scope
, TREE_PURPOSE (value
)))
5141 if (arg_assoc_namespace (k
, TREE_PURPOSE (value
)))
5144 value
= namespace_binding (k
->name
, scope
);
5148 for (; value
; value
= OVL_NEXT (value
))
5150 /* We don't want to find arbitrary hidden functions via argument
5151 dependent lookup. We only want to find friends of associated
5152 classes, which we'll do via arg_assoc_class. */
5153 if (hidden_name_p (OVL_CURRENT (value
)))
5156 if (add_function (k
, OVL_CURRENT (value
)))
5163 /* Adds everything associated with a template argument to the lookup
5164 structure. Returns true on error. */
5167 arg_assoc_template_arg (struct arg_lookup
*k
, tree arg
)
5169 /* [basic.lookup.koenig]
5171 If T is a template-id, its associated namespaces and classes are
5172 ... the namespaces and classes associated with the types of the
5173 template arguments provided for template type parameters
5174 (excluding template template parameters); the namespaces in which
5175 any template template arguments are defined; and the classes in
5176 which any member templates used as template template arguments
5177 are defined. [Note: non-type template arguments do not
5178 contribute to the set of associated namespaces. ] */
5180 /* Consider first template template arguments. */
5181 if (TREE_CODE (arg
) == TEMPLATE_TEMPLATE_PARM
5182 || TREE_CODE (arg
) == UNBOUND_CLASS_TEMPLATE
)
5184 else if (TREE_CODE (arg
) == TEMPLATE_DECL
)
5186 tree ctx
= CP_DECL_CONTEXT (arg
);
5188 /* It's not a member template. */
5189 if (TREE_CODE (ctx
) == NAMESPACE_DECL
)
5190 return arg_assoc_namespace (k
, ctx
);
5191 /* Otherwise, it must be member template. */
5193 return arg_assoc_class_only (k
, ctx
);
5195 /* It's an argument pack; handle it recursively. */
5196 else if (ARGUMENT_PACK_P (arg
))
5198 tree args
= ARGUMENT_PACK_ARGS (arg
);
5199 int i
, len
= TREE_VEC_LENGTH (args
);
5200 for (i
= 0; i
< len
; ++i
)
5201 if (arg_assoc_template_arg (k
, TREE_VEC_ELT (args
, i
)))
5206 /* It's not a template template argument, but it is a type template
5208 else if (TYPE_P (arg
))
5209 return arg_assoc_type (k
, arg
);
5210 /* It's a non-type template argument. */
5215 /* Adds the class and its friends to the lookup structure.
5216 Returns true on error. */
5219 arg_assoc_class_only (struct arg_lookup
*k
, tree type
)
5221 tree list
, friends
, context
;
5223 /* Backend-built structures, such as __builtin_va_list, aren't
5224 affected by all this. */
5225 if (!CLASS_TYPE_P (type
))
5228 context
= decl_namespace_context (type
);
5229 if (arg_assoc_namespace (k
, context
))
5232 complete_type (type
);
5234 /* Process friends. */
5235 for (list
= DECL_FRIENDLIST (TYPE_MAIN_DECL (type
)); list
;
5236 list
= TREE_CHAIN (list
))
5237 if (k
->name
== FRIEND_NAME (list
))
5238 for (friends
= FRIEND_DECLS (list
); friends
;
5239 friends
= TREE_CHAIN (friends
))
5241 tree fn
= TREE_VALUE (friends
);
5243 /* Only interested in global functions with potentially hidden
5244 (i.e. unqualified) declarations. */
5245 if (CP_DECL_CONTEXT (fn
) != context
)
5247 /* Template specializations are never found by name lookup.
5248 (Templates themselves can be found, but not template
5249 specializations.) */
5250 if (TREE_CODE (fn
) == FUNCTION_DECL
&& DECL_USE_TEMPLATE (fn
))
5252 if (add_function (k
, fn
))
5259 /* Adds the class and its bases to the lookup structure.
5260 Returns true on error. */
5263 arg_assoc_bases (struct arg_lookup
*k
, tree type
)
5265 if (arg_assoc_class_only (k
, type
))
5268 if (TYPE_BINFO (type
))
5270 /* Process baseclasses. */
5271 tree binfo
, base_binfo
;
5274 for (binfo
= TYPE_BINFO (type
), i
= 0;
5275 BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); i
++)
5276 if (arg_assoc_bases (k
, BINFO_TYPE (base_binfo
)))
5283 /* Adds everything associated with a class argument type to the lookup
5284 structure. Returns true on error.
5286 If T is a class type (including unions), its associated classes are: the
5287 class itself; the class of which it is a member, if any; and its direct
5288 and indirect base classes. Its associated namespaces are the namespaces
5289 of which its associated classes are members. Furthermore, if T is a
5290 class template specialization, its associated namespaces and classes
5291 also include: the namespaces and classes associated with the types of
5292 the template arguments provided for template type parameters (excluding
5293 template template parameters); the namespaces of which any template
5294 template arguments are members; and the classes of which any member
5295 templates used as template template arguments are members. [ Note:
5296 non-type template arguments do not contribute to the set of associated
5297 namespaces. --end note] */
5300 arg_assoc_class (struct arg_lookup
*k
, tree type
)
5305 /* Backend build structures, such as __builtin_va_list, aren't
5306 affected by all this. */
5307 if (!CLASS_TYPE_P (type
))
5310 if (vec_member (type
, k
->classes
))
5312 VEC_safe_push (tree
, gc
, k
->classes
, type
);
5314 if (TYPE_CLASS_SCOPE_P (type
)
5315 && arg_assoc_class_only (k
, TYPE_CONTEXT (type
)))
5318 if (arg_assoc_bases (k
, type
))
5321 /* Process template arguments. */
5322 if (CLASSTYPE_TEMPLATE_INFO (type
)
5323 && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (type
)))
5325 list
= INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (type
));
5326 for (i
= 0; i
< TREE_VEC_LENGTH (list
); ++i
)
5327 if (arg_assoc_template_arg (k
, TREE_VEC_ELT (list
, i
)))
5334 /* Adds everything associated with a given type.
5335 Returns 1 on error. */
5338 arg_assoc_type (struct arg_lookup
*k
, tree type
)
5340 /* As we do not get the type of non-type dependent expressions
5341 right, we can end up with such things without a type. */
5345 if (TYPE_PTRDATAMEM_P (type
))
5347 /* Pointer to member: associate class type and value type. */
5348 if (arg_assoc_type (k
, TYPE_PTRMEM_CLASS_TYPE (type
)))
5350 return arg_assoc_type (k
, TYPE_PTRMEM_POINTED_TO_TYPE (type
));
5352 else switch (TREE_CODE (type
))
5362 case FIXED_POINT_TYPE
:
5367 if (TYPE_PTRMEMFUNC_P (type
))
5368 return arg_assoc_type (k
, TYPE_PTRMEMFUNC_FN_TYPE (type
));
5370 return arg_assoc_class (k
, type
);
5372 case REFERENCE_TYPE
:
5374 return arg_assoc_type (k
, TREE_TYPE (type
));
5376 if (TYPE_CLASS_SCOPE_P (type
)
5377 && arg_assoc_class_only (k
, TYPE_CONTEXT (type
)))
5379 return arg_assoc_namespace (k
, decl_namespace_context (type
));
5381 /* The basetype is referenced in the first arg type, so just
5384 /* Associate the parameter types. */
5385 if (arg_assoc_args (k
, TYPE_ARG_TYPES (type
)))
5387 /* Associate the return type. */
5388 return arg_assoc_type (k
, TREE_TYPE (type
));
5389 case TEMPLATE_TYPE_PARM
:
5390 case BOUND_TEMPLATE_TEMPLATE_PARM
:
5395 gcc_assert (type
== unknown_type_node
5396 || type
== init_list_type_node
);
5398 case TYPE_PACK_EXPANSION
:
5399 return arg_assoc_type (k
, PACK_EXPANSION_PATTERN (type
));
5407 /* Adds everything associated with arguments. Returns true on error. */
5410 arg_assoc_args (struct arg_lookup
*k
, tree args
)
5412 for (; args
; args
= TREE_CHAIN (args
))
5413 if (arg_assoc (k
, TREE_VALUE (args
)))
5418 /* Adds everything associated with an argument vector. Returns true
5422 arg_assoc_args_vec (struct arg_lookup
*k
, VEC(tree
,gc
) *args
)
5427 FOR_EACH_VEC_ELT (tree
, args
, ix
, arg
)
5428 if (arg_assoc (k
, arg
))
5433 /* Adds everything associated with a given tree_node. Returns 1 on error. */
5436 arg_assoc (struct arg_lookup
*k
, tree n
)
5438 if (n
== error_mark_node
)
5442 return arg_assoc_type (k
, n
);
5444 if (! type_unknown_p (n
))
5445 return arg_assoc_type (k
, TREE_TYPE (n
));
5447 if (TREE_CODE (n
) == ADDR_EXPR
)
5448 n
= TREE_OPERAND (n
, 0);
5449 if (TREE_CODE (n
) == COMPONENT_REF
)
5450 n
= TREE_OPERAND (n
, 1);
5451 if (TREE_CODE (n
) == OFFSET_REF
)
5452 n
= TREE_OPERAND (n
, 1);
5453 while (TREE_CODE (n
) == TREE_LIST
)
5456 n
= BASELINK_FUNCTIONS (n
);
5458 if (TREE_CODE (n
) == FUNCTION_DECL
)
5459 return arg_assoc_type (k
, TREE_TYPE (n
));
5460 if (TREE_CODE (n
) == TEMPLATE_ID_EXPR
)
5462 /* The working paper doesn't currently say how to handle template-id
5463 arguments. The sensible thing would seem to be to handle the list
5464 of template candidates like a normal overload set, and handle the
5465 template arguments like we do for class template
5467 tree templ
= TREE_OPERAND (n
, 0);
5468 tree args
= TREE_OPERAND (n
, 1);
5471 /* First the templates. */
5472 if (arg_assoc (k
, templ
))
5475 /* Now the arguments. */
5477 for (ix
= TREE_VEC_LENGTH (args
); ix
--;)
5478 if (arg_assoc_template_arg (k
, TREE_VEC_ELT (args
, ix
)) == 1)
5481 else if (TREE_CODE (n
) == OVERLOAD
)
5483 for (; n
; n
= OVL_NEXT (n
))
5484 if (arg_assoc_type (k
, TREE_TYPE (OVL_CURRENT (n
))))
5491 /* Performs Koenig lookup depending on arguments, where fns
5492 are the functions found in normal lookup. */
5495 lookup_arg_dependent_1 (tree name
, tree fns
, VEC(tree
,gc
) *args
,
5498 struct arg_lookup k
;
5500 /* Remove any hidden friend functions from the list of functions
5501 found so far. They will be added back by arg_assoc_class as
5503 fns
= remove_hidden_names (fns
);
5508 k
.classes
= make_tree_vector ();
5510 /* We previously performed an optimization here by setting
5511 NAMESPACES to the current namespace when it was safe. However, DR
5512 164 says that namespaces that were already searched in the first
5513 stage of template processing are searched again (potentially
5514 picking up later definitions) in the second stage. */
5515 k
.namespaces
= make_tree_vector ();
5517 /* We used to allow duplicates and let joust discard them, but
5518 since the above change for DR 164 we end up with duplicates of
5519 all the functions found by unqualified lookup. So keep track
5520 of which ones we've seen. */
5524 /* We shouldn't be here if lookup found something other than
5525 namespace-scope functions. */
5526 gcc_assert (DECL_NAMESPACE_SCOPE_P (OVL_CURRENT (fns
)));
5527 k
.fn_set
= pointer_set_create ();
5528 for (ovl
= fns
; ovl
; ovl
= OVL_NEXT (ovl
))
5529 pointer_set_insert (k
.fn_set
, OVL_CURRENT (ovl
));
5535 arg_assoc_namespace (&k
, std_node
);
5536 arg_assoc_args_vec (&k
, args
);
5541 && TREE_CODE (fns
) != VAR_DECL
5542 && !is_overloaded_fn (fns
))
5544 error ("argument dependent lookup finds %q+D", fns
);
5545 error (" in call to %qD", name
);
5546 fns
= error_mark_node
;
5549 release_tree_vector (k
.classes
);
5550 release_tree_vector (k
.namespaces
);
5552 pointer_set_destroy (k
.fn_set
);
5557 /* Wrapper for lookup_arg_dependent_1. */
5560 lookup_arg_dependent (tree name
, tree fns
, VEC(tree
,gc
) *args
,
5565 subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
5566 ret
= lookup_arg_dependent_1 (name
, fns
, args
, include_std
);
5567 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
5572 /* Add namespace to using_directives. Return NULL_TREE if nothing was
5573 changed (i.e. there was already a directive), or the fresh
5574 TREE_LIST otherwise. */
5577 push_using_directive_1 (tree used
)
5579 tree ud
= current_binding_level
->using_directives
;
5580 tree iter
, ancestor
;
5582 /* Check if we already have this. */
5583 if (purpose_member (used
, ud
) != NULL_TREE
)
5586 ancestor
= namespace_ancestor (current_decl_namespace (), used
);
5587 ud
= current_binding_level
->using_directives
;
5588 ud
= tree_cons (used
, ancestor
, ud
);
5589 current_binding_level
->using_directives
= ud
;
5591 /* Recursively add all namespaces used. */
5592 for (iter
= DECL_NAMESPACE_USING (used
); iter
; iter
= TREE_CHAIN (iter
))
5593 push_using_directive (TREE_PURPOSE (iter
));
5598 /* Wrapper for push_using_directive_1. */
5601 push_using_directive (tree used
)
5604 timevar_start (TV_NAME_LOOKUP
);
5605 ret
= push_using_directive_1 (used
);
5606 timevar_stop (TV_NAME_LOOKUP
);
5610 /* The type TYPE is being declared. If it is a class template, or a
5611 specialization of a class template, do any processing required and
5612 perform error-checking. If IS_FRIEND is nonzero, this TYPE is
5613 being declared a friend. B is the binding level at which this TYPE
5616 Returns the TYPE_DECL for TYPE, which may have been altered by this
5620 maybe_process_template_type_declaration (tree type
, int is_friend
,
5621 cp_binding_level
*b
)
5623 tree decl
= TYPE_NAME (type
);
5625 if (processing_template_parmlist
)
5626 /* You can't declare a new template type in a template parameter
5627 list. But, you can declare a non-template type:
5629 template <class A*> struct S;
5631 is a forward-declaration of `A'. */
5633 else if (b
->kind
== sk_namespace
5634 && current_binding_level
->kind
!= sk_namespace
)
5635 /* If this new type is being injected into a containing scope,
5636 then it's not a template type. */
5640 gcc_assert (MAYBE_CLASS_TYPE_P (type
)
5641 || TREE_CODE (type
) == ENUMERAL_TYPE
);
5643 if (processing_template_decl
)
5645 /* This may change after the call to
5646 push_template_decl_real, but we want the original value. */
5647 tree name
= DECL_NAME (decl
);
5649 decl
= push_template_decl_real (decl
, is_friend
);
5650 if (decl
== error_mark_node
)
5651 return error_mark_node
;
5653 /* If the current binding level is the binding level for the
5654 template parameters (see the comment in
5655 begin_template_parm_list) and the enclosing level is a class
5656 scope, and we're not looking at a friend, push the
5657 declaration of the member class into the class scope. In the
5658 friend case, push_template_decl will already have put the
5659 friend into global scope, if appropriate. */
5660 if (TREE_CODE (type
) != ENUMERAL_TYPE
5661 && !is_friend
&& b
->kind
== sk_template_parms
5662 && b
->level_chain
->kind
== sk_class
)
5664 finish_member_declaration (CLASSTYPE_TI_TEMPLATE (type
));
5666 if (!COMPLETE_TYPE_P (current_class_type
))
5668 maybe_add_class_template_decl_list (current_class_type
,
5669 type
, /*friend_p=*/0);
5670 /* Put this UTD in the table of UTDs for the class. */
5671 if (CLASSTYPE_NESTED_UTDS (current_class_type
) == NULL
)
5672 CLASSTYPE_NESTED_UTDS (current_class_type
) =
5673 binding_table_new (SCOPE_DEFAULT_HT_SIZE
);
5675 binding_table_insert
5676 (CLASSTYPE_NESTED_UTDS (current_class_type
), name
, type
);
5685 /* Push a tag name NAME for struct/class/union/enum type TYPE. In case
5686 that the NAME is a class template, the tag is processed but not pushed.
5688 The pushed scope depend on the SCOPE parameter:
5689 - When SCOPE is TS_CURRENT, put it into the inner-most non-sk_cleanup
5691 - When SCOPE is TS_GLOBAL, put it in the inner-most non-class and
5692 non-template-parameter scope. This case is needed for forward
5694 - When SCOPE is TS_WITHIN_ENCLOSING_NON_CLASS, this is similar to
5695 TS_GLOBAL case except that names within template-parameter scopes
5696 are not pushed at all.
5698 Returns TYPE upon success and ERROR_MARK_NODE otherwise. */
5701 pushtag_1 (tree name
, tree type
, tag_scope scope
)
5703 cp_binding_level
*b
;
5706 b
= current_binding_level
;
5707 while (/* Cleanup scopes are not scopes from the point of view of
5709 b
->kind
== sk_cleanup
5710 /* Neither are function parameter scopes. */
5711 || b
->kind
== sk_function_parms
5712 /* Neither are the scopes used to hold template parameters
5713 for an explicit specialization. For an ordinary template
5714 declaration, these scopes are not scopes from the point of
5715 view of the language. */
5716 || (b
->kind
== sk_template_parms
5717 && (b
->explicit_spec_p
|| scope
== ts_global
))
5718 || (b
->kind
== sk_class
5719 && (scope
!= ts_current
5720 /* We may be defining a new type in the initializer
5721 of a static member variable. We allow this when
5722 not pedantic, and it is particularly useful for
5723 type punning via an anonymous union. */
5724 || COMPLETE_TYPE_P (b
->this_entity
))))
5727 gcc_assert (TREE_CODE (name
) == IDENTIFIER_NODE
);
5729 /* Do C++ gratuitous typedefing. */
5730 if (identifier_type_value_1 (name
) != type
)
5734 tree context
= TYPE_CONTEXT (type
);
5738 tree cs
= current_scope ();
5740 if (scope
== ts_current
5741 || (cs
&& TREE_CODE (cs
) == FUNCTION_DECL
))
5743 else if (cs
!= NULL_TREE
&& TYPE_P (cs
))
5744 /* When declaring a friend class of a local class, we want
5745 to inject the newly named class into the scope
5746 containing the local class, not the namespace
5748 context
= decl_function_context (get_type_decl (cs
));
5751 context
= current_namespace
;
5753 if (b
->kind
== sk_class
5754 || (b
->kind
== sk_template_parms
5755 && b
->level_chain
->kind
== sk_class
))
5758 if (current_lang_name
== lang_name_java
)
5759 TYPE_FOR_JAVA (type
) = 1;
5761 tdef
= create_implicit_typedef (name
, type
);
5762 DECL_CONTEXT (tdef
) = FROB_CONTEXT (context
);
5763 if (scope
== ts_within_enclosing_non_class
)
5765 /* This is a friend. Make this TYPE_DECL node hidden from
5766 ordinary name lookup. Its corresponding TEMPLATE_DECL
5767 will be marked in push_template_decl_real. */
5768 retrofit_lang_decl (tdef
);
5769 DECL_ANTICIPATED (tdef
) = 1;
5770 DECL_FRIEND_P (tdef
) = 1;
5773 decl
= maybe_process_template_type_declaration
5774 (type
, scope
== ts_within_enclosing_non_class
, b
);
5775 if (decl
== error_mark_node
)
5778 if (b
->kind
== sk_class
)
5780 if (!TYPE_BEING_DEFINED (current_class_type
))
5781 return error_mark_node
;
5783 if (!PROCESSING_REAL_TEMPLATE_DECL_P ())
5784 /* Put this TYPE_DECL on the TYPE_FIELDS list for the
5785 class. But if it's a member template class, we want
5786 the TEMPLATE_DECL, not the TYPE_DECL, so this is done
5788 finish_member_declaration (decl
);
5790 pushdecl_class_level (decl
);
5792 else if (b
->kind
!= sk_template_parms
)
5794 decl
= pushdecl_with_scope_1 (decl
, b
, /*is_friend=*/false);
5795 if (decl
== error_mark_node
)
5800 set_identifier_type_value_with_scope (name
, tdef
, b
);
5802 TYPE_CONTEXT (type
) = DECL_CONTEXT (decl
);
5804 /* If this is a local class, keep track of it. We need this
5805 information for name-mangling, and so that it is possible to
5806 find all function definitions in a translation unit in a
5807 convenient way. (It's otherwise tricky to find a member
5808 function definition it's only pointed to from within a local
5810 if (TYPE_CONTEXT (type
)
5811 && TREE_CODE (TYPE_CONTEXT (type
)) == FUNCTION_DECL
)
5813 if (processing_template_decl
)
5815 /* Push a DECL_EXPR so we call pushtag at the right time in
5816 template instantiation rather than in some nested context. */
5817 add_decl_expr (decl
);
5820 VEC_safe_push (tree
, gc
, local_classes
, type
);
5823 if (b
->kind
== sk_class
5824 && !COMPLETE_TYPE_P (current_class_type
))
5826 maybe_add_class_template_decl_list (current_class_type
,
5827 type
, /*friend_p=*/0);
5829 if (CLASSTYPE_NESTED_UTDS (current_class_type
) == NULL
)
5830 CLASSTYPE_NESTED_UTDS (current_class_type
)
5831 = binding_table_new (SCOPE_DEFAULT_HT_SIZE
);
5833 binding_table_insert
5834 (CLASSTYPE_NESTED_UTDS (current_class_type
), name
, type
);
5837 decl
= TYPE_NAME (type
);
5838 gcc_assert (TREE_CODE (decl
) == TYPE_DECL
);
5840 /* Set type visibility now if this is a forward declaration. */
5841 TREE_PUBLIC (decl
) = 1;
5842 determine_visibility (decl
);
5847 /* Wrapper for pushtag_1. */
5850 pushtag (tree name
, tree type
, tag_scope scope
)
5853 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
5854 ret
= pushtag_1 (name
, type
, scope
);
5855 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
5859 /* Subroutines for reverting temporarily to top-level for instantiation
5860 of templates and such. We actually need to clear out the class- and
5861 local-value slots of all identifiers, so that only the global values
5862 are at all visible. Simply setting current_binding_level to the global
5863 scope isn't enough, because more binding levels may be pushed. */
5864 struct saved_scope
*scope_chain
;
5866 /* Return true if ID has not already been marked. */
5869 store_binding_p (tree id
)
5871 if (!id
|| !IDENTIFIER_BINDING (id
))
5874 if (IDENTIFIER_MARKED (id
))
5880 /* Add an appropriate binding to *OLD_BINDINGS which needs to already
5881 have enough space reserved. */
5884 store_binding (tree id
, VEC(cxx_saved_binding
,gc
) **old_bindings
)
5886 cxx_saved_binding
*saved
;
5888 gcc_checking_assert (store_binding_p (id
));
5890 IDENTIFIER_MARKED (id
) = 1;
5892 saved
= VEC_quick_push (cxx_saved_binding
, *old_bindings
, NULL
);
5893 saved
->identifier
= id
;
5894 saved
->binding
= IDENTIFIER_BINDING (id
);
5895 saved
->real_type_value
= REAL_IDENTIFIER_TYPE_VALUE (id
);
5896 IDENTIFIER_BINDING (id
) = NULL
;
5900 store_bindings (tree names
, VEC(cxx_saved_binding
,gc
) **old_bindings
)
5902 static VEC(tree
,heap
) *bindings_need_stored
= NULL
;
5906 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
5907 for (t
= names
; t
; t
= TREE_CHAIN (t
))
5909 if (TREE_CODE (t
) == TREE_LIST
)
5910 id
= TREE_PURPOSE (t
);
5914 if (store_binding_p (id
))
5915 VEC_safe_push(tree
, heap
, bindings_need_stored
, id
);
5917 if (!VEC_empty (tree
, bindings_need_stored
))
5919 VEC_reserve_exact (cxx_saved_binding
, gc
, *old_bindings
,
5920 VEC_length (tree
, bindings_need_stored
));
5921 for (i
= 0; VEC_iterate(tree
, bindings_need_stored
, i
, id
); ++i
)
5923 /* We can appearantly have duplicates in NAMES. */
5924 if (store_binding_p (id
))
5925 store_binding (id
, old_bindings
);
5927 VEC_truncate (tree
, bindings_need_stored
, 0);
5929 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
5932 /* Like store_bindings, but NAMES is a vector of cp_class_binding
5933 objects, rather than a TREE_LIST. */
5936 store_class_bindings (VEC(cp_class_binding
,gc
) *names
,
5937 VEC(cxx_saved_binding
,gc
) **old_bindings
)
5939 static VEC(tree
,heap
) *bindings_need_stored
= NULL
;
5941 cp_class_binding
*cb
;
5943 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
5944 for (i
= 0; VEC_iterate(cp_class_binding
, names
, i
, cb
); ++i
)
5945 if (store_binding_p (cb
->identifier
))
5946 VEC_safe_push (tree
, heap
, bindings_need_stored
, cb
->identifier
);
5947 if (!VEC_empty (tree
, bindings_need_stored
))
5950 VEC_reserve_exact (cxx_saved_binding
, gc
, *old_bindings
,
5951 VEC_length (tree
, bindings_need_stored
));
5952 for (i
= 0; VEC_iterate(tree
, bindings_need_stored
, i
, id
); ++i
)
5953 store_binding (id
, old_bindings
);
5954 VEC_truncate (tree
, bindings_need_stored
, 0);
5956 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
5960 push_to_top_level (void)
5962 struct saved_scope
*s
;
5963 cp_binding_level
*b
;
5964 cxx_saved_binding
*sb
;
5968 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
5969 s
= ggc_alloc_cleared_saved_scope ();
5971 b
= scope_chain
? current_binding_level
: 0;
5973 /* If we're in the middle of some function, save our state. */
5977 push_function_context ();
5982 if (scope_chain
&& previous_class_level
)
5983 store_class_bindings (previous_class_level
->class_shadowed
,
5986 /* Have to include the global scope, because class-scope decls
5987 aren't listed anywhere useful. */
5988 for (; b
; b
= b
->level_chain
)
5992 /* Template IDs are inserted into the global level. If they were
5993 inserted into namespace level, finish_file wouldn't find them
5994 when doing pending instantiations. Therefore, don't stop at
5995 namespace level, but continue until :: . */
5996 if (global_scope_p (b
))
5999 store_bindings (b
->names
, &s
->old_bindings
);
6000 /* We also need to check class_shadowed to save class-level type
6001 bindings, since pushclass doesn't fill in b->names. */
6002 if (b
->kind
== sk_class
)
6003 store_class_bindings (b
->class_shadowed
, &s
->old_bindings
);
6005 /* Unwind type-value slots back to top level. */
6006 for (t
= b
->type_shadowed
; t
; t
= TREE_CHAIN (t
))
6007 SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (t
), TREE_VALUE (t
));
6010 FOR_EACH_VEC_ELT (cxx_saved_binding
, s
->old_bindings
, i
, sb
)
6011 IDENTIFIER_MARKED (sb
->identifier
) = 0;
6013 s
->prev
= scope_chain
;
6015 s
->need_pop_function_context
= need_pop
;
6016 s
->function_decl
= current_function_decl
;
6017 s
->unevaluated_operand
= cp_unevaluated_operand
;
6018 s
->inhibit_evaluation_warnings
= c_inhibit_evaluation_warnings
;
6019 s
->x_stmt_tree
.stmts_are_full_exprs_p
= true;
6022 current_function_decl
= NULL_TREE
;
6023 current_lang_base
= VEC_alloc (tree
, gc
, 10);
6024 current_lang_name
= lang_name_cplusplus
;
6025 current_namespace
= global_namespace
;
6026 push_class_stack ();
6027 cp_unevaluated_operand
= 0;
6028 c_inhibit_evaluation_warnings
= 0;
6029 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
6033 pop_from_top_level_1 (void)
6035 struct saved_scope
*s
= scope_chain
;
6036 cxx_saved_binding
*saved
;
6039 /* Clear out class-level bindings cache. */
6040 if (previous_class_level
)
6041 invalidate_class_lookup_cache ();
6044 current_lang_base
= 0;
6046 scope_chain
= s
->prev
;
6047 FOR_EACH_VEC_ELT (cxx_saved_binding
, s
->old_bindings
, i
, saved
)
6049 tree id
= saved
->identifier
;
6051 IDENTIFIER_BINDING (id
) = saved
->binding
;
6052 SET_IDENTIFIER_TYPE_VALUE (id
, saved
->real_type_value
);
6055 /* If we were in the middle of compiling a function, restore our
6057 if (s
->need_pop_function_context
)
6058 pop_function_context ();
6059 current_function_decl
= s
->function_decl
;
6060 cp_unevaluated_operand
= s
->unevaluated_operand
;
6061 c_inhibit_evaluation_warnings
= s
->inhibit_evaluation_warnings
;
6064 /* Wrapper for pop_from_top_level_1. */
6067 pop_from_top_level (void)
6069 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
6070 pop_from_top_level_1 ();
6071 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
6075 /* Pop off extraneous binding levels left over due to syntax errors.
6077 We don't pop past namespaces, as they might be valid. */
6080 pop_everything (void)
6082 if (ENABLE_SCOPE_CHECKING
)
6083 verbatim ("XXX entering pop_everything ()\n");
6084 while (!toplevel_bindings_p ())
6086 if (current_binding_level
->kind
== sk_class
)
6087 pop_nested_class ();
6091 if (ENABLE_SCOPE_CHECKING
)
6092 verbatim ("XXX leaving pop_everything ()\n");
6095 /* Emit debugging information for using declarations and directives.
6096 If input tree is overloaded fn then emit debug info for all
6100 cp_emit_debug_info_for_using (tree t
, tree context
)
6102 /* Don't try to emit any debug information if we have errors. */
6106 /* Ignore this FUNCTION_DECL if it refers to a builtin declaration
6107 of a builtin function. */
6108 if (TREE_CODE (t
) == FUNCTION_DECL
6109 && DECL_EXTERNAL (t
)
6110 && DECL_BUILT_IN (t
))
6113 /* Do not supply context to imported_module_or_decl, if
6114 it is a global namespace. */
6115 if (context
== global_namespace
)
6116 context
= NULL_TREE
;
6119 t
= BASELINK_FUNCTIONS (t
);
6121 /* FIXME: Handle TEMPLATE_DECLs. */
6122 for (t
= OVL_CURRENT (t
); t
; t
= OVL_NEXT (t
))
6123 if (TREE_CODE (t
) != TEMPLATE_DECL
)
6125 if (building_stmt_list_p ())
6126 add_stmt (build_stmt (input_location
, USING_STMT
, t
));
6128 (*debug_hooks
->imported_module_or_decl
) (t
, NULL_TREE
, context
, false);
6132 #include "gt-cp-name-lookup.h"