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
= {cxx_binding_make (value
, type
), name
};
322 cxx_binding
*binding
= cb
.base
;
323 VEC_safe_push (cp_class_binding
, gc
, scope
->class_shadowed
, cb
);
324 binding
->scope
= scope
;
328 /* Make DECL the innermost binding for ID. The LEVEL is the binding
329 level at which this declaration is being bound. */
332 push_binding (tree id
, tree decl
, cp_binding_level
* level
)
334 cxx_binding
*binding
;
336 if (level
!= class_binding_level
)
338 binding
= cxx_binding_make (decl
, NULL_TREE
);
339 binding
->scope
= level
;
342 binding
= new_class_binding (id
, decl
, /*type=*/NULL_TREE
, level
);
344 /* Now, fill in the binding information. */
345 binding
->previous
= IDENTIFIER_BINDING (id
);
346 INHERITED_VALUE_BINDING_P (binding
) = 0;
347 LOCAL_BINDING_P (binding
) = (level
!= class_binding_level
);
349 /* And put it on the front of the list of bindings for ID. */
350 IDENTIFIER_BINDING (id
) = binding
;
353 /* Remove the binding for DECL which should be the innermost binding
357 pop_binding (tree id
, tree decl
)
359 cxx_binding
*binding
;
362 /* It's easiest to write the loops that call this function without
363 checking whether or not the entities involved have names. We
364 get here for such an entity. */
367 /* Get the innermost binding for ID. */
368 binding
= IDENTIFIER_BINDING (id
);
370 /* The name should be bound. */
371 gcc_assert (binding
!= NULL
);
373 /* The DECL will be either the ordinary binding or the type
374 binding for this identifier. Remove that binding. */
375 if (binding
->value
== decl
)
376 binding
->value
= NULL_TREE
;
379 gcc_assert (binding
->type
== decl
);
380 binding
->type
= NULL_TREE
;
383 if (!binding
->value
&& !binding
->type
)
385 /* We're completely done with the innermost binding for this
386 identifier. Unhook it from the list of bindings. */
387 IDENTIFIER_BINDING (id
) = binding
->previous
;
389 /* Add it to the free list. */
390 cxx_binding_free (binding
);
394 /* Strip non dependent using declarations. */
397 strip_using_decl (tree decl
)
399 if (decl
== NULL_TREE
)
402 while (TREE_CODE (decl
) == USING_DECL
&& !DECL_DEPENDENT_P (decl
))
403 decl
= USING_DECL_DECLS (decl
);
407 /* BINDING records an existing declaration for a name in the current scope.
408 But, DECL is another declaration for that same identifier in the
409 same scope. This is the `struct stat' hack whereby a non-typedef
410 class name or enum-name can be bound at the same level as some other
414 A class name (9.1) or enumeration name (7.2) can be hidden by the
415 name of an object, function, or enumerator declared in the same scope.
416 If a class or enumeration name and an object, function, or enumerator
417 are declared in the same scope (in any order) with the same name, the
418 class or enumeration name is hidden wherever the object, function, or
419 enumerator name is visible.
421 It's the responsibility of the caller to check that
422 inserting this name is valid here. Returns nonzero if the new binding
426 supplement_binding_1 (cxx_binding
*binding
, tree decl
)
428 tree bval
= binding
->value
;
430 tree target_bval
= strip_using_decl (bval
);
431 tree target_decl
= strip_using_decl (decl
);
433 if (TREE_CODE (target_decl
) == TYPE_DECL
&& DECL_ARTIFICIAL (target_decl
)
434 && target_decl
!= target_bval
435 && (TREE_CODE (target_bval
) != TYPE_DECL
436 /* We allow pushing an enum multiple times in a class
437 template in order to handle late matching of underlying
438 type on an opaque-enum-declaration followed by an
440 || (processing_template_decl
441 && TREE_CODE (TREE_TYPE (target_decl
)) == ENUMERAL_TYPE
442 && TREE_CODE (TREE_TYPE (target_bval
)) == ENUMERAL_TYPE
443 && (dependent_type_p (ENUM_UNDERLYING_TYPE
444 (TREE_TYPE (target_decl
)))
445 || dependent_type_p (ENUM_UNDERLYING_TYPE
446 (TREE_TYPE (target_bval
)))))))
447 /* The new name is the type name. */
448 binding
->type
= decl
;
449 else if (/* TARGET_BVAL is null when push_class_level_binding moves
450 an inherited type-binding out of the way to make room
451 for a new value binding. */
453 /* TARGET_BVAL is error_mark_node when TARGET_DECL's name
454 has been used in a non-class scope prior declaration.
455 In that case, we should have already issued a
456 diagnostic; for graceful error recovery purpose, pretend
457 this was the intended declaration for that name. */
458 || target_bval
== error_mark_node
459 /* If TARGET_BVAL is anticipated but has not yet been
460 declared, pretend it is not there at all. */
461 || (TREE_CODE (target_bval
) == FUNCTION_DECL
462 && DECL_ANTICIPATED (target_bval
)
463 && !DECL_HIDDEN_FRIEND_P (target_bval
)))
464 binding
->value
= decl
;
465 else if (TREE_CODE (target_bval
) == TYPE_DECL
466 && DECL_ARTIFICIAL (target_bval
)
467 && target_decl
!= target_bval
468 && (TREE_CODE (target_decl
) != TYPE_DECL
469 || same_type_p (TREE_TYPE (target_decl
),
470 TREE_TYPE (target_bval
))))
472 /* The old binding was a type name. It was placed in
473 VALUE field because it was thought, at the point it was
474 declared, to be the only entity with such a name. Move the
475 type name into the type slot; it is now hidden by the new
477 binding
->type
= bval
;
478 binding
->value
= decl
;
479 binding
->value_is_inherited
= false;
481 else if (TREE_CODE (target_bval
) == TYPE_DECL
482 && TREE_CODE (target_decl
) == TYPE_DECL
483 && DECL_NAME (target_decl
) == DECL_NAME (target_bval
)
484 && binding
->scope
->kind
!= sk_class
485 && (same_type_p (TREE_TYPE (target_decl
), TREE_TYPE (target_bval
))
486 /* If either type involves template parameters, we must
487 wait until instantiation. */
488 || uses_template_parms (TREE_TYPE (target_decl
))
489 || uses_template_parms (TREE_TYPE (target_bval
))))
490 /* We have two typedef-names, both naming the same type to have
491 the same name. In general, this is OK because of:
495 In a given scope, a typedef specifier can be used to redefine
496 the name of any type declared in that scope to refer to the
497 type to which it already refers.
499 However, in class scopes, this rule does not apply due to the
500 stricter language in [class.mem] prohibiting redeclarations of
503 /* There can be two block-scope declarations of the same variable,
504 so long as they are `extern' declarations. However, there cannot
505 be two declarations of the same static data member:
509 A member shall not be declared twice in the
510 member-specification. */
511 else if (TREE_CODE (target_decl
) == VAR_DECL
512 && TREE_CODE (target_bval
) == VAR_DECL
513 && DECL_EXTERNAL (target_decl
) && DECL_EXTERNAL (target_bval
)
514 && !DECL_CLASS_SCOPE_P (target_decl
))
516 duplicate_decls (decl
, binding
->value
, /*newdecl_is_friend=*/false);
519 else if (TREE_CODE (decl
) == NAMESPACE_DECL
520 && TREE_CODE (bval
) == NAMESPACE_DECL
521 && DECL_NAMESPACE_ALIAS (decl
)
522 && DECL_NAMESPACE_ALIAS (bval
)
523 && ORIGINAL_NAMESPACE (bval
) == ORIGINAL_NAMESPACE (decl
))
526 In a declarative region, a namespace-alias-definition can be
527 used to redefine a namespace-alias declared in that declarative
528 region to refer only to the namespace to which it already
533 diagnose_name_conflict (decl
, bval
);
540 /* Diagnose a name conflict between DECL and BVAL. */
543 diagnose_name_conflict (tree decl
, tree bval
)
545 if (TREE_CODE (decl
) == TREE_CODE (bval
)
546 && (TREE_CODE (decl
) != TYPE_DECL
547 || (DECL_ARTIFICIAL (decl
) && DECL_ARTIFICIAL (bval
))
548 || (!DECL_ARTIFICIAL (decl
) && !DECL_ARTIFICIAL (bval
)))
549 && !is_overloaded_fn (decl
))
550 error ("redeclaration of %q#D", decl
);
552 error ("%q#D conflicts with a previous declaration", decl
);
554 inform (input_location
, "previous declaration %q+#D", bval
);
557 /* Wrapper for supplement_binding_1. */
560 supplement_binding (cxx_binding
*binding
, tree decl
)
563 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
564 ret
= supplement_binding_1 (binding
, decl
);
565 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
569 /* Add DECL to the list of things declared in B. */
572 add_decl_to_level (tree decl
, cp_binding_level
*b
)
574 /* We used to record virtual tables as if they were ordinary
575 variables, but no longer do so. */
576 gcc_assert (!(TREE_CODE (decl
) == VAR_DECL
&& DECL_VIRTUAL_P (decl
)));
578 if (TREE_CODE (decl
) == NAMESPACE_DECL
579 && !DECL_NAMESPACE_ALIAS (decl
))
581 DECL_CHAIN (decl
) = b
->namespaces
;
582 b
->namespaces
= decl
;
586 /* We build up the list in reverse order, and reverse it later if
588 TREE_CHAIN (decl
) = b
->names
;
591 /* If appropriate, add decl to separate list of statics. We
592 include extern variables because they might turn out to be
593 static later. It's OK for this list to contain a few false
595 if (b
->kind
== sk_namespace
)
596 if ((TREE_CODE (decl
) == VAR_DECL
597 && (TREE_STATIC (decl
) || DECL_EXTERNAL (decl
)))
598 || (TREE_CODE (decl
) == FUNCTION_DECL
599 && (!TREE_PUBLIC (decl
) || DECL_DECLARED_INLINE_P (decl
))))
600 VEC_safe_push (tree
, gc
, b
->static_decls
, decl
);
604 /* Record a decl-node X as belonging to the current lexical scope.
605 Check for errors (such as an incompatible declaration for the same
606 name already seen in the same scope). IS_FRIEND is true if X is
607 declared as a friend.
609 Returns either X or an old decl for the same name.
610 If an old decl is returned, it may have been smashed
611 to agree with what X says. */
614 pushdecl_maybe_friend_1 (tree x
, bool is_friend
)
618 int need_new_binding
;
620 if (x
== error_mark_node
)
621 return error_mark_node
;
623 need_new_binding
= 1;
625 if (DECL_TEMPLATE_PARM_P (x
))
626 /* Template parameters have no context; they are not X::T even
627 when declared within a class or namespace. */
631 if (current_function_decl
&& x
!= current_function_decl
632 /* A local declaration for a function doesn't constitute
634 && TREE_CODE (x
) != FUNCTION_DECL
635 /* A local declaration for an `extern' variable is in the
636 scope of the current namespace, not the current
638 && !(TREE_CODE (x
) == VAR_DECL
&& DECL_EXTERNAL (x
))
639 /* When parsing the parameter list of a function declarator,
640 don't set DECL_CONTEXT to an enclosing function. When we
641 push the PARM_DECLs in order to process the function body,
642 current_binding_level->this_entity will be set. */
643 && !(TREE_CODE (x
) == PARM_DECL
644 && current_binding_level
->kind
== sk_function_parms
645 && current_binding_level
->this_entity
== NULL
)
646 && !DECL_CONTEXT (x
))
647 DECL_CONTEXT (x
) = current_function_decl
;
649 /* If this is the declaration for a namespace-scope function,
650 but the declaration itself is in a local scope, mark the
652 if (TREE_CODE (x
) == FUNCTION_DECL
653 && DECL_NAMESPACE_SCOPE_P (x
)
654 && current_function_decl
655 && x
!= current_function_decl
)
656 DECL_LOCAL_FUNCTION_P (x
) = 1;
659 name
= DECL_NAME (x
);
662 int different_binding_level
= 0;
664 if (TREE_CODE (name
) == TEMPLATE_ID_EXPR
)
665 name
= TREE_OPERAND (name
, 0);
667 /* In case this decl was explicitly namespace-qualified, look it
668 up in its namespace context. */
669 if (DECL_NAMESPACE_SCOPE_P (x
) && namespace_bindings_p ())
670 t
= namespace_binding (name
, DECL_CONTEXT (x
));
672 t
= lookup_name_innermost_nonclass_level (name
);
674 /* [basic.link] If there is a visible declaration of an entity
675 with linkage having the same name and type, ignoring entities
676 declared outside the innermost enclosing namespace scope, the
677 block scope declaration declares that same entity and
678 receives the linkage of the previous declaration. */
679 if (! t
&& current_function_decl
&& x
!= current_function_decl
680 && (TREE_CODE (x
) == FUNCTION_DECL
|| TREE_CODE (x
) == VAR_DECL
)
681 && DECL_EXTERNAL (x
))
683 /* Look in block scope. */
684 t
= innermost_non_namespace_value (name
);
685 /* Or in the innermost namespace. */
687 t
= namespace_binding (name
, DECL_CONTEXT (x
));
688 /* Does it have linkage? Note that if this isn't a DECL, it's an
689 OVERLOAD, which is OK. */
690 if (t
&& DECL_P (t
) && ! (TREE_STATIC (t
) || DECL_EXTERNAL (t
)))
693 different_binding_level
= 1;
696 /* If we are declaring a function, and the result of name-lookup
697 was an OVERLOAD, look for an overloaded instance that is
698 actually the same as the function we are declaring. (If
699 there is one, we have to merge our declaration with the
700 previous declaration.) */
701 if (t
&& TREE_CODE (t
) == OVERLOAD
)
705 if (TREE_CODE (x
) == FUNCTION_DECL
)
706 for (match
= t
; match
; match
= OVL_NEXT (match
))
708 if (decls_match (OVL_CURRENT (match
), x
))
712 /* Just choose one. */
716 t
= OVL_CURRENT (match
);
721 if (t
&& t
!= error_mark_node
)
723 if (different_binding_level
)
725 if (decls_match (x
, t
))
726 /* The standard only says that the local extern
727 inherits linkage from the previous decl; in
728 particular, default args are not shared. Add
729 the decl into a hash table to make sure only
730 the previous decl in this case is seen by the
733 struct cxx_int_tree_map
*h
;
736 TREE_PUBLIC (x
) = TREE_PUBLIC (t
);
738 if (cp_function_chain
->extern_decl_map
== NULL
)
739 cp_function_chain
->extern_decl_map
740 = htab_create_ggc (20, cxx_int_tree_map_hash
,
741 cxx_int_tree_map_eq
, NULL
);
743 h
= ggc_alloc_cxx_int_tree_map ();
744 h
->uid
= DECL_UID (x
);
746 loc
= htab_find_slot_with_hash
747 (cp_function_chain
->extern_decl_map
, h
,
749 *(struct cxx_int_tree_map
**) loc
= h
;
752 else if (TREE_CODE (t
) == PARM_DECL
)
754 /* Check for duplicate params. */
755 tree d
= duplicate_decls (x
, t
, is_friend
);
759 else if ((DECL_EXTERN_C_FUNCTION_P (x
)
760 || DECL_FUNCTION_TEMPLATE_P (x
))
761 && is_overloaded_fn (t
))
762 /* Don't do anything just yet. */;
763 else if (t
== wchar_decl_node
)
765 if (! DECL_IN_SYSTEM_HEADER (x
))
766 pedwarn (input_location
, OPT_Wpedantic
, "redeclaration of %<wchar_t%> as %qT",
769 /* Throw away the redeclaration. */
774 tree olddecl
= duplicate_decls (x
, t
, is_friend
);
776 /* If the redeclaration failed, we can stop at this
778 if (olddecl
== error_mark_node
)
779 return error_mark_node
;
783 if (TREE_CODE (t
) == TYPE_DECL
)
784 SET_IDENTIFIER_TYPE_VALUE (name
, TREE_TYPE (t
));
788 else if (DECL_MAIN_P (x
) && TREE_CODE (t
) == FUNCTION_DECL
)
790 /* A redeclaration of main, but not a duplicate of the
795 This function shall not be overloaded. */
796 error ("invalid redeclaration of %q+D", t
);
798 /* We don't try to push this declaration since that
805 /* If x has C linkage-specification, (extern "C"),
806 lookup its binding, in case it's already bound to an object.
807 The lookup is done in all namespaces.
808 If we find an existing binding, make sure it has the same
809 exception specification as x, otherwise, bail in error [7.5, 7.6]. */
810 if ((TREE_CODE (x
) == FUNCTION_DECL
)
811 && DECL_EXTERN_C_P (x
)
812 /* We should ignore declarations happening in system headers. */
813 && !DECL_ARTIFICIAL (x
)
814 && !DECL_IN_SYSTEM_HEADER (x
))
816 tree previous
= lookup_extern_c_fun_in_all_ns (x
);
818 && !DECL_ARTIFICIAL (previous
)
819 && !DECL_IN_SYSTEM_HEADER (previous
)
820 && DECL_CONTEXT (previous
) != DECL_CONTEXT (x
))
822 /* In case either x or previous is declared to throw an exception,
823 make sure both exception specifications are equal. */
824 if (decls_match (x
, previous
))
826 tree x_exception_spec
= NULL_TREE
;
827 tree previous_exception_spec
= NULL_TREE
;
830 TYPE_RAISES_EXCEPTIONS (TREE_TYPE (x
));
831 previous_exception_spec
=
832 TYPE_RAISES_EXCEPTIONS (TREE_TYPE (previous
));
833 if (!comp_except_specs (previous_exception_spec
,
837 pedwarn (input_location
, 0,
838 "declaration of %q#D with C language linkage",
840 pedwarn (input_location
, 0,
841 "conflicts with previous declaration %q+#D",
843 pedwarn (input_location
, 0,
844 "due to different exception specifications");
845 return error_mark_node
;
847 if (DECL_ASSEMBLER_NAME_SET_P (previous
))
848 SET_DECL_ASSEMBLER_NAME (x
,
849 DECL_ASSEMBLER_NAME (previous
));
853 pedwarn (input_location
, 0,
854 "declaration of %q#D with C language linkage", x
);
855 pedwarn (input_location
, 0,
856 "conflicts with previous declaration %q+#D",
862 check_template_shadow (x
);
864 /* If this is a function conjured up by the back end, massage it
865 so it looks friendly. */
866 if (DECL_NON_THUNK_FUNCTION_P (x
) && ! DECL_LANG_SPECIFIC (x
))
868 retrofit_lang_decl (x
);
869 SET_DECL_LANGUAGE (x
, lang_c
);
873 if (DECL_NON_THUNK_FUNCTION_P (x
) && ! DECL_FUNCTION_MEMBER_P (x
))
875 t
= push_overloaded_decl (x
, PUSH_LOCAL
, is_friend
);
876 if (!namespace_bindings_p ())
877 /* We do not need to create a binding for this name;
878 push_overloaded_decl will have already done so if
880 need_new_binding
= 0;
882 else if (DECL_FUNCTION_TEMPLATE_P (x
) && DECL_NAMESPACE_SCOPE_P (x
))
884 t
= push_overloaded_decl (x
, PUSH_GLOBAL
, is_friend
);
886 add_decl_to_level (x
, NAMESPACE_LEVEL (CP_DECL_CONTEXT (t
)));
889 if (TREE_CODE (t
) == FUNCTION_DECL
|| DECL_FUNCTION_TEMPLATE_P (t
))
890 check_default_args (t
);
892 if (t
!= x
|| DECL_FUNCTION_TEMPLATE_P (t
))
895 /* If declaring a type as a typedef, copy the type (unless we're
896 at line 0), and install this TYPE_DECL as the new type's typedef
897 name. See the extensive comment of set_underlying_type (). */
898 if (TREE_CODE (x
) == TYPE_DECL
)
900 tree type
= TREE_TYPE (x
);
902 if (DECL_IS_BUILTIN (x
)
903 || (TREE_TYPE (x
) != error_mark_node
904 && TYPE_NAME (type
) != x
905 /* We don't want to copy the type when all we're
906 doing is making a TYPE_DECL for the purposes of
908 && (!TYPE_NAME (type
)
909 || TYPE_NAME (type
) != DECL_ABSTRACT_ORIGIN (x
))))
910 set_underlying_type (x
);
912 if (type
!= error_mark_node
914 && TYPE_IDENTIFIER (type
))
915 set_identifier_type_value (DECL_NAME (x
), x
);
917 /* If this is a locally defined typedef in a function that
918 is not a template instantation, record it to implement
919 -Wunused-local-typedefs. */
920 if (current_instantiation () == NULL
921 || (current_instantiation ()->decl
!= current_function_decl
))
922 record_locally_defined_typedef (x
);
925 /* Multiple external decls of the same identifier ought to match.
927 We get warnings about inline functions where they are defined.
928 We get warnings about other functions from push_overloaded_decl.
930 Avoid duplicate warnings where they are used. */
931 if (TREE_PUBLIC (x
) && TREE_CODE (x
) != FUNCTION_DECL
)
935 decl
= IDENTIFIER_NAMESPACE_VALUE (name
);
936 if (decl
&& TREE_CODE (decl
) == OVERLOAD
)
937 decl
= OVL_FUNCTION (decl
);
939 if (decl
&& decl
!= error_mark_node
940 && (DECL_EXTERNAL (decl
) || TREE_PUBLIC (decl
))
941 /* If different sort of thing, we already gave an error. */
942 && TREE_CODE (decl
) == TREE_CODE (x
)
943 && !same_type_p (TREE_TYPE (x
), TREE_TYPE (decl
)))
945 permerror (input_location
, "type mismatch with previous external decl of %q#D", x
);
946 permerror (input_location
, "previous external decl of %q+#D", decl
);
950 if (TREE_CODE (x
) == FUNCTION_DECL
952 && !flag_friend_injection
)
954 /* This is a new declaration of a friend function, so hide
955 it from ordinary function lookup. */
956 DECL_ANTICIPATED (x
) = 1;
957 DECL_HIDDEN_FRIEND_P (x
) = 1;
960 /* This name is new in its binding level.
961 Install the new declaration and return it. */
962 if (namespace_bindings_p ())
964 /* Install a global value. */
966 /* If the first global decl has external linkage,
967 warn if we later see static one. */
968 if (IDENTIFIER_GLOBAL_VALUE (name
) == NULL_TREE
&& TREE_PUBLIC (x
))
969 TREE_PUBLIC (name
) = 1;
971 /* Bind the name for the entity. */
972 if (!(TREE_CODE (x
) == TYPE_DECL
&& DECL_ARTIFICIAL (x
)
974 && (TREE_CODE (x
) == TYPE_DECL
975 || TREE_CODE (x
) == VAR_DECL
976 || TREE_CODE (x
) == NAMESPACE_DECL
977 || TREE_CODE (x
) == CONST_DECL
978 || TREE_CODE (x
) == TEMPLATE_DECL
))
979 SET_IDENTIFIER_NAMESPACE_VALUE (name
, x
);
981 /* If new decl is `static' and an `extern' was seen previously,
983 if (x
!= NULL_TREE
&& t
!= NULL_TREE
&& decls_match (x
, t
))
984 warn_extern_redeclared_static (x
, t
);
988 /* Here to install a non-global value. */
989 tree oldglobal
= IDENTIFIER_NAMESPACE_VALUE (name
);
990 tree oldlocal
= NULL_TREE
;
991 cp_binding_level
*oldscope
= NULL
;
992 cxx_binding
*oldbinding
= outer_binding (name
, NULL
, true);
995 oldlocal
= oldbinding
->value
;
996 oldscope
= oldbinding
->scope
;
999 if (need_new_binding
)
1001 push_local_binding (name
, x
, 0);
1002 /* Because push_local_binding will hook X on to the
1003 current_binding_level's name list, we don't want to
1004 do that again below. */
1005 need_new_binding
= 0;
1008 /* If this is a TYPE_DECL, push it into the type value slot. */
1009 if (TREE_CODE (x
) == TYPE_DECL
)
1010 set_identifier_type_value (name
, x
);
1012 /* Clear out any TYPE_DECL shadowed by a namespace so that
1013 we won't think this is a type. The C struct hack doesn't
1014 go through namespaces. */
1015 if (TREE_CODE (x
) == NAMESPACE_DECL
)
1016 set_identifier_type_value (name
, NULL_TREE
);
1023 && TREE_CODE (oldlocal
) == VAR_DECL
1024 && DECL_DEAD_FOR_LOCAL (oldlocal
))
1025 oldlocal
= DECL_SHADOWED_FOR_VAR (oldlocal
);
1027 if (oldlocal
== NULL_TREE
)
1028 oldlocal
= IDENTIFIER_NAMESPACE_VALUE (DECL_NAME (d
));
1031 /* If this is an extern function declaration, see if we
1032 have a global definition or declaration for the function. */
1033 if (oldlocal
== NULL_TREE
1034 && DECL_EXTERNAL (x
)
1035 && oldglobal
!= NULL_TREE
1036 && TREE_CODE (x
) == FUNCTION_DECL
1037 && TREE_CODE (oldglobal
) == FUNCTION_DECL
)
1039 /* We have one. Their types must agree. */
1040 if (decls_match (x
, oldglobal
))
1044 warning (0, "extern declaration of %q#D doesn%'t match", x
);
1045 warning (0, "global declaration %q+#D", oldglobal
);
1048 /* If we have a local external declaration,
1049 and no file-scope declaration has yet been seen,
1050 then if we later have a file-scope decl it must not be static. */
1051 if (oldlocal
== NULL_TREE
1052 && oldglobal
== NULL_TREE
1053 && DECL_EXTERNAL (x
)
1055 TREE_PUBLIC (name
) = 1;
1057 /* Don't complain about the parms we push and then pop
1058 while tentatively parsing a function declarator. */
1059 if (TREE_CODE (x
) == PARM_DECL
&& DECL_CONTEXT (x
) == NULL_TREE
)
1062 /* Warn if shadowing an argument at the top level of the body. */
1063 else if (oldlocal
!= NULL_TREE
&& !DECL_EXTERNAL (x
)
1064 /* Inline decls shadow nothing. */
1065 && !DECL_FROM_INLINE (x
)
1066 && (TREE_CODE (oldlocal
) == PARM_DECL
1067 || TREE_CODE (oldlocal
) == VAR_DECL
1068 /* If the old decl is a type decl, only warn if the
1069 old decl is an explicit typedef or if both the old
1070 and new decls are type decls. */
1071 || (TREE_CODE (oldlocal
) == TYPE_DECL
1072 && (!DECL_ARTIFICIAL (oldlocal
)
1073 || TREE_CODE (x
) == TYPE_DECL
)))
1074 /* Don't check for internally generated vars unless
1075 it's an implicit typedef (see create_implicit_typedef
1077 && (!DECL_ARTIFICIAL (x
) || DECL_IMPLICIT_TYPEDEF_P (x
)))
1079 bool nowarn
= false;
1081 /* Don't complain if it's from an enclosing function. */
1082 if (DECL_CONTEXT (oldlocal
) == current_function_decl
1083 && TREE_CODE (x
) != PARM_DECL
1084 && TREE_CODE (oldlocal
) == PARM_DECL
)
1086 /* Go to where the parms should be and see if we find
1088 cp_binding_level
*b
= current_binding_level
->level_chain
;
1090 if (FUNCTION_NEEDS_BODY_BLOCK (current_function_decl
))
1091 /* Skip the ctor/dtor cleanup level. */
1095 if (b
->kind
== sk_function_parms
)
1097 error ("declaration of %q#D shadows a parameter", x
);
1102 /* The local structure or class can't use parameters of
1103 the containing function anyway. */
1104 if (DECL_CONTEXT (oldlocal
) != current_function_decl
)
1106 cp_binding_level
*scope
= current_binding_level
;
1107 tree context
= DECL_CONTEXT (oldlocal
);
1108 for (; scope
; scope
= scope
->level_chain
)
1110 if (scope
->kind
== sk_function_parms
1111 && scope
->this_entity
== context
)
1113 if (scope
->kind
== sk_class
1114 && !LAMBDA_TYPE_P (scope
->this_entity
))
1121 /* Error if redeclaring a local declared in a
1122 for-init-statement or in the condition of an if or
1123 switch statement when the new declaration is in the
1124 outermost block of the controlled statement.
1125 Redeclaring a variable from a for or while condition is
1126 detected elsewhere. */
1127 else if (TREE_CODE (oldlocal
) == VAR_DECL
1128 && oldscope
== current_binding_level
->level_chain
1129 && (oldscope
->kind
== sk_cond
1130 || oldscope
->kind
== sk_for
))
1132 error ("redeclaration of %q#D", x
);
1133 error ("%q+#D previously declared here", oldlocal
);
1136 if (warn_shadow
&& !nowarn
)
1138 if (TREE_CODE (oldlocal
) == PARM_DECL
)
1139 warning_at (input_location
, OPT_Wshadow
,
1140 "declaration of %q#D shadows a parameter", x
);
1141 else if (is_capture_proxy (oldlocal
))
1142 warning_at (input_location
, OPT_Wshadow
,
1143 "declaration of %qD shadows a lambda capture",
1146 warning_at (input_location
, OPT_Wshadow
,
1147 "declaration of %qD shadows a previous local",
1149 warning_at (DECL_SOURCE_LOCATION (oldlocal
), OPT_Wshadow
,
1150 "shadowed declaration is here");
1154 /* Maybe warn if shadowing something else. */
1155 else if (warn_shadow
&& !DECL_EXTERNAL (x
)
1156 /* No shadow warnings for internally generated vars unless
1157 it's an implicit typedef (see create_implicit_typedef
1159 && (! DECL_ARTIFICIAL (x
) || DECL_IMPLICIT_TYPEDEF_P (x
))
1160 /* No shadow warnings for vars made for inlining. */
1161 && ! DECL_FROM_INLINE (x
))
1165 if (current_class_ptr
)
1166 member
= lookup_member (current_class_type
,
1169 /*want_type=*/false,
1170 tf_warning_or_error
);
1174 if (member
&& !TREE_STATIC (member
))
1176 /* Location of previous decl is not useful in this case. */
1177 warning (OPT_Wshadow
, "declaration of %qD shadows a member of 'this'",
1180 else if (oldglobal
!= NULL_TREE
1181 && (TREE_CODE (oldglobal
) == VAR_DECL
1182 /* If the old decl is a type decl, only warn if the
1183 old decl is an explicit typedef or if both the
1184 old and new decls are type decls. */
1185 || (TREE_CODE (oldglobal
) == TYPE_DECL
1186 && (!DECL_ARTIFICIAL (oldglobal
)
1187 || TREE_CODE (x
) == TYPE_DECL
))))
1188 /* XXX shadow warnings in outer-more namespaces */
1190 warning_at (input_location
, OPT_Wshadow
,
1191 "declaration of %qD shadows a global declaration", x
);
1192 warning_at (DECL_SOURCE_LOCATION (oldglobal
), OPT_Wshadow
,
1193 "shadowed declaration is here");
1198 if (TREE_CODE (x
) == VAR_DECL
)
1199 maybe_register_incomplete_var (x
);
1202 if (need_new_binding
)
1203 add_decl_to_level (x
,
1204 DECL_NAMESPACE_SCOPE_P (x
)
1205 ? NAMESPACE_LEVEL (CP_DECL_CONTEXT (x
))
1206 : current_binding_level
);
1211 /* Wrapper for pushdecl_maybe_friend_1. */
1214 pushdecl_maybe_friend (tree x
, bool is_friend
)
1217 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
1218 ret
= pushdecl_maybe_friend_1 (x
, is_friend
);
1219 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
1223 /* Record a decl-node X as belonging to the current lexical scope. */
1228 return pushdecl_maybe_friend (x
, false);
1231 /* Enter DECL into the symbol table, if that's appropriate. Returns
1232 DECL, or a modified version thereof. */
1235 maybe_push_decl (tree decl
)
1237 tree type
= TREE_TYPE (decl
);
1239 /* Add this decl to the current binding level, but not if it comes
1240 from another scope, e.g. a static member variable. TEM may equal
1241 DECL or it may be a previous decl of the same name. */
1242 if (decl
== error_mark_node
1243 || (TREE_CODE (decl
) != PARM_DECL
1244 && DECL_CONTEXT (decl
) != NULL_TREE
1245 /* Definitions of namespace members outside their namespace are
1247 && !DECL_NAMESPACE_SCOPE_P (decl
))
1248 || (TREE_CODE (decl
) == TEMPLATE_DECL
&& !namespace_bindings_p ())
1249 || type
== unknown_type_node
1250 /* The declaration of a template specialization does not affect
1251 the functions available for overload resolution, so we do not
1253 || (TREE_CODE (decl
) == FUNCTION_DECL
1254 && DECL_TEMPLATE_SPECIALIZATION (decl
)))
1257 return pushdecl (decl
);
1260 /* Bind DECL to ID in the current_binding_level, assumed to be a local
1261 binding level. If PUSH_USING is set in FLAGS, we know that DECL
1262 doesn't really belong to this binding level, that it got here
1263 through a using-declaration. */
1266 push_local_binding (tree id
, tree decl
, int flags
)
1268 cp_binding_level
*b
;
1270 /* Skip over any local classes. This makes sense if we call
1271 push_local_binding with a friend decl of a local class. */
1272 b
= innermost_nonclass_level ();
1274 if (lookup_name_innermost_nonclass_level (id
))
1276 /* Supplement the existing binding. */
1277 if (!supplement_binding (IDENTIFIER_BINDING (id
), decl
))
1278 /* It didn't work. Something else must be bound at this
1279 level. Do not add DECL to the list of things to pop
1284 /* Create a new binding. */
1285 push_binding (id
, decl
, b
);
1287 if (TREE_CODE (decl
) == OVERLOAD
|| (flags
& PUSH_USING
))
1288 /* We must put the OVERLOAD into a TREE_LIST since the
1289 TREE_CHAIN of an OVERLOAD is already used. Similarly for
1290 decls that got here through a using-declaration. */
1291 decl
= build_tree_list (NULL_TREE
, decl
);
1293 /* And put DECL on the list of things declared by the current
1295 add_decl_to_level (decl
, b
);
1298 /* Check to see whether or not DECL is a variable that would have been
1299 in scope under the ARM, but is not in scope under the ANSI/ISO
1300 standard. If so, issue an error message. If name lookup would
1301 work in both cases, but return a different result, this function
1302 returns the result of ANSI/ISO lookup. Otherwise, it returns
1306 check_for_out_of_scope_variable (tree decl
)
1310 /* We only care about out of scope variables. */
1311 if (!(TREE_CODE (decl
) == VAR_DECL
&& DECL_DEAD_FOR_LOCAL (decl
)))
1314 shadowed
= DECL_HAS_SHADOWED_FOR_VAR_P (decl
)
1315 ? DECL_SHADOWED_FOR_VAR (decl
) : NULL_TREE
;
1316 while (shadowed
!= NULL_TREE
&& TREE_CODE (shadowed
) == VAR_DECL
1317 && DECL_DEAD_FOR_LOCAL (shadowed
))
1318 shadowed
= DECL_HAS_SHADOWED_FOR_VAR_P (shadowed
)
1319 ? DECL_SHADOWED_FOR_VAR (shadowed
) : NULL_TREE
;
1321 shadowed
= IDENTIFIER_NAMESPACE_VALUE (DECL_NAME (decl
));
1324 if (!DECL_ERROR_REPORTED (decl
))
1326 warning (0, "name lookup of %qD changed", DECL_NAME (decl
));
1327 warning (0, " matches this %q+D under ISO standard rules",
1329 warning (0, " matches this %q+D under old rules", decl
);
1330 DECL_ERROR_REPORTED (decl
) = 1;
1335 /* If we have already complained about this declaration, there's no
1336 need to do it again. */
1337 if (DECL_ERROR_REPORTED (decl
))
1340 DECL_ERROR_REPORTED (decl
) = 1;
1342 if (TREE_TYPE (decl
) == error_mark_node
)
1345 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TREE_TYPE (decl
)))
1347 error ("name lookup of %qD changed for ISO %<for%> scoping",
1349 error (" cannot use obsolete binding at %q+D because "
1350 "it has a destructor", decl
);
1351 return error_mark_node
;
1355 permerror (input_location
, "name lookup of %qD changed for ISO %<for%> scoping",
1357 if (flag_permissive
)
1358 permerror (input_location
, " using obsolete binding at %q+D", decl
);
1364 inform (input_location
, "(if you use %<-fpermissive%> G++ will accept your code)");
1373 /* true means unconditionally make a BLOCK for the next level pushed. */
1375 static bool keep_next_level_flag
;
1377 static int binding_depth
= 0;
1384 for (i
= 0; i
< depth
* 2; i
++)
1388 /* Return a string describing the kind of SCOPE we have. */
1390 cp_binding_level_descriptor (cp_binding_level
*scope
)
1392 /* The order of this table must match the "scope_kind"
1394 static const char* scope_kind_names
[] = {
1400 "function-parameter-scope",
1403 "template-parameter-scope",
1404 "template-explicit-spec-scope"
1406 const scope_kind kind
= scope
->explicit_spec_p
1407 ? sk_template_spec
: scope
->kind
;
1409 return scope_kind_names
[kind
];
1412 /* Output a debugging information about SCOPE when performing
1415 cp_binding_level_debug (cp_binding_level
*scope
, int line
, const char *action
)
1417 const char *desc
= cp_binding_level_descriptor (scope
);
1418 if (scope
->this_entity
)
1419 verbatim ("%s %s(%E) %p %d\n", action
, desc
,
1420 scope
->this_entity
, (void *) scope
, line
);
1422 verbatim ("%s %s %p %d\n", action
, desc
, (void *) scope
, line
);
1425 /* Return the estimated initial size of the hashtable of a NAMESPACE
1428 static inline size_t
1429 namespace_scope_ht_size (tree ns
)
1431 tree name
= DECL_NAME (ns
);
1433 return name
== std_identifier
1434 ? NAMESPACE_STD_HT_SIZE
1435 : (name
== global_scope_name
1436 ? GLOBAL_SCOPE_HT_SIZE
1437 : NAMESPACE_ORDINARY_HT_SIZE
);
1440 /* A chain of binding_level structures awaiting reuse. */
1442 static GTY((deletable
)) cp_binding_level
*free_binding_level
;
1444 /* Insert SCOPE as the innermost binding level. */
1447 push_binding_level (cp_binding_level
*scope
)
1449 /* Add it to the front of currently active scopes stack. */
1450 scope
->level_chain
= current_binding_level
;
1451 current_binding_level
= scope
;
1452 keep_next_level_flag
= false;
1454 if (ENABLE_SCOPE_CHECKING
)
1456 scope
->binding_depth
= binding_depth
;
1457 indent (binding_depth
);
1458 cp_binding_level_debug (scope
, input_line
, "push");
1463 /* Create a new KIND scope and make it the top of the active scopes stack.
1464 ENTITY is the scope of the associated C++ entity (namespace, class,
1465 function, C++0x enumeration); it is NULL otherwise. */
1468 begin_scope (scope_kind kind
, tree entity
)
1470 cp_binding_level
*scope
;
1472 /* Reuse or create a struct for this binding level. */
1473 if (!ENABLE_SCOPE_CHECKING
&& free_binding_level
)
1475 scope
= free_binding_level
;
1476 memset (scope
, 0, sizeof (cp_binding_level
));
1477 free_binding_level
= scope
->level_chain
;
1480 scope
= ggc_alloc_cleared_cp_binding_level ();
1482 scope
->this_entity
= entity
;
1483 scope
->more_cleanups_ok
= true;
1490 case sk_template_spec
:
1491 scope
->explicit_spec_p
= true;
1492 kind
= sk_template_parms
;
1494 case sk_template_parms
:
1501 case sk_scoped_enum
:
1502 case sk_function_parms
:
1504 scope
->keep
= keep_next_level_flag
;
1508 NAMESPACE_LEVEL (entity
) = scope
;
1509 scope
->static_decls
=
1510 VEC_alloc (tree
, gc
,
1511 DECL_NAME (entity
) == std_identifier
1512 || DECL_NAME (entity
) == global_scope_name
1517 /* Should not happen. */
1523 push_binding_level (scope
);
1528 /* We're about to leave current scope. Pop the top of the stack of
1529 currently active scopes. Return the enclosing scope, now active. */
1534 cp_binding_level
*scope
= current_binding_level
;
1536 if (scope
->kind
== sk_namespace
&& class_binding_level
)
1537 current_binding_level
= class_binding_level
;
1539 /* We cannot leave a scope, if there are none left. */
1540 if (NAMESPACE_LEVEL (global_namespace
))
1541 gcc_assert (!global_scope_p (scope
));
1543 if (ENABLE_SCOPE_CHECKING
)
1545 indent (--binding_depth
);
1546 cp_binding_level_debug (scope
, input_line
, "leave");
1549 /* Move one nesting level up. */
1550 current_binding_level
= scope
->level_chain
;
1552 /* Namespace-scopes are left most probably temporarily, not
1553 completely; they can be reopened later, e.g. in namespace-extension
1554 or any name binding activity that requires us to resume a
1555 namespace. For classes, we cache some binding levels. For other
1556 scopes, we just make the structure available for reuse. */
1557 if (scope
->kind
!= sk_namespace
1558 && scope
->kind
!= sk_class
)
1560 scope
->level_chain
= free_binding_level
;
1561 gcc_assert (!ENABLE_SCOPE_CHECKING
1562 || scope
->binding_depth
== binding_depth
);
1563 free_binding_level
= scope
;
1566 /* Find the innermost enclosing class scope, and reset
1567 CLASS_BINDING_LEVEL appropriately. */
1568 if (scope
->kind
== sk_class
)
1570 class_binding_level
= NULL
;
1571 for (scope
= current_binding_level
; scope
; scope
= scope
->level_chain
)
1572 if (scope
->kind
== sk_class
)
1574 class_binding_level
= scope
;
1579 return current_binding_level
;
1583 resume_scope (cp_binding_level
* b
)
1585 /* Resuming binding levels is meant only for namespaces,
1586 and those cannot nest into classes. */
1587 gcc_assert (!class_binding_level
);
1588 /* Also, resuming a non-directly nested namespace is a no-no. */
1589 gcc_assert (b
->level_chain
== current_binding_level
);
1590 current_binding_level
= b
;
1591 if (ENABLE_SCOPE_CHECKING
)
1593 b
->binding_depth
= binding_depth
;
1594 indent (binding_depth
);
1595 cp_binding_level_debug (b
, input_line
, "resume");
1600 /* Return the innermost binding level that is not for a class scope. */
1602 static cp_binding_level
*
1603 innermost_nonclass_level (void)
1605 cp_binding_level
*b
;
1607 b
= current_binding_level
;
1608 while (b
->kind
== sk_class
)
1614 /* We're defining an object of type TYPE. If it needs a cleanup, but
1615 we're not allowed to add any more objects with cleanups to the current
1616 scope, create a new binding level. */
1619 maybe_push_cleanup_level (tree type
)
1621 if (type
!= error_mark_node
1622 && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
)
1623 && current_binding_level
->more_cleanups_ok
== 0)
1625 begin_scope (sk_cleanup
, NULL
);
1626 current_binding_level
->statement_list
= push_stmt_list ();
1630 /* Return true if we are in the global binding level. */
1633 global_bindings_p (void)
1635 return global_scope_p (current_binding_level
);
1638 /* True if we are currently in a toplevel binding level. This
1639 means either the global binding level or a namespace in a toplevel
1640 binding level. Since there are no non-toplevel namespace levels,
1641 this really means any namespace or template parameter level. We
1642 also include a class whose context is toplevel. */
1645 toplevel_bindings_p (void)
1647 cp_binding_level
*b
= innermost_nonclass_level ();
1649 return b
->kind
== sk_namespace
|| b
->kind
== sk_template_parms
;
1652 /* True if this is a namespace scope, or if we are defining a class
1653 which is itself at namespace scope, or whose enclosing class is
1654 such a class, etc. */
1657 namespace_bindings_p (void)
1659 cp_binding_level
*b
= innermost_nonclass_level ();
1661 return b
->kind
== sk_namespace
;
1664 /* True if the innermost non-class scope is a block scope. */
1667 local_bindings_p (void)
1669 cp_binding_level
*b
= innermost_nonclass_level ();
1670 return b
->kind
< sk_function_parms
|| b
->kind
== sk_omp
;
1673 /* True if the current level needs to have a BLOCK made. */
1678 return (current_binding_level
->blocks
!= NULL_TREE
1679 || current_binding_level
->keep
1680 || current_binding_level
->kind
== sk_cleanup
1681 || current_binding_level
->names
!= NULL_TREE
1682 || current_binding_level
->using_directives
);
1685 /* Returns the kind of the innermost scope. */
1688 innermost_scope_kind (void)
1690 return current_binding_level
->kind
;
1693 /* Returns true if this scope was created to store template parameters. */
1696 template_parm_scope_p (void)
1698 return innermost_scope_kind () == sk_template_parms
;
1701 /* If KEEP is true, make a BLOCK node for the next binding level,
1702 unconditionally. Otherwise, use the normal logic to decide whether
1703 or not to create a BLOCK. */
1706 keep_next_level (bool keep
)
1708 keep_next_level_flag
= keep
;
1711 /* Return the list of declarations of the current level.
1712 Note that this list is in reverse order unless/until
1713 you nreverse it; and when you do nreverse it, you must
1714 store the result back using `storedecls' or you will lose. */
1719 return current_binding_level
->names
;
1722 /* Return how many function prototypes we are currently nested inside. */
1725 function_parm_depth (void)
1728 cp_binding_level
*b
;
1730 for (b
= current_binding_level
;
1731 b
->kind
== sk_function_parms
;
1738 /* For debugging. */
1739 static int no_print_functions
= 0;
1740 static int no_print_builtins
= 0;
1743 print_binding_level (cp_binding_level
* lvl
)
1747 fprintf (stderr
, " blocks=%p", (void *) lvl
->blocks
);
1748 if (lvl
->more_cleanups_ok
)
1749 fprintf (stderr
, " more-cleanups-ok");
1750 if (lvl
->have_cleanups
)
1751 fprintf (stderr
, " have-cleanups");
1752 fprintf (stderr
, "\n");
1755 fprintf (stderr
, " names:\t");
1756 /* We can probably fit 3 names to a line? */
1757 for (t
= lvl
->names
; t
; t
= TREE_CHAIN (t
))
1759 if (no_print_functions
&& (TREE_CODE (t
) == FUNCTION_DECL
))
1761 if (no_print_builtins
1762 && (TREE_CODE (t
) == TYPE_DECL
)
1763 && DECL_IS_BUILTIN (t
))
1766 /* Function decls tend to have longer names. */
1767 if (TREE_CODE (t
) == FUNCTION_DECL
)
1774 fprintf (stderr
, "\n\t");
1777 print_node_brief (stderr
, "", t
, 0);
1778 if (t
== error_mark_node
)
1782 fprintf (stderr
, "\n");
1784 if (VEC_length (cp_class_binding
, lvl
->class_shadowed
))
1787 cp_class_binding
*b
;
1788 fprintf (stderr
, " class-shadowed:");
1789 FOR_EACH_VEC_ELT (cp_class_binding
, lvl
->class_shadowed
, i
, b
)
1790 fprintf (stderr
, " %s ", IDENTIFIER_POINTER (b
->identifier
));
1791 fprintf (stderr
, "\n");
1793 if (lvl
->type_shadowed
)
1795 fprintf (stderr
, " type-shadowed:");
1796 for (t
= lvl
->type_shadowed
; t
; t
= TREE_CHAIN (t
))
1798 fprintf (stderr
, " %s ", IDENTIFIER_POINTER (TREE_PURPOSE (t
)));
1800 fprintf (stderr
, "\n");
1805 print_other_binding_stack (cp_binding_level
*stack
)
1807 cp_binding_level
*level
;
1808 for (level
= stack
; !global_scope_p (level
); level
= level
->level_chain
)
1810 fprintf (stderr
, "binding level %p\n", (void *) level
);
1811 print_binding_level (level
);
1816 print_binding_stack (void)
1818 cp_binding_level
*b
;
1819 fprintf (stderr
, "current_binding_level=%p\n"
1820 "class_binding_level=%p\n"
1821 "NAMESPACE_LEVEL (global_namespace)=%p\n",
1822 (void *) current_binding_level
, (void *) class_binding_level
,
1823 (void *) NAMESPACE_LEVEL (global_namespace
));
1824 if (class_binding_level
)
1826 for (b
= class_binding_level
; b
; b
= b
->level_chain
)
1827 if (b
== current_binding_level
)
1830 b
= class_binding_level
;
1832 b
= current_binding_level
;
1835 b
= current_binding_level
;
1836 print_other_binding_stack (b
);
1837 fprintf (stderr
, "global:\n");
1838 print_binding_level (NAMESPACE_LEVEL (global_namespace
));
1841 /* Return the type associated with ID. */
1844 identifier_type_value_1 (tree id
)
1846 /* There is no type with that name, anywhere. */
1847 if (REAL_IDENTIFIER_TYPE_VALUE (id
) == NULL_TREE
)
1849 /* This is not the type marker, but the real thing. */
1850 if (REAL_IDENTIFIER_TYPE_VALUE (id
) != global_type_node
)
1851 return REAL_IDENTIFIER_TYPE_VALUE (id
);
1852 /* Have to search for it. It must be on the global level, now.
1853 Ask lookup_name not to return non-types. */
1854 id
= lookup_name_real (id
, 2, 1, /*block_p=*/true, 0, 0);
1856 return TREE_TYPE (id
);
1860 /* Wrapper for identifier_type_value_1. */
1863 identifier_type_value (tree id
)
1866 timevar_start (TV_NAME_LOOKUP
);
1867 ret
= identifier_type_value_1 (id
);
1868 timevar_stop (TV_NAME_LOOKUP
);
1873 /* Return the IDENTIFIER_GLOBAL_VALUE of T, for use in common code, since
1874 the definition of IDENTIFIER_GLOBAL_VALUE is different for C and C++. */
1877 identifier_global_value (tree t
)
1879 return IDENTIFIER_GLOBAL_VALUE (t
);
1882 /* Push a definition of struct, union or enum tag named ID. into
1883 binding_level B. DECL is a TYPE_DECL for the type. We assume that
1884 the tag ID is not already defined. */
1887 set_identifier_type_value_with_scope (tree id
, tree decl
, cp_binding_level
*b
)
1891 if (b
->kind
!= sk_namespace
)
1893 /* Shadow the marker, not the real thing, so that the marker
1894 gets restored later. */
1895 tree old_type_value
= REAL_IDENTIFIER_TYPE_VALUE (id
);
1897 = tree_cons (id
, old_type_value
, b
->type_shadowed
);
1898 type
= decl
? TREE_TYPE (decl
) : NULL_TREE
;
1899 TREE_TYPE (b
->type_shadowed
) = type
;
1903 cxx_binding
*binding
=
1904 binding_for_name (NAMESPACE_LEVEL (current_namespace
), id
);
1907 supplement_binding (binding
, decl
);
1909 binding
->value
= decl
;
1911 /* Store marker instead of real type. */
1912 type
= global_type_node
;
1914 SET_IDENTIFIER_TYPE_VALUE (id
, type
);
1917 /* As set_identifier_type_value_with_scope, but using
1918 current_binding_level. */
1921 set_identifier_type_value (tree id
, tree decl
)
1923 set_identifier_type_value_with_scope (id
, decl
, current_binding_level
);
1926 /* Return the name for the constructor (or destructor) for the
1927 specified class TYPE. When given a template, this routine doesn't
1928 lose the specialization. */
1931 constructor_name_full (tree type
)
1933 return TYPE_IDENTIFIER (TYPE_MAIN_VARIANT (type
));
1936 /* Return the name for the constructor (or destructor) for the
1937 specified class. When given a template, return the plain
1938 unspecialized name. */
1941 constructor_name (tree type
)
1944 name
= constructor_name_full (type
);
1945 if (IDENTIFIER_TEMPLATE (name
))
1946 name
= IDENTIFIER_TEMPLATE (name
);
1950 /* Returns TRUE if NAME is the name for the constructor for TYPE,
1951 which must be a class type. */
1954 constructor_name_p (tree name
, tree type
)
1958 gcc_assert (MAYBE_CLASS_TYPE_P (type
));
1963 if (TREE_CODE (name
) != IDENTIFIER_NODE
)
1966 /* These don't have names. */
1967 if (TREE_CODE (type
) == DECLTYPE_TYPE
1968 || TREE_CODE (type
) == TYPEOF_TYPE
)
1971 ctor_name
= constructor_name_full (type
);
1972 if (name
== ctor_name
)
1974 if (IDENTIFIER_TEMPLATE (ctor_name
)
1975 && name
== IDENTIFIER_TEMPLATE (ctor_name
))
1980 /* Counter used to create anonymous type names. */
1982 static GTY(()) int anon_cnt
;
1984 /* Return an IDENTIFIER which can be used as a name for
1985 anonymous structs and unions. */
1988 make_anon_name (void)
1992 sprintf (buf
, ANON_AGGRNAME_FORMAT
, anon_cnt
++);
1993 return get_identifier (buf
);
1996 /* This code is practically identical to that for creating
1997 anonymous names, but is just used for lambdas instead. This isn't really
1998 necessary, but it's convenient to avoid treating lambdas like other
2001 static GTY(()) int lambda_cnt
= 0;
2004 make_lambda_name (void)
2008 sprintf (buf
, LAMBDANAME_FORMAT
, lambda_cnt
++);
2009 return get_identifier (buf
);
2012 /* Return (from the stack of) the BINDING, if any, established at SCOPE. */
2014 static inline cxx_binding
*
2015 find_binding (cp_binding_level
*scope
, cxx_binding
*binding
)
2017 for (; binding
!= NULL
; binding
= binding
->previous
)
2018 if (binding
->scope
== scope
)
2021 return (cxx_binding
*)0;
2024 /* Return the binding for NAME in SCOPE, if any. Otherwise, return NULL. */
2026 static inline cxx_binding
*
2027 cp_binding_level_find_binding_for_name (cp_binding_level
*scope
, tree name
)
2029 cxx_binding
*b
= IDENTIFIER_NAMESPACE_BINDINGS (name
);
2032 /* Fold-in case where NAME is used only once. */
2033 if (scope
== b
->scope
&& b
->previous
== NULL
)
2035 return find_binding (scope
, b
);
2040 /* Always returns a binding for name in scope. If no binding is
2041 found, make a new one. */
2043 static cxx_binding
*
2044 binding_for_name (cp_binding_level
*scope
, tree name
)
2046 cxx_binding
*result
;
2048 result
= cp_binding_level_find_binding_for_name (scope
, name
);
2051 /* Not found, make a new one. */
2052 result
= cxx_binding_make (NULL
, NULL
);
2053 result
->previous
= IDENTIFIER_NAMESPACE_BINDINGS (name
);
2054 result
->scope
= scope
;
2055 result
->is_local
= false;
2056 result
->value_is_inherited
= false;
2057 IDENTIFIER_NAMESPACE_BINDINGS (name
) = result
;
2061 /* Walk through the bindings associated to the name of FUNCTION,
2062 and return the first declaration of a function with a
2063 "C" linkage specification, a.k.a 'extern "C"'.
2064 This function looks for the binding, regardless of which scope it
2065 has been defined in. It basically looks in all the known scopes.
2066 Note that this function does not lookup for bindings of builtin functions
2067 or for functions declared in system headers. */
2069 lookup_extern_c_fun_in_all_ns (tree function
)
2074 gcc_assert (function
&& TREE_CODE (function
) == FUNCTION_DECL
);
2076 name
= DECL_NAME (function
);
2077 gcc_assert (name
&& TREE_CODE (name
) == IDENTIFIER_NODE
);
2079 for (iter
= IDENTIFIER_NAMESPACE_BINDINGS (name
);
2081 iter
= iter
->previous
)
2084 for (ovl
= iter
->value
; ovl
; ovl
= OVL_NEXT (ovl
))
2086 tree decl
= OVL_CURRENT (ovl
);
2088 && TREE_CODE (decl
) == FUNCTION_DECL
2089 && DECL_EXTERN_C_P (decl
)
2090 && !DECL_ARTIFICIAL (decl
))
2099 /* Returns a list of C-linkage decls with the name NAME. */
2102 c_linkage_bindings (tree name
)
2104 tree decls
= NULL_TREE
;
2107 for (iter
= IDENTIFIER_NAMESPACE_BINDINGS (name
);
2109 iter
= iter
->previous
)
2112 for (ovl
= iter
->value
; ovl
; ovl
= OVL_NEXT (ovl
))
2114 tree decl
= OVL_CURRENT (ovl
);
2116 && DECL_EXTERN_C_P (decl
)
2117 && !DECL_ARTIFICIAL (decl
))
2119 if (decls
== NULL_TREE
)
2122 decls
= tree_cons (NULL_TREE
, decl
, decls
);
2129 /* Insert another USING_DECL into the current binding level, returning
2130 this declaration. If this is a redeclaration, do nothing, and
2131 return NULL_TREE if this not in namespace scope (in namespace
2132 scope, a using decl might extend any previous bindings). */
2135 push_using_decl_1 (tree scope
, tree name
)
2139 gcc_assert (TREE_CODE (scope
) == NAMESPACE_DECL
);
2140 gcc_assert (TREE_CODE (name
) == IDENTIFIER_NODE
);
2141 for (decl
= current_binding_level
->usings
; decl
; decl
= DECL_CHAIN (decl
))
2142 if (USING_DECL_SCOPE (decl
) == scope
&& DECL_NAME (decl
) == name
)
2145 return namespace_bindings_p () ? decl
: NULL_TREE
;
2146 decl
= build_lang_decl (USING_DECL
, name
, NULL_TREE
);
2147 USING_DECL_SCOPE (decl
) = scope
;
2148 DECL_CHAIN (decl
) = current_binding_level
->usings
;
2149 current_binding_level
->usings
= decl
;
2153 /* Wrapper for push_using_decl_1. */
2156 push_using_decl (tree scope
, tree name
)
2159 timevar_start (TV_NAME_LOOKUP
);
2160 ret
= push_using_decl_1 (scope
, name
);
2161 timevar_stop (TV_NAME_LOOKUP
);
2165 /* Same as pushdecl, but define X in binding-level LEVEL. We rely on the
2166 caller to set DECL_CONTEXT properly.
2168 Note that this must only be used when X will be the new innermost
2169 binding for its name, as we tack it onto the front of IDENTIFIER_BINDING
2170 without checking to see if the current IDENTIFIER_BINDING comes from a
2171 closer binding level than LEVEL. */
2174 pushdecl_with_scope_1 (tree x
, cp_binding_level
*level
, bool is_friend
)
2176 cp_binding_level
*b
;
2177 tree function_decl
= current_function_decl
;
2179 current_function_decl
= NULL_TREE
;
2180 if (level
->kind
== sk_class
)
2182 b
= class_binding_level
;
2183 class_binding_level
= level
;
2184 pushdecl_class_level (x
);
2185 class_binding_level
= b
;
2189 b
= current_binding_level
;
2190 current_binding_level
= level
;
2191 x
= pushdecl_maybe_friend (x
, is_friend
);
2192 current_binding_level
= b
;
2194 current_function_decl
= function_decl
;
2198 /* Wrapper for pushdecl_with_scope_1. */
2201 pushdecl_with_scope (tree x
, cp_binding_level
*level
, bool is_friend
)
2204 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
2205 ret
= pushdecl_with_scope_1 (x
, level
, is_friend
);
2206 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
2211 /* DECL is a FUNCTION_DECL for a non-member function, which may have
2212 other definitions already in place. We get around this by making
2213 the value of the identifier point to a list of all the things that
2214 want to be referenced by that name. It is then up to the users of
2215 that name to decide what to do with that list.
2217 DECL may also be a TEMPLATE_DECL, with a FUNCTION_DECL in its
2218 DECL_TEMPLATE_RESULT. It is dealt with the same way.
2220 FLAGS is a bitwise-or of the following values:
2221 PUSH_LOCAL: Bind DECL in the current scope, rather than at
2223 PUSH_USING: DECL is being pushed as the result of a using
2226 IS_FRIEND is true if this is a friend declaration.
2228 The value returned may be a previous declaration if we guessed wrong
2229 about what language DECL should belong to (C or C++). Otherwise,
2230 it's always DECL (and never something that's not a _DECL). */
2233 push_overloaded_decl_1 (tree decl
, int flags
, bool is_friend
)
2235 tree name
= DECL_NAME (decl
);
2238 int doing_global
= (namespace_bindings_p () || !(flags
& PUSH_LOCAL
));
2241 old
= namespace_binding (name
, DECL_CONTEXT (decl
));
2243 old
= lookup_name_innermost_nonclass_level (name
);
2247 if (TREE_CODE (old
) == TYPE_DECL
&& DECL_ARTIFICIAL (old
))
2249 tree t
= TREE_TYPE (old
);
2250 if (MAYBE_CLASS_TYPE_P (t
) && warn_shadow
2251 && (! DECL_IN_SYSTEM_HEADER (decl
)
2252 || ! DECL_IN_SYSTEM_HEADER (old
)))
2253 warning (OPT_Wshadow
, "%q#D hides constructor for %q#T", decl
, t
);
2256 else if (is_overloaded_fn (old
))
2260 for (tmp
= old
; tmp
; tmp
= OVL_NEXT (tmp
))
2262 tree fn
= OVL_CURRENT (tmp
);
2265 if (TREE_CODE (tmp
) == OVERLOAD
&& OVL_USED (tmp
)
2266 && !(flags
& PUSH_USING
)
2267 && compparms (TYPE_ARG_TYPES (TREE_TYPE (fn
)),
2268 TYPE_ARG_TYPES (TREE_TYPE (decl
)))
2269 && ! decls_match (fn
, decl
))
2270 error ("%q#D conflicts with previous using declaration %q#D",
2273 dup
= duplicate_decls (decl
, fn
, is_friend
);
2274 /* If DECL was a redeclaration of FN -- even an invalid
2275 one -- pass that information along to our caller. */
2276 if (dup
== fn
|| dup
== error_mark_node
)
2280 /* We don't overload implicit built-ins. duplicate_decls()
2281 may fail to merge the decls if the new decl is e.g. a
2282 template function. */
2283 if (TREE_CODE (old
) == FUNCTION_DECL
2284 && DECL_ANTICIPATED (old
)
2285 && !DECL_HIDDEN_FRIEND_P (old
))
2288 else if (old
== error_mark_node
)
2289 /* Ignore the undefined symbol marker. */
2293 error ("previous non-function declaration %q+#D", old
);
2294 error ("conflicts with function declaration %q#D", decl
);
2299 if (old
|| TREE_CODE (decl
) == TEMPLATE_DECL
2300 /* If it's a using declaration, we always need to build an OVERLOAD,
2301 because it's the only way to remember that the declaration comes
2302 from 'using', and have the lookup behave correctly. */
2303 || (flags
& PUSH_USING
))
2305 if (old
&& TREE_CODE (old
) != OVERLOAD
)
2306 new_binding
= ovl_cons (decl
, ovl_cons (old
, NULL_TREE
));
2308 new_binding
= ovl_cons (decl
, old
);
2309 if (flags
& PUSH_USING
)
2310 OVL_USED (new_binding
) = 1;
2313 /* NAME is not ambiguous. */
2317 set_namespace_binding (name
, current_namespace
, new_binding
);
2320 /* We only create an OVERLOAD if there was a previous binding at
2321 this level, or if decl is a template. In the former case, we
2322 need to remove the old binding and replace it with the new
2323 binding. We must also run through the NAMES on the binding
2324 level where the name was bound to update the chain. */
2326 if (TREE_CODE (new_binding
) == OVERLOAD
&& old
)
2330 for (d
= &IDENTIFIER_BINDING (name
)->scope
->names
;
2332 d
= &TREE_CHAIN (*d
))
2334 || (TREE_CODE (*d
) == TREE_LIST
2335 && TREE_VALUE (*d
) == old
))
2337 if (TREE_CODE (*d
) == TREE_LIST
)
2338 /* Just replace the old binding with the new. */
2339 TREE_VALUE (*d
) = new_binding
;
2341 /* Build a TREE_LIST to wrap the OVERLOAD. */
2342 *d
= tree_cons (NULL_TREE
, new_binding
,
2345 /* And update the cxx_binding node. */
2346 IDENTIFIER_BINDING (name
)->value
= new_binding
;
2350 /* We should always find a previous binding in this case. */
2354 /* Install the new binding. */
2355 push_local_binding (name
, new_binding
, flags
);
2361 /* Wrapper for push_overloaded_decl_1. */
2364 push_overloaded_decl (tree decl
, int flags
, bool is_friend
)
2367 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
2368 ret
= push_overloaded_decl_1 (decl
, flags
, is_friend
);
2369 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
2373 /* Check a non-member using-declaration. Return the name and scope
2374 being used, and the USING_DECL, or NULL_TREE on failure. */
2377 validate_nonmember_using_decl (tree decl
, tree scope
, tree name
)
2379 /* [namespace.udecl]
2380 A using-declaration for a class member shall be a
2381 member-declaration. */
2384 error ("%qT is not a namespace", scope
);
2387 else if (scope
== error_mark_node
)
2390 if (TREE_CODE (decl
) == TEMPLATE_ID_EXPR
)
2393 A using-declaration shall not name a template-id. */
2394 error ("a using-declaration cannot specify a template-id. "
2395 "Try %<using %D%>", name
);
2399 if (TREE_CODE (decl
) == NAMESPACE_DECL
)
2401 error ("namespace %qD not allowed in using-declaration", decl
);
2405 if (TREE_CODE (decl
) == SCOPE_REF
)
2407 /* It's a nested name with template parameter dependent scope.
2408 This can only be using-declaration for class member. */
2409 error ("%qT is not a namespace", TREE_OPERAND (decl
, 0));
2413 if (is_overloaded_fn (decl
))
2414 decl
= get_first_fn (decl
);
2416 gcc_assert (DECL_P (decl
));
2418 /* Make a USING_DECL. */
2419 tree using_decl
= push_using_decl (scope
, name
);
2421 if (using_decl
== NULL_TREE
2422 && at_function_scope_p ()
2423 && TREE_CODE (decl
) == VAR_DECL
)
2424 /* C++11 7.3.3/10. */
2425 error ("%qD is already declared in this scope", name
);
2430 /* Process local and global using-declarations. */
2433 do_nonmember_using_decl (tree scope
, tree name
, tree oldval
, tree oldtype
,
2434 tree
*newval
, tree
*newtype
)
2436 struct scope_binding decls
= EMPTY_SCOPE_BINDING
;
2438 *newval
= *newtype
= NULL_TREE
;
2439 if (!qualified_lookup_using_namespace (name
, scope
, &decls
, 0))
2443 if (!decls
.value
&& !decls
.type
)
2445 error ("%qD not declared", name
);
2449 /* Shift the old and new bindings around so we're comparing class and
2450 enumeration names to each other. */
2451 if (oldval
&& DECL_IMPLICIT_TYPEDEF_P (oldval
))
2457 if (decls
.value
&& DECL_IMPLICIT_TYPEDEF_P (decls
.value
))
2459 decls
.type
= decls
.value
;
2460 decls
.value
= NULL_TREE
;
2463 /* It is impossible to overload a built-in function; any explicit
2464 declaration eliminates the built-in declaration. So, if OLDVAL
2465 is a built-in, then we can just pretend it isn't there. */
2467 && TREE_CODE (oldval
) == FUNCTION_DECL
2468 && DECL_ANTICIPATED (oldval
)
2469 && !DECL_HIDDEN_FRIEND_P (oldval
))
2474 /* Check for using functions. */
2475 if (is_overloaded_fn (decls
.value
))
2479 if (oldval
&& !is_overloaded_fn (oldval
))
2481 error ("%qD is already declared in this scope", name
);
2486 for (tmp
= decls
.value
; tmp
; tmp
= OVL_NEXT (tmp
))
2488 tree new_fn
= OVL_CURRENT (tmp
);
2490 /* [namespace.udecl]
2492 If a function declaration in namespace scope or block
2493 scope has the same name and the same parameter types as a
2494 function introduced by a using declaration the program is
2496 for (tmp1
= oldval
; tmp1
; tmp1
= OVL_NEXT (tmp1
))
2498 tree old_fn
= OVL_CURRENT (tmp1
);
2500 if (new_fn
== old_fn
)
2501 /* The function already exists in the current namespace. */
2503 else if (OVL_USED (tmp1
))
2504 continue; /* this is a using decl */
2505 else if (compparms (TYPE_ARG_TYPES (TREE_TYPE (new_fn
)),
2506 TYPE_ARG_TYPES (TREE_TYPE (old_fn
))))
2508 gcc_assert (!DECL_ANTICIPATED (old_fn
)
2509 || DECL_HIDDEN_FRIEND_P (old_fn
));
2511 /* There was already a non-using declaration in
2512 this scope with the same parameter types. If both
2513 are the same extern "C" functions, that's ok. */
2514 if (decls_match (new_fn
, old_fn
))
2518 error ("%qD is already declared in this scope", name
);
2524 /* If we broke out of the loop, there's no reason to add
2525 this function to the using declarations for this
2530 /* If we are adding to an existing OVERLOAD, then we no
2531 longer know the type of the set of functions. */
2532 if (*newval
&& TREE_CODE (*newval
) == OVERLOAD
)
2533 TREE_TYPE (*newval
) = unknown_type_node
;
2534 /* Add this new function to the set. */
2535 *newval
= build_overload (OVL_CURRENT (tmp
), *newval
);
2536 /* If there is only one function, then we use its type. (A
2537 using-declaration naming a single function can be used in
2538 contexts where overload resolution cannot be
2540 if (TREE_CODE (*newval
) != OVERLOAD
)
2542 *newval
= ovl_cons (*newval
, NULL_TREE
);
2543 TREE_TYPE (*newval
) = TREE_TYPE (OVL_CURRENT (tmp
));
2545 OVL_USED (*newval
) = 1;
2550 *newval
= decls
.value
;
2551 if (oldval
&& !decls_match (*newval
, oldval
))
2552 error ("%qD is already declared in this scope", name
);
2558 if (decls
.type
&& TREE_CODE (decls
.type
) == TREE_LIST
)
2560 error ("reference to %qD is ambiguous", name
);
2561 print_candidates (decls
.type
);
2565 *newtype
= decls
.type
;
2566 if (oldtype
&& *newtype
&& !decls_match (oldtype
, *newtype
))
2567 error ("%qD is already declared in this scope", name
);
2570 /* If *newval is empty, shift any class or enumeration name down. */
2574 *newtype
= NULL_TREE
;
2578 /* Process a using-declaration at function scope. */
2581 do_local_using_decl (tree decl
, tree scope
, tree name
)
2583 tree oldval
, oldtype
, newval
, newtype
;
2584 tree orig_decl
= decl
;
2586 decl
= validate_nonmember_using_decl (decl
, scope
, name
);
2587 if (decl
== NULL_TREE
)
2590 if (building_stmt_list_p ()
2591 && at_function_scope_p ())
2592 add_decl_expr (decl
);
2594 oldval
= lookup_name_innermost_nonclass_level (name
);
2595 oldtype
= lookup_type_current_level (name
);
2597 do_nonmember_using_decl (scope
, name
, oldval
, oldtype
, &newval
, &newtype
);
2601 if (is_overloaded_fn (newval
))
2605 /* We only need to push declarations for those functions
2606 that were not already bound in the current level.
2607 The old value might be NULL_TREE, it might be a single
2608 function, or an OVERLOAD. */
2609 if (oldval
&& TREE_CODE (oldval
) == OVERLOAD
)
2610 term
= OVL_FUNCTION (oldval
);
2613 for (fn
= newval
; fn
&& OVL_CURRENT (fn
) != term
;
2615 push_overloaded_decl (OVL_CURRENT (fn
),
2616 PUSH_LOCAL
| PUSH_USING
,
2620 push_local_binding (name
, newval
, PUSH_USING
);
2624 push_local_binding (name
, newtype
, PUSH_USING
);
2625 set_identifier_type_value (name
, newtype
);
2628 /* Emit debug info. */
2629 if (!processing_template_decl
)
2630 cp_emit_debug_info_for_using (orig_decl
, current_scope());
2633 /* Returns true if ROOT (a namespace, class, or function) encloses
2634 CHILD. CHILD may be either a class type or a namespace. */
2637 is_ancestor (tree root
, tree child
)
2639 gcc_assert ((TREE_CODE (root
) == NAMESPACE_DECL
2640 || TREE_CODE (root
) == FUNCTION_DECL
2641 || CLASS_TYPE_P (root
)));
2642 gcc_assert ((TREE_CODE (child
) == NAMESPACE_DECL
2643 || CLASS_TYPE_P (child
)));
2645 /* The global namespace encloses everything. */
2646 if (root
== global_namespace
)
2651 /* If we've run out of scopes, stop. */
2654 /* If we've reached the ROOT, it encloses CHILD. */
2657 /* Go out one level. */
2659 child
= TYPE_NAME (child
);
2660 child
= DECL_CONTEXT (child
);
2664 /* Enter the class or namespace scope indicated by T suitable for name
2665 lookup. T can be arbitrary scope, not necessary nested inside the
2666 current scope. Returns a non-null scope to pop iff pop_scope
2667 should be called later to exit this scope. */
2672 if (TREE_CODE (t
) == NAMESPACE_DECL
)
2673 push_decl_namespace (t
);
2674 else if (CLASS_TYPE_P (t
))
2676 if (!at_class_scope_p ()
2677 || !same_type_p (current_class_type
, t
))
2678 push_nested_class (t
);
2680 /* T is the same as the current scope. There is therefore no
2681 need to re-enter the scope. Since we are not actually
2682 pushing a new scope, our caller should not call
2690 /* Leave scope pushed by push_scope. */
2697 if (TREE_CODE (t
) == NAMESPACE_DECL
)
2698 pop_decl_namespace ();
2699 else if CLASS_TYPE_P (t
)
2700 pop_nested_class ();
2703 /* Subroutine of push_inner_scope. */
2706 push_inner_scope_r (tree outer
, tree inner
)
2711 || (TREE_CODE (inner
) != NAMESPACE_DECL
&& !CLASS_TYPE_P (inner
)))
2714 prev
= CP_DECL_CONTEXT (TREE_CODE (inner
) == NAMESPACE_DECL
? inner
: TYPE_NAME (inner
));
2716 push_inner_scope_r (outer
, prev
);
2717 if (TREE_CODE (inner
) == NAMESPACE_DECL
)
2719 cp_binding_level
*save_template_parm
= 0;
2720 /* Temporary take out template parameter scopes. They are saved
2721 in reversed order in save_template_parm. */
2722 while (current_binding_level
->kind
== sk_template_parms
)
2724 cp_binding_level
*b
= current_binding_level
;
2725 current_binding_level
= b
->level_chain
;
2726 b
->level_chain
= save_template_parm
;
2727 save_template_parm
= b
;
2730 resume_scope (NAMESPACE_LEVEL (inner
));
2731 current_namespace
= inner
;
2733 /* Restore template parameter scopes. */
2734 while (save_template_parm
)
2736 cp_binding_level
*b
= save_template_parm
;
2737 save_template_parm
= b
->level_chain
;
2738 b
->level_chain
= current_binding_level
;
2739 current_binding_level
= b
;
2746 /* Enter the scope INNER from current scope. INNER must be a scope
2747 nested inside current scope. This works with both name lookup and
2748 pushing name into scope. In case a template parameter scope is present,
2749 namespace is pushed under the template parameter scope according to
2750 name lookup rule in 14.6.1/6.
2752 Return the former current scope suitable for pop_inner_scope. */
2755 push_inner_scope (tree inner
)
2757 tree outer
= current_scope ();
2759 outer
= current_namespace
;
2761 push_inner_scope_r (outer
, inner
);
2765 /* Exit the current scope INNER back to scope OUTER. */
2768 pop_inner_scope (tree outer
, tree inner
)
2771 || (TREE_CODE (inner
) != NAMESPACE_DECL
&& !CLASS_TYPE_P (inner
)))
2774 while (outer
!= inner
)
2776 if (TREE_CODE (inner
) == NAMESPACE_DECL
)
2778 cp_binding_level
*save_template_parm
= 0;
2779 /* Temporary take out template parameter scopes. They are saved
2780 in reversed order in save_template_parm. */
2781 while (current_binding_level
->kind
== sk_template_parms
)
2783 cp_binding_level
*b
= current_binding_level
;
2784 current_binding_level
= b
->level_chain
;
2785 b
->level_chain
= save_template_parm
;
2786 save_template_parm
= b
;
2791 /* Restore template parameter scopes. */
2792 while (save_template_parm
)
2794 cp_binding_level
*b
= save_template_parm
;
2795 save_template_parm
= b
->level_chain
;
2796 b
->level_chain
= current_binding_level
;
2797 current_binding_level
= b
;
2803 inner
= CP_DECL_CONTEXT (TREE_CODE (inner
) == NAMESPACE_DECL
? inner
: TYPE_NAME (inner
));
2807 /* Do a pushlevel for class declarations. */
2810 pushlevel_class (void)
2812 class_binding_level
= begin_scope (sk_class
, current_class_type
);
2815 /* ...and a poplevel for class declarations. */
2818 poplevel_class (void)
2820 cp_binding_level
*level
= class_binding_level
;
2821 cp_class_binding
*cb
;
2825 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
2826 gcc_assert (level
!= 0);
2828 /* If we're leaving a toplevel class, cache its binding level. */
2829 if (current_class_depth
== 1)
2830 previous_class_level
= level
;
2831 for (shadowed
= level
->type_shadowed
;
2833 shadowed
= TREE_CHAIN (shadowed
))
2834 SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (shadowed
), TREE_VALUE (shadowed
));
2836 /* Remove the bindings for all of the class-level declarations. */
2837 if (level
->class_shadowed
)
2839 FOR_EACH_VEC_ELT (cp_class_binding
, level
->class_shadowed
, i
, cb
)
2841 IDENTIFIER_BINDING (cb
->identifier
) = cb
->base
->previous
;
2842 cxx_binding_free (cb
->base
);
2844 ggc_free (level
->class_shadowed
);
2845 level
->class_shadowed
= NULL
;
2848 /* Now, pop out of the binding level which we created up in the
2849 `pushlevel_class' routine. */
2850 gcc_assert (current_binding_level
== level
);
2852 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
2855 /* Set INHERITED_VALUE_BINDING_P on BINDING to true or false, as
2856 appropriate. DECL is the value to which a name has just been
2857 bound. CLASS_TYPE is the class in which the lookup occurred. */
2860 set_inherited_value_binding_p (cxx_binding
*binding
, tree decl
,
2863 if (binding
->value
== decl
&& TREE_CODE (decl
) != TREE_LIST
)
2867 if (TREE_CODE (decl
) == OVERLOAD
)
2868 context
= ovl_scope (decl
);
2871 gcc_assert (DECL_P (decl
));
2872 context
= context_for_name_lookup (decl
);
2875 if (is_properly_derived_from (class_type
, context
))
2876 INHERITED_VALUE_BINDING_P (binding
) = 1;
2878 INHERITED_VALUE_BINDING_P (binding
) = 0;
2880 else if (binding
->value
== decl
)
2881 /* We only encounter a TREE_LIST when there is an ambiguity in the
2882 base classes. Such an ambiguity can be overridden by a
2883 definition in this class. */
2884 INHERITED_VALUE_BINDING_P (binding
) = 1;
2886 INHERITED_VALUE_BINDING_P (binding
) = 0;
2889 /* Make the declaration of X appear in CLASS scope. */
2892 pushdecl_class_level (tree x
)
2895 bool is_valid
= true;
2898 /* Do nothing if we're adding to an outer lambda closure type,
2899 outer_binding will add it later if it's needed. */
2900 if (current_class_type
!= class_binding_level
->this_entity
)
2903 subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
2904 /* Get the name of X. */
2905 if (TREE_CODE (x
) == OVERLOAD
)
2906 name
= DECL_NAME (get_first_fn (x
));
2908 name
= DECL_NAME (x
);
2912 is_valid
= push_class_level_binding (name
, x
);
2913 if (TREE_CODE (x
) == TYPE_DECL
)
2914 set_identifier_type_value (name
, x
);
2916 else if (ANON_AGGR_TYPE_P (TREE_TYPE (x
)))
2918 /* If X is an anonymous aggregate, all of its members are
2919 treated as if they were members of the class containing the
2920 aggregate, for naming purposes. */
2923 for (f
= TYPE_FIELDS (TREE_TYPE (x
)); f
; f
= DECL_CHAIN (f
))
2925 location_t save_location
= input_location
;
2926 input_location
= DECL_SOURCE_LOCATION (f
);
2927 if (!pushdecl_class_level (f
))
2929 input_location
= save_location
;
2932 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
2936 /* Return the BINDING (if any) for NAME in SCOPE, which is a class
2937 scope. If the value returned is non-NULL, and the PREVIOUS field
2938 is not set, callers must set the PREVIOUS field explicitly. */
2940 static cxx_binding
*
2941 get_class_binding (tree name
, cp_binding_level
*scope
)
2946 cxx_binding
*binding
;
2948 class_type
= scope
->this_entity
;
2950 /* Get the type binding. */
2951 type_binding
= lookup_member (class_type
, name
,
2952 /*protect=*/2, /*want_type=*/true,
2953 tf_warning_or_error
);
2954 /* Get the value binding. */
2955 value_binding
= lookup_member (class_type
, name
,
2956 /*protect=*/2, /*want_type=*/false,
2957 tf_warning_or_error
);
2960 && (TREE_CODE (value_binding
) == TYPE_DECL
2961 || DECL_CLASS_TEMPLATE_P (value_binding
)
2962 || (TREE_CODE (value_binding
) == TREE_LIST
2963 && TREE_TYPE (value_binding
) == error_mark_node
2964 && (TREE_CODE (TREE_VALUE (value_binding
))
2966 /* We found a type binding, even when looking for a non-type
2967 binding. This means that we already processed this binding
2970 else if (value_binding
)
2972 if (TREE_CODE (value_binding
) == TREE_LIST
2973 && TREE_TYPE (value_binding
) == error_mark_node
)
2974 /* NAME is ambiguous. */
2976 else if (BASELINK_P (value_binding
))
2977 /* NAME is some overloaded functions. */
2978 value_binding
= BASELINK_FUNCTIONS (value_binding
);
2981 /* If we found either a type binding or a value binding, create a
2982 new binding object. */
2983 if (type_binding
|| value_binding
)
2985 binding
= new_class_binding (name
,
2989 /* This is a class-scope binding, not a block-scope binding. */
2990 LOCAL_BINDING_P (binding
) = 0;
2991 set_inherited_value_binding_p (binding
, value_binding
, class_type
);
2999 /* Make the declaration(s) of X appear in CLASS scope under the name
3000 NAME. Returns true if the binding is valid. */
3003 push_class_level_binding_1 (tree name
, tree x
)
3005 cxx_binding
*binding
;
3009 /* The class_binding_level will be NULL if x is a template
3010 parameter name in a member template. */
3011 if (!class_binding_level
)
3014 if (name
== error_mark_node
)
3017 /* Check for invalid member names. */
3018 gcc_assert (TYPE_BEING_DEFINED (current_class_type
));
3019 /* Check that we're pushing into the right binding level. */
3020 gcc_assert (current_class_type
== class_binding_level
->this_entity
);
3022 /* We could have been passed a tree list if this is an ambiguous
3023 declaration. If so, pull the declaration out because
3024 check_template_shadow will not handle a TREE_LIST. */
3025 if (TREE_CODE (decl
) == TREE_LIST
3026 && TREE_TYPE (decl
) == error_mark_node
)
3027 decl
= TREE_VALUE (decl
);
3029 if (!check_template_shadow (decl
))
3034 If T is the name of a class, then each of the following shall
3035 have a name different from T:
3037 -- every static data member of class T;
3039 -- every member of class T that is itself a type;
3041 -- every enumerator of every member of class T that is an
3044 -- every member of every anonymous union that is a member of
3047 (Non-static data members were also forbidden to have the same
3048 name as T until TC1.) */
3049 if ((TREE_CODE (x
) == VAR_DECL
3050 || TREE_CODE (x
) == CONST_DECL
3051 || (TREE_CODE (x
) == TYPE_DECL
3052 && !DECL_SELF_REFERENCE_P (x
))
3053 /* A data member of an anonymous union. */
3054 || (TREE_CODE (x
) == FIELD_DECL
3055 && DECL_CONTEXT (x
) != current_class_type
))
3056 && DECL_NAME (x
) == constructor_name (current_class_type
))
3058 tree scope
= context_for_name_lookup (x
);
3059 if (TYPE_P (scope
) && same_type_p (scope
, current_class_type
))
3061 error ("%qD has the same name as the class in which it is "
3068 /* Get the current binding for NAME in this class, if any. */
3069 binding
= IDENTIFIER_BINDING (name
);
3070 if (!binding
|| binding
->scope
!= class_binding_level
)
3072 binding
= get_class_binding (name
, class_binding_level
);
3073 /* If a new binding was created, put it at the front of the
3074 IDENTIFIER_BINDING list. */
3077 binding
->previous
= IDENTIFIER_BINDING (name
);
3078 IDENTIFIER_BINDING (name
) = binding
;
3082 /* If there is already a binding, then we may need to update the
3084 if (binding
&& binding
->value
)
3086 tree bval
= binding
->value
;
3087 tree old_decl
= NULL_TREE
;
3088 tree target_decl
= strip_using_decl (decl
);
3089 tree target_bval
= strip_using_decl (bval
);
3091 if (INHERITED_VALUE_BINDING_P (binding
))
3093 /* If the old binding was from a base class, and was for a
3094 tag name, slide it over to make room for the new binding.
3095 The old binding is still visible if explicitly qualified
3096 with a class-key. */
3097 if (TREE_CODE (target_bval
) == TYPE_DECL
3098 && DECL_ARTIFICIAL (target_bval
)
3099 && !(TREE_CODE (target_decl
) == TYPE_DECL
3100 && DECL_ARTIFICIAL (target_decl
)))
3102 old_decl
= binding
->type
;
3103 binding
->type
= bval
;
3104 binding
->value
= NULL_TREE
;
3105 INHERITED_VALUE_BINDING_P (binding
) = 0;
3110 /* Any inherited type declaration is hidden by the type
3111 declaration in the derived class. */
3112 if (TREE_CODE (target_decl
) == TYPE_DECL
3113 && DECL_ARTIFICIAL (target_decl
))
3114 binding
->type
= NULL_TREE
;
3117 else if (TREE_CODE (target_decl
) == OVERLOAD
3118 && is_overloaded_fn (target_bval
))
3120 else if (TREE_CODE (decl
) == USING_DECL
3121 && TREE_CODE (bval
) == USING_DECL
3122 && same_type_p (USING_DECL_SCOPE (decl
),
3123 USING_DECL_SCOPE (bval
)))
3124 /* This is a using redeclaration that will be diagnosed later
3125 in supplement_binding */
3127 else if (TREE_CODE (decl
) == USING_DECL
3128 && TREE_CODE (bval
) == USING_DECL
3129 && DECL_DEPENDENT_P (decl
)
3130 && DECL_DEPENDENT_P (bval
))
3132 else if (TREE_CODE (decl
) == USING_DECL
3133 && is_overloaded_fn (target_bval
))
3135 else if (TREE_CODE (bval
) == USING_DECL
3136 && is_overloaded_fn (target_decl
))
3139 if (old_decl
&& binding
->scope
== class_binding_level
)
3142 /* It is always safe to clear INHERITED_VALUE_BINDING_P
3143 here. This function is only used to register bindings
3144 from with the class definition itself. */
3145 INHERITED_VALUE_BINDING_P (binding
) = 0;
3150 /* Note that we declared this value so that we can issue an error if
3151 this is an invalid redeclaration of a name already used for some
3153 note_name_declared_in_class (name
, decl
);
3155 /* If we didn't replace an existing binding, put the binding on the
3156 stack of bindings for the identifier, and update the shadowed
3158 if (binding
&& binding
->scope
== class_binding_level
)
3159 /* Supplement the existing binding. */
3160 ok
= supplement_binding (binding
, decl
);
3163 /* Create a new binding. */
3164 push_binding (name
, decl
, class_binding_level
);
3171 /* Wrapper for push_class_level_binding_1. */
3174 push_class_level_binding (tree name
, tree x
)
3177 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
3178 ret
= push_class_level_binding_1 (name
, x
);
3179 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
3183 /* Process "using SCOPE::NAME" in a class scope. Return the
3184 USING_DECL created. */
3187 do_class_using_decl (tree scope
, tree name
)
3189 /* The USING_DECL returned by this function. */
3191 /* The declaration (or declarations) name by this using
3192 declaration. NULL if we are in a template and cannot figure out
3193 what has been named. */
3195 /* True if SCOPE is a dependent type. */
3196 bool scope_dependent_p
;
3197 /* True if SCOPE::NAME is dependent. */
3198 bool name_dependent_p
;
3199 /* True if any of the bases of CURRENT_CLASS_TYPE are dependent. */
3200 bool bases_dependent_p
;
3205 if (name
== error_mark_node
)
3208 if (!scope
|| !TYPE_P (scope
))
3210 error ("using-declaration for non-member at class scope");
3214 /* Make sure the name is not invalid */
3215 if (TREE_CODE (name
) == BIT_NOT_EXPR
)
3217 error ("%<%T::%D%> names destructor", scope
, name
);
3220 if (MAYBE_CLASS_TYPE_P (scope
) && constructor_name_p (name
, scope
))
3222 error ("%<%T::%D%> names constructor", scope
, name
);
3225 if (constructor_name_p (name
, current_class_type
))
3227 error ("%<%T::%D%> names constructor in %qT",
3228 scope
, name
, current_class_type
);
3232 scope_dependent_p
= dependent_scope_p (scope
);
3233 name_dependent_p
= (scope_dependent_p
3234 || (IDENTIFIER_TYPENAME_P (name
)
3235 && dependent_type_p (TREE_TYPE (name
))));
3237 bases_dependent_p
= false;
3238 if (processing_template_decl
)
3239 for (binfo
= TYPE_BINFO (current_class_type
), i
= 0;
3240 BINFO_BASE_ITERATE (binfo
, i
, base_binfo
);
3242 if (dependent_type_p (TREE_TYPE (base_binfo
)))
3244 bases_dependent_p
= true;
3250 /* From [namespace.udecl]:
3252 A using-declaration used as a member-declaration shall refer to a
3253 member of a base class of the class being defined.
3255 In general, we cannot check this constraint in a template because
3256 we do not know the entire set of base classes of the current
3257 class type. Morover, if SCOPE is dependent, it might match a
3258 non-dependent base. */
3260 if (!scope_dependent_p
)
3263 binfo
= lookup_base (current_class_type
, scope
, ba_any
, &b_kind
,
3264 tf_warning_or_error
);
3265 if (b_kind
< bk_proper_base
)
3267 if (!bases_dependent_p
)
3269 error_not_base_type (scope
, current_class_type
);
3273 else if (!name_dependent_p
)
3275 decl
= lookup_member (binfo
, name
, 0, false, tf_warning_or_error
);
3278 error ("no members matching %<%T::%D%> in %q#T", scope
, name
,
3282 /* The binfo from which the functions came does not matter. */
3283 if (BASELINK_P (decl
))
3284 decl
= BASELINK_FUNCTIONS (decl
);
3288 value
= build_lang_decl (USING_DECL
, name
, NULL_TREE
);
3289 USING_DECL_DECLS (value
) = decl
;
3290 USING_DECL_SCOPE (value
) = scope
;
3291 DECL_DEPENDENT_P (value
) = !decl
;
3297 /* Return the binding value for name in scope. */
3301 namespace_binding_1 (tree name
, tree scope
)
3303 cxx_binding
*binding
;
3305 if (SCOPE_FILE_SCOPE_P (scope
))
3306 scope
= global_namespace
;
3308 /* Unnecessary for the global namespace because it can't be an alias. */
3309 scope
= ORIGINAL_NAMESPACE (scope
);
3311 binding
= cp_binding_level_find_binding_for_name (NAMESPACE_LEVEL (scope
), name
);
3313 return binding
? binding
->value
: NULL_TREE
;
3317 namespace_binding (tree name
, tree scope
)
3320 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
3321 ret
= namespace_binding_1 (name
, scope
);
3322 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
3326 /* Set the binding value for name in scope. */
3329 set_namespace_binding_1 (tree name
, tree scope
, tree val
)
3333 if (scope
== NULL_TREE
)
3334 scope
= global_namespace
;
3335 b
= binding_for_name (NAMESPACE_LEVEL (scope
), name
);
3336 if (!b
->value
|| TREE_CODE (val
) == OVERLOAD
|| val
== error_mark_node
)
3339 supplement_binding (b
, val
);
3342 /* Wrapper for set_namespace_binding_1. */
3345 set_namespace_binding (tree name
, tree scope
, tree val
)
3347 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
3348 set_namespace_binding_1 (name
, scope
, val
);
3349 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
3352 /* Set the context of a declaration to scope. Complain if we are not
3356 set_decl_namespace (tree decl
, tree scope
, bool friendp
)
3360 /* Get rid of namespace aliases. */
3361 scope
= ORIGINAL_NAMESPACE (scope
);
3363 /* It is ok for friends to be qualified in parallel space. */
3364 if (!friendp
&& !is_ancestor (current_namespace
, scope
))
3365 error ("declaration of %qD not in a namespace surrounding %qD",
3367 DECL_CONTEXT (decl
) = FROB_CONTEXT (scope
);
3369 /* Writing "int N::i" to declare a variable within "N" is invalid. */
3370 if (scope
== current_namespace
)
3372 if (at_namespace_scope_p ())
3373 error ("explicit qualification in declaration of %qD",
3378 /* See whether this has been declared in the namespace. */
3379 old
= lookup_qualified_name (scope
, DECL_NAME (decl
), false, true);
3380 if (old
== error_mark_node
)
3381 /* No old declaration at all. */
3383 /* If it's a TREE_LIST, the result of the lookup was ambiguous. */
3384 if (TREE_CODE (old
) == TREE_LIST
)
3386 error ("reference to %qD is ambiguous", decl
);
3387 print_candidates (old
);
3390 if (!is_overloaded_fn (decl
))
3392 /* We might have found OLD in an inline namespace inside SCOPE. */
3393 if (TREE_CODE (decl
) == TREE_CODE (old
))
3394 DECL_CONTEXT (decl
) = DECL_CONTEXT (old
);
3395 /* Don't compare non-function decls with decls_match here, since
3396 it can't check for the correct constness at this
3397 point. pushdecl will find those errors later. */
3400 /* Since decl is a function, old should contain a function decl. */
3401 if (!is_overloaded_fn (old
))
3403 /* A template can be explicitly specialized in any namespace. */
3404 if (processing_explicit_instantiation
)
3406 if (processing_template_decl
|| processing_specialization
)
3407 /* We have not yet called push_template_decl to turn a
3408 FUNCTION_DECL into a TEMPLATE_DECL, so the declarations won't
3409 match. But, we'll check later, when we construct the
3412 /* Instantiations or specializations of templates may be declared as
3413 friends in any namespace. */
3414 if (friendp
&& DECL_USE_TEMPLATE (decl
))
3416 if (is_overloaded_fn (old
))
3418 tree found
= NULL_TREE
;
3420 for (; elt
; elt
= OVL_NEXT (elt
))
3422 tree ofn
= OVL_CURRENT (elt
);
3423 /* Adjust DECL_CONTEXT first so decls_match will return true
3424 if DECL will match a declaration in an inline namespace. */
3425 DECL_CONTEXT (decl
) = DECL_CONTEXT (ofn
);
3426 if (decls_match (decl
, ofn
))
3428 if (found
&& !decls_match (found
, ofn
))
3430 DECL_CONTEXT (decl
) = FROB_CONTEXT (scope
);
3431 error ("reference to %qD is ambiguous", decl
);
3432 print_candidates (old
);
3440 if (!is_associated_namespace (scope
, CP_DECL_CONTEXT (found
)))
3442 DECL_CONTEXT (decl
) = DECL_CONTEXT (found
);
3448 DECL_CONTEXT (decl
) = DECL_CONTEXT (old
);
3449 if (decls_match (decl
, old
))
3453 /* It didn't work, go back to the explicit scope. */
3454 DECL_CONTEXT (decl
) = FROB_CONTEXT (scope
);
3456 error ("%qD should have been declared inside %qD", decl
, scope
);
3459 /* Return the namespace where the current declaration is declared. */
3462 current_decl_namespace (void)
3465 /* If we have been pushed into a different namespace, use it. */
3466 if (!VEC_empty (tree
, decl_namespace_list
))
3467 return VEC_last (tree
, decl_namespace_list
);
3469 if (current_class_type
)
3470 result
= decl_namespace_context (current_class_type
);
3471 else if (current_function_decl
)
3472 result
= decl_namespace_context (current_function_decl
);
3474 result
= current_namespace
;
3478 /* Process any ATTRIBUTES on a namespace definition. Currently only
3479 attribute visibility is meaningful, which is a property of the syntactic
3480 block rather than the namespace as a whole, so we don't touch the
3481 NAMESPACE_DECL at all. Returns true if attribute visibility is seen. */
3484 handle_namespace_attrs (tree ns
, tree attributes
)
3487 bool saw_vis
= false;
3489 for (d
= attributes
; d
; d
= TREE_CHAIN (d
))
3491 tree name
= TREE_PURPOSE (d
);
3492 tree args
= TREE_VALUE (d
);
3494 if (is_attribute_p ("visibility", name
))
3496 tree x
= args
? TREE_VALUE (args
) : NULL_TREE
;
3497 if (x
== NULL_TREE
|| TREE_CODE (x
) != STRING_CST
|| TREE_CHAIN (args
))
3499 warning (OPT_Wattributes
,
3500 "%qD attribute requires a single NTBS argument",
3505 if (!TREE_PUBLIC (ns
))
3506 warning (OPT_Wattributes
,
3507 "%qD attribute is meaningless since members of the "
3508 "anonymous namespace get local symbols", name
);
3510 push_visibility (TREE_STRING_POINTER (x
), 1);
3515 warning (OPT_Wattributes
, "%qD attribute directive ignored",
3524 /* Push into the scope of the NAME namespace. If NAME is NULL_TREE, then we
3525 select a name that is unique to this compilation unit. */
3528 push_namespace (tree name
)
3531 bool need_new
= true;
3532 bool implicit_use
= false;
3535 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
3537 /* We should not get here if the global_namespace is not yet constructed
3538 nor if NAME designates the global namespace: The global scope is
3539 constructed elsewhere. */
3540 gcc_assert (global_namespace
!= NULL
&& name
!= global_scope_name
);
3544 name
= get_anonymous_namespace_name();
3545 d
= IDENTIFIER_NAMESPACE_VALUE (name
);
3547 /* Reopening anonymous namespace. */
3549 implicit_use
= true;
3553 /* Check whether this is an extended namespace definition. */
3554 d
= IDENTIFIER_NAMESPACE_VALUE (name
);
3555 if (d
!= NULL_TREE
&& TREE_CODE (d
) == NAMESPACE_DECL
)
3557 tree dna
= DECL_NAMESPACE_ALIAS (d
);
3560 /* We do some error recovery for, eg, the redeclaration
3567 However, in nasty cases like:
3575 we just error out below, in duplicate_decls. */
3576 if (NAMESPACE_LEVEL (dna
)->level_chain
3577 == current_binding_level
)
3579 error ("namespace alias %qD not allowed here, "
3580 "assuming %qD", d
, dna
);
3592 /* Make a new namespace, binding the name to it. */
3593 d
= build_lang_decl (NAMESPACE_DECL
, name
, void_type_node
);
3594 DECL_CONTEXT (d
) = FROB_CONTEXT (current_namespace
);
3595 /* The name of this namespace is not visible to other translation
3596 units if it is an anonymous namespace or member thereof. */
3597 if (anon
|| decl_anon_ns_mem_p (current_namespace
))
3598 TREE_PUBLIC (d
) = 0;
3600 TREE_PUBLIC (d
) = 1;
3604 /* Clear DECL_NAME for the benefit of debugging back ends. */
3605 SET_DECL_ASSEMBLER_NAME (d
, name
);
3606 DECL_NAME (d
) = NULL_TREE
;
3608 begin_scope (sk_namespace
, d
);
3611 resume_scope (NAMESPACE_LEVEL (d
));
3614 do_using_directive (d
);
3615 /* Enter the name space. */
3616 current_namespace
= d
;
3618 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
3621 /* Pop from the scope of the current namespace. */
3624 pop_namespace (void)
3626 gcc_assert (current_namespace
!= global_namespace
);
3627 current_namespace
= CP_DECL_CONTEXT (current_namespace
);
3628 /* The binding level is not popped, as it might be re-opened later. */
3632 /* Push into the scope of the namespace NS, even if it is deeply
3633 nested within another namespace. */
3636 push_nested_namespace (tree ns
)
3638 if (ns
== global_namespace
)
3639 push_to_top_level ();
3642 push_nested_namespace (CP_DECL_CONTEXT (ns
));
3643 push_namespace (DECL_NAME (ns
));
3647 /* Pop back from the scope of the namespace NS, which was previously
3648 entered with push_nested_namespace. */
3651 pop_nested_namespace (tree ns
)
3653 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
3654 gcc_assert (current_namespace
== ns
);
3655 while (ns
!= global_namespace
)
3658 ns
= CP_DECL_CONTEXT (ns
);
3661 pop_from_top_level ();
3662 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
3665 /* Temporarily set the namespace for the current declaration. */
3668 push_decl_namespace (tree decl
)
3670 if (TREE_CODE (decl
) != NAMESPACE_DECL
)
3671 decl
= decl_namespace_context (decl
);
3672 VEC_safe_push (tree
, gc
, decl_namespace_list
, ORIGINAL_NAMESPACE (decl
));
3675 /* [namespace.memdef]/2 */
3678 pop_decl_namespace (void)
3680 VEC_pop (tree
, decl_namespace_list
);
3683 /* Return the namespace that is the common ancestor
3684 of two given namespaces. */
3687 namespace_ancestor_1 (tree ns1
, tree ns2
)
3690 if (is_ancestor (ns1
, ns2
))
3693 nsr
= namespace_ancestor_1 (CP_DECL_CONTEXT (ns1
), ns2
);
3697 /* Wrapper for namespace_ancestor_1. */
3700 namespace_ancestor (tree ns1
, tree ns2
)
3703 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
3704 nsr
= namespace_ancestor_1 (ns1
, ns2
);
3705 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
3709 /* Process a namespace-alias declaration. */
3712 do_namespace_alias (tree alias
, tree name_space
)
3714 if (name_space
== error_mark_node
)
3717 gcc_assert (TREE_CODE (name_space
) == NAMESPACE_DECL
);
3719 name_space
= ORIGINAL_NAMESPACE (name_space
);
3721 /* Build the alias. */
3722 alias
= build_lang_decl (NAMESPACE_DECL
, alias
, void_type_node
);
3723 DECL_NAMESPACE_ALIAS (alias
) = name_space
;
3724 DECL_EXTERNAL (alias
) = 1;
3725 DECL_CONTEXT (alias
) = FROB_CONTEXT (current_scope ());
3728 /* Emit debug info for namespace alias. */
3729 if (!building_stmt_list_p ())
3730 (*debug_hooks
->global_decl
) (alias
);
3733 /* Like pushdecl, only it places X in the current namespace,
3737 pushdecl_namespace_level (tree x
, bool is_friend
)
3739 cp_binding_level
*b
= current_binding_level
;
3742 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
3743 t
= pushdecl_with_scope (x
, NAMESPACE_LEVEL (current_namespace
), is_friend
);
3745 /* Now, the type_shadowed stack may screw us. Munge it so it does
3747 if (TREE_CODE (t
) == TYPE_DECL
)
3749 tree name
= DECL_NAME (t
);
3751 tree
*ptr
= (tree
*)0;
3752 for (; !global_scope_p (b
); b
= b
->level_chain
)
3754 tree shadowed
= b
->type_shadowed
;
3755 for (; shadowed
; shadowed
= TREE_CHAIN (shadowed
))
3756 if (TREE_PURPOSE (shadowed
) == name
)
3758 ptr
= &TREE_VALUE (shadowed
);
3759 /* Can't break out of the loop here because sometimes
3760 a binding level will have duplicate bindings for
3761 PT names. It's gross, but I haven't time to fix it. */
3764 newval
= TREE_TYPE (t
);
3765 if (ptr
== (tree
*)0)
3767 /* @@ This shouldn't be needed. My test case "zstring.cc" trips
3768 up here if this is changed to an assertion. --KR */
3769 SET_IDENTIFIER_TYPE_VALUE (name
, t
);
3776 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
3780 /* Insert USED into the using list of USER. Set INDIRECT_flag if this
3781 directive is not directly from the source. Also find the common
3782 ancestor and let our users know about the new namespace */
3785 add_using_namespace_1 (tree user
, tree used
, bool indirect
)
3788 /* Using oneself is a no-op. */
3791 gcc_assert (TREE_CODE (user
) == NAMESPACE_DECL
);
3792 gcc_assert (TREE_CODE (used
) == NAMESPACE_DECL
);
3793 /* Check if we already have this. */
3794 t
= purpose_member (used
, DECL_NAMESPACE_USING (user
));
3798 /* Promote to direct usage. */
3799 TREE_INDIRECT_USING (t
) = 0;
3803 /* Add used to the user's using list. */
3804 DECL_NAMESPACE_USING (user
)
3805 = tree_cons (used
, namespace_ancestor (user
, used
),
3806 DECL_NAMESPACE_USING (user
));
3808 TREE_INDIRECT_USING (DECL_NAMESPACE_USING (user
)) = indirect
;
3810 /* Add user to the used's users list. */
3811 DECL_NAMESPACE_USERS (used
)
3812 = tree_cons (user
, 0, DECL_NAMESPACE_USERS (used
));
3814 /* Recursively add all namespaces used. */
3815 for (t
= DECL_NAMESPACE_USING (used
); t
; t
= TREE_CHAIN (t
))
3816 /* indirect usage */
3817 add_using_namespace_1 (user
, TREE_PURPOSE (t
), 1);
3819 /* Tell everyone using us about the new used namespaces. */
3820 for (t
= DECL_NAMESPACE_USERS (user
); t
; t
= TREE_CHAIN (t
))
3821 add_using_namespace_1 (TREE_PURPOSE (t
), used
, 1);
3824 /* Wrapper for add_using_namespace_1. */
3827 add_using_namespace (tree user
, tree used
, bool indirect
)
3829 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
3830 add_using_namespace_1 (user
, used
, indirect
);
3831 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
3834 /* Process a using-declaration not appearing in class or local scope. */
3837 do_toplevel_using_decl (tree decl
, tree scope
, tree name
)
3839 tree oldval
, oldtype
, newval
, newtype
;
3840 tree orig_decl
= decl
;
3841 cxx_binding
*binding
;
3843 decl
= validate_nonmember_using_decl (decl
, scope
, name
);
3844 if (decl
== NULL_TREE
)
3847 binding
= binding_for_name (NAMESPACE_LEVEL (current_namespace
), name
);
3849 oldval
= binding
->value
;
3850 oldtype
= binding
->type
;
3852 do_nonmember_using_decl (scope
, name
, oldval
, oldtype
, &newval
, &newtype
);
3854 /* Emit debug info. */
3855 if (!processing_template_decl
)
3856 cp_emit_debug_info_for_using (orig_decl
, current_namespace
);
3858 /* Copy declarations found. */
3860 binding
->value
= newval
;
3862 binding
->type
= newtype
;
3865 /* Process a using-directive. */
3868 do_using_directive (tree name_space
)
3870 tree context
= NULL_TREE
;
3872 if (name_space
== error_mark_node
)
3875 gcc_assert (TREE_CODE (name_space
) == NAMESPACE_DECL
);
3877 if (building_stmt_list_p ())
3878 add_stmt (build_stmt (input_location
, USING_STMT
, name_space
));
3879 name_space
= ORIGINAL_NAMESPACE (name_space
);
3881 if (!toplevel_bindings_p ())
3883 push_using_directive (name_space
);
3888 add_using_namespace (current_namespace
, name_space
, 0);
3889 if (current_namespace
!= global_namespace
)
3890 context
= current_namespace
;
3892 /* Emit debugging info. */
3893 if (!processing_template_decl
)
3894 (*debug_hooks
->imported_module_or_decl
) (name_space
, NULL_TREE
,
3899 /* Deal with a using-directive seen by the parser. Currently we only
3900 handle attributes here, since they cannot appear inside a template. */
3903 parse_using_directive (tree name_space
, tree attribs
)
3907 do_using_directive (name_space
);
3909 for (a
= attribs
; a
; a
= TREE_CHAIN (a
))
3911 tree name
= TREE_PURPOSE (a
);
3912 if (is_attribute_p ("strong", name
))
3914 if (!toplevel_bindings_p ())
3915 error ("strong using only meaningful at namespace scope");
3916 else if (name_space
!= error_mark_node
)
3918 if (!is_ancestor (current_namespace
, name_space
))
3919 error ("current namespace %qD does not enclose strongly used namespace %qD",
3920 current_namespace
, name_space
);
3921 DECL_NAMESPACE_ASSOCIATIONS (name_space
)
3922 = tree_cons (current_namespace
, 0,
3923 DECL_NAMESPACE_ASSOCIATIONS (name_space
));
3927 warning (OPT_Wattributes
, "%qD attribute directive ignored", name
);
3931 /* Like pushdecl, only it places X in the global scope if appropriate.
3932 Calls cp_finish_decl to register the variable, initializing it with
3933 *INIT, if INIT is non-NULL. */
3936 pushdecl_top_level_1 (tree x
, tree
*init
, bool is_friend
)
3938 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
3939 push_to_top_level ();
3940 x
= pushdecl_namespace_level (x
, is_friend
);
3942 cp_finish_decl (x
, *init
, false, NULL_TREE
, 0);
3943 pop_from_top_level ();
3944 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
3948 /* Like pushdecl, only it places X in the global scope if appropriate. */
3951 pushdecl_top_level (tree x
)
3953 return pushdecl_top_level_1 (x
, NULL
, false);
3956 /* Like pushdecl_top_level, but adding the IS_FRIEND parameter. */
3959 pushdecl_top_level_maybe_friend (tree x
, bool is_friend
)
3961 return pushdecl_top_level_1 (x
, NULL
, is_friend
);
3964 /* Like pushdecl, only it places X in the global scope if
3965 appropriate. Calls cp_finish_decl to register the variable,
3966 initializing it with INIT. */
3969 pushdecl_top_level_and_finish (tree x
, tree init
)
3971 return pushdecl_top_level_1 (x
, &init
, false);
3974 /* Combines two sets of overloaded functions into an OVERLOAD chain, removing
3975 duplicates. The first list becomes the tail of the result.
3977 The algorithm is O(n^2). We could get this down to O(n log n) by
3978 doing a sort on the addresses of the functions, if that becomes
3982 merge_functions (tree s1
, tree s2
)
3984 for (; s2
; s2
= OVL_NEXT (s2
))
3986 tree fn2
= OVL_CURRENT (s2
);
3989 for (fns1
= s1
; fns1
; fns1
= OVL_NEXT (fns1
))
3991 tree fn1
= OVL_CURRENT (fns1
);
3993 /* If the function from S2 is already in S1, there is no
3994 need to add it again. For `extern "C"' functions, we
3995 might have two FUNCTION_DECLs for the same function, in
3996 different namespaces, but let's leave them in in case
3997 they have different default arguments. */
4002 /* If we exhausted all of the functions in S1, FN2 is new. */
4004 s1
= build_overload (fn2
, s1
);
4009 /* Returns TRUE iff OLD and NEW are the same entity.
4011 3 [basic]/3: An entity is a value, object, reference, function,
4012 enumerator, type, class member, template, template specialization,
4013 namespace, parameter pack, or this.
4015 7.3.4 [namespace.udir]/4: If name lookup finds a declaration for a name
4016 in two different namespaces, and the declarations do not declare the
4017 same entity and do not declare functions, the use of the name is
4021 same_entity_p (tree one
, tree two
)
4027 if (TREE_CODE (one
) == TYPE_DECL
4028 && TREE_CODE (two
) == TYPE_DECL
4029 && same_type_p (TREE_TYPE (one
), TREE_TYPE (two
)))
4034 /* This should return an error not all definitions define functions.
4035 It is not an error if we find two functions with exactly the
4036 same signature, only if these are selected in overload resolution.
4037 old is the current set of bindings, new_binding the freshly-found binding.
4038 XXX Do we want to give *all* candidates in case of ambiguity?
4039 XXX In what way should I treat extern declarations?
4040 XXX I don't want to repeat the entire duplicate_decls here */
4043 ambiguous_decl (struct scope_binding
*old
, cxx_binding
*new_binding
, int flags
)
4046 gcc_assert (old
!= NULL
);
4048 /* Copy the type. */
4049 type
= new_binding
->type
;
4050 if (LOOKUP_NAMESPACES_ONLY (flags
)
4051 || (type
&& hidden_name_p (type
) && !(flags
& LOOKUP_HIDDEN
)))
4054 /* Copy the value. */
4055 val
= new_binding
->value
;
4058 if (hidden_name_p (val
) && !(flags
& LOOKUP_HIDDEN
))
4061 switch (TREE_CODE (val
))
4064 /* If we expect types or namespaces, and not templates,
4065 or this is not a template class. */
4066 if ((LOOKUP_QUALIFIERS_ONLY (flags
)
4067 && !DECL_TYPE_TEMPLATE_P (val
)))
4071 if (LOOKUP_NAMESPACES_ONLY (flags
)
4072 || (type
&& (flags
& LOOKUP_PREFER_TYPES
)))
4075 case NAMESPACE_DECL
:
4076 if (LOOKUP_TYPES_ONLY (flags
))
4080 /* Ignore built-in functions that are still anticipated. */
4081 if (LOOKUP_QUALIFIERS_ONLY (flags
))
4085 if (LOOKUP_QUALIFIERS_ONLY (flags
))
4090 /* If val is hidden, shift down any class or enumeration name. */
4099 else if (val
&& !same_entity_p (val
, old
->value
))
4101 if (is_overloaded_fn (old
->value
) && is_overloaded_fn (val
))
4102 old
->value
= merge_functions (old
->value
, val
);
4105 old
->value
= tree_cons (NULL_TREE
, old
->value
,
4106 build_tree_list (NULL_TREE
, val
));
4107 TREE_TYPE (old
->value
) = error_mark_node
;
4113 else if (type
&& old
->type
!= type
)
4115 old
->type
= tree_cons (NULL_TREE
, old
->type
,
4116 build_tree_list (NULL_TREE
, type
));
4117 TREE_TYPE (old
->type
) = error_mark_node
;
4121 /* Return the declarations that are members of the namespace NS. */
4124 cp_namespace_decls (tree ns
)
4126 return NAMESPACE_LEVEL (ns
)->names
;
4129 /* Combine prefer_type and namespaces_only into flags. */
4132 lookup_flags (int prefer_type
, int namespaces_only
)
4134 if (namespaces_only
)
4135 return LOOKUP_PREFER_NAMESPACES
;
4136 if (prefer_type
> 1)
4137 return LOOKUP_PREFER_TYPES
;
4138 if (prefer_type
> 0)
4139 return LOOKUP_PREFER_BOTH
;
4143 /* Given a lookup that returned VAL, use FLAGS to decide if we want to
4144 ignore it or not. Subroutine of lookup_name_real and
4145 lookup_type_scope. */
4148 qualify_lookup (tree val
, int flags
)
4150 if (val
== NULL_TREE
)
4152 if ((flags
& LOOKUP_PREFER_NAMESPACES
) && TREE_CODE (val
) == NAMESPACE_DECL
)
4154 if (flags
& LOOKUP_PREFER_TYPES
)
4156 tree target_val
= strip_using_decl (val
);
4157 if (TREE_CODE (target_val
) == TYPE_DECL
4158 || TREE_CODE (target_val
) == TEMPLATE_DECL
)
4161 if (flags
& (LOOKUP_PREFER_NAMESPACES
| LOOKUP_PREFER_TYPES
))
4163 /* Look through lambda things that we shouldn't be able to see. */
4164 if (is_lambda_ignored_entity (val
))
4169 /* Given a lookup that returned VAL, decide if we want to ignore it or
4170 not based on DECL_ANTICIPATED. */
4173 hidden_name_p (tree val
)
4176 && DECL_LANG_SPECIFIC (val
)
4177 && DECL_ANTICIPATED (val
))
4182 /* Remove any hidden friend functions from a possibly overloaded set
4186 remove_hidden_names (tree fns
)
4191 if (TREE_CODE (fns
) == FUNCTION_DECL
&& hidden_name_p (fns
))
4193 else if (TREE_CODE (fns
) == OVERLOAD
)
4197 for (o
= fns
; o
; o
= OVL_NEXT (o
))
4198 if (hidden_name_p (OVL_CURRENT (o
)))
4204 for (o
= fns
; o
; o
= OVL_NEXT (o
))
4205 if (!hidden_name_p (OVL_CURRENT (o
)))
4206 n
= build_overload (OVL_CURRENT (o
), n
);
4214 /* Suggest alternatives for NAME, an IDENTIFIER_NODE for which name
4215 lookup failed. Search through all available namespaces and print out
4216 possible candidates. */
4219 suggest_alternatives_for (location_t location
, tree name
)
4221 VEC(tree
,heap
) *candidates
= NULL
;
4222 VEC(tree
,heap
) *namespaces_to_search
= NULL
;
4223 int max_to_search
= PARAM_VALUE (CXX_MAX_NAMESPACES_FOR_DIAGNOSTIC_HELP
);
4228 VEC_safe_push (tree
, heap
, namespaces_to_search
, global_namespace
);
4230 while (!VEC_empty (tree
, namespaces_to_search
)
4231 && n_searched
< max_to_search
)
4233 tree scope
= VEC_pop (tree
, namespaces_to_search
);
4234 struct scope_binding binding
= EMPTY_SCOPE_BINDING
;
4235 cp_binding_level
*level
= NAMESPACE_LEVEL (scope
);
4237 /* Look in this namespace. */
4238 qualified_lookup_using_namespace (name
, scope
, &binding
, 0);
4243 VEC_safe_push (tree
, heap
, candidates
, binding
.value
);
4245 /* Add child namespaces. */
4246 for (t
= level
->namespaces
; t
; t
= DECL_CHAIN (t
))
4247 VEC_safe_push (tree
, heap
, namespaces_to_search
, t
);
4250 /* If we stopped before we could examine all namespaces, inform the
4251 user. Do this even if we don't have any candidates, since there
4252 might be more candidates further down that we weren't able to
4254 if (n_searched
>= max_to_search
4255 && !VEC_empty (tree
, namespaces_to_search
))
4257 "maximum limit of %d namespaces searched for %qE",
4258 max_to_search
, name
);
4260 VEC_free (tree
, heap
, namespaces_to_search
);
4262 /* Nothing useful to report. */
4263 if (VEC_empty (tree
, candidates
))
4266 inform_n (location
, VEC_length (tree
, candidates
),
4267 "suggested alternative:",
4268 "suggested alternatives:");
4270 FOR_EACH_VEC_ELT (tree
, candidates
, ix
, t
)
4271 inform (location_of (t
), " %qE", t
);
4273 VEC_free (tree
, heap
, candidates
);
4276 /* Unscoped lookup of a global: iterate over current namespaces,
4277 considering using-directives. */
4280 unqualified_namespace_lookup_1 (tree name
, int flags
)
4282 tree initial
= current_decl_namespace ();
4283 tree scope
= initial
;
4285 cp_binding_level
*level
;
4286 tree val
= NULL_TREE
;
4288 for (; !val
; scope
= CP_DECL_CONTEXT (scope
))
4290 struct scope_binding binding
= EMPTY_SCOPE_BINDING
;
4292 cp_binding_level_find_binding_for_name (NAMESPACE_LEVEL (scope
), name
);
4295 ambiguous_decl (&binding
, b
, flags
);
4297 /* Add all _DECLs seen through local using-directives. */
4298 for (level
= current_binding_level
;
4299 level
->kind
!= sk_namespace
;
4300 level
= level
->level_chain
)
4301 if (!lookup_using_namespace (name
, &binding
, level
->using_directives
,
4303 /* Give up because of error. */
4304 return error_mark_node
;
4306 /* Add all _DECLs seen through global using-directives. */
4307 /* XXX local and global using lists should work equally. */
4311 if (!lookup_using_namespace (name
, &binding
,
4312 DECL_NAMESPACE_USING (siter
),
4314 /* Give up because of error. */
4315 return error_mark_node
;
4316 if (siter
== scope
) break;
4317 siter
= CP_DECL_CONTEXT (siter
);
4320 val
= binding
.value
;
4321 if (scope
== global_namespace
)
4327 /* Wrapper for unqualified_namespace_lookup_1. */
4330 unqualified_namespace_lookup (tree name
, int flags
)
4333 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
4334 ret
= unqualified_namespace_lookup_1 (name
, flags
);
4335 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
4339 /* Look up NAME (an IDENTIFIER_NODE) in SCOPE (either a NAMESPACE_DECL
4340 or a class TYPE). If IS_TYPE_P is TRUE, then ignore non-type
4343 Returns a DECL (or OVERLOAD, or BASELINK) representing the
4344 declaration found. If no suitable declaration can be found,
4345 ERROR_MARK_NODE is returned. If COMPLAIN is true and SCOPE is
4346 neither a class-type nor a namespace a diagnostic is issued. */
4349 lookup_qualified_name (tree scope
, tree name
, bool is_type_p
, bool complain
)
4354 if (TREE_CODE (scope
) == NAMESPACE_DECL
)
4356 struct scope_binding binding
= EMPTY_SCOPE_BINDING
;
4359 flags
|= LOOKUP_PREFER_TYPES
;
4360 if (qualified_lookup_using_namespace (name
, scope
, &binding
, flags
))
4363 else if (cxx_dialect
!= cxx98
&& TREE_CODE (scope
) == ENUMERAL_TYPE
)
4364 t
= lookup_enumerator (scope
, name
);
4365 else if (is_class_type (scope
, complain
))
4366 t
= lookup_member (scope
, name
, 2, is_type_p
, tf_warning_or_error
);
4369 return error_mark_node
;
4373 /* Subroutine of unqualified_namespace_lookup:
4374 Add the bindings of NAME in used namespaces to VAL.
4375 We are currently looking for names in namespace SCOPE, so we
4376 look through USINGS for using-directives of namespaces
4377 which have SCOPE as a common ancestor with the current scope.
4378 Returns false on errors. */
4381 lookup_using_namespace (tree name
, struct scope_binding
*val
,
4382 tree usings
, tree scope
, int flags
)
4385 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
4386 /* Iterate over all used namespaces in current, searching for using
4387 directives of scope. */
4388 for (iter
= usings
; iter
; iter
= TREE_CHAIN (iter
))
4389 if (TREE_VALUE (iter
) == scope
)
4391 tree used
= ORIGINAL_NAMESPACE (TREE_PURPOSE (iter
));
4393 cp_binding_level_find_binding_for_name (NAMESPACE_LEVEL (used
), name
);
4394 /* Resolve ambiguities. */
4396 ambiguous_decl (val
, val1
, flags
);
4398 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
4399 return val
->value
!= error_mark_node
;
4402 /* Returns true iff VEC contains TARGET. */
4405 tree_vec_contains (VEC(tree
,gc
)* vec
, tree target
)
4409 FOR_EACH_VEC_ELT (tree
,vec
,i
,elt
)
4416 Accepts the NAME to lookup and its qualifying SCOPE.
4417 Returns the name/type pair found into the cxx_binding *RESULT,
4418 or false on error. */
4421 qualified_lookup_using_namespace (tree name
, tree scope
,
4422 struct scope_binding
*result
, int flags
)
4424 /* Maintain a list of namespaces visited... */
4425 VEC(tree
,gc
) *seen
= NULL
;
4426 VEC(tree
,gc
) *seen_inline
= NULL
;
4427 /* ... and a list of namespace yet to see. */
4428 VEC(tree
,gc
) *todo
= NULL
;
4429 VEC(tree
,gc
) *todo_maybe
= NULL
;
4430 VEC(tree
,gc
) *todo_inline
= NULL
;
4432 timevar_start (TV_NAME_LOOKUP
);
4433 /* Look through namespace aliases. */
4434 scope
= ORIGINAL_NAMESPACE (scope
);
4436 /* Algorithm: Starting with SCOPE, walk through the set of used
4437 namespaces. For each used namespace, look through its inline
4438 namespace set for any bindings and usings. If no bindings are
4439 found, add any usings seen to the set of used namespaces. */
4440 VEC_safe_push (tree
, gc
, todo
, scope
);
4442 while (VEC_length (tree
, todo
))
4445 scope
= VEC_pop (tree
, todo
);
4446 if (tree_vec_contains (seen
, scope
))
4448 VEC_safe_push (tree
, gc
, seen
, scope
);
4449 VEC_safe_push (tree
, gc
, todo_inline
, scope
);
4452 while (VEC_length (tree
, todo_inline
))
4454 cxx_binding
*binding
;
4456 scope
= VEC_pop (tree
, todo_inline
);
4457 if (tree_vec_contains (seen_inline
, scope
))
4459 VEC_safe_push (tree
, gc
, seen_inline
, scope
);
4462 cp_binding_level_find_binding_for_name (NAMESPACE_LEVEL (scope
), name
);
4466 ambiguous_decl (result
, binding
, flags
);
4469 for (usings
= DECL_NAMESPACE_USING (scope
); usings
;
4470 usings
= TREE_CHAIN (usings
))
4471 if (!TREE_INDIRECT_USING (usings
))
4473 if (is_associated_namespace (scope
, TREE_PURPOSE (usings
)))
4474 VEC_safe_push (tree
, gc
, todo_inline
, TREE_PURPOSE (usings
));
4476 VEC_safe_push (tree
, gc
, todo_maybe
, TREE_PURPOSE (usings
));
4481 VEC_truncate (tree
, todo_maybe
, 0);
4483 while (VEC_length (tree
, todo_maybe
))
4484 VEC_safe_push (tree
, gc
, todo
, VEC_pop (tree
, todo_maybe
));
4486 VEC_free (tree
,gc
,todo
);
4487 VEC_free (tree
,gc
,todo_maybe
);
4488 VEC_free (tree
,gc
,todo_inline
);
4489 VEC_free (tree
,gc
,seen
);
4490 VEC_free (tree
,gc
,seen_inline
);
4491 timevar_stop (TV_NAME_LOOKUP
);
4492 return result
->value
!= error_mark_node
;
4495 /* Subroutine of outer_binding.
4497 Returns TRUE if BINDING is a binding to a template parameter of
4498 SCOPE. In that case SCOPE is the scope of a primary template
4499 parameter -- in the sense of G++, i.e, a template that has its own
4502 Returns FALSE otherwise. */
4505 binding_to_template_parms_of_scope_p (cxx_binding
*binding
,
4506 cp_binding_level
*scope
)
4508 tree binding_value
, tmpl
, tinfo
;
4511 if (!binding
|| !scope
|| !scope
->this_entity
)
4514 binding_value
= binding
->value
? binding
->value
: binding
->type
;
4515 tinfo
= get_template_info (scope
->this_entity
);
4517 /* BINDING_VALUE must be a template parm. */
4518 if (binding_value
== NULL_TREE
4519 || (!DECL_P (binding_value
)
4520 || !DECL_TEMPLATE_PARM_P (binding_value
)))
4523 /* The level of BINDING_VALUE. */
4525 template_type_parameter_p (binding_value
)
4526 ? TEMPLATE_PARM_LEVEL (TEMPLATE_TYPE_PARM_INDEX
4527 (TREE_TYPE (binding_value
)))
4528 : TEMPLATE_PARM_LEVEL (DECL_INITIAL (binding_value
));
4530 /* The template of the current scope, iff said scope is a primary
4533 && PRIMARY_TEMPLATE_P (TI_TEMPLATE (tinfo
))
4534 ? TI_TEMPLATE (tinfo
)
4537 /* If the level of the parm BINDING_VALUE equals the depth of TMPL,
4538 then BINDING_VALUE is a parameter of TMPL. */
4539 return (tmpl
&& level
== TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (tmpl
)));
4542 /* Return the innermost non-namespace binding for NAME from a scope
4543 containing BINDING, or, if BINDING is NULL, the current scope.
4544 Please note that for a given template, the template parameters are
4545 considered to be in the scope containing the current scope.
4546 If CLASS_P is false, then class bindings are ignored. */
4549 outer_binding (tree name
,
4550 cxx_binding
*binding
,
4554 cp_binding_level
*scope
;
4555 cp_binding_level
*outer_scope
;
4559 scope
= binding
->scope
->level_chain
;
4560 outer
= binding
->previous
;
4564 scope
= current_binding_level
;
4565 outer
= IDENTIFIER_BINDING (name
);
4567 outer_scope
= outer
? outer
->scope
: NULL
;
4569 /* Because we create class bindings lazily, we might be missing a
4570 class binding for NAME. If there are any class binding levels
4571 between the LAST_BINDING_LEVEL and the scope in which OUTER was
4572 declared, we must lookup NAME in those class scopes. */
4574 while (scope
&& scope
!= outer_scope
&& scope
->kind
!= sk_namespace
)
4576 if (scope
->kind
== sk_class
)
4578 cxx_binding
*class_binding
;
4580 class_binding
= get_class_binding (name
, scope
);
4583 /* Thread this new class-scope binding onto the
4584 IDENTIFIER_BINDING list so that future lookups
4586 class_binding
->previous
= outer
;
4588 binding
->previous
= class_binding
;
4590 IDENTIFIER_BINDING (name
) = class_binding
;
4591 return class_binding
;
4594 /* If we are in a member template, the template parms of the member
4595 template are considered to be inside the scope of the containing
4596 class, but within G++ the class bindings are all pushed between the
4597 template parms and the function body. So if the outer binding is
4598 a template parm for the current scope, return it now rather than
4599 look for a class binding. */
4600 if (outer_scope
&& outer_scope
->kind
== sk_template_parms
4601 && binding_to_template_parms_of_scope_p (outer
, scope
))
4604 scope
= scope
->level_chain
;
4610 /* Return the innermost block-scope or class-scope value binding for
4611 NAME, or NULL_TREE if there is no such binding. */
4614 innermost_non_namespace_value (tree name
)
4616 cxx_binding
*binding
;
4617 binding
= outer_binding (name
, /*binding=*/NULL
, /*class_p=*/true);
4618 return binding
? binding
->value
: NULL_TREE
;
4621 /* Look up NAME in the current binding level and its superiors in the
4622 namespace of variables, functions and typedefs. Return a ..._DECL
4623 node of some kind representing its definition if there is only one
4624 such declaration, or return a TREE_LIST with all the overloaded
4625 definitions if there are many, or return 0 if it is undefined.
4626 Hidden name, either friend declaration or built-in function, are
4629 If PREFER_TYPE is > 0, we prefer TYPE_DECLs or namespaces.
4630 If PREFER_TYPE is > 1, we reject non-type decls (e.g. namespaces).
4631 Otherwise we prefer non-TYPE_DECLs.
4633 If NONCLASS is nonzero, bindings in class scopes are ignored. If
4634 BLOCK_P is false, bindings in block scopes are ignored. */
4637 lookup_name_real_1 (tree name
, int prefer_type
, int nonclass
, bool block_p
,
4638 int namespaces_only
, int flags
)
4641 tree val
= NULL_TREE
;
4643 /* Conversion operators are handled specially because ordinary
4644 unqualified name lookup will not find template conversion
4646 if (IDENTIFIER_TYPENAME_P (name
))
4648 cp_binding_level
*level
;
4650 for (level
= current_binding_level
;
4651 level
&& level
->kind
!= sk_namespace
;
4652 level
= level
->level_chain
)
4657 /* A conversion operator can only be declared in a class
4659 if (level
->kind
!= sk_class
)
4662 /* Lookup the conversion operator in the class. */
4663 class_type
= level
->this_entity
;
4664 operators
= lookup_fnfields (class_type
, name
, /*protect=*/0);
4672 flags
|= lookup_flags (prefer_type
, namespaces_only
);
4674 /* First, look in non-namespace scopes. */
4676 if (current_class_type
== NULL_TREE
)
4679 if (block_p
|| !nonclass
)
4680 for (iter
= outer_binding (name
, NULL
, !nonclass
);
4682 iter
= outer_binding (name
, iter
, !nonclass
))
4686 /* Skip entities we don't want. */
4687 if (LOCAL_BINDING_P (iter
) ? !block_p
: nonclass
)
4690 /* If this is the kind of thing we're looking for, we're done. */
4691 if (qualify_lookup (iter
->value
, flags
))
4692 binding
= iter
->value
;
4693 else if ((flags
& LOOKUP_PREFER_TYPES
)
4694 && qualify_lookup (iter
->type
, flags
))
4695 binding
= iter
->type
;
4697 binding
= NULL_TREE
;
4701 if (hidden_name_p (binding
))
4703 /* A non namespace-scope binding can only be hidden in the
4704 presence of a local class, due to friend declarations.
4706 In particular, consider:
4714 B* b; // error: B is hidden
4715 C* c; // OK, finds ::C
4718 B *b; // error: B is hidden
4719 C *c; // OK, finds ::C
4724 The standard says that "B" is a local class in "f"
4725 (but not nested within "A") -- but that name lookup
4726 for "B" does not find this declaration until it is
4727 declared directly with "f".
4733 If a friend declaration appears in a local class and
4734 the name specified is an unqualified name, a prior
4735 declaration is looked up without considering scopes
4736 that are outside the innermost enclosing non-class
4737 scope. For a friend function declaration, if there is
4738 no prior declaration, the program is ill-formed. For a
4739 friend class declaration, if there is no prior
4740 declaration, the class that is specified belongs to the
4741 innermost enclosing non-class scope, but if it is
4742 subsequently referenced, its name is not found by name
4743 lookup until a matching declaration is provided in the
4744 innermost enclosing nonclass scope.
4746 So just keep looking for a non-hidden binding.
4748 gcc_assert (TREE_CODE (binding
) == TYPE_DECL
);
4756 /* Now lookup in namespace scopes. */
4758 val
= unqualified_namespace_lookup (name
, flags
);
4760 /* If we have a single function from a using decl, pull it out. */
4761 if (val
&& TREE_CODE (val
) == OVERLOAD
&& !really_overloaded_fn (val
))
4762 val
= OVL_FUNCTION (val
);
4767 /* Wrapper for lookup_name_real_1. */
4770 lookup_name_real (tree name
, int prefer_type
, int nonclass
, bool block_p
,
4771 int namespaces_only
, int flags
)
4774 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
4775 ret
= lookup_name_real_1 (name
, prefer_type
, nonclass
, block_p
,
4776 namespaces_only
, flags
);
4777 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
4782 lookup_name_nonclass (tree name
)
4784 return lookup_name_real (name
, 0, 1, /*block_p=*/true, 0, 0);
4788 lookup_function_nonclass (tree name
, VEC(tree
,gc
) *args
, bool block_p
)
4791 lookup_arg_dependent (name
,
4792 lookup_name_real (name
, 0, 1, block_p
, 0, 0),
4797 lookup_name (tree name
)
4799 return lookup_name_real (name
, 0, 0, /*block_p=*/true, 0, 0);
4803 lookup_name_prefer_type (tree name
, int prefer_type
)
4805 return lookup_name_real (name
, prefer_type
, 0, /*block_p=*/true, 0, 0);
4808 /* Look up NAME for type used in elaborated name specifier in
4809 the scopes given by SCOPE. SCOPE can be either TS_CURRENT or
4810 TS_WITHIN_ENCLOSING_NON_CLASS. Although not implied by the
4811 name, more scopes are checked if cleanup or template parameter
4812 scope is encountered.
4814 Unlike lookup_name_real, we make sure that NAME is actually
4815 declared in the desired scope, not from inheritance, nor using
4816 directive. For using declaration, there is DR138 still waiting
4817 to be resolved. Hidden name coming from an earlier friend
4818 declaration is also returned.
4820 A TYPE_DECL best matching the NAME is returned. Catching error
4821 and issuing diagnostics are caller's responsibility. */
4824 lookup_type_scope_1 (tree name
, tag_scope scope
)
4826 cxx_binding
*iter
= NULL
;
4827 tree val
= NULL_TREE
;
4829 /* Look in non-namespace scope first. */
4830 if (current_binding_level
->kind
!= sk_namespace
)
4831 iter
= outer_binding (name
, NULL
, /*class_p=*/ true);
4832 for (; iter
; iter
= outer_binding (name
, iter
, /*class_p=*/ true))
4834 /* Check if this is the kind of thing we're looking for.
4835 If SCOPE is TS_CURRENT, also make sure it doesn't come from
4836 base class. For ITER->VALUE, we can simply use
4837 INHERITED_VALUE_BINDING_P. For ITER->TYPE, we have to use
4840 We check ITER->TYPE before ITER->VALUE in order to handle
4841 typedef struct C {} C;
4844 if (qualify_lookup (iter
->type
, LOOKUP_PREFER_TYPES
)
4845 && (scope
!= ts_current
4846 || LOCAL_BINDING_P (iter
)
4847 || DECL_CONTEXT (iter
->type
) == iter
->scope
->this_entity
))
4849 else if ((scope
!= ts_current
4850 || !INHERITED_VALUE_BINDING_P (iter
))
4851 && qualify_lookup (iter
->value
, LOOKUP_PREFER_TYPES
))
4858 /* Look in namespace scope. */
4861 iter
= cp_binding_level_find_binding_for_name
4862 (NAMESPACE_LEVEL (current_decl_namespace ()), name
);
4866 /* If this is the kind of thing we're looking for, we're done. */
4867 if (qualify_lookup (iter
->type
, LOOKUP_PREFER_TYPES
))
4869 else if (qualify_lookup (iter
->value
, LOOKUP_PREFER_TYPES
))
4875 /* Type found, check if it is in the allowed scopes, ignoring cleanup
4876 and template parameter scopes. */
4879 cp_binding_level
*b
= current_binding_level
;
4882 if (iter
->scope
== b
)
4885 if (b
->kind
== sk_cleanup
|| b
->kind
== sk_template_parms
4886 || b
->kind
== sk_function_parms
)
4888 else if (b
->kind
== sk_class
4889 && scope
== ts_within_enclosing_non_class
)
4899 /* Wrapper for lookup_type_scope_1. */
4902 lookup_type_scope (tree name
, tag_scope scope
)
4905 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
4906 ret
= lookup_type_scope_1 (name
, scope
);
4907 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
4912 /* Similar to `lookup_name' but look only in the innermost non-class
4916 lookup_name_innermost_nonclass_level_1 (tree name
)
4918 cp_binding_level
*b
;
4921 b
= innermost_nonclass_level ();
4923 if (b
->kind
== sk_namespace
)
4925 t
= IDENTIFIER_NAMESPACE_VALUE (name
);
4927 /* extern "C" function() */
4928 if (t
!= NULL_TREE
&& TREE_CODE (t
) == TREE_LIST
)
4931 else if (IDENTIFIER_BINDING (name
)
4932 && LOCAL_BINDING_P (IDENTIFIER_BINDING (name
)))
4934 cxx_binding
*binding
;
4935 binding
= IDENTIFIER_BINDING (name
);
4938 if (binding
->scope
== b
4939 && !(TREE_CODE (binding
->value
) == VAR_DECL
4940 && DECL_DEAD_FOR_LOCAL (binding
->value
)))
4941 return binding
->value
;
4943 if (b
->kind
== sk_cleanup
)
4953 /* Wrapper for lookup_name_innermost_nonclass_level_1. */
4956 lookup_name_innermost_nonclass_level (tree name
)
4959 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
4960 ret
= lookup_name_innermost_nonclass_level_1 (name
);
4961 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
4966 /* Returns true iff DECL is a block-scope extern declaration of a function
4970 is_local_extern (tree decl
)
4972 cxx_binding
*binding
;
4974 /* For functions, this is easy. */
4975 if (TREE_CODE (decl
) == FUNCTION_DECL
)
4976 return DECL_LOCAL_FUNCTION_P (decl
);
4978 if (TREE_CODE (decl
) != VAR_DECL
)
4980 if (!current_function_decl
)
4983 /* For variables, this is not easy. We need to look at the binding stack
4984 for the identifier to see whether the decl we have is a local. */
4985 for (binding
= IDENTIFIER_BINDING (DECL_NAME (decl
));
4986 binding
&& binding
->scope
->kind
!= sk_namespace
;
4987 binding
= binding
->previous
)
4988 if (binding
->value
== decl
)
4989 return LOCAL_BINDING_P (binding
);
4994 /* Like lookup_name_innermost_nonclass_level, but for types. */
4997 lookup_type_current_level (tree name
)
5001 timevar_start (TV_NAME_LOOKUP
);
5002 gcc_assert (current_binding_level
->kind
!= sk_namespace
);
5004 if (REAL_IDENTIFIER_TYPE_VALUE (name
) != NULL_TREE
5005 && REAL_IDENTIFIER_TYPE_VALUE (name
) != global_type_node
)
5007 cp_binding_level
*b
= current_binding_level
;
5010 if (purpose_member (name
, b
->type_shadowed
))
5012 t
= REAL_IDENTIFIER_TYPE_VALUE (name
);
5015 if (b
->kind
== sk_cleanup
)
5022 timevar_stop (TV_NAME_LOOKUP
);
5026 /* [basic.lookup.koenig] */
5027 /* A nonzero return value in the functions below indicates an error. */
5033 VEC(tree
,gc
) *namespaces
;
5034 VEC(tree
,gc
) *classes
;
5036 struct pointer_set_t
*fn_set
;
5039 static bool arg_assoc (struct arg_lookup
*, tree
);
5040 static bool arg_assoc_args (struct arg_lookup
*, tree
);
5041 static bool arg_assoc_args_vec (struct arg_lookup
*, VEC(tree
,gc
) *);
5042 static bool arg_assoc_type (struct arg_lookup
*, tree
);
5043 static bool add_function (struct arg_lookup
*, tree
);
5044 static bool arg_assoc_namespace (struct arg_lookup
*, tree
);
5045 static bool arg_assoc_class_only (struct arg_lookup
*, tree
);
5046 static bool arg_assoc_bases (struct arg_lookup
*, tree
);
5047 static bool arg_assoc_class (struct arg_lookup
*, tree
);
5048 static bool arg_assoc_template_arg (struct arg_lookup
*, tree
);
5050 /* Add a function to the lookup structure.
5051 Returns true on error. */
5054 add_function (struct arg_lookup
*k
, tree fn
)
5056 if (!is_overloaded_fn (fn
))
5057 /* All names except those of (possibly overloaded) functions and
5058 function templates are ignored. */;
5059 else if (k
->fn_set
&& pointer_set_insert (k
->fn_set
, fn
))
5060 /* It's already in the list. */;
5061 else if (!k
->functions
)
5063 else if (fn
== k
->functions
)
5067 k
->functions
= build_overload (fn
, k
->functions
);
5068 if (TREE_CODE (k
->functions
) == OVERLOAD
)
5069 OVL_ARG_DEPENDENT (k
->functions
) = true;
5075 /* Returns true iff CURRENT has declared itself to be an associated
5076 namespace of SCOPE via a strong using-directive (or transitive chain
5077 thereof). Both are namespaces. */
5080 is_associated_namespace (tree current
, tree scope
)
5082 VEC(tree
,gc
) *seen
= make_tree_vector ();
5083 VEC(tree
,gc
) *todo
= make_tree_vector ();
5089 if (scope
== current
)
5094 VEC_safe_push (tree
, gc
, seen
, scope
);
5095 for (t
= DECL_NAMESPACE_ASSOCIATIONS (scope
); t
; t
= TREE_CHAIN (t
))
5096 if (!vec_member (TREE_PURPOSE (t
), seen
))
5097 VEC_safe_push (tree
, gc
, todo
, TREE_PURPOSE (t
));
5098 if (!VEC_empty (tree
, todo
))
5100 scope
= VEC_last (tree
, todo
);
5101 VEC_pop (tree
, todo
);
5110 release_tree_vector (seen
);
5111 release_tree_vector (todo
);
5116 /* Add functions of a namespace to the lookup structure.
5117 Returns true on error. */
5120 arg_assoc_namespace (struct arg_lookup
*k
, tree scope
)
5124 if (vec_member (scope
, k
->namespaces
))
5126 VEC_safe_push (tree
, gc
, k
->namespaces
, scope
);
5128 /* Check out our super-users. */
5129 for (value
= DECL_NAMESPACE_ASSOCIATIONS (scope
); value
;
5130 value
= TREE_CHAIN (value
))
5131 if (arg_assoc_namespace (k
, TREE_PURPOSE (value
)))
5134 /* Also look down into inline namespaces. */
5135 for (value
= DECL_NAMESPACE_USING (scope
); value
;
5136 value
= TREE_CHAIN (value
))
5137 if (is_associated_namespace (scope
, TREE_PURPOSE (value
)))
5138 if (arg_assoc_namespace (k
, TREE_PURPOSE (value
)))
5141 value
= namespace_binding (k
->name
, scope
);
5145 for (; value
; value
= OVL_NEXT (value
))
5147 /* We don't want to find arbitrary hidden functions via argument
5148 dependent lookup. We only want to find friends of associated
5149 classes, which we'll do via arg_assoc_class. */
5150 if (hidden_name_p (OVL_CURRENT (value
)))
5153 if (add_function (k
, OVL_CURRENT (value
)))
5160 /* Adds everything associated with a template argument to the lookup
5161 structure. Returns true on error. */
5164 arg_assoc_template_arg (struct arg_lookup
*k
, tree arg
)
5166 /* [basic.lookup.koenig]
5168 If T is a template-id, its associated namespaces and classes are
5169 ... the namespaces and classes associated with the types of the
5170 template arguments provided for template type parameters
5171 (excluding template template parameters); the namespaces in which
5172 any template template arguments are defined; and the classes in
5173 which any member templates used as template template arguments
5174 are defined. [Note: non-type template arguments do not
5175 contribute to the set of associated namespaces. ] */
5177 /* Consider first template template arguments. */
5178 if (TREE_CODE (arg
) == TEMPLATE_TEMPLATE_PARM
5179 || TREE_CODE (arg
) == UNBOUND_CLASS_TEMPLATE
)
5181 else if (TREE_CODE (arg
) == TEMPLATE_DECL
)
5183 tree ctx
= CP_DECL_CONTEXT (arg
);
5185 /* It's not a member template. */
5186 if (TREE_CODE (ctx
) == NAMESPACE_DECL
)
5187 return arg_assoc_namespace (k
, ctx
);
5188 /* Otherwise, it must be member template. */
5190 return arg_assoc_class_only (k
, ctx
);
5192 /* It's an argument pack; handle it recursively. */
5193 else if (ARGUMENT_PACK_P (arg
))
5195 tree args
= ARGUMENT_PACK_ARGS (arg
);
5196 int i
, len
= TREE_VEC_LENGTH (args
);
5197 for (i
= 0; i
< len
; ++i
)
5198 if (arg_assoc_template_arg (k
, TREE_VEC_ELT (args
, i
)))
5203 /* It's not a template template argument, but it is a type template
5205 else if (TYPE_P (arg
))
5206 return arg_assoc_type (k
, arg
);
5207 /* It's a non-type template argument. */
5212 /* Adds the class and its friends to the lookup structure.
5213 Returns true on error. */
5216 arg_assoc_class_only (struct arg_lookup
*k
, tree type
)
5218 tree list
, friends
, context
;
5220 /* Backend-built structures, such as __builtin_va_list, aren't
5221 affected by all this. */
5222 if (!CLASS_TYPE_P (type
))
5225 context
= decl_namespace_context (type
);
5226 if (arg_assoc_namespace (k
, context
))
5229 complete_type (type
);
5231 /* Process friends. */
5232 for (list
= DECL_FRIENDLIST (TYPE_MAIN_DECL (type
)); list
;
5233 list
= TREE_CHAIN (list
))
5234 if (k
->name
== FRIEND_NAME (list
))
5235 for (friends
= FRIEND_DECLS (list
); friends
;
5236 friends
= TREE_CHAIN (friends
))
5238 tree fn
= TREE_VALUE (friends
);
5240 /* Only interested in global functions with potentially hidden
5241 (i.e. unqualified) declarations. */
5242 if (CP_DECL_CONTEXT (fn
) != context
)
5244 /* Template specializations are never found by name lookup.
5245 (Templates themselves can be found, but not template
5246 specializations.) */
5247 if (TREE_CODE (fn
) == FUNCTION_DECL
&& DECL_USE_TEMPLATE (fn
))
5249 if (add_function (k
, fn
))
5256 /* Adds the class and its bases to the lookup structure.
5257 Returns true on error. */
5260 arg_assoc_bases (struct arg_lookup
*k
, tree type
)
5262 if (arg_assoc_class_only (k
, type
))
5265 if (TYPE_BINFO (type
))
5267 /* Process baseclasses. */
5268 tree binfo
, base_binfo
;
5271 for (binfo
= TYPE_BINFO (type
), i
= 0;
5272 BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); i
++)
5273 if (arg_assoc_bases (k
, BINFO_TYPE (base_binfo
)))
5280 /* Adds everything associated with a class argument type to the lookup
5281 structure. Returns true on error.
5283 If T is a class type (including unions), its associated classes are: the
5284 class itself; the class of which it is a member, if any; and its direct
5285 and indirect base classes. Its associated namespaces are the namespaces
5286 of which its associated classes are members. Furthermore, if T is a
5287 class template specialization, its associated namespaces and classes
5288 also include: the namespaces and classes associated with the types of
5289 the template arguments provided for template type parameters (excluding
5290 template template parameters); the namespaces of which any template
5291 template arguments are members; and the classes of which any member
5292 templates used as template template arguments are members. [ Note:
5293 non-type template arguments do not contribute to the set of associated
5294 namespaces. --end note] */
5297 arg_assoc_class (struct arg_lookup
*k
, tree type
)
5302 /* Backend build structures, such as __builtin_va_list, aren't
5303 affected by all this. */
5304 if (!CLASS_TYPE_P (type
))
5307 if (vec_member (type
, k
->classes
))
5309 VEC_safe_push (tree
, gc
, k
->classes
, type
);
5311 if (TYPE_CLASS_SCOPE_P (type
)
5312 && arg_assoc_class_only (k
, TYPE_CONTEXT (type
)))
5315 if (arg_assoc_bases (k
, type
))
5318 /* Process template arguments. */
5319 if (CLASSTYPE_TEMPLATE_INFO (type
)
5320 && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (type
)))
5322 list
= INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (type
));
5323 for (i
= 0; i
< TREE_VEC_LENGTH (list
); ++i
)
5324 if (arg_assoc_template_arg (k
, TREE_VEC_ELT (list
, i
)))
5331 /* Adds everything associated with a given type.
5332 Returns 1 on error. */
5335 arg_assoc_type (struct arg_lookup
*k
, tree type
)
5337 /* As we do not get the type of non-type dependent expressions
5338 right, we can end up with such things without a type. */
5342 if (TYPE_PTRDATAMEM_P (type
))
5344 /* Pointer to member: associate class type and value type. */
5345 if (arg_assoc_type (k
, TYPE_PTRMEM_CLASS_TYPE (type
)))
5347 return arg_assoc_type (k
, TYPE_PTRMEM_POINTED_TO_TYPE (type
));
5349 else switch (TREE_CODE (type
))
5359 case FIXED_POINT_TYPE
:
5364 if (TYPE_PTRMEMFUNC_P (type
))
5365 return arg_assoc_type (k
, TYPE_PTRMEMFUNC_FN_TYPE (type
));
5367 return arg_assoc_class (k
, type
);
5369 case REFERENCE_TYPE
:
5371 return arg_assoc_type (k
, TREE_TYPE (type
));
5373 if (TYPE_CLASS_SCOPE_P (type
)
5374 && arg_assoc_class_only (k
, TYPE_CONTEXT (type
)))
5376 return arg_assoc_namespace (k
, decl_namespace_context (type
));
5378 /* The basetype is referenced in the first arg type, so just
5381 /* Associate the parameter types. */
5382 if (arg_assoc_args (k
, TYPE_ARG_TYPES (type
)))
5384 /* Associate the return type. */
5385 return arg_assoc_type (k
, TREE_TYPE (type
));
5386 case TEMPLATE_TYPE_PARM
:
5387 case BOUND_TEMPLATE_TEMPLATE_PARM
:
5392 gcc_assert (type
== unknown_type_node
5393 || type
== init_list_type_node
);
5395 case TYPE_PACK_EXPANSION
:
5396 return arg_assoc_type (k
, PACK_EXPANSION_PATTERN (type
));
5404 /* Adds everything associated with arguments. Returns true on error. */
5407 arg_assoc_args (struct arg_lookup
*k
, tree args
)
5409 for (; args
; args
= TREE_CHAIN (args
))
5410 if (arg_assoc (k
, TREE_VALUE (args
)))
5415 /* Adds everything associated with an argument vector. Returns true
5419 arg_assoc_args_vec (struct arg_lookup
*k
, VEC(tree
,gc
) *args
)
5424 FOR_EACH_VEC_ELT (tree
, args
, ix
, arg
)
5425 if (arg_assoc (k
, arg
))
5430 /* Adds everything associated with a given tree_node. Returns 1 on error. */
5433 arg_assoc (struct arg_lookup
*k
, tree n
)
5435 if (n
== error_mark_node
)
5439 return arg_assoc_type (k
, n
);
5441 if (! type_unknown_p (n
))
5442 return arg_assoc_type (k
, TREE_TYPE (n
));
5444 if (TREE_CODE (n
) == ADDR_EXPR
)
5445 n
= TREE_OPERAND (n
, 0);
5446 if (TREE_CODE (n
) == COMPONENT_REF
)
5447 n
= TREE_OPERAND (n
, 1);
5448 if (TREE_CODE (n
) == OFFSET_REF
)
5449 n
= TREE_OPERAND (n
, 1);
5450 while (TREE_CODE (n
) == TREE_LIST
)
5453 n
= BASELINK_FUNCTIONS (n
);
5455 if (TREE_CODE (n
) == FUNCTION_DECL
)
5456 return arg_assoc_type (k
, TREE_TYPE (n
));
5457 if (TREE_CODE (n
) == TEMPLATE_ID_EXPR
)
5459 /* The working paper doesn't currently say how to handle template-id
5460 arguments. The sensible thing would seem to be to handle the list
5461 of template candidates like a normal overload set, and handle the
5462 template arguments like we do for class template
5464 tree templ
= TREE_OPERAND (n
, 0);
5465 tree args
= TREE_OPERAND (n
, 1);
5468 /* First the templates. */
5469 if (arg_assoc (k
, templ
))
5472 /* Now the arguments. */
5474 for (ix
= TREE_VEC_LENGTH (args
); ix
--;)
5475 if (arg_assoc_template_arg (k
, TREE_VEC_ELT (args
, ix
)) == 1)
5478 else if (TREE_CODE (n
) == OVERLOAD
)
5480 for (; n
; n
= OVL_NEXT (n
))
5481 if (arg_assoc_type (k
, TREE_TYPE (OVL_CURRENT (n
))))
5488 /* Performs Koenig lookup depending on arguments, where fns
5489 are the functions found in normal lookup. */
5492 lookup_arg_dependent_1 (tree name
, tree fns
, VEC(tree
,gc
) *args
,
5495 struct arg_lookup k
;
5497 /* Remove any hidden friend functions from the list of functions
5498 found so far. They will be added back by arg_assoc_class as
5500 fns
= remove_hidden_names (fns
);
5505 k
.classes
= make_tree_vector ();
5507 /* We previously performed an optimization here by setting
5508 NAMESPACES to the current namespace when it was safe. However, DR
5509 164 says that namespaces that were already searched in the first
5510 stage of template processing are searched again (potentially
5511 picking up later definitions) in the second stage. */
5512 k
.namespaces
= make_tree_vector ();
5514 /* We used to allow duplicates and let joust discard them, but
5515 since the above change for DR 164 we end up with duplicates of
5516 all the functions found by unqualified lookup. So keep track
5517 of which ones we've seen. */
5521 /* We shouldn't be here if lookup found something other than
5522 namespace-scope functions. */
5523 gcc_assert (DECL_NAMESPACE_SCOPE_P (OVL_CURRENT (fns
)));
5524 k
.fn_set
= pointer_set_create ();
5525 for (ovl
= fns
; ovl
; ovl
= OVL_NEXT (ovl
))
5526 pointer_set_insert (k
.fn_set
, OVL_CURRENT (ovl
));
5532 arg_assoc_namespace (&k
, std_node
);
5533 arg_assoc_args_vec (&k
, args
);
5538 && TREE_CODE (fns
) != VAR_DECL
5539 && !is_overloaded_fn (fns
))
5541 error ("argument dependent lookup finds %q+D", fns
);
5542 error (" in call to %qD", name
);
5543 fns
= error_mark_node
;
5546 release_tree_vector (k
.classes
);
5547 release_tree_vector (k
.namespaces
);
5549 pointer_set_destroy (k
.fn_set
);
5554 /* Wrapper for lookup_arg_dependent_1. */
5557 lookup_arg_dependent (tree name
, tree fns
, VEC(tree
,gc
) *args
,
5562 subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
5563 ret
= lookup_arg_dependent_1 (name
, fns
, args
, include_std
);
5564 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
5569 /* Add namespace to using_directives. Return NULL_TREE if nothing was
5570 changed (i.e. there was already a directive), or the fresh
5571 TREE_LIST otherwise. */
5574 push_using_directive_1 (tree used
)
5576 tree ud
= current_binding_level
->using_directives
;
5577 tree iter
, ancestor
;
5579 /* Check if we already have this. */
5580 if (purpose_member (used
, ud
) != NULL_TREE
)
5583 ancestor
= namespace_ancestor (current_decl_namespace (), used
);
5584 ud
= current_binding_level
->using_directives
;
5585 ud
= tree_cons (used
, ancestor
, ud
);
5586 current_binding_level
->using_directives
= ud
;
5588 /* Recursively add all namespaces used. */
5589 for (iter
= DECL_NAMESPACE_USING (used
); iter
; iter
= TREE_CHAIN (iter
))
5590 push_using_directive (TREE_PURPOSE (iter
));
5595 /* Wrapper for push_using_directive_1. */
5598 push_using_directive (tree used
)
5601 timevar_start (TV_NAME_LOOKUP
);
5602 ret
= push_using_directive_1 (used
);
5603 timevar_stop (TV_NAME_LOOKUP
);
5607 /* The type TYPE is being declared. If it is a class template, or a
5608 specialization of a class template, do any processing required and
5609 perform error-checking. If IS_FRIEND is nonzero, this TYPE is
5610 being declared a friend. B is the binding level at which this TYPE
5613 Returns the TYPE_DECL for TYPE, which may have been altered by this
5617 maybe_process_template_type_declaration (tree type
, int is_friend
,
5618 cp_binding_level
*b
)
5620 tree decl
= TYPE_NAME (type
);
5622 if (processing_template_parmlist
)
5623 /* You can't declare a new template type in a template parameter
5624 list. But, you can declare a non-template type:
5626 template <class A*> struct S;
5628 is a forward-declaration of `A'. */
5630 else if (b
->kind
== sk_namespace
5631 && current_binding_level
->kind
!= sk_namespace
)
5632 /* If this new type is being injected into a containing scope,
5633 then it's not a template type. */
5637 gcc_assert (MAYBE_CLASS_TYPE_P (type
)
5638 || TREE_CODE (type
) == ENUMERAL_TYPE
);
5640 if (processing_template_decl
)
5642 /* This may change after the call to
5643 push_template_decl_real, but we want the original value. */
5644 tree name
= DECL_NAME (decl
);
5646 decl
= push_template_decl_real (decl
, is_friend
);
5647 if (decl
== error_mark_node
)
5648 return error_mark_node
;
5650 /* If the current binding level is the binding level for the
5651 template parameters (see the comment in
5652 begin_template_parm_list) and the enclosing level is a class
5653 scope, and we're not looking at a friend, push the
5654 declaration of the member class into the class scope. In the
5655 friend case, push_template_decl will already have put the
5656 friend into global scope, if appropriate. */
5657 if (TREE_CODE (type
) != ENUMERAL_TYPE
5658 && !is_friend
&& b
->kind
== sk_template_parms
5659 && b
->level_chain
->kind
== sk_class
)
5661 finish_member_declaration (CLASSTYPE_TI_TEMPLATE (type
));
5663 if (!COMPLETE_TYPE_P (current_class_type
))
5665 maybe_add_class_template_decl_list (current_class_type
,
5666 type
, /*friend_p=*/0);
5667 /* Put this UTD in the table of UTDs for the class. */
5668 if (CLASSTYPE_NESTED_UTDS (current_class_type
) == NULL
)
5669 CLASSTYPE_NESTED_UTDS (current_class_type
) =
5670 binding_table_new (SCOPE_DEFAULT_HT_SIZE
);
5672 binding_table_insert
5673 (CLASSTYPE_NESTED_UTDS (current_class_type
), name
, type
);
5682 /* Push a tag name NAME for struct/class/union/enum type TYPE. In case
5683 that the NAME is a class template, the tag is processed but not pushed.
5685 The pushed scope depend on the SCOPE parameter:
5686 - When SCOPE is TS_CURRENT, put it into the inner-most non-sk_cleanup
5688 - When SCOPE is TS_GLOBAL, put it in the inner-most non-class and
5689 non-template-parameter scope. This case is needed for forward
5691 - When SCOPE is TS_WITHIN_ENCLOSING_NON_CLASS, this is similar to
5692 TS_GLOBAL case except that names within template-parameter scopes
5693 are not pushed at all.
5695 Returns TYPE upon success and ERROR_MARK_NODE otherwise. */
5698 pushtag_1 (tree name
, tree type
, tag_scope scope
)
5700 cp_binding_level
*b
;
5703 b
= current_binding_level
;
5704 while (/* Cleanup scopes are not scopes from the point of view of
5706 b
->kind
== sk_cleanup
5707 /* Neither are function parameter scopes. */
5708 || b
->kind
== sk_function_parms
5709 /* Neither are the scopes used to hold template parameters
5710 for an explicit specialization. For an ordinary template
5711 declaration, these scopes are not scopes from the point of
5712 view of the language. */
5713 || (b
->kind
== sk_template_parms
5714 && (b
->explicit_spec_p
|| scope
== ts_global
))
5715 || (b
->kind
== sk_class
5716 && (scope
!= ts_current
5717 /* We may be defining a new type in the initializer
5718 of a static member variable. We allow this when
5719 not pedantic, and it is particularly useful for
5720 type punning via an anonymous union. */
5721 || COMPLETE_TYPE_P (b
->this_entity
))))
5724 gcc_assert (TREE_CODE (name
) == IDENTIFIER_NODE
);
5726 /* Do C++ gratuitous typedefing. */
5727 if (identifier_type_value_1 (name
) != type
)
5731 tree context
= TYPE_CONTEXT (type
);
5735 tree cs
= current_scope ();
5737 if (scope
== ts_current
5738 || (cs
&& TREE_CODE (cs
) == FUNCTION_DECL
))
5740 else if (cs
!= NULL_TREE
&& TYPE_P (cs
))
5741 /* When declaring a friend class of a local class, we want
5742 to inject the newly named class into the scope
5743 containing the local class, not the namespace
5745 context
= decl_function_context (get_type_decl (cs
));
5748 context
= current_namespace
;
5750 if (b
->kind
== sk_class
5751 || (b
->kind
== sk_template_parms
5752 && b
->level_chain
->kind
== sk_class
))
5755 if (current_lang_name
== lang_name_java
)
5756 TYPE_FOR_JAVA (type
) = 1;
5758 tdef
= create_implicit_typedef (name
, type
);
5759 DECL_CONTEXT (tdef
) = FROB_CONTEXT (context
);
5760 if (scope
== ts_within_enclosing_non_class
)
5762 /* This is a friend. Make this TYPE_DECL node hidden from
5763 ordinary name lookup. Its corresponding TEMPLATE_DECL
5764 will be marked in push_template_decl_real. */
5765 retrofit_lang_decl (tdef
);
5766 DECL_ANTICIPATED (tdef
) = 1;
5767 DECL_FRIEND_P (tdef
) = 1;
5770 decl
= maybe_process_template_type_declaration
5771 (type
, scope
== ts_within_enclosing_non_class
, b
);
5772 if (decl
== error_mark_node
)
5775 if (b
->kind
== sk_class
)
5777 if (!TYPE_BEING_DEFINED (current_class_type
))
5778 return error_mark_node
;
5780 if (!PROCESSING_REAL_TEMPLATE_DECL_P ())
5781 /* Put this TYPE_DECL on the TYPE_FIELDS list for the
5782 class. But if it's a member template class, we want
5783 the TEMPLATE_DECL, not the TYPE_DECL, so this is done
5785 finish_member_declaration (decl
);
5787 pushdecl_class_level (decl
);
5789 else if (b
->kind
!= sk_template_parms
)
5791 decl
= pushdecl_with_scope_1 (decl
, b
, /*is_friend=*/false);
5792 if (decl
== error_mark_node
)
5797 set_identifier_type_value_with_scope (name
, tdef
, b
);
5799 TYPE_CONTEXT (type
) = DECL_CONTEXT (decl
);
5801 /* If this is a local class, keep track of it. We need this
5802 information for name-mangling, and so that it is possible to
5803 find all function definitions in a translation unit in a
5804 convenient way. (It's otherwise tricky to find a member
5805 function definition it's only pointed to from within a local
5807 if (TYPE_CONTEXT (type
)
5808 && TREE_CODE (TYPE_CONTEXT (type
)) == FUNCTION_DECL
)
5810 if (processing_template_decl
)
5812 /* Push a DECL_EXPR so we call pushtag at the right time in
5813 template instantiation rather than in some nested context. */
5814 add_decl_expr (decl
);
5817 VEC_safe_push (tree
, gc
, local_classes
, type
);
5820 if (b
->kind
== sk_class
5821 && !COMPLETE_TYPE_P (current_class_type
))
5823 maybe_add_class_template_decl_list (current_class_type
,
5824 type
, /*friend_p=*/0);
5826 if (CLASSTYPE_NESTED_UTDS (current_class_type
) == NULL
)
5827 CLASSTYPE_NESTED_UTDS (current_class_type
)
5828 = binding_table_new (SCOPE_DEFAULT_HT_SIZE
);
5830 binding_table_insert
5831 (CLASSTYPE_NESTED_UTDS (current_class_type
), name
, type
);
5834 decl
= TYPE_NAME (type
);
5835 gcc_assert (TREE_CODE (decl
) == TYPE_DECL
);
5837 /* Set type visibility now if this is a forward declaration. */
5838 TREE_PUBLIC (decl
) = 1;
5839 determine_visibility (decl
);
5844 /* Wrapper for pushtag_1. */
5847 pushtag (tree name
, tree type
, tag_scope scope
)
5850 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
5851 ret
= pushtag_1 (name
, type
, scope
);
5852 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
5856 /* Subroutines for reverting temporarily to top-level for instantiation
5857 of templates and such. We actually need to clear out the class- and
5858 local-value slots of all identifiers, so that only the global values
5859 are at all visible. Simply setting current_binding_level to the global
5860 scope isn't enough, because more binding levels may be pushed. */
5861 struct saved_scope
*scope_chain
;
5863 /* Return true if ID has not already been marked. */
5866 store_binding_p (tree id
)
5868 if (!id
|| !IDENTIFIER_BINDING (id
))
5871 if (IDENTIFIER_MARKED (id
))
5877 /* Add an appropriate binding to *OLD_BINDINGS which needs to already
5878 have enough space reserved. */
5881 store_binding (tree id
, VEC(cxx_saved_binding
,gc
) **old_bindings
)
5883 cxx_saved_binding saved
;
5885 gcc_checking_assert (store_binding_p (id
));
5887 IDENTIFIER_MARKED (id
) = 1;
5889 saved
.identifier
= id
;
5890 saved
.binding
= IDENTIFIER_BINDING (id
);
5891 saved
.real_type_value
= REAL_IDENTIFIER_TYPE_VALUE (id
);
5892 VEC_quick_push (cxx_saved_binding
, *old_bindings
, saved
);
5893 IDENTIFIER_BINDING (id
) = NULL
;
5897 store_bindings (tree names
, VEC(cxx_saved_binding
,gc
) **old_bindings
)
5899 static VEC(tree
,heap
) *bindings_need_stored
= NULL
;
5903 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
5904 for (t
= names
; t
; t
= TREE_CHAIN (t
))
5906 if (TREE_CODE (t
) == TREE_LIST
)
5907 id
= TREE_PURPOSE (t
);
5911 if (store_binding_p (id
))
5912 VEC_safe_push(tree
, heap
, bindings_need_stored
, id
);
5914 if (!VEC_empty (tree
, bindings_need_stored
))
5916 VEC_reserve_exact (cxx_saved_binding
, gc
, *old_bindings
,
5917 VEC_length (tree
, bindings_need_stored
));
5918 for (i
= 0; VEC_iterate(tree
, bindings_need_stored
, i
, id
); ++i
)
5920 /* We can appearantly have duplicates in NAMES. */
5921 if (store_binding_p (id
))
5922 store_binding (id
, old_bindings
);
5924 VEC_truncate (tree
, bindings_need_stored
, 0);
5926 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
5929 /* Like store_bindings, but NAMES is a vector of cp_class_binding
5930 objects, rather than a TREE_LIST. */
5933 store_class_bindings (VEC(cp_class_binding
,gc
) *names
,
5934 VEC(cxx_saved_binding
,gc
) **old_bindings
)
5936 static VEC(tree
,heap
) *bindings_need_stored
= NULL
;
5938 cp_class_binding
*cb
;
5940 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
5941 for (i
= 0; VEC_iterate(cp_class_binding
, names
, i
, cb
); ++i
)
5942 if (store_binding_p (cb
->identifier
))
5943 VEC_safe_push (tree
, heap
, bindings_need_stored
, cb
->identifier
);
5944 if (!VEC_empty (tree
, bindings_need_stored
))
5947 VEC_reserve_exact (cxx_saved_binding
, gc
, *old_bindings
,
5948 VEC_length (tree
, bindings_need_stored
));
5949 for (i
= 0; VEC_iterate(tree
, bindings_need_stored
, i
, id
); ++i
)
5950 store_binding (id
, old_bindings
);
5951 VEC_truncate (tree
, bindings_need_stored
, 0);
5953 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
5957 push_to_top_level (void)
5959 struct saved_scope
*s
;
5960 cp_binding_level
*b
;
5961 cxx_saved_binding
*sb
;
5965 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
5966 s
= ggc_alloc_cleared_saved_scope ();
5968 b
= scope_chain
? current_binding_level
: 0;
5970 /* If we're in the middle of some function, save our state. */
5974 push_function_context ();
5979 if (scope_chain
&& previous_class_level
)
5980 store_class_bindings (previous_class_level
->class_shadowed
,
5983 /* Have to include the global scope, because class-scope decls
5984 aren't listed anywhere useful. */
5985 for (; b
; b
= b
->level_chain
)
5989 /* Template IDs are inserted into the global level. If they were
5990 inserted into namespace level, finish_file wouldn't find them
5991 when doing pending instantiations. Therefore, don't stop at
5992 namespace level, but continue until :: . */
5993 if (global_scope_p (b
))
5996 store_bindings (b
->names
, &s
->old_bindings
);
5997 /* We also need to check class_shadowed to save class-level type
5998 bindings, since pushclass doesn't fill in b->names. */
5999 if (b
->kind
== sk_class
)
6000 store_class_bindings (b
->class_shadowed
, &s
->old_bindings
);
6002 /* Unwind type-value slots back to top level. */
6003 for (t
= b
->type_shadowed
; t
; t
= TREE_CHAIN (t
))
6004 SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (t
), TREE_VALUE (t
));
6007 FOR_EACH_VEC_ELT (cxx_saved_binding
, s
->old_bindings
, i
, sb
)
6008 IDENTIFIER_MARKED (sb
->identifier
) = 0;
6010 s
->prev
= scope_chain
;
6012 s
->need_pop_function_context
= need_pop
;
6013 s
->function_decl
= current_function_decl
;
6014 s
->unevaluated_operand
= cp_unevaluated_operand
;
6015 s
->inhibit_evaluation_warnings
= c_inhibit_evaluation_warnings
;
6016 s
->x_stmt_tree
.stmts_are_full_exprs_p
= true;
6019 current_function_decl
= NULL_TREE
;
6020 current_lang_base
= VEC_alloc (tree
, gc
, 10);
6021 current_lang_name
= lang_name_cplusplus
;
6022 current_namespace
= global_namespace
;
6023 push_class_stack ();
6024 cp_unevaluated_operand
= 0;
6025 c_inhibit_evaluation_warnings
= 0;
6026 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
6030 pop_from_top_level_1 (void)
6032 struct saved_scope
*s
= scope_chain
;
6033 cxx_saved_binding
*saved
;
6036 /* Clear out class-level bindings cache. */
6037 if (previous_class_level
)
6038 invalidate_class_lookup_cache ();
6041 current_lang_base
= 0;
6043 scope_chain
= s
->prev
;
6044 FOR_EACH_VEC_ELT (cxx_saved_binding
, s
->old_bindings
, i
, saved
)
6046 tree id
= saved
->identifier
;
6048 IDENTIFIER_BINDING (id
) = saved
->binding
;
6049 SET_IDENTIFIER_TYPE_VALUE (id
, saved
->real_type_value
);
6052 /* If we were in the middle of compiling a function, restore our
6054 if (s
->need_pop_function_context
)
6055 pop_function_context ();
6056 current_function_decl
= s
->function_decl
;
6057 cp_unevaluated_operand
= s
->unevaluated_operand
;
6058 c_inhibit_evaluation_warnings
= s
->inhibit_evaluation_warnings
;
6061 /* Wrapper for pop_from_top_level_1. */
6064 pop_from_top_level (void)
6066 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
6067 pop_from_top_level_1 ();
6068 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
6072 /* Pop off extraneous binding levels left over due to syntax errors.
6074 We don't pop past namespaces, as they might be valid. */
6077 pop_everything (void)
6079 if (ENABLE_SCOPE_CHECKING
)
6080 verbatim ("XXX entering pop_everything ()\n");
6081 while (!toplevel_bindings_p ())
6083 if (current_binding_level
->kind
== sk_class
)
6084 pop_nested_class ();
6088 if (ENABLE_SCOPE_CHECKING
)
6089 verbatim ("XXX leaving pop_everything ()\n");
6092 /* Emit debugging information for using declarations and directives.
6093 If input tree is overloaded fn then emit debug info for all
6097 cp_emit_debug_info_for_using (tree t
, tree context
)
6099 /* Don't try to emit any debug information if we have errors. */
6103 /* Ignore this FUNCTION_DECL if it refers to a builtin declaration
6104 of a builtin function. */
6105 if (TREE_CODE (t
) == FUNCTION_DECL
6106 && DECL_EXTERNAL (t
)
6107 && DECL_BUILT_IN (t
))
6110 /* Do not supply context to imported_module_or_decl, if
6111 it is a global namespace. */
6112 if (context
== global_namespace
)
6113 context
= NULL_TREE
;
6116 t
= BASELINK_FUNCTIONS (t
);
6118 /* FIXME: Handle TEMPLATE_DECLs. */
6119 for (t
= OVL_CURRENT (t
); t
; t
= OVL_NEXT (t
))
6120 if (TREE_CODE (t
) != TEMPLATE_DECL
)
6122 if (building_stmt_list_p ())
6123 add_stmt (build_stmt (input_location
, USING_STMT
, t
));
6125 (*debug_hooks
->imported_module_or_decl
) (t
, NULL_TREE
, context
, false);
6129 #include "gt-cp-name-lookup.h"