1 /* Definitions for C++ name lookup routines.
2 Copyright (C) 2003-2014 Free Software Foundation, Inc.
3 Contributed by Gabriel Dos Reis <gdr@integrable-solutions.net>
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3, or (at your option)
12 GCC is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING3. If not see
19 <http://www.gnu.org/licenses/>. */
23 #include "coretypes.h"
27 #include "stringpool.h"
28 #include "print-tree.h"
31 #include "name-lookup.h"
33 #include "diagnostic-core.h"
36 #include "c-family/c-pragma.h"
38 #include "pointer-set.h"
40 /* The bindings for a particular name in a particular scope. */
42 struct scope_binding
{
46 #define EMPTY_SCOPE_BINDING { NULL_TREE, NULL_TREE }
48 static cp_binding_level
*innermost_nonclass_level (void);
49 static cxx_binding
*binding_for_name (cp_binding_level
*, tree
);
50 static tree
push_overloaded_decl (tree
, int, bool);
51 static bool lookup_using_namespace (tree
, struct scope_binding
*, tree
,
53 static bool qualified_lookup_using_namespace (tree
, tree
,
54 struct scope_binding
*, int);
55 static tree
lookup_type_current_level (tree
);
56 static tree
push_using_directive (tree
);
57 static tree
lookup_extern_c_fun_in_all_ns (tree
);
58 static void diagnose_name_conflict (tree
, tree
);
60 /* The :: namespace. */
62 tree global_namespace
;
64 /* The name of the anonymous namespace, throughout this translation
66 static GTY(()) tree anonymous_namespace_name
;
68 /* Initialize anonymous_namespace_name if necessary, and return it. */
71 get_anonymous_namespace_name (void)
73 if (!anonymous_namespace_name
)
75 /* We used to use get_file_function_name here, but that isn't
76 necessary now that anonymous namespace typeinfos
77 are !TREE_PUBLIC, and thus compared by address. */
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
)
260 chain_count
= table
->chain_count
;
261 for (i
= 0; i
< chain_count
; ++i
)
263 binding_entry entry
= table
->chain
[i
];
264 for (; entry
!= NULL
; entry
= entry
->chain
)
269 #ifndef ENABLE_SCOPE_CHECKING
270 # define ENABLE_SCOPE_CHECKING 0
272 # define ENABLE_SCOPE_CHECKING 1
275 /* A free list of "cxx_binding"s, connected by their PREVIOUS. */
277 static GTY((deletable
)) cxx_binding
*free_bindings
;
279 /* Initialize VALUE and TYPE field for BINDING, and set the PREVIOUS
283 cxx_binding_init (cxx_binding
*binding
, tree value
, tree type
)
285 binding
->value
= value
;
286 binding
->type
= type
;
287 binding
->previous
= NULL
;
290 /* (GC)-allocate a binding object with VALUE and TYPE member initialized. */
293 cxx_binding_make (tree value
, tree type
)
295 cxx_binding
*binding
;
298 binding
= free_bindings
;
299 free_bindings
= binding
->previous
;
302 binding
= ggc_alloc_cxx_binding ();
304 cxx_binding_init (binding
, value
, type
);
309 /* Put BINDING back on the free list. */
312 cxx_binding_free (cxx_binding
*binding
)
314 binding
->scope
= NULL
;
315 binding
->previous
= free_bindings
;
316 free_bindings
= binding
;
319 /* Create a new binding for NAME (with the indicated VALUE and TYPE
320 bindings) in the class scope indicated by SCOPE. */
323 new_class_binding (tree name
, tree value
, tree type
, cp_binding_level
*scope
)
325 cp_class_binding cb
= {cxx_binding_make (value
, type
), name
};
326 cxx_binding
*binding
= cb
.base
;
327 vec_safe_push (scope
->class_shadowed
, cb
);
328 binding
->scope
= scope
;
332 /* Make DECL the innermost binding for ID. The LEVEL is the binding
333 level at which this declaration is being bound. */
336 push_binding (tree id
, tree decl
, cp_binding_level
* level
)
338 cxx_binding
*binding
;
340 if (level
!= class_binding_level
)
342 binding
= cxx_binding_make (decl
, NULL_TREE
);
343 binding
->scope
= level
;
346 binding
= new_class_binding (id
, decl
, /*type=*/NULL_TREE
, level
);
348 /* Now, fill in the binding information. */
349 binding
->previous
= IDENTIFIER_BINDING (id
);
350 INHERITED_VALUE_BINDING_P (binding
) = 0;
351 LOCAL_BINDING_P (binding
) = (level
!= class_binding_level
);
353 /* And put it on the front of the list of bindings for ID. */
354 IDENTIFIER_BINDING (id
) = binding
;
357 /* Remove the binding for DECL which should be the innermost binding
361 pop_binding (tree id
, tree decl
)
363 cxx_binding
*binding
;
366 /* It's easiest to write the loops that call this function without
367 checking whether or not the entities involved have names. We
368 get here for such an entity. */
371 /* Get the innermost binding for ID. */
372 binding
= IDENTIFIER_BINDING (id
);
374 /* The name should be bound. */
375 gcc_assert (binding
!= NULL
);
377 /* The DECL will be either the ordinary binding or the type
378 binding for this identifier. Remove that binding. */
379 if (binding
->value
== decl
)
380 binding
->value
= NULL_TREE
;
383 gcc_assert (binding
->type
== decl
);
384 binding
->type
= NULL_TREE
;
387 if (!binding
->value
&& !binding
->type
)
389 /* We're completely done with the innermost binding for this
390 identifier. Unhook it from the list of bindings. */
391 IDENTIFIER_BINDING (id
) = binding
->previous
;
393 /* Add it to the free list. */
394 cxx_binding_free (binding
);
398 /* Remove the bindings for the decls of the current level and leave
399 the current scope. */
402 pop_bindings_and_leave_scope (void)
404 for (tree t
= getdecls (); t
; t
= DECL_CHAIN (t
))
405 pop_binding (DECL_NAME (t
), t
);
409 /* Strip non dependent using declarations. If DECL is dependent,
410 surreptitiously create a typename_type and return it. */
413 strip_using_decl (tree decl
)
415 if (decl
== NULL_TREE
)
418 while (TREE_CODE (decl
) == USING_DECL
&& !DECL_DEPENDENT_P (decl
))
419 decl
= USING_DECL_DECLS (decl
);
421 if (TREE_CODE (decl
) == USING_DECL
&& DECL_DEPENDENT_P (decl
)
422 && USING_DECL_TYPENAME_P (decl
))
424 /* We have found a type introduced by a using
425 declaration at class scope that refers to a dependent
428 using typename :: [opt] nested-name-specifier unqualified-id ;
430 decl
= make_typename_type (TREE_TYPE (decl
),
432 typename_type
, tf_error
);
433 if (decl
!= error_mark_node
)
434 decl
= TYPE_NAME (decl
);
440 /* BINDING records an existing declaration for a name in the current scope.
441 But, DECL is another declaration for that same identifier in the
442 same scope. This is the `struct stat' hack whereby a non-typedef
443 class name or enum-name can be bound at the same level as some other
447 A class name (9.1) or enumeration name (7.2) can be hidden by the
448 name of an object, function, or enumerator declared in the same scope.
449 If a class or enumeration name and an object, function, or enumerator
450 are declared in the same scope (in any order) with the same name, the
451 class or enumeration name is hidden wherever the object, function, or
452 enumerator name is visible.
454 It's the responsibility of the caller to check that
455 inserting this name is valid here. Returns nonzero if the new binding
459 supplement_binding_1 (cxx_binding
*binding
, tree decl
)
461 tree bval
= binding
->value
;
463 tree target_bval
= strip_using_decl (bval
);
464 tree target_decl
= strip_using_decl (decl
);
466 if (TREE_CODE (target_decl
) == TYPE_DECL
&& DECL_ARTIFICIAL (target_decl
)
467 && target_decl
!= target_bval
468 && (TREE_CODE (target_bval
) != TYPE_DECL
469 /* We allow pushing an enum multiple times in a class
470 template in order to handle late matching of underlying
471 type on an opaque-enum-declaration followed by an
473 || (processing_template_decl
474 && TREE_CODE (TREE_TYPE (target_decl
)) == ENUMERAL_TYPE
475 && TREE_CODE (TREE_TYPE (target_bval
)) == ENUMERAL_TYPE
476 && (dependent_type_p (ENUM_UNDERLYING_TYPE
477 (TREE_TYPE (target_decl
)))
478 || dependent_type_p (ENUM_UNDERLYING_TYPE
479 (TREE_TYPE (target_bval
)))))))
480 /* The new name is the type name. */
481 binding
->type
= decl
;
482 else if (/* TARGET_BVAL is null when push_class_level_binding moves
483 an inherited type-binding out of the way to make room
484 for a new value binding. */
486 /* TARGET_BVAL is error_mark_node when TARGET_DECL's name
487 has been used in a non-class scope prior declaration.
488 In that case, we should have already issued a
489 diagnostic; for graceful error recovery purpose, pretend
490 this was the intended declaration for that name. */
491 || target_bval
== error_mark_node
492 /* If TARGET_BVAL is anticipated but has not yet been
493 declared, pretend it is not there at all. */
494 || (TREE_CODE (target_bval
) == FUNCTION_DECL
495 && DECL_ANTICIPATED (target_bval
)
496 && !DECL_HIDDEN_FRIEND_P (target_bval
)))
497 binding
->value
= decl
;
498 else if (TREE_CODE (target_bval
) == TYPE_DECL
499 && DECL_ARTIFICIAL (target_bval
)
500 && target_decl
!= target_bval
501 && (TREE_CODE (target_decl
) != TYPE_DECL
502 || same_type_p (TREE_TYPE (target_decl
),
503 TREE_TYPE (target_bval
))))
505 /* The old binding was a type name. It was placed in
506 VALUE field because it was thought, at the point it was
507 declared, to be the only entity with such a name. Move the
508 type name into the type slot; it is now hidden by the new
510 binding
->type
= bval
;
511 binding
->value
= decl
;
512 binding
->value_is_inherited
= false;
514 else if (TREE_CODE (target_bval
) == TYPE_DECL
515 && TREE_CODE (target_decl
) == TYPE_DECL
516 && DECL_NAME (target_decl
) == DECL_NAME (target_bval
)
517 && binding
->scope
->kind
!= sk_class
518 && (same_type_p (TREE_TYPE (target_decl
), TREE_TYPE (target_bval
))
519 /* If either type involves template parameters, we must
520 wait until instantiation. */
521 || uses_template_parms (TREE_TYPE (target_decl
))
522 || uses_template_parms (TREE_TYPE (target_bval
))))
523 /* We have two typedef-names, both naming the same type to have
524 the same name. In general, this is OK because of:
528 In a given scope, a typedef specifier can be used to redefine
529 the name of any type declared in that scope to refer to the
530 type to which it already refers.
532 However, in class scopes, this rule does not apply due to the
533 stricter language in [class.mem] prohibiting redeclarations of
536 /* There can be two block-scope declarations of the same variable,
537 so long as they are `extern' declarations. However, there cannot
538 be two declarations of the same static data member:
542 A member shall not be declared twice in the
543 member-specification. */
544 else if (VAR_P (target_decl
)
545 && VAR_P (target_bval
)
546 && DECL_EXTERNAL (target_decl
) && DECL_EXTERNAL (target_bval
)
547 && !DECL_CLASS_SCOPE_P (target_decl
))
549 duplicate_decls (decl
, binding
->value
, /*newdecl_is_friend=*/false);
552 else if (TREE_CODE (decl
) == NAMESPACE_DECL
553 && TREE_CODE (bval
) == NAMESPACE_DECL
554 && DECL_NAMESPACE_ALIAS (decl
)
555 && DECL_NAMESPACE_ALIAS (bval
)
556 && ORIGINAL_NAMESPACE (bval
) == ORIGINAL_NAMESPACE (decl
))
559 In a declarative region, a namespace-alias-definition can be
560 used to redefine a namespace-alias declared in that declarative
561 region to refer only to the namespace to which it already
566 diagnose_name_conflict (decl
, bval
);
573 /* Diagnose a name conflict between DECL and BVAL. */
576 diagnose_name_conflict (tree decl
, tree bval
)
578 if (TREE_CODE (decl
) == TREE_CODE (bval
)
579 && (TREE_CODE (decl
) != TYPE_DECL
580 || (DECL_ARTIFICIAL (decl
) && DECL_ARTIFICIAL (bval
))
581 || (!DECL_ARTIFICIAL (decl
) && !DECL_ARTIFICIAL (bval
)))
582 && !is_overloaded_fn (decl
))
583 error ("redeclaration of %q#D", decl
);
585 error ("%q#D conflicts with a previous declaration", decl
);
587 inform (input_location
, "previous declaration %q+#D", bval
);
590 /* Wrapper for supplement_binding_1. */
593 supplement_binding (cxx_binding
*binding
, tree decl
)
596 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
597 ret
= supplement_binding_1 (binding
, decl
);
598 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
602 /* Add DECL to the list of things declared in B. */
605 add_decl_to_level (tree decl
, cp_binding_level
*b
)
607 /* We used to record virtual tables as if they were ordinary
608 variables, but no longer do so. */
609 gcc_assert (!(VAR_P (decl
) && DECL_VIRTUAL_P (decl
)));
611 if (TREE_CODE (decl
) == NAMESPACE_DECL
612 && !DECL_NAMESPACE_ALIAS (decl
))
614 DECL_CHAIN (decl
) = b
->namespaces
;
615 b
->namespaces
= decl
;
619 /* We build up the list in reverse order, and reverse it later if
621 TREE_CHAIN (decl
) = b
->names
;
624 /* If appropriate, add decl to separate list of statics. We
625 include extern variables because they might turn out to be
626 static later. It's OK for this list to contain a few false
628 if (b
->kind
== sk_namespace
)
630 && (TREE_STATIC (decl
) || DECL_EXTERNAL (decl
)))
631 || (TREE_CODE (decl
) == FUNCTION_DECL
632 && (!TREE_PUBLIC (decl
)
633 || decl_anon_ns_mem_p (decl
)
634 || DECL_DECLARED_INLINE_P (decl
))))
635 vec_safe_push (b
->static_decls
, decl
);
639 /* Record a decl-node X as belonging to the current lexical scope.
640 Check for errors (such as an incompatible declaration for the same
641 name already seen in the same scope). IS_FRIEND is true if X is
642 declared as a friend.
644 Returns either X or an old decl for the same name.
645 If an old decl is returned, it may have been smashed
646 to agree with what X says. */
649 pushdecl_maybe_friend_1 (tree x
, bool is_friend
)
653 int need_new_binding
;
655 if (x
== error_mark_node
)
656 return error_mark_node
;
658 need_new_binding
= 1;
660 if (DECL_TEMPLATE_PARM_P (x
))
661 /* Template parameters have no context; they are not X::T even
662 when declared within a class or namespace. */
666 if (current_function_decl
&& x
!= current_function_decl
667 /* A local declaration for a function doesn't constitute
669 && TREE_CODE (x
) != FUNCTION_DECL
670 /* A local declaration for an `extern' variable is in the
671 scope of the current namespace, not the current
673 && !(VAR_P (x
) && DECL_EXTERNAL (x
))
674 /* When parsing the parameter list of a function declarator,
675 don't set DECL_CONTEXT to an enclosing function. When we
676 push the PARM_DECLs in order to process the function body,
677 current_binding_level->this_entity will be set. */
678 && !(TREE_CODE (x
) == PARM_DECL
679 && current_binding_level
->kind
== sk_function_parms
680 && current_binding_level
->this_entity
== NULL
)
681 && !DECL_CONTEXT (x
))
682 DECL_CONTEXT (x
) = current_function_decl
;
684 /* If this is the declaration for a namespace-scope function,
685 but the declaration itself is in a local scope, mark the
687 if (TREE_CODE (x
) == FUNCTION_DECL
688 && DECL_NAMESPACE_SCOPE_P (x
)
689 && current_function_decl
690 && x
!= current_function_decl
)
691 DECL_LOCAL_FUNCTION_P (x
) = 1;
694 name
= DECL_NAME (x
);
697 int different_binding_level
= 0;
699 if (TREE_CODE (name
) == TEMPLATE_ID_EXPR
)
700 name
= TREE_OPERAND (name
, 0);
702 /* In case this decl was explicitly namespace-qualified, look it
703 up in its namespace context. */
704 if (DECL_NAMESPACE_SCOPE_P (x
) && namespace_bindings_p ())
705 t
= namespace_binding (name
, DECL_CONTEXT (x
));
707 t
= lookup_name_innermost_nonclass_level (name
);
709 /* [basic.link] If there is a visible declaration of an entity
710 with linkage having the same name and type, ignoring entities
711 declared outside the innermost enclosing namespace scope, the
712 block scope declaration declares that same entity and
713 receives the linkage of the previous declaration. */
714 if (! t
&& current_function_decl
&& x
!= current_function_decl
715 && VAR_OR_FUNCTION_DECL_P (x
)
716 && DECL_EXTERNAL (x
))
718 /* Look in block scope. */
719 t
= innermost_non_namespace_value (name
);
720 /* Or in the innermost namespace. */
722 t
= namespace_binding (name
, DECL_CONTEXT (x
));
723 /* Does it have linkage? Note that if this isn't a DECL, it's an
724 OVERLOAD, which is OK. */
725 if (t
&& DECL_P (t
) && ! (TREE_STATIC (t
) || DECL_EXTERNAL (t
)))
728 different_binding_level
= 1;
731 /* If we are declaring a function, and the result of name-lookup
732 was an OVERLOAD, look for an overloaded instance that is
733 actually the same as the function we are declaring. (If
734 there is one, we have to merge our declaration with the
735 previous declaration.) */
736 if (t
&& TREE_CODE (t
) == OVERLOAD
)
740 if (TREE_CODE (x
) == FUNCTION_DECL
)
741 for (match
= t
; match
; match
= OVL_NEXT (match
))
743 if (decls_match (OVL_CURRENT (match
), x
))
747 /* Just choose one. */
751 t
= OVL_CURRENT (match
);
756 if (t
&& t
!= error_mark_node
)
758 if (different_binding_level
)
760 if (decls_match (x
, t
))
761 /* The standard only says that the local extern
762 inherits linkage from the previous decl; in
763 particular, default args are not shared. Add
764 the decl into a hash table to make sure only
765 the previous decl in this case is seen by the
768 struct cxx_int_tree_map
*h
;
771 TREE_PUBLIC (x
) = TREE_PUBLIC (t
);
773 if (cp_function_chain
->extern_decl_map
== NULL
)
774 cp_function_chain
->extern_decl_map
775 = htab_create_ggc (20, cxx_int_tree_map_hash
,
776 cxx_int_tree_map_eq
, NULL
);
778 h
= ggc_alloc_cxx_int_tree_map ();
779 h
->uid
= DECL_UID (x
);
781 loc
= htab_find_slot_with_hash
782 (cp_function_chain
->extern_decl_map
, h
,
784 *(struct cxx_int_tree_map
**) loc
= h
;
787 else if (TREE_CODE (t
) == PARM_DECL
)
789 /* Check for duplicate params. */
790 tree d
= duplicate_decls (x
, t
, is_friend
);
794 else if ((DECL_EXTERN_C_FUNCTION_P (x
)
795 || DECL_FUNCTION_TEMPLATE_P (x
))
796 && is_overloaded_fn (t
))
797 /* Don't do anything just yet. */;
798 else if (t
== wchar_decl_node
)
800 if (! DECL_IN_SYSTEM_HEADER (x
))
801 pedwarn (input_location
, OPT_Wpedantic
, "redeclaration of %<wchar_t%> as %qT",
804 /* Throw away the redeclaration. */
809 tree olddecl
= duplicate_decls (x
, t
, is_friend
);
811 /* If the redeclaration failed, we can stop at this
813 if (olddecl
== error_mark_node
)
814 return error_mark_node
;
818 if (TREE_CODE (t
) == TYPE_DECL
)
819 SET_IDENTIFIER_TYPE_VALUE (name
, TREE_TYPE (t
));
823 else if (DECL_MAIN_P (x
) && TREE_CODE (t
) == FUNCTION_DECL
)
825 /* A redeclaration of main, but not a duplicate of the
830 This function shall not be overloaded. */
831 error ("invalid redeclaration of %q+D", t
);
833 /* We don't try to push this declaration since that
840 /* If x has C linkage-specification, (extern "C"),
841 lookup its binding, in case it's already bound to an object.
842 The lookup is done in all namespaces.
843 If we find an existing binding, make sure it has the same
844 exception specification as x, otherwise, bail in error [7.5, 7.6]. */
845 if ((TREE_CODE (x
) == FUNCTION_DECL
)
846 && DECL_EXTERN_C_P (x
)
847 /* We should ignore declarations happening in system headers. */
848 && !DECL_ARTIFICIAL (x
)
849 && !DECL_IN_SYSTEM_HEADER (x
))
851 tree previous
= lookup_extern_c_fun_in_all_ns (x
);
853 && !DECL_ARTIFICIAL (previous
)
854 && !DECL_IN_SYSTEM_HEADER (previous
)
855 && DECL_CONTEXT (previous
) != DECL_CONTEXT (x
))
857 /* In case either x or previous is declared to throw an exception,
858 make sure both exception specifications are equal. */
859 if (decls_match (x
, previous
))
861 tree x_exception_spec
= NULL_TREE
;
862 tree previous_exception_spec
= NULL_TREE
;
865 TYPE_RAISES_EXCEPTIONS (TREE_TYPE (x
));
866 previous_exception_spec
=
867 TYPE_RAISES_EXCEPTIONS (TREE_TYPE (previous
));
868 if (!comp_except_specs (previous_exception_spec
,
872 pedwarn (input_location
, 0,
873 "declaration of %q#D with C language linkage",
875 pedwarn (input_location
, 0,
876 "conflicts with previous declaration %q+#D",
878 pedwarn (input_location
, 0,
879 "due to different exception specifications");
880 return error_mark_node
;
882 if (DECL_ASSEMBLER_NAME_SET_P (previous
))
883 SET_DECL_ASSEMBLER_NAME (x
,
884 DECL_ASSEMBLER_NAME (previous
));
888 pedwarn (input_location
, 0,
889 "declaration of %q#D with C language linkage", x
);
890 pedwarn (input_location
, 0,
891 "conflicts with previous declaration %q+#D",
897 check_template_shadow (x
);
899 /* If this is a function conjured up by the back end, massage it
900 so it looks friendly. */
901 if (DECL_NON_THUNK_FUNCTION_P (x
) && ! DECL_LANG_SPECIFIC (x
))
903 retrofit_lang_decl (x
);
904 SET_DECL_LANGUAGE (x
, lang_c
);
908 if (DECL_NON_THUNK_FUNCTION_P (x
) && ! DECL_FUNCTION_MEMBER_P (x
))
910 t
= push_overloaded_decl (x
, PUSH_LOCAL
, is_friend
);
911 if (!namespace_bindings_p ())
912 /* We do not need to create a binding for this name;
913 push_overloaded_decl will have already done so if
915 need_new_binding
= 0;
917 else if (DECL_FUNCTION_TEMPLATE_P (x
) && DECL_NAMESPACE_SCOPE_P (x
))
919 t
= push_overloaded_decl (x
, PUSH_GLOBAL
, is_friend
);
921 add_decl_to_level (x
, NAMESPACE_LEVEL (CP_DECL_CONTEXT (t
)));
924 if (DECL_DECLARES_FUNCTION_P (t
))
925 check_default_args (t
);
927 if (t
!= x
|| DECL_FUNCTION_TEMPLATE_P (t
))
930 /* If declaring a type as a typedef, copy the type (unless we're
931 at line 0), and install this TYPE_DECL as the new type's typedef
932 name. See the extensive comment of set_underlying_type (). */
933 if (TREE_CODE (x
) == TYPE_DECL
)
935 tree type
= TREE_TYPE (x
);
937 if (DECL_IS_BUILTIN (x
)
938 || (TREE_TYPE (x
) != error_mark_node
939 && TYPE_NAME (type
) != x
940 /* We don't want to copy the type when all we're
941 doing is making a TYPE_DECL for the purposes of
943 && (!TYPE_NAME (type
)
944 || TYPE_NAME (type
) != DECL_ABSTRACT_ORIGIN (x
))))
945 set_underlying_type (x
);
947 if (type
!= error_mark_node
949 && TYPE_IDENTIFIER (type
))
950 set_identifier_type_value (DECL_NAME (x
), x
);
952 /* If this is a locally defined typedef in a function that
953 is not a template instantation, record it to implement
954 -Wunused-local-typedefs. */
955 if (current_instantiation () == NULL
956 || (current_instantiation ()->decl
!= current_function_decl
))
957 record_locally_defined_typedef (x
);
960 /* Multiple external decls of the same identifier ought to match.
962 We get warnings about inline functions where they are defined.
963 We get warnings about other functions from push_overloaded_decl.
965 Avoid duplicate warnings where they are used. */
966 if (TREE_PUBLIC (x
) && TREE_CODE (x
) != FUNCTION_DECL
)
970 decl
= IDENTIFIER_NAMESPACE_VALUE (name
);
971 if (decl
&& TREE_CODE (decl
) == OVERLOAD
)
972 decl
= OVL_FUNCTION (decl
);
974 if (decl
&& decl
!= error_mark_node
975 && (DECL_EXTERNAL (decl
) || TREE_PUBLIC (decl
))
976 /* If different sort of thing, we already gave an error. */
977 && TREE_CODE (decl
) == TREE_CODE (x
)
978 && !same_type_p (TREE_TYPE (x
), TREE_TYPE (decl
)))
980 if (permerror (input_location
, "type mismatch with previous "
981 "external decl of %q#D", x
))
982 inform (input_location
, "previous external decl of %q+#D",
987 if (TREE_CODE (x
) == FUNCTION_DECL
989 && !flag_friend_injection
)
991 /* This is a new declaration of a friend function, so hide
992 it from ordinary function lookup. */
993 DECL_ANTICIPATED (x
) = 1;
994 DECL_HIDDEN_FRIEND_P (x
) = 1;
997 /* This name is new in its binding level.
998 Install the new declaration and return it. */
999 if (namespace_bindings_p ())
1001 /* Install a global value. */
1003 /* If the first global decl has external linkage,
1004 warn if we later see static one. */
1005 if (IDENTIFIER_GLOBAL_VALUE (name
) == NULL_TREE
&& TREE_PUBLIC (x
))
1006 TREE_PUBLIC (name
) = 1;
1008 /* Bind the name for the entity. */
1009 if (!(TREE_CODE (x
) == TYPE_DECL
&& DECL_ARTIFICIAL (x
)
1011 && (TREE_CODE (x
) == TYPE_DECL
1013 || TREE_CODE (x
) == NAMESPACE_DECL
1014 || TREE_CODE (x
) == CONST_DECL
1015 || TREE_CODE (x
) == TEMPLATE_DECL
))
1016 SET_IDENTIFIER_NAMESPACE_VALUE (name
, x
);
1018 /* If new decl is `static' and an `extern' was seen previously,
1020 if (x
!= NULL_TREE
&& t
!= NULL_TREE
&& decls_match (x
, t
))
1021 warn_extern_redeclared_static (x
, t
);
1025 /* Here to install a non-global value. */
1026 tree oldglobal
= IDENTIFIER_NAMESPACE_VALUE (name
);
1027 tree oldlocal
= NULL_TREE
;
1028 cp_binding_level
*oldscope
= NULL
;
1029 cxx_binding
*oldbinding
= outer_binding (name
, NULL
, true);
1032 oldlocal
= oldbinding
->value
;
1033 oldscope
= oldbinding
->scope
;
1036 if (need_new_binding
)
1038 push_local_binding (name
, x
, 0);
1039 /* Because push_local_binding will hook X on to the
1040 current_binding_level's name list, we don't want to
1041 do that again below. */
1042 need_new_binding
= 0;
1045 /* If this is a TYPE_DECL, push it into the type value slot. */
1046 if (TREE_CODE (x
) == TYPE_DECL
)
1047 set_identifier_type_value (name
, x
);
1049 /* Clear out any TYPE_DECL shadowed by a namespace so that
1050 we won't think this is a type. The C struct hack doesn't
1051 go through namespaces. */
1052 if (TREE_CODE (x
) == NAMESPACE_DECL
)
1053 set_identifier_type_value (name
, NULL_TREE
);
1061 && DECL_DEAD_FOR_LOCAL (oldlocal
))
1062 oldlocal
= DECL_SHADOWED_FOR_VAR (oldlocal
);
1064 if (oldlocal
== NULL_TREE
)
1065 oldlocal
= IDENTIFIER_NAMESPACE_VALUE (DECL_NAME (d
));
1068 /* If this is an extern function declaration, see if we
1069 have a global definition or declaration for the function. */
1070 if (oldlocal
== NULL_TREE
1071 && DECL_EXTERNAL (x
)
1072 && oldglobal
!= NULL_TREE
1073 && TREE_CODE (x
) == FUNCTION_DECL
1074 && TREE_CODE (oldglobal
) == FUNCTION_DECL
)
1076 /* We have one. Their types must agree. */
1077 if (decls_match (x
, oldglobal
))
1081 warning (0, "extern declaration of %q#D doesn%'t match", x
);
1082 warning (0, "global declaration %q+#D", oldglobal
);
1085 /* If we have a local external declaration,
1086 and no file-scope declaration has yet been seen,
1087 then if we later have a file-scope decl it must not be static. */
1088 if (oldlocal
== NULL_TREE
1089 && oldglobal
== NULL_TREE
1090 && DECL_EXTERNAL (x
)
1092 TREE_PUBLIC (name
) = 1;
1094 /* Don't complain about the parms we push and then pop
1095 while tentatively parsing a function declarator. */
1096 if (TREE_CODE (x
) == PARM_DECL
&& DECL_CONTEXT (x
) == NULL_TREE
)
1099 /* Warn if shadowing an argument at the top level of the body. */
1100 else if (oldlocal
!= NULL_TREE
&& !DECL_EXTERNAL (x
)
1101 /* Inline decls shadow nothing. */
1102 && !DECL_FROM_INLINE (x
)
1103 && (TREE_CODE (oldlocal
) == PARM_DECL
1105 /* If the old decl is a type decl, only warn if the
1106 old decl is an explicit typedef or if both the old
1107 and new decls are type decls. */
1108 || (TREE_CODE (oldlocal
) == TYPE_DECL
1109 && (!DECL_ARTIFICIAL (oldlocal
)
1110 || TREE_CODE (x
) == TYPE_DECL
)))
1111 /* Don't check for internally generated vars unless
1112 it's an implicit typedef (see create_implicit_typedef
1114 && (!DECL_ARTIFICIAL (x
) || DECL_IMPLICIT_TYPEDEF_P (x
)))
1116 bool nowarn
= false;
1118 /* Don't complain if it's from an enclosing function. */
1119 if (DECL_CONTEXT (oldlocal
) == current_function_decl
1120 && TREE_CODE (x
) != PARM_DECL
1121 && TREE_CODE (oldlocal
) == PARM_DECL
)
1123 /* Go to where the parms should be and see if we find
1125 cp_binding_level
*b
= current_binding_level
->level_chain
;
1127 if (FUNCTION_NEEDS_BODY_BLOCK (current_function_decl
))
1128 /* Skip the ctor/dtor cleanup level. */
1132 if (b
->kind
== sk_function_parms
)
1134 error ("declaration of %q#D shadows a parameter", x
);
1139 /* The local structure or class can't use parameters of
1140 the containing function anyway. */
1141 if (DECL_CONTEXT (oldlocal
) != current_function_decl
)
1143 cp_binding_level
*scope
= current_binding_level
;
1144 tree context
= DECL_CONTEXT (oldlocal
);
1145 for (; scope
; scope
= scope
->level_chain
)
1147 if (scope
->kind
== sk_function_parms
1148 && scope
->this_entity
== context
)
1150 if (scope
->kind
== sk_class
1151 && !LAMBDA_TYPE_P (scope
->this_entity
))
1158 /* Error if redeclaring a local declared in a
1159 for-init-statement or in the condition of an if or
1160 switch statement when the new declaration is in the
1161 outermost block of the controlled statement.
1162 Redeclaring a variable from a for or while condition is
1163 detected elsewhere. */
1164 else if (VAR_P (oldlocal
)
1165 && oldscope
== current_binding_level
->level_chain
1166 && (oldscope
->kind
== sk_cond
1167 || oldscope
->kind
== sk_for
))
1169 error ("redeclaration of %q#D", x
);
1170 inform (input_location
, "%q+#D previously declared here",
1175 3.3.3/3: The name declared in an exception-declaration (...)
1176 shall not be redeclared in the outermost block of the handler.
1177 3.3.3/2: A parameter name shall not be redeclared (...) in
1178 the outermost block of any handler associated with a
1180 3.4.1/15: The function parameter names shall not be redeclared
1181 in the exception-declaration nor in the outermost block of a
1182 handler for the function-try-block. */
1183 else if ((VAR_P (oldlocal
)
1184 && oldscope
== current_binding_level
->level_chain
1185 && oldscope
->kind
== sk_catch
)
1186 || (TREE_CODE (oldlocal
) == PARM_DECL
1187 && (current_binding_level
->kind
== sk_catch
1188 || (current_binding_level
->level_chain
->kind
1190 && in_function_try_handler
))
1192 if (permerror (input_location
, "redeclaration of %q#D", x
))
1193 inform (input_location
, "%q+#D previously declared here",
1198 if (warn_shadow
&& !nowarn
)
1202 if (TREE_CODE (oldlocal
) == PARM_DECL
)
1203 warned
= warning_at (input_location
, OPT_Wshadow
,
1204 "declaration of %q#D shadows a parameter", x
);
1205 else if (is_capture_proxy (oldlocal
))
1206 warned
= warning_at (input_location
, OPT_Wshadow
,
1207 "declaration of %qD shadows a lambda capture",
1210 warned
= warning_at (input_location
, OPT_Wshadow
,
1211 "declaration of %qD shadows a previous local",
1215 inform (DECL_SOURCE_LOCATION (oldlocal
),
1216 "shadowed declaration is here");
1220 /* Maybe warn if shadowing something else. */
1221 else if (warn_shadow
&& !DECL_EXTERNAL (x
)
1222 /* No shadow warnings for internally generated vars unless
1223 it's an implicit typedef (see create_implicit_typedef
1225 && (! DECL_ARTIFICIAL (x
) || DECL_IMPLICIT_TYPEDEF_P (x
))
1226 /* No shadow warnings for vars made for inlining. */
1227 && ! DECL_FROM_INLINE (x
))
1231 if (nonlambda_method_basetype ())
1232 member
= lookup_member (current_nonlambda_class_type (),
1235 /*want_type=*/false,
1236 tf_warning_or_error
);
1240 if (member
&& !TREE_STATIC (member
))
1242 /* Location of previous decl is not useful in this case. */
1243 warning (OPT_Wshadow
, "declaration of %qD shadows a member of 'this'",
1246 else if (oldglobal
!= NULL_TREE
1247 && (VAR_P (oldglobal
)
1248 /* If the old decl is a type decl, only warn if the
1249 old decl is an explicit typedef or if both the
1250 old and new decls are type decls. */
1251 || (TREE_CODE (oldglobal
) == TYPE_DECL
1252 && (!DECL_ARTIFICIAL (oldglobal
)
1253 || TREE_CODE (x
) == TYPE_DECL
))))
1254 /* XXX shadow warnings in outer-more namespaces */
1256 if (warning_at (input_location
, OPT_Wshadow
,
1257 "declaration of %qD shadows a "
1258 "global declaration", x
))
1259 inform (DECL_SOURCE_LOCATION (oldglobal
),
1260 "shadowed declaration is here");
1266 maybe_register_incomplete_var (x
);
1269 if (need_new_binding
)
1270 add_decl_to_level (x
,
1271 DECL_NAMESPACE_SCOPE_P (x
)
1272 ? NAMESPACE_LEVEL (CP_DECL_CONTEXT (x
))
1273 : current_binding_level
);
1278 /* Wrapper for pushdecl_maybe_friend_1. */
1281 pushdecl_maybe_friend (tree x
, bool is_friend
)
1284 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
1285 ret
= pushdecl_maybe_friend_1 (x
, is_friend
);
1286 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
1290 /* Record a decl-node X as belonging to the current lexical scope. */
1295 return pushdecl_maybe_friend (x
, false);
1298 /* Enter DECL into the symbol table, if that's appropriate. Returns
1299 DECL, or a modified version thereof. */
1302 maybe_push_decl (tree decl
)
1304 tree type
= TREE_TYPE (decl
);
1306 /* Add this decl to the current binding level, but not if it comes
1307 from another scope, e.g. a static member variable. TEM may equal
1308 DECL or it may be a previous decl of the same name. */
1309 if (decl
== error_mark_node
1310 || (TREE_CODE (decl
) != PARM_DECL
1311 && DECL_CONTEXT (decl
) != NULL_TREE
1312 /* Definitions of namespace members outside their namespace are
1314 && !DECL_NAMESPACE_SCOPE_P (decl
))
1315 || (TREE_CODE (decl
) == TEMPLATE_DECL
&& !namespace_bindings_p ())
1316 || type
== unknown_type_node
1317 /* The declaration of a template specialization does not affect
1318 the functions available for overload resolution, so we do not
1320 || (TREE_CODE (decl
) == FUNCTION_DECL
1321 && DECL_TEMPLATE_SPECIALIZATION (decl
)))
1324 return pushdecl (decl
);
1327 /* Bind DECL to ID in the current_binding_level, assumed to be a local
1328 binding level. If PUSH_USING is set in FLAGS, we know that DECL
1329 doesn't really belong to this binding level, that it got here
1330 through a using-declaration. */
1333 push_local_binding (tree id
, tree decl
, int flags
)
1335 cp_binding_level
*b
;
1337 /* Skip over any local classes. This makes sense if we call
1338 push_local_binding with a friend decl of a local class. */
1339 b
= innermost_nonclass_level ();
1341 if (lookup_name_innermost_nonclass_level (id
))
1343 /* Supplement the existing binding. */
1344 if (!supplement_binding (IDENTIFIER_BINDING (id
), decl
))
1345 /* It didn't work. Something else must be bound at this
1346 level. Do not add DECL to the list of things to pop
1351 /* Create a new binding. */
1352 push_binding (id
, decl
, b
);
1354 if (TREE_CODE (decl
) == OVERLOAD
|| (flags
& PUSH_USING
))
1355 /* We must put the OVERLOAD into a TREE_LIST since the
1356 TREE_CHAIN of an OVERLOAD is already used. Similarly for
1357 decls that got here through a using-declaration. */
1358 decl
= build_tree_list (NULL_TREE
, decl
);
1360 /* And put DECL on the list of things declared by the current
1362 add_decl_to_level (decl
, b
);
1365 /* Check to see whether or not DECL is a variable that would have been
1366 in scope under the ARM, but is not in scope under the ANSI/ISO
1367 standard. If so, issue an error message. If name lookup would
1368 work in both cases, but return a different result, this function
1369 returns the result of ANSI/ISO lookup. Otherwise, it returns
1373 check_for_out_of_scope_variable (tree decl
)
1377 /* We only care about out of scope variables. */
1378 if (!(VAR_P (decl
) && DECL_DEAD_FOR_LOCAL (decl
)))
1381 shadowed
= DECL_HAS_SHADOWED_FOR_VAR_P (decl
)
1382 ? DECL_SHADOWED_FOR_VAR (decl
) : NULL_TREE
;
1383 while (shadowed
!= NULL_TREE
&& VAR_P (shadowed
)
1384 && DECL_DEAD_FOR_LOCAL (shadowed
))
1385 shadowed
= DECL_HAS_SHADOWED_FOR_VAR_P (shadowed
)
1386 ? DECL_SHADOWED_FOR_VAR (shadowed
) : NULL_TREE
;
1388 shadowed
= IDENTIFIER_NAMESPACE_VALUE (DECL_NAME (decl
));
1391 if (!DECL_ERROR_REPORTED (decl
))
1393 warning (0, "name lookup of %qD changed", DECL_NAME (decl
));
1394 warning (0, " matches this %q+D under ISO standard rules",
1396 warning (0, " matches this %q+D under old rules", decl
);
1397 DECL_ERROR_REPORTED (decl
) = 1;
1402 /* If we have already complained about this declaration, there's no
1403 need to do it again. */
1404 if (DECL_ERROR_REPORTED (decl
))
1407 DECL_ERROR_REPORTED (decl
) = 1;
1409 if (TREE_TYPE (decl
) == error_mark_node
)
1412 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TREE_TYPE (decl
)))
1414 error ("name lookup of %qD changed for ISO %<for%> scoping",
1416 error (" cannot use obsolete binding at %q+D because "
1417 "it has a destructor", decl
);
1418 return error_mark_node
;
1422 permerror (input_location
, "name lookup of %qD changed for ISO %<for%> scoping",
1424 if (flag_permissive
)
1425 permerror (input_location
, " using obsolete binding at %q+D", decl
);
1431 inform (input_location
, "(if you use %<-fpermissive%> G++ will accept your code)");
1440 /* true means unconditionally make a BLOCK for the next level pushed. */
1442 static bool keep_next_level_flag
;
1444 static int binding_depth
= 0;
1451 for (i
= 0; i
< depth
* 2; i
++)
1455 /* Return a string describing the kind of SCOPE we have. */
1457 cp_binding_level_descriptor (cp_binding_level
*scope
)
1459 /* The order of this table must match the "scope_kind"
1461 static const char* scope_kind_names
[] = {
1467 "function-parameter-scope",
1470 "template-parameter-scope",
1471 "template-explicit-spec-scope"
1473 const scope_kind kind
= scope
->explicit_spec_p
1474 ? sk_template_spec
: scope
->kind
;
1476 return scope_kind_names
[kind
];
1479 /* Output a debugging information about SCOPE when performing
1482 cp_binding_level_debug (cp_binding_level
*scope
, int line
, const char *action
)
1484 const char *desc
= cp_binding_level_descriptor (scope
);
1485 if (scope
->this_entity
)
1486 verbatim ("%s %s(%E) %p %d\n", action
, desc
,
1487 scope
->this_entity
, (void *) scope
, line
);
1489 verbatim ("%s %s %p %d\n", action
, desc
, (void *) scope
, line
);
1492 /* Return the estimated initial size of the hashtable of a NAMESPACE
1495 static inline size_t
1496 namespace_scope_ht_size (tree ns
)
1498 tree name
= DECL_NAME (ns
);
1500 return name
== std_identifier
1501 ? NAMESPACE_STD_HT_SIZE
1502 : (name
== global_scope_name
1503 ? GLOBAL_SCOPE_HT_SIZE
1504 : NAMESPACE_ORDINARY_HT_SIZE
);
1507 /* A chain of binding_level structures awaiting reuse. */
1509 static GTY((deletable
)) cp_binding_level
*free_binding_level
;
1511 /* Insert SCOPE as the innermost binding level. */
1514 push_binding_level (cp_binding_level
*scope
)
1516 /* Add it to the front of currently active scopes stack. */
1517 scope
->level_chain
= current_binding_level
;
1518 current_binding_level
= scope
;
1519 keep_next_level_flag
= false;
1521 if (ENABLE_SCOPE_CHECKING
)
1523 scope
->binding_depth
= binding_depth
;
1524 indent (binding_depth
);
1525 cp_binding_level_debug (scope
, LOCATION_LINE (input_location
),
1531 /* Create a new KIND scope and make it the top of the active scopes stack.
1532 ENTITY is the scope of the associated C++ entity (namespace, class,
1533 function, C++0x enumeration); it is NULL otherwise. */
1536 begin_scope (scope_kind kind
, tree entity
)
1538 cp_binding_level
*scope
;
1540 /* Reuse or create a struct for this binding level. */
1541 if (!ENABLE_SCOPE_CHECKING
&& free_binding_level
)
1543 scope
= free_binding_level
;
1544 memset (scope
, 0, sizeof (cp_binding_level
));
1545 free_binding_level
= scope
->level_chain
;
1548 scope
= ggc_alloc_cleared_cp_binding_level ();
1550 scope
->this_entity
= entity
;
1551 scope
->more_cleanups_ok
= true;
1558 case sk_template_spec
:
1559 scope
->explicit_spec_p
= true;
1560 kind
= sk_template_parms
;
1562 case sk_template_parms
:
1569 case sk_scoped_enum
:
1570 case sk_function_parms
:
1572 scope
->keep
= keep_next_level_flag
;
1576 NAMESPACE_LEVEL (entity
) = scope
;
1577 vec_alloc (scope
->static_decls
,
1578 (DECL_NAME (entity
) == std_identifier
1579 || DECL_NAME (entity
) == global_scope_name
) ? 200 : 10);
1583 /* Should not happen. */
1589 push_binding_level (scope
);
1594 /* We're about to leave current scope. Pop the top of the stack of
1595 currently active scopes. Return the enclosing scope, now active. */
1600 cp_binding_level
*scope
= current_binding_level
;
1602 if (scope
->kind
== sk_namespace
&& class_binding_level
)
1603 current_binding_level
= class_binding_level
;
1605 /* We cannot leave a scope, if there are none left. */
1606 if (NAMESPACE_LEVEL (global_namespace
))
1607 gcc_assert (!global_scope_p (scope
));
1609 if (ENABLE_SCOPE_CHECKING
)
1611 indent (--binding_depth
);
1612 cp_binding_level_debug (scope
, LOCATION_LINE (input_location
),
1616 /* Move one nesting level up. */
1617 current_binding_level
= scope
->level_chain
;
1619 /* Namespace-scopes are left most probably temporarily, not
1620 completely; they can be reopened later, e.g. in namespace-extension
1621 or any name binding activity that requires us to resume a
1622 namespace. For classes, we cache some binding levels. For other
1623 scopes, we just make the structure available for reuse. */
1624 if (scope
->kind
!= sk_namespace
1625 && scope
->kind
!= sk_class
)
1627 scope
->level_chain
= free_binding_level
;
1628 gcc_assert (!ENABLE_SCOPE_CHECKING
1629 || scope
->binding_depth
== binding_depth
);
1630 free_binding_level
= scope
;
1633 if (scope
->kind
== sk_class
)
1635 /* Reset DEFINING_CLASS_P to allow for reuse of a
1636 class-defining scope in a non-defining context. */
1637 scope
->defining_class_p
= 0;
1639 /* Find the innermost enclosing class scope, and reset
1640 CLASS_BINDING_LEVEL appropriately. */
1641 class_binding_level
= NULL
;
1642 for (scope
= current_binding_level
; scope
; scope
= scope
->level_chain
)
1643 if (scope
->kind
== sk_class
)
1645 class_binding_level
= scope
;
1650 return current_binding_level
;
1654 resume_scope (cp_binding_level
* b
)
1656 /* Resuming binding levels is meant only for namespaces,
1657 and those cannot nest into classes. */
1658 gcc_assert (!class_binding_level
);
1659 /* Also, resuming a non-directly nested namespace is a no-no. */
1660 gcc_assert (b
->level_chain
== current_binding_level
);
1661 current_binding_level
= b
;
1662 if (ENABLE_SCOPE_CHECKING
)
1664 b
->binding_depth
= binding_depth
;
1665 indent (binding_depth
);
1666 cp_binding_level_debug (b
, LOCATION_LINE (input_location
), "resume");
1671 /* Return the innermost binding level that is not for a class scope. */
1673 static cp_binding_level
*
1674 innermost_nonclass_level (void)
1676 cp_binding_level
*b
;
1678 b
= current_binding_level
;
1679 while (b
->kind
== sk_class
)
1685 /* We're defining an object of type TYPE. If it needs a cleanup, but
1686 we're not allowed to add any more objects with cleanups to the current
1687 scope, create a new binding level. */
1690 maybe_push_cleanup_level (tree type
)
1692 if (type
!= error_mark_node
1693 && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
)
1694 && current_binding_level
->more_cleanups_ok
== 0)
1696 begin_scope (sk_cleanup
, NULL
);
1697 current_binding_level
->statement_list
= push_stmt_list ();
1701 /* Return true if we are in the global binding level. */
1704 global_bindings_p (void)
1706 return global_scope_p (current_binding_level
);
1709 /* True if we are currently in a toplevel binding level. This
1710 means either the global binding level or a namespace in a toplevel
1711 binding level. Since there are no non-toplevel namespace levels,
1712 this really means any namespace or template parameter level. We
1713 also include a class whose context is toplevel. */
1716 toplevel_bindings_p (void)
1718 cp_binding_level
*b
= innermost_nonclass_level ();
1720 return b
->kind
== sk_namespace
|| b
->kind
== sk_template_parms
;
1723 /* True if this is a namespace scope, or if we are defining a class
1724 which is itself at namespace scope, or whose enclosing class is
1725 such a class, etc. */
1728 namespace_bindings_p (void)
1730 cp_binding_level
*b
= innermost_nonclass_level ();
1732 return b
->kind
== sk_namespace
;
1735 /* True if the innermost non-class scope is a block scope. */
1738 local_bindings_p (void)
1740 cp_binding_level
*b
= innermost_nonclass_level ();
1741 return b
->kind
< sk_function_parms
|| b
->kind
== sk_omp
;
1744 /* True if the current level needs to have a BLOCK made. */
1749 return (current_binding_level
->blocks
!= NULL_TREE
1750 || current_binding_level
->keep
1751 || current_binding_level
->kind
== sk_cleanup
1752 || current_binding_level
->names
!= NULL_TREE
1753 || current_binding_level
->using_directives
);
1756 /* Returns the kind of the innermost scope. */
1759 innermost_scope_kind (void)
1761 return current_binding_level
->kind
;
1764 /* Returns true if this scope was created to store template parameters. */
1767 template_parm_scope_p (void)
1769 return innermost_scope_kind () == sk_template_parms
;
1772 /* If KEEP is true, make a BLOCK node for the next binding level,
1773 unconditionally. Otherwise, use the normal logic to decide whether
1774 or not to create a BLOCK. */
1777 keep_next_level (bool keep
)
1779 keep_next_level_flag
= keep
;
1782 /* Return the list of declarations of the current level.
1783 Note that this list is in reverse order unless/until
1784 you nreverse it; and when you do nreverse it, you must
1785 store the result back using `storedecls' or you will lose. */
1790 return current_binding_level
->names
;
1793 /* Return how many function prototypes we are currently nested inside. */
1796 function_parm_depth (void)
1799 cp_binding_level
*b
;
1801 for (b
= current_binding_level
;
1802 b
->kind
== sk_function_parms
;
1809 /* For debugging. */
1810 static int no_print_functions
= 0;
1811 static int no_print_builtins
= 0;
1814 print_binding_level (cp_binding_level
* lvl
)
1818 fprintf (stderr
, " blocks=%p", (void *) lvl
->blocks
);
1819 if (lvl
->more_cleanups_ok
)
1820 fprintf (stderr
, " more-cleanups-ok");
1821 if (lvl
->have_cleanups
)
1822 fprintf (stderr
, " have-cleanups");
1823 fprintf (stderr
, "\n");
1826 fprintf (stderr
, " names:\t");
1827 /* We can probably fit 3 names to a line? */
1828 for (t
= lvl
->names
; t
; t
= TREE_CHAIN (t
))
1830 if (no_print_functions
&& (TREE_CODE (t
) == FUNCTION_DECL
))
1832 if (no_print_builtins
1833 && (TREE_CODE (t
) == TYPE_DECL
)
1834 && DECL_IS_BUILTIN (t
))
1837 /* Function decls tend to have longer names. */
1838 if (TREE_CODE (t
) == FUNCTION_DECL
)
1845 fprintf (stderr
, "\n\t");
1848 print_node_brief (stderr
, "", t
, 0);
1849 if (t
== error_mark_node
)
1853 fprintf (stderr
, "\n");
1855 if (vec_safe_length (lvl
->class_shadowed
))
1858 cp_class_binding
*b
;
1859 fprintf (stderr
, " class-shadowed:");
1860 FOR_EACH_VEC_ELT (*lvl
->class_shadowed
, i
, b
)
1861 fprintf (stderr
, " %s ", IDENTIFIER_POINTER (b
->identifier
));
1862 fprintf (stderr
, "\n");
1864 if (lvl
->type_shadowed
)
1866 fprintf (stderr
, " type-shadowed:");
1867 for (t
= lvl
->type_shadowed
; t
; t
= TREE_CHAIN (t
))
1869 fprintf (stderr
, " %s ", IDENTIFIER_POINTER (TREE_PURPOSE (t
)));
1871 fprintf (stderr
, "\n");
1876 debug (cp_binding_level
&ref
)
1878 print_binding_level (&ref
);
1882 debug (cp_binding_level
*ptr
)
1887 fprintf (stderr
, "<nil>\n");
1892 print_other_binding_stack (cp_binding_level
*stack
)
1894 cp_binding_level
*level
;
1895 for (level
= stack
; !global_scope_p (level
); level
= level
->level_chain
)
1897 fprintf (stderr
, "binding level %p\n", (void *) level
);
1898 print_binding_level (level
);
1903 print_binding_stack (void)
1905 cp_binding_level
*b
;
1906 fprintf (stderr
, "current_binding_level=%p\n"
1907 "class_binding_level=%p\n"
1908 "NAMESPACE_LEVEL (global_namespace)=%p\n",
1909 (void *) current_binding_level
, (void *) class_binding_level
,
1910 (void *) NAMESPACE_LEVEL (global_namespace
));
1911 if (class_binding_level
)
1913 for (b
= class_binding_level
; b
; b
= b
->level_chain
)
1914 if (b
== current_binding_level
)
1917 b
= class_binding_level
;
1919 b
= current_binding_level
;
1922 b
= current_binding_level
;
1923 print_other_binding_stack (b
);
1924 fprintf (stderr
, "global:\n");
1925 print_binding_level (NAMESPACE_LEVEL (global_namespace
));
1928 /* Return the type associated with ID. */
1931 identifier_type_value_1 (tree id
)
1933 /* There is no type with that name, anywhere. */
1934 if (REAL_IDENTIFIER_TYPE_VALUE (id
) == NULL_TREE
)
1936 /* This is not the type marker, but the real thing. */
1937 if (REAL_IDENTIFIER_TYPE_VALUE (id
) != global_type_node
)
1938 return REAL_IDENTIFIER_TYPE_VALUE (id
);
1939 /* Have to search for it. It must be on the global level, now.
1940 Ask lookup_name not to return non-types. */
1941 id
= lookup_name_real (id
, 2, 1, /*block_p=*/true, 0, 0);
1943 return TREE_TYPE (id
);
1947 /* Wrapper for identifier_type_value_1. */
1950 identifier_type_value (tree id
)
1953 timevar_start (TV_NAME_LOOKUP
);
1954 ret
= identifier_type_value_1 (id
);
1955 timevar_stop (TV_NAME_LOOKUP
);
1960 /* Return the IDENTIFIER_GLOBAL_VALUE of T, for use in common code, since
1961 the definition of IDENTIFIER_GLOBAL_VALUE is different for C and C++. */
1964 identifier_global_value (tree t
)
1966 return IDENTIFIER_GLOBAL_VALUE (t
);
1969 /* Push a definition of struct, union or enum tag named ID. into
1970 binding_level B. DECL is a TYPE_DECL for the type. We assume that
1971 the tag ID is not already defined. */
1974 set_identifier_type_value_with_scope (tree id
, tree decl
, cp_binding_level
*b
)
1978 if (b
->kind
!= sk_namespace
)
1980 /* Shadow the marker, not the real thing, so that the marker
1981 gets restored later. */
1982 tree old_type_value
= REAL_IDENTIFIER_TYPE_VALUE (id
);
1984 = tree_cons (id
, old_type_value
, b
->type_shadowed
);
1985 type
= decl
? TREE_TYPE (decl
) : NULL_TREE
;
1986 TREE_TYPE (b
->type_shadowed
) = type
;
1990 cxx_binding
*binding
=
1991 binding_for_name (NAMESPACE_LEVEL (current_namespace
), id
);
1994 supplement_binding (binding
, decl
);
1996 binding
->value
= decl
;
1998 /* Store marker instead of real type. */
1999 type
= global_type_node
;
2001 SET_IDENTIFIER_TYPE_VALUE (id
, type
);
2004 /* As set_identifier_type_value_with_scope, but using
2005 current_binding_level. */
2008 set_identifier_type_value (tree id
, tree decl
)
2010 set_identifier_type_value_with_scope (id
, decl
, current_binding_level
);
2013 /* Return the name for the constructor (or destructor) for the
2014 specified class TYPE. When given a template, this routine doesn't
2015 lose the specialization. */
2018 constructor_name_full (tree type
)
2020 return TYPE_IDENTIFIER (TYPE_MAIN_VARIANT (type
));
2023 /* Return the name for the constructor (or destructor) for the
2024 specified class. When given a template, return the plain
2025 unspecialized name. */
2028 constructor_name (tree type
)
2031 name
= constructor_name_full (type
);
2032 if (IDENTIFIER_TEMPLATE (name
))
2033 name
= IDENTIFIER_TEMPLATE (name
);
2037 /* Returns TRUE if NAME is the name for the constructor for TYPE,
2038 which must be a class type. */
2041 constructor_name_p (tree name
, tree type
)
2045 gcc_assert (MAYBE_CLASS_TYPE_P (type
));
2050 if (!identifier_p (name
))
2053 /* These don't have names. */
2054 if (TREE_CODE (type
) == DECLTYPE_TYPE
2055 || TREE_CODE (type
) == TYPEOF_TYPE
)
2058 ctor_name
= constructor_name_full (type
);
2059 if (name
== ctor_name
)
2061 if (IDENTIFIER_TEMPLATE (ctor_name
)
2062 && name
== IDENTIFIER_TEMPLATE (ctor_name
))
2067 /* Counter used to create anonymous type names. */
2069 static GTY(()) int anon_cnt
;
2071 /* Return an IDENTIFIER which can be used as a name for
2072 anonymous structs and unions. */
2075 make_anon_name (void)
2079 sprintf (buf
, ANON_AGGRNAME_FORMAT
, anon_cnt
++);
2080 return get_identifier (buf
);
2083 /* This code is practically identical to that for creating
2084 anonymous names, but is just used for lambdas instead. This isn't really
2085 necessary, but it's convenient to avoid treating lambdas like other
2088 static GTY(()) int lambda_cnt
= 0;
2091 make_lambda_name (void)
2095 sprintf (buf
, LAMBDANAME_FORMAT
, lambda_cnt
++);
2096 return get_identifier (buf
);
2099 /* Return (from the stack of) the BINDING, if any, established at SCOPE. */
2101 static inline cxx_binding
*
2102 find_binding (cp_binding_level
*scope
, cxx_binding
*binding
)
2104 for (; binding
!= NULL
; binding
= binding
->previous
)
2105 if (binding
->scope
== scope
)
2108 return (cxx_binding
*)0;
2111 /* Return the binding for NAME in SCOPE, if any. Otherwise, return NULL. */
2113 static inline cxx_binding
*
2114 cp_binding_level_find_binding_for_name (cp_binding_level
*scope
, tree name
)
2116 cxx_binding
*b
= IDENTIFIER_NAMESPACE_BINDINGS (name
);
2119 /* Fold-in case where NAME is used only once. */
2120 if (scope
== b
->scope
&& b
->previous
== NULL
)
2122 return find_binding (scope
, b
);
2127 /* Always returns a binding for name in scope. If no binding is
2128 found, make a new one. */
2130 static cxx_binding
*
2131 binding_for_name (cp_binding_level
*scope
, tree name
)
2133 cxx_binding
*result
;
2135 result
= cp_binding_level_find_binding_for_name (scope
, name
);
2138 /* Not found, make a new one. */
2139 result
= cxx_binding_make (NULL
, NULL
);
2140 result
->previous
= IDENTIFIER_NAMESPACE_BINDINGS (name
);
2141 result
->scope
= scope
;
2142 result
->is_local
= false;
2143 result
->value_is_inherited
= false;
2144 IDENTIFIER_NAMESPACE_BINDINGS (name
) = result
;
2148 /* Walk through the bindings associated to the name of FUNCTION,
2149 and return the first declaration of a function with a
2150 "C" linkage specification, a.k.a 'extern "C"'.
2151 This function looks for the binding, regardless of which scope it
2152 has been defined in. It basically looks in all the known scopes.
2153 Note that this function does not lookup for bindings of builtin functions
2154 or for functions declared in system headers. */
2156 lookup_extern_c_fun_in_all_ns (tree function
)
2161 gcc_assert (function
&& TREE_CODE (function
) == FUNCTION_DECL
);
2163 name
= DECL_NAME (function
);
2164 gcc_assert (name
&& identifier_p (name
));
2166 for (iter
= IDENTIFIER_NAMESPACE_BINDINGS (name
);
2168 iter
= iter
->previous
)
2171 for (ovl
= iter
->value
; ovl
; ovl
= OVL_NEXT (ovl
))
2173 tree decl
= OVL_CURRENT (ovl
);
2175 && TREE_CODE (decl
) == FUNCTION_DECL
2176 && DECL_EXTERN_C_P (decl
)
2177 && !DECL_ARTIFICIAL (decl
))
2186 /* Returns a list of C-linkage decls with the name NAME. */
2189 c_linkage_bindings (tree name
)
2191 tree decls
= NULL_TREE
;
2194 for (iter
= IDENTIFIER_NAMESPACE_BINDINGS (name
);
2196 iter
= iter
->previous
)
2199 for (ovl
= iter
->value
; ovl
; ovl
= OVL_NEXT (ovl
))
2201 tree decl
= OVL_CURRENT (ovl
);
2203 && DECL_EXTERN_C_P (decl
)
2204 && !DECL_ARTIFICIAL (decl
))
2206 if (decls
== NULL_TREE
)
2209 decls
= tree_cons (NULL_TREE
, decl
, decls
);
2216 /* Insert another USING_DECL into the current binding level, returning
2217 this declaration. If this is a redeclaration, do nothing, and
2218 return NULL_TREE if this not in namespace scope (in namespace
2219 scope, a using decl might extend any previous bindings). */
2222 push_using_decl_1 (tree scope
, tree name
)
2226 gcc_assert (TREE_CODE (scope
) == NAMESPACE_DECL
);
2227 gcc_assert (identifier_p (name
));
2228 for (decl
= current_binding_level
->usings
; decl
; decl
= DECL_CHAIN (decl
))
2229 if (USING_DECL_SCOPE (decl
) == scope
&& DECL_NAME (decl
) == name
)
2232 return namespace_bindings_p () ? decl
: NULL_TREE
;
2233 decl
= build_lang_decl (USING_DECL
, name
, NULL_TREE
);
2234 USING_DECL_SCOPE (decl
) = scope
;
2235 DECL_CHAIN (decl
) = current_binding_level
->usings
;
2236 current_binding_level
->usings
= decl
;
2240 /* Wrapper for push_using_decl_1. */
2243 push_using_decl (tree scope
, tree name
)
2246 timevar_start (TV_NAME_LOOKUP
);
2247 ret
= push_using_decl_1 (scope
, name
);
2248 timevar_stop (TV_NAME_LOOKUP
);
2252 /* Same as pushdecl, but define X in binding-level LEVEL. We rely on the
2253 caller to set DECL_CONTEXT properly.
2255 Note that this must only be used when X will be the new innermost
2256 binding for its name, as we tack it onto the front of IDENTIFIER_BINDING
2257 without checking to see if the current IDENTIFIER_BINDING comes from a
2258 closer binding level than LEVEL. */
2261 pushdecl_with_scope_1 (tree x
, cp_binding_level
*level
, bool is_friend
)
2263 cp_binding_level
*b
;
2264 tree function_decl
= current_function_decl
;
2266 current_function_decl
= NULL_TREE
;
2267 if (level
->kind
== sk_class
)
2269 b
= class_binding_level
;
2270 class_binding_level
= level
;
2271 pushdecl_class_level (x
);
2272 class_binding_level
= b
;
2276 b
= current_binding_level
;
2277 current_binding_level
= level
;
2278 x
= pushdecl_maybe_friend (x
, is_friend
);
2279 current_binding_level
= b
;
2281 current_function_decl
= function_decl
;
2285 /* Wrapper for pushdecl_with_scope_1. */
2288 pushdecl_with_scope (tree x
, cp_binding_level
*level
, bool is_friend
)
2291 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
2292 ret
= pushdecl_with_scope_1 (x
, level
, is_friend
);
2293 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
2297 /* Helper function for push_overloaded_decl_1 and do_nonmember_using_decl.
2298 Compares the parameter-type-lists of DECL1 and DECL2 and returns false
2299 if they are different. If the DECLs are template functions, the return
2300 types and the template parameter lists are compared too (DR 565). */
2303 compparms_for_decl_and_using_decl (tree decl1
, tree decl2
)
2305 if (!compparms (TYPE_ARG_TYPES (TREE_TYPE (decl1
)),
2306 TYPE_ARG_TYPES (TREE_TYPE (decl2
))))
2309 if (! DECL_FUNCTION_TEMPLATE_P (decl1
)
2310 || ! DECL_FUNCTION_TEMPLATE_P (decl2
))
2313 return (comp_template_parms (DECL_TEMPLATE_PARMS (decl1
),
2314 DECL_TEMPLATE_PARMS (decl2
))
2315 && same_type_p (TREE_TYPE (TREE_TYPE (decl1
)),
2316 TREE_TYPE (TREE_TYPE (decl2
))));
2319 /* DECL is a FUNCTION_DECL for a non-member function, which may have
2320 other definitions already in place. We get around this by making
2321 the value of the identifier point to a list of all the things that
2322 want to be referenced by that name. It is then up to the users of
2323 that name to decide what to do with that list.
2325 DECL may also be a TEMPLATE_DECL, with a FUNCTION_DECL in its
2326 DECL_TEMPLATE_RESULT. It is dealt with the same way.
2328 FLAGS is a bitwise-or of the following values:
2329 PUSH_LOCAL: Bind DECL in the current scope, rather than at
2331 PUSH_USING: DECL is being pushed as the result of a using
2334 IS_FRIEND is true if this is a friend declaration.
2336 The value returned may be a previous declaration if we guessed wrong
2337 about what language DECL should belong to (C or C++). Otherwise,
2338 it's always DECL (and never something that's not a _DECL). */
2341 push_overloaded_decl_1 (tree decl
, int flags
, bool is_friend
)
2343 tree name
= DECL_NAME (decl
);
2346 int doing_global
= (namespace_bindings_p () || !(flags
& PUSH_LOCAL
));
2349 old
= namespace_binding (name
, DECL_CONTEXT (decl
));
2351 old
= lookup_name_innermost_nonclass_level (name
);
2355 if (TREE_CODE (old
) == TYPE_DECL
&& DECL_ARTIFICIAL (old
))
2357 tree t
= TREE_TYPE (old
);
2358 if (MAYBE_CLASS_TYPE_P (t
) && warn_shadow
2359 && (! DECL_IN_SYSTEM_HEADER (decl
)
2360 || ! DECL_IN_SYSTEM_HEADER (old
)))
2361 warning (OPT_Wshadow
, "%q#D hides constructor for %q#T", decl
, t
);
2364 else if (is_overloaded_fn (old
))
2368 for (tmp
= old
; tmp
; tmp
= OVL_NEXT (tmp
))
2370 tree fn
= OVL_CURRENT (tmp
);
2373 if (TREE_CODE (tmp
) == OVERLOAD
&& OVL_USED (tmp
)
2374 && !(flags
& PUSH_USING
)
2375 && compparms_for_decl_and_using_decl (fn
, decl
)
2376 && ! decls_match (fn
, decl
))
2377 diagnose_name_conflict (decl
, fn
);
2379 dup
= duplicate_decls (decl
, fn
, is_friend
);
2380 /* If DECL was a redeclaration of FN -- even an invalid
2381 one -- pass that information along to our caller. */
2382 if (dup
== fn
|| dup
== error_mark_node
)
2386 /* We don't overload implicit built-ins. duplicate_decls()
2387 may fail to merge the decls if the new decl is e.g. a
2388 template function. */
2389 if (TREE_CODE (old
) == FUNCTION_DECL
2390 && DECL_ANTICIPATED (old
)
2391 && !DECL_HIDDEN_FRIEND_P (old
))
2394 else if (old
== error_mark_node
)
2395 /* Ignore the undefined symbol marker. */
2399 error ("previous non-function declaration %q+#D", old
);
2400 error ("conflicts with function declaration %q#D", decl
);
2405 if (old
|| TREE_CODE (decl
) == TEMPLATE_DECL
2406 /* If it's a using declaration, we always need to build an OVERLOAD,
2407 because it's the only way to remember that the declaration comes
2408 from 'using', and have the lookup behave correctly. */
2409 || (flags
& PUSH_USING
))
2411 if (old
&& TREE_CODE (old
) != OVERLOAD
)
2412 new_binding
= ovl_cons (decl
, ovl_cons (old
, NULL_TREE
));
2414 new_binding
= ovl_cons (decl
, old
);
2415 if (flags
& PUSH_USING
)
2416 OVL_USED (new_binding
) = 1;
2419 /* NAME is not ambiguous. */
2423 set_namespace_binding (name
, current_namespace
, new_binding
);
2426 /* We only create an OVERLOAD if there was a previous binding at
2427 this level, or if decl is a template. In the former case, we
2428 need to remove the old binding and replace it with the new
2429 binding. We must also run through the NAMES on the binding
2430 level where the name was bound to update the chain. */
2432 if (TREE_CODE (new_binding
) == OVERLOAD
&& old
)
2436 for (d
= &IDENTIFIER_BINDING (name
)->scope
->names
;
2438 d
= &TREE_CHAIN (*d
))
2440 || (TREE_CODE (*d
) == TREE_LIST
2441 && TREE_VALUE (*d
) == old
))
2443 if (TREE_CODE (*d
) == TREE_LIST
)
2444 /* Just replace the old binding with the new. */
2445 TREE_VALUE (*d
) = new_binding
;
2447 /* Build a TREE_LIST to wrap the OVERLOAD. */
2448 *d
= tree_cons (NULL_TREE
, new_binding
,
2451 /* And update the cxx_binding node. */
2452 IDENTIFIER_BINDING (name
)->value
= new_binding
;
2456 /* We should always find a previous binding in this case. */
2460 /* Install the new binding. */
2461 push_local_binding (name
, new_binding
, flags
);
2467 /* Wrapper for push_overloaded_decl_1. */
2470 push_overloaded_decl (tree decl
, int flags
, bool is_friend
)
2473 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
2474 ret
= push_overloaded_decl_1 (decl
, flags
, is_friend
);
2475 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
2479 /* Check a non-member using-declaration. Return the name and scope
2480 being used, and the USING_DECL, or NULL_TREE on failure. */
2483 validate_nonmember_using_decl (tree decl
, tree scope
, tree name
)
2485 /* [namespace.udecl]
2486 A using-declaration for a class member shall be a
2487 member-declaration. */
2490 error ("%qT is not a namespace", scope
);
2493 else if (scope
== error_mark_node
)
2496 if (TREE_CODE (decl
) == TEMPLATE_ID_EXPR
)
2499 A using-declaration shall not name a template-id. */
2500 error ("a using-declaration cannot specify a template-id. "
2501 "Try %<using %D%>", name
);
2505 if (TREE_CODE (decl
) == NAMESPACE_DECL
)
2507 error ("namespace %qD not allowed in using-declaration", decl
);
2511 if (TREE_CODE (decl
) == SCOPE_REF
)
2513 /* It's a nested name with template parameter dependent scope.
2514 This can only be using-declaration for class member. */
2515 error ("%qT is not a namespace", TREE_OPERAND (decl
, 0));
2519 if (is_overloaded_fn (decl
))
2520 decl
= get_first_fn (decl
);
2522 gcc_assert (DECL_P (decl
));
2524 /* Make a USING_DECL. */
2525 tree using_decl
= push_using_decl (scope
, name
);
2527 if (using_decl
== NULL_TREE
2528 && at_function_scope_p ()
2530 /* C++11 7.3.3/10. */
2531 error ("%qD is already declared in this scope", name
);
2536 /* Process local and global using-declarations. */
2539 do_nonmember_using_decl (tree scope
, tree name
, tree oldval
, tree oldtype
,
2540 tree
*newval
, tree
*newtype
)
2542 struct scope_binding decls
= EMPTY_SCOPE_BINDING
;
2544 *newval
= *newtype
= NULL_TREE
;
2545 if (!qualified_lookup_using_namespace (name
, scope
, &decls
, 0))
2549 if (!decls
.value
&& !decls
.type
)
2551 error ("%qD not declared", name
);
2555 /* Shift the old and new bindings around so we're comparing class and
2556 enumeration names to each other. */
2557 if (oldval
&& DECL_IMPLICIT_TYPEDEF_P (oldval
))
2563 if (decls
.value
&& DECL_IMPLICIT_TYPEDEF_P (decls
.value
))
2565 decls
.type
= decls
.value
;
2566 decls
.value
= NULL_TREE
;
2569 /* It is impossible to overload a built-in function; any explicit
2570 declaration eliminates the built-in declaration. So, if OLDVAL
2571 is a built-in, then we can just pretend it isn't there. */
2573 && TREE_CODE (oldval
) == FUNCTION_DECL
2574 && DECL_ANTICIPATED (oldval
)
2575 && !DECL_HIDDEN_FRIEND_P (oldval
))
2580 /* Check for using functions. */
2581 if (is_overloaded_fn (decls
.value
))
2585 if (oldval
&& !is_overloaded_fn (oldval
))
2587 error ("%qD is already declared in this scope", name
);
2592 for (tmp
= decls
.value
; tmp
; tmp
= OVL_NEXT (tmp
))
2594 tree new_fn
= OVL_CURRENT (tmp
);
2596 /* [namespace.udecl]
2598 If a function declaration in namespace scope or block
2599 scope has the same name and the same parameter types as a
2600 function introduced by a using declaration the program is
2602 for (tmp1
= oldval
; tmp1
; tmp1
= OVL_NEXT (tmp1
))
2604 tree old_fn
= OVL_CURRENT (tmp1
);
2606 if (new_fn
== old_fn
)
2607 /* The function already exists in the current namespace. */
2609 else if (TREE_CODE (tmp1
) == OVERLOAD
&& OVL_USED (tmp1
))
2610 continue; /* this is a using decl */
2611 else if (compparms_for_decl_and_using_decl (new_fn
, old_fn
))
2613 gcc_assert (!DECL_ANTICIPATED (old_fn
)
2614 || DECL_HIDDEN_FRIEND_P (old_fn
));
2616 /* There was already a non-using declaration in
2617 this scope with the same parameter types. If both
2618 are the same extern "C" functions, that's ok. */
2619 if (decls_match (new_fn
, old_fn
))
2623 diagnose_name_conflict (new_fn
, old_fn
);
2629 /* If we broke out of the loop, there's no reason to add
2630 this function to the using declarations for this
2635 /* If we are adding to an existing OVERLOAD, then we no
2636 longer know the type of the set of functions. */
2637 if (*newval
&& TREE_CODE (*newval
) == OVERLOAD
)
2638 TREE_TYPE (*newval
) = unknown_type_node
;
2639 /* Add this new function to the set. */
2640 *newval
= build_overload (OVL_CURRENT (tmp
), *newval
);
2641 /* If there is only one function, then we use its type. (A
2642 using-declaration naming a single function can be used in
2643 contexts where overload resolution cannot be
2645 if (TREE_CODE (*newval
) != OVERLOAD
)
2647 *newval
= ovl_cons (*newval
, NULL_TREE
);
2648 TREE_TYPE (*newval
) = TREE_TYPE (OVL_CURRENT (tmp
));
2650 OVL_USED (*newval
) = 1;
2655 *newval
= decls
.value
;
2656 if (oldval
&& !decls_match (*newval
, oldval
))
2657 error ("%qD is already declared in this scope", name
);
2663 if (decls
.type
&& TREE_CODE (decls
.type
) == TREE_LIST
)
2665 error ("reference to %qD is ambiguous", name
);
2666 print_candidates (decls
.type
);
2670 *newtype
= decls
.type
;
2671 if (oldtype
&& *newtype
&& !decls_match (oldtype
, *newtype
))
2672 error ("%qD is already declared in this scope", name
);
2675 /* If *newval is empty, shift any class or enumeration name down. */
2679 *newtype
= NULL_TREE
;
2683 /* Process a using-declaration at function scope. */
2686 do_local_using_decl (tree decl
, tree scope
, tree name
)
2688 tree oldval
, oldtype
, newval
, newtype
;
2689 tree orig_decl
= decl
;
2691 decl
= validate_nonmember_using_decl (decl
, scope
, name
);
2692 if (decl
== NULL_TREE
)
2695 if (building_stmt_list_p ()
2696 && at_function_scope_p ())
2697 add_decl_expr (decl
);
2699 oldval
= lookup_name_innermost_nonclass_level (name
);
2700 oldtype
= lookup_type_current_level (name
);
2702 do_nonmember_using_decl (scope
, name
, oldval
, oldtype
, &newval
, &newtype
);
2706 if (is_overloaded_fn (newval
))
2710 /* We only need to push declarations for those functions
2711 that were not already bound in the current level.
2712 The old value might be NULL_TREE, it might be a single
2713 function, or an OVERLOAD. */
2714 if (oldval
&& TREE_CODE (oldval
) == OVERLOAD
)
2715 term
= OVL_FUNCTION (oldval
);
2718 for (fn
= newval
; fn
&& OVL_CURRENT (fn
) != term
;
2720 push_overloaded_decl (OVL_CURRENT (fn
),
2721 PUSH_LOCAL
| PUSH_USING
,
2725 push_local_binding (name
, newval
, PUSH_USING
);
2729 push_local_binding (name
, newtype
, PUSH_USING
);
2730 set_identifier_type_value (name
, newtype
);
2733 /* Emit debug info. */
2734 if (!processing_template_decl
)
2735 cp_emit_debug_info_for_using (orig_decl
, current_scope());
2738 /* Returns true if ROOT (a namespace, class, or function) encloses
2739 CHILD. CHILD may be either a class type or a namespace. */
2742 is_ancestor (tree root
, tree child
)
2744 gcc_assert ((TREE_CODE (root
) == NAMESPACE_DECL
2745 || TREE_CODE (root
) == FUNCTION_DECL
2746 || CLASS_TYPE_P (root
)));
2747 gcc_assert ((TREE_CODE (child
) == NAMESPACE_DECL
2748 || CLASS_TYPE_P (child
)));
2750 /* The global namespace encloses everything. */
2751 if (root
== global_namespace
)
2756 /* If we've run out of scopes, stop. */
2759 /* If we've reached the ROOT, it encloses CHILD. */
2762 /* Go out one level. */
2764 child
= TYPE_NAME (child
);
2765 child
= DECL_CONTEXT (child
);
2769 /* Enter the class or namespace scope indicated by T suitable for name
2770 lookup. T can be arbitrary scope, not necessary nested inside the
2771 current scope. Returns a non-null scope to pop iff pop_scope
2772 should be called later to exit this scope. */
2777 if (TREE_CODE (t
) == NAMESPACE_DECL
)
2778 push_decl_namespace (t
);
2779 else if (CLASS_TYPE_P (t
))
2781 if (!at_class_scope_p ()
2782 || !same_type_p (current_class_type
, t
))
2783 push_nested_class (t
);
2785 /* T is the same as the current scope. There is therefore no
2786 need to re-enter the scope. Since we are not actually
2787 pushing a new scope, our caller should not call
2795 /* Leave scope pushed by push_scope. */
2802 if (TREE_CODE (t
) == NAMESPACE_DECL
)
2803 pop_decl_namespace ();
2804 else if CLASS_TYPE_P (t
)
2805 pop_nested_class ();
2808 /* Subroutine of push_inner_scope. */
2811 push_inner_scope_r (tree outer
, tree inner
)
2816 || (TREE_CODE (inner
) != NAMESPACE_DECL
&& !CLASS_TYPE_P (inner
)))
2819 prev
= CP_DECL_CONTEXT (TREE_CODE (inner
) == NAMESPACE_DECL
? inner
: TYPE_NAME (inner
));
2821 push_inner_scope_r (outer
, prev
);
2822 if (TREE_CODE (inner
) == NAMESPACE_DECL
)
2824 cp_binding_level
*save_template_parm
= 0;
2825 /* Temporary take out template parameter scopes. They are saved
2826 in reversed order in save_template_parm. */
2827 while (current_binding_level
->kind
== sk_template_parms
)
2829 cp_binding_level
*b
= current_binding_level
;
2830 current_binding_level
= b
->level_chain
;
2831 b
->level_chain
= save_template_parm
;
2832 save_template_parm
= b
;
2835 resume_scope (NAMESPACE_LEVEL (inner
));
2836 current_namespace
= inner
;
2838 /* Restore template parameter scopes. */
2839 while (save_template_parm
)
2841 cp_binding_level
*b
= save_template_parm
;
2842 save_template_parm
= b
->level_chain
;
2843 b
->level_chain
= current_binding_level
;
2844 current_binding_level
= b
;
2851 /* Enter the scope INNER from current scope. INNER must be a scope
2852 nested inside current scope. This works with both name lookup and
2853 pushing name into scope. In case a template parameter scope is present,
2854 namespace is pushed under the template parameter scope according to
2855 name lookup rule in 14.6.1/6.
2857 Return the former current scope suitable for pop_inner_scope. */
2860 push_inner_scope (tree inner
)
2862 tree outer
= current_scope ();
2864 outer
= current_namespace
;
2866 push_inner_scope_r (outer
, inner
);
2870 /* Exit the current scope INNER back to scope OUTER. */
2873 pop_inner_scope (tree outer
, tree inner
)
2876 || (TREE_CODE (inner
) != NAMESPACE_DECL
&& !CLASS_TYPE_P (inner
)))
2879 while (outer
!= inner
)
2881 if (TREE_CODE (inner
) == NAMESPACE_DECL
)
2883 cp_binding_level
*save_template_parm
= 0;
2884 /* Temporary take out template parameter scopes. They are saved
2885 in reversed order in save_template_parm. */
2886 while (current_binding_level
->kind
== sk_template_parms
)
2888 cp_binding_level
*b
= current_binding_level
;
2889 current_binding_level
= b
->level_chain
;
2890 b
->level_chain
= save_template_parm
;
2891 save_template_parm
= b
;
2896 /* Restore template parameter scopes. */
2897 while (save_template_parm
)
2899 cp_binding_level
*b
= save_template_parm
;
2900 save_template_parm
= b
->level_chain
;
2901 b
->level_chain
= current_binding_level
;
2902 current_binding_level
= b
;
2908 inner
= CP_DECL_CONTEXT (TREE_CODE (inner
) == NAMESPACE_DECL
? inner
: TYPE_NAME (inner
));
2912 /* Do a pushlevel for class declarations. */
2915 pushlevel_class (void)
2917 class_binding_level
= begin_scope (sk_class
, current_class_type
);
2920 /* ...and a poplevel for class declarations. */
2923 poplevel_class (void)
2925 cp_binding_level
*level
= class_binding_level
;
2926 cp_class_binding
*cb
;
2930 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
2931 gcc_assert (level
!= 0);
2933 /* If we're leaving a toplevel class, cache its binding level. */
2934 if (current_class_depth
== 1)
2935 previous_class_level
= level
;
2936 for (shadowed
= level
->type_shadowed
;
2938 shadowed
= TREE_CHAIN (shadowed
))
2939 SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (shadowed
), TREE_VALUE (shadowed
));
2941 /* Remove the bindings for all of the class-level declarations. */
2942 if (level
->class_shadowed
)
2944 FOR_EACH_VEC_ELT (*level
->class_shadowed
, i
, cb
)
2946 IDENTIFIER_BINDING (cb
->identifier
) = cb
->base
->previous
;
2947 cxx_binding_free (cb
->base
);
2949 ggc_free (level
->class_shadowed
);
2950 level
->class_shadowed
= NULL
;
2953 /* Now, pop out of the binding level which we created up in the
2954 `pushlevel_class' routine. */
2955 gcc_assert (current_binding_level
== level
);
2957 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
2960 /* Set INHERITED_VALUE_BINDING_P on BINDING to true or false, as
2961 appropriate. DECL is the value to which a name has just been
2962 bound. CLASS_TYPE is the class in which the lookup occurred. */
2965 set_inherited_value_binding_p (cxx_binding
*binding
, tree decl
,
2968 if (binding
->value
== decl
&& TREE_CODE (decl
) != TREE_LIST
)
2972 if (TREE_CODE (decl
) == OVERLOAD
)
2973 context
= ovl_scope (decl
);
2976 gcc_assert (DECL_P (decl
));
2977 context
= context_for_name_lookup (decl
);
2980 if (is_properly_derived_from (class_type
, context
))
2981 INHERITED_VALUE_BINDING_P (binding
) = 1;
2983 INHERITED_VALUE_BINDING_P (binding
) = 0;
2985 else if (binding
->value
== decl
)
2986 /* We only encounter a TREE_LIST when there is an ambiguity in the
2987 base classes. Such an ambiguity can be overridden by a
2988 definition in this class. */
2989 INHERITED_VALUE_BINDING_P (binding
) = 1;
2991 INHERITED_VALUE_BINDING_P (binding
) = 0;
2994 /* Make the declaration of X appear in CLASS scope. */
2997 pushdecl_class_level (tree x
)
3000 bool is_valid
= true;
3003 /* Do nothing if we're adding to an outer lambda closure type,
3004 outer_binding will add it later if it's needed. */
3005 if (current_class_type
!= class_binding_level
->this_entity
)
3008 subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
3009 /* Get the name of X. */
3010 if (TREE_CODE (x
) == OVERLOAD
)
3011 name
= DECL_NAME (get_first_fn (x
));
3013 name
= DECL_NAME (x
);
3017 is_valid
= push_class_level_binding (name
, x
);
3018 if (TREE_CODE (x
) == TYPE_DECL
)
3019 set_identifier_type_value (name
, x
);
3021 else if (ANON_AGGR_TYPE_P (TREE_TYPE (x
)))
3023 /* If X is an anonymous aggregate, all of its members are
3024 treated as if they were members of the class containing the
3025 aggregate, for naming purposes. */
3028 for (f
= TYPE_FIELDS (TREE_TYPE (x
)); f
; f
= DECL_CHAIN (f
))
3030 location_t save_location
= input_location
;
3031 input_location
= DECL_SOURCE_LOCATION (f
);
3032 if (!pushdecl_class_level (f
))
3034 input_location
= save_location
;
3037 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
3041 /* Return the BINDING (if any) for NAME in SCOPE, which is a class
3042 scope. If the value returned is non-NULL, and the PREVIOUS field
3043 is not set, callers must set the PREVIOUS field explicitly. */
3045 static cxx_binding
*
3046 get_class_binding (tree name
, cp_binding_level
*scope
)
3051 cxx_binding
*binding
;
3053 class_type
= scope
->this_entity
;
3055 /* Get the type binding. */
3056 type_binding
= lookup_member (class_type
, name
,
3057 /*protect=*/2, /*want_type=*/true,
3058 tf_warning_or_error
);
3059 /* Get the value binding. */
3060 value_binding
= lookup_member (class_type
, name
,
3061 /*protect=*/2, /*want_type=*/false,
3062 tf_warning_or_error
);
3065 && (TREE_CODE (value_binding
) == TYPE_DECL
3066 || DECL_CLASS_TEMPLATE_P (value_binding
)
3067 || (TREE_CODE (value_binding
) == TREE_LIST
3068 && TREE_TYPE (value_binding
) == error_mark_node
3069 && (TREE_CODE (TREE_VALUE (value_binding
))
3071 /* We found a type binding, even when looking for a non-type
3072 binding. This means that we already processed this binding
3075 else if (value_binding
)
3077 if (TREE_CODE (value_binding
) == TREE_LIST
3078 && TREE_TYPE (value_binding
) == error_mark_node
)
3079 /* NAME is ambiguous. */
3081 else if (BASELINK_P (value_binding
))
3082 /* NAME is some overloaded functions. */
3083 value_binding
= BASELINK_FUNCTIONS (value_binding
);
3086 /* If we found either a type binding or a value binding, create a
3087 new binding object. */
3088 if (type_binding
|| value_binding
)
3090 binding
= new_class_binding (name
,
3094 /* This is a class-scope binding, not a block-scope binding. */
3095 LOCAL_BINDING_P (binding
) = 0;
3096 set_inherited_value_binding_p (binding
, value_binding
, class_type
);
3104 /* Make the declaration(s) of X appear in CLASS scope under the name
3105 NAME. Returns true if the binding is valid. */
3108 push_class_level_binding_1 (tree name
, tree x
)
3110 cxx_binding
*binding
;
3114 /* The class_binding_level will be NULL if x is a template
3115 parameter name in a member template. */
3116 if (!class_binding_level
)
3119 if (name
== error_mark_node
)
3122 /* Can happen for an erroneous declaration (c++/60384). */
3123 if (!identifier_p (name
))
3125 gcc_assert (errorcount
|| sorrycount
);
3129 /* Check for invalid member names. But don't worry about a default
3130 argument-scope lambda being pushed after the class is complete. */
3131 gcc_assert (TYPE_BEING_DEFINED (current_class_type
)
3132 || LAMBDA_TYPE_P (TREE_TYPE (decl
)));
3133 /* Check that we're pushing into the right binding level. */
3134 gcc_assert (current_class_type
== class_binding_level
->this_entity
);
3136 /* We could have been passed a tree list if this is an ambiguous
3137 declaration. If so, pull the declaration out because
3138 check_template_shadow will not handle a TREE_LIST. */
3139 if (TREE_CODE (decl
) == TREE_LIST
3140 && TREE_TYPE (decl
) == error_mark_node
)
3141 decl
= TREE_VALUE (decl
);
3143 if (!check_template_shadow (decl
))
3148 If T is the name of a class, then each of the following shall
3149 have a name different from T:
3151 -- every static data member of class T;
3153 -- every member of class T that is itself a type;
3155 -- every enumerator of every member of class T that is an
3158 -- every member of every anonymous union that is a member of
3161 (Non-static data members were also forbidden to have the same
3162 name as T until TC1.) */
3164 || TREE_CODE (x
) == CONST_DECL
3165 || (TREE_CODE (x
) == TYPE_DECL
3166 && !DECL_SELF_REFERENCE_P (x
))
3167 /* A data member of an anonymous union. */
3168 || (TREE_CODE (x
) == FIELD_DECL
3169 && DECL_CONTEXT (x
) != current_class_type
))
3170 && DECL_NAME (x
) == constructor_name (current_class_type
))
3172 tree scope
= context_for_name_lookup (x
);
3173 if (TYPE_P (scope
) && same_type_p (scope
, current_class_type
))
3175 error ("%qD has the same name as the class in which it is "
3182 /* Get the current binding for NAME in this class, if any. */
3183 binding
= IDENTIFIER_BINDING (name
);
3184 if (!binding
|| binding
->scope
!= class_binding_level
)
3186 binding
= get_class_binding (name
, class_binding_level
);
3187 /* If a new binding was created, put it at the front of the
3188 IDENTIFIER_BINDING list. */
3191 binding
->previous
= IDENTIFIER_BINDING (name
);
3192 IDENTIFIER_BINDING (name
) = binding
;
3196 /* If there is already a binding, then we may need to update the
3198 if (binding
&& binding
->value
)
3200 tree bval
= binding
->value
;
3201 tree old_decl
= NULL_TREE
;
3202 tree target_decl
= strip_using_decl (decl
);
3203 tree target_bval
= strip_using_decl (bval
);
3205 if (INHERITED_VALUE_BINDING_P (binding
))
3207 /* If the old binding was from a base class, and was for a
3208 tag name, slide it over to make room for the new binding.
3209 The old binding is still visible if explicitly qualified
3210 with a class-key. */
3211 if (TREE_CODE (target_bval
) == TYPE_DECL
3212 && DECL_ARTIFICIAL (target_bval
)
3213 && !(TREE_CODE (target_decl
) == TYPE_DECL
3214 && DECL_ARTIFICIAL (target_decl
)))
3216 old_decl
= binding
->type
;
3217 binding
->type
= bval
;
3218 binding
->value
= NULL_TREE
;
3219 INHERITED_VALUE_BINDING_P (binding
) = 0;
3224 /* Any inherited type declaration is hidden by the type
3225 declaration in the derived class. */
3226 if (TREE_CODE (target_decl
) == TYPE_DECL
3227 && DECL_ARTIFICIAL (target_decl
))
3228 binding
->type
= NULL_TREE
;
3231 else if (TREE_CODE (target_decl
) == OVERLOAD
3232 && is_overloaded_fn (target_bval
))
3234 else if (TREE_CODE (decl
) == USING_DECL
3235 && TREE_CODE (bval
) == USING_DECL
3236 && same_type_p (USING_DECL_SCOPE (decl
),
3237 USING_DECL_SCOPE (bval
)))
3238 /* This is a using redeclaration that will be diagnosed later
3239 in supplement_binding */
3241 else if (TREE_CODE (decl
) == USING_DECL
3242 && TREE_CODE (bval
) == USING_DECL
3243 && DECL_DEPENDENT_P (decl
)
3244 && DECL_DEPENDENT_P (bval
))
3246 else if (TREE_CODE (decl
) == USING_DECL
3247 && is_overloaded_fn (target_bval
))
3249 else if (TREE_CODE (bval
) == USING_DECL
3250 && is_overloaded_fn (target_decl
))
3253 if (old_decl
&& binding
->scope
== class_binding_level
)
3256 /* It is always safe to clear INHERITED_VALUE_BINDING_P
3257 here. This function is only used to register bindings
3258 from with the class definition itself. */
3259 INHERITED_VALUE_BINDING_P (binding
) = 0;
3264 /* Note that we declared this value so that we can issue an error if
3265 this is an invalid redeclaration of a name already used for some
3267 note_name_declared_in_class (name
, decl
);
3269 /* If we didn't replace an existing binding, put the binding on the
3270 stack of bindings for the identifier, and update the shadowed
3272 if (binding
&& binding
->scope
== class_binding_level
)
3273 /* Supplement the existing binding. */
3274 ok
= supplement_binding (binding
, decl
);
3277 /* Create a new binding. */
3278 push_binding (name
, decl
, class_binding_level
);
3285 /* Wrapper for push_class_level_binding_1. */
3288 push_class_level_binding (tree name
, tree x
)
3291 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
3292 ret
= push_class_level_binding_1 (name
, x
);
3293 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
3297 /* Process "using SCOPE::NAME" in a class scope. Return the
3298 USING_DECL created. */
3301 do_class_using_decl (tree scope
, tree name
)
3303 /* The USING_DECL returned by this function. */
3305 /* The declaration (or declarations) name by this using
3306 declaration. NULL if we are in a template and cannot figure out
3307 what has been named. */
3309 /* True if SCOPE is a dependent type. */
3310 bool scope_dependent_p
;
3311 /* True if SCOPE::NAME is dependent. */
3312 bool name_dependent_p
;
3313 /* True if any of the bases of CURRENT_CLASS_TYPE are dependent. */
3314 bool bases_dependent_p
;
3319 if (name
== error_mark_node
)
3322 if (!scope
|| !TYPE_P (scope
))
3324 error ("using-declaration for non-member at class scope");
3328 /* Make sure the name is not invalid */
3329 if (TREE_CODE (name
) == BIT_NOT_EXPR
)
3331 error ("%<%T::%D%> names destructor", scope
, name
);
3334 /* Using T::T declares inheriting ctors, even if T is a typedef. */
3335 if (MAYBE_CLASS_TYPE_P (scope
)
3336 && ((TYPE_NAME (scope
) && name
== TYPE_IDENTIFIER (scope
))
3337 || constructor_name_p (name
, scope
)))
3339 maybe_warn_cpp0x (CPP0X_INHERITING_CTORS
);
3340 name
= ctor_identifier
;
3342 if (constructor_name_p (name
, current_class_type
))
3344 error ("%<%T::%D%> names constructor in %qT",
3345 scope
, name
, current_class_type
);
3349 scope_dependent_p
= dependent_scope_p (scope
);
3350 name_dependent_p
= (scope_dependent_p
3351 || (IDENTIFIER_TYPENAME_P (name
)
3352 && dependent_type_p (TREE_TYPE (name
))));
3354 bases_dependent_p
= false;
3355 if (processing_template_decl
)
3356 for (binfo
= TYPE_BINFO (current_class_type
), i
= 0;
3357 BINFO_BASE_ITERATE (binfo
, i
, base_binfo
);
3359 if (dependent_type_p (TREE_TYPE (base_binfo
)))
3361 bases_dependent_p
= true;
3367 /* From [namespace.udecl]:
3369 A using-declaration used as a member-declaration shall refer to a
3370 member of a base class of the class being defined.
3372 In general, we cannot check this constraint in a template because
3373 we do not know the entire set of base classes of the current
3374 class type. Morover, if SCOPE is dependent, it might match a
3375 non-dependent base. */
3377 if (!scope_dependent_p
)
3380 binfo
= lookup_base (current_class_type
, scope
, ba_any
, &b_kind
,
3381 tf_warning_or_error
);
3382 if (b_kind
< bk_proper_base
)
3384 if (!bases_dependent_p
|| b_kind
== bk_same_type
)
3386 error_not_base_type (scope
, current_class_type
);
3390 else if (!name_dependent_p
)
3392 decl
= lookup_member (binfo
, name
, 0, false, tf_warning_or_error
);
3395 error ("no members matching %<%T::%D%> in %q#T", scope
, name
,
3399 /* The binfo from which the functions came does not matter. */
3400 if (BASELINK_P (decl
))
3401 decl
= BASELINK_FUNCTIONS (decl
);
3405 value
= build_lang_decl (USING_DECL
, name
, NULL_TREE
);
3406 USING_DECL_DECLS (value
) = decl
;
3407 USING_DECL_SCOPE (value
) = scope
;
3408 DECL_DEPENDENT_P (value
) = !decl
;
3414 /* Return the binding value for name in scope. */
3418 namespace_binding_1 (tree name
, tree scope
)
3420 cxx_binding
*binding
;
3422 if (SCOPE_FILE_SCOPE_P (scope
))
3423 scope
= global_namespace
;
3425 /* Unnecessary for the global namespace because it can't be an alias. */
3426 scope
= ORIGINAL_NAMESPACE (scope
);
3428 binding
= cp_binding_level_find_binding_for_name (NAMESPACE_LEVEL (scope
), name
);
3430 return binding
? binding
->value
: NULL_TREE
;
3434 namespace_binding (tree name
, tree scope
)
3437 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
3438 ret
= namespace_binding_1 (name
, scope
);
3439 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
3443 /* Set the binding value for name in scope. */
3446 set_namespace_binding_1 (tree name
, tree scope
, tree val
)
3450 if (scope
== NULL_TREE
)
3451 scope
= global_namespace
;
3452 b
= binding_for_name (NAMESPACE_LEVEL (scope
), name
);
3453 if (!b
->value
|| TREE_CODE (val
) == OVERLOAD
|| val
== error_mark_node
)
3456 supplement_binding (b
, val
);
3459 /* Wrapper for set_namespace_binding_1. */
3462 set_namespace_binding (tree name
, tree scope
, tree val
)
3464 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
3465 set_namespace_binding_1 (name
, scope
, val
);
3466 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
3469 /* Set the context of a declaration to scope. Complain if we are not
3473 set_decl_namespace (tree decl
, tree scope
, bool friendp
)
3477 /* Get rid of namespace aliases. */
3478 scope
= ORIGINAL_NAMESPACE (scope
);
3480 /* It is ok for friends to be qualified in parallel space. */
3481 if (!friendp
&& !is_ancestor (current_namespace
, scope
))
3482 error ("declaration of %qD not in a namespace surrounding %qD",
3484 DECL_CONTEXT (decl
) = FROB_CONTEXT (scope
);
3486 /* Writing "int N::i" to declare a variable within "N" is invalid. */
3487 if (scope
== current_namespace
)
3489 if (at_namespace_scope_p ())
3490 error ("explicit qualification in declaration of %qD",
3495 /* See whether this has been declared in the namespace. */
3496 old
= lookup_qualified_name (scope
, DECL_NAME (decl
), false, true);
3497 if (old
== error_mark_node
)
3498 /* No old declaration at all. */
3500 /* If it's a TREE_LIST, the result of the lookup was ambiguous. */
3501 if (TREE_CODE (old
) == TREE_LIST
)
3503 error ("reference to %qD is ambiguous", decl
);
3504 print_candidates (old
);
3507 if (!is_overloaded_fn (decl
))
3509 /* We might have found OLD in an inline namespace inside SCOPE. */
3510 if (TREE_CODE (decl
) == TREE_CODE (old
))
3511 DECL_CONTEXT (decl
) = DECL_CONTEXT (old
);
3512 /* Don't compare non-function decls with decls_match here, since
3513 it can't check for the correct constness at this
3514 point. pushdecl will find those errors later. */
3517 /* Since decl is a function, old should contain a function decl. */
3518 if (!is_overloaded_fn (old
))
3520 /* A template can be explicitly specialized in any namespace. */
3521 if (processing_explicit_instantiation
)
3523 if (processing_template_decl
|| processing_specialization
)
3524 /* We have not yet called push_template_decl to turn a
3525 FUNCTION_DECL into a TEMPLATE_DECL, so the declarations won't
3526 match. But, we'll check later, when we construct the
3529 /* Instantiations or specializations of templates may be declared as
3530 friends in any namespace. */
3531 if (friendp
&& DECL_USE_TEMPLATE (decl
))
3533 if (is_overloaded_fn (old
))
3535 tree found
= NULL_TREE
;
3537 for (; elt
; elt
= OVL_NEXT (elt
))
3539 tree ofn
= OVL_CURRENT (elt
);
3540 /* Adjust DECL_CONTEXT first so decls_match will return true
3541 if DECL will match a declaration in an inline namespace. */
3542 DECL_CONTEXT (decl
) = DECL_CONTEXT (ofn
);
3543 if (decls_match (decl
, ofn
))
3545 if (found
&& !decls_match (found
, ofn
))
3547 DECL_CONTEXT (decl
) = FROB_CONTEXT (scope
);
3548 error ("reference to %qD is ambiguous", decl
);
3549 print_candidates (old
);
3557 if (!is_associated_namespace (scope
, CP_DECL_CONTEXT (found
)))
3559 DECL_CONTEXT (decl
) = DECL_CONTEXT (found
);
3565 DECL_CONTEXT (decl
) = DECL_CONTEXT (old
);
3566 if (decls_match (decl
, old
))
3570 /* It didn't work, go back to the explicit scope. */
3571 DECL_CONTEXT (decl
) = FROB_CONTEXT (scope
);
3573 error ("%qD should have been declared inside %qD", decl
, scope
);
3576 /* Return the namespace where the current declaration is declared. */
3579 current_decl_namespace (void)
3582 /* If we have been pushed into a different namespace, use it. */
3583 if (!vec_safe_is_empty (decl_namespace_list
))
3584 return decl_namespace_list
->last ();
3586 if (current_class_type
)
3587 result
= decl_namespace_context (current_class_type
);
3588 else if (current_function_decl
)
3589 result
= decl_namespace_context (current_function_decl
);
3591 result
= current_namespace
;
3595 /* Process any ATTRIBUTES on a namespace definition. Currently only
3596 attribute visibility is meaningful, which is a property of the syntactic
3597 block rather than the namespace as a whole, so we don't touch the
3598 NAMESPACE_DECL at all. Returns true if attribute visibility is seen. */
3601 handle_namespace_attrs (tree ns
, tree attributes
)
3604 bool saw_vis
= false;
3606 for (d
= attributes
; d
; d
= TREE_CHAIN (d
))
3608 tree name
= get_attribute_name (d
);
3609 tree args
= TREE_VALUE (d
);
3611 if (is_attribute_p ("visibility", name
))
3613 tree x
= args
? TREE_VALUE (args
) : NULL_TREE
;
3614 if (x
== NULL_TREE
|| TREE_CODE (x
) != STRING_CST
|| TREE_CHAIN (args
))
3616 warning (OPT_Wattributes
,
3617 "%qD attribute requires a single NTBS argument",
3622 if (!TREE_PUBLIC (ns
))
3623 warning (OPT_Wattributes
,
3624 "%qD attribute is meaningless since members of the "
3625 "anonymous namespace get local symbols", name
);
3627 push_visibility (TREE_STRING_POINTER (x
), 1);
3632 warning (OPT_Wattributes
, "%qD attribute directive ignored",
3641 /* Push into the scope of the NAME namespace. If NAME is NULL_TREE, then we
3642 select a name that is unique to this compilation unit. */
3645 push_namespace (tree name
)
3648 bool need_new
= true;
3649 bool implicit_use
= false;
3652 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
3654 /* We should not get here if the global_namespace is not yet constructed
3655 nor if NAME designates the global namespace: The global scope is
3656 constructed elsewhere. */
3657 gcc_assert (global_namespace
!= NULL
&& name
!= global_scope_name
);
3661 name
= get_anonymous_namespace_name();
3662 d
= IDENTIFIER_NAMESPACE_VALUE (name
);
3664 /* Reopening anonymous namespace. */
3666 implicit_use
= true;
3670 /* Check whether this is an extended namespace definition. */
3671 d
= IDENTIFIER_NAMESPACE_VALUE (name
);
3672 if (d
!= NULL_TREE
&& TREE_CODE (d
) == NAMESPACE_DECL
)
3674 tree dna
= DECL_NAMESPACE_ALIAS (d
);
3677 /* We do some error recovery for, eg, the redeclaration
3684 However, in nasty cases like:
3692 we just error out below, in duplicate_decls. */
3693 if (NAMESPACE_LEVEL (dna
)->level_chain
3694 == current_binding_level
)
3696 error ("namespace alias %qD not allowed here, "
3697 "assuming %qD", d
, dna
);
3709 /* Make a new namespace, binding the name to it. */
3710 d
= build_lang_decl (NAMESPACE_DECL
, name
, void_type_node
);
3711 DECL_CONTEXT (d
) = FROB_CONTEXT (current_namespace
);
3712 /* The name of this namespace is not visible to other translation
3713 units if it is an anonymous namespace or member thereof. */
3714 if (anon
|| decl_anon_ns_mem_p (current_namespace
))
3715 TREE_PUBLIC (d
) = 0;
3717 TREE_PUBLIC (d
) = 1;
3721 /* Clear DECL_NAME for the benefit of debugging back ends. */
3722 SET_DECL_ASSEMBLER_NAME (d
, name
);
3723 DECL_NAME (d
) = NULL_TREE
;
3725 begin_scope (sk_namespace
, d
);
3728 resume_scope (NAMESPACE_LEVEL (d
));
3731 do_using_directive (d
);
3732 /* Enter the name space. */
3733 current_namespace
= d
;
3735 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
3738 /* Pop from the scope of the current namespace. */
3741 pop_namespace (void)
3743 gcc_assert (current_namespace
!= global_namespace
);
3744 current_namespace
= CP_DECL_CONTEXT (current_namespace
);
3745 /* The binding level is not popped, as it might be re-opened later. */
3749 /* Push into the scope of the namespace NS, even if it is deeply
3750 nested within another namespace. */
3753 push_nested_namespace (tree ns
)
3755 if (ns
== global_namespace
)
3756 push_to_top_level ();
3759 push_nested_namespace (CP_DECL_CONTEXT (ns
));
3760 push_namespace (DECL_NAME (ns
));
3764 /* Pop back from the scope of the namespace NS, which was previously
3765 entered with push_nested_namespace. */
3768 pop_nested_namespace (tree ns
)
3770 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
3771 gcc_assert (current_namespace
== ns
);
3772 while (ns
!= global_namespace
)
3775 ns
= CP_DECL_CONTEXT (ns
);
3778 pop_from_top_level ();
3779 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
3782 /* Temporarily set the namespace for the current declaration. */
3785 push_decl_namespace (tree decl
)
3787 if (TREE_CODE (decl
) != NAMESPACE_DECL
)
3788 decl
= decl_namespace_context (decl
);
3789 vec_safe_push (decl_namespace_list
, ORIGINAL_NAMESPACE (decl
));
3792 /* [namespace.memdef]/2 */
3795 pop_decl_namespace (void)
3797 decl_namespace_list
->pop ();
3800 /* Return the namespace that is the common ancestor
3801 of two given namespaces. */
3804 namespace_ancestor_1 (tree ns1
, tree ns2
)
3807 if (is_ancestor (ns1
, ns2
))
3810 nsr
= namespace_ancestor_1 (CP_DECL_CONTEXT (ns1
), ns2
);
3814 /* Wrapper for namespace_ancestor_1. */
3817 namespace_ancestor (tree ns1
, tree ns2
)
3820 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
3821 nsr
= namespace_ancestor_1 (ns1
, ns2
);
3822 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
3826 /* Process a namespace-alias declaration. */
3829 do_namespace_alias (tree alias
, tree name_space
)
3831 if (name_space
== error_mark_node
)
3834 gcc_assert (TREE_CODE (name_space
) == NAMESPACE_DECL
);
3836 name_space
= ORIGINAL_NAMESPACE (name_space
);
3838 /* Build the alias. */
3839 alias
= build_lang_decl (NAMESPACE_DECL
, alias
, void_type_node
);
3840 DECL_NAMESPACE_ALIAS (alias
) = name_space
;
3841 DECL_EXTERNAL (alias
) = 1;
3842 DECL_CONTEXT (alias
) = FROB_CONTEXT (current_scope ());
3845 /* Emit debug info for namespace alias. */
3846 if (!building_stmt_list_p ())
3847 (*debug_hooks
->global_decl
) (alias
);
3850 /* Like pushdecl, only it places X in the current namespace,
3854 pushdecl_namespace_level (tree x
, bool is_friend
)
3856 cp_binding_level
*b
= current_binding_level
;
3859 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
3860 t
= pushdecl_with_scope (x
, NAMESPACE_LEVEL (current_namespace
), is_friend
);
3862 /* Now, the type_shadowed stack may screw us. Munge it so it does
3864 if (TREE_CODE (t
) == TYPE_DECL
)
3866 tree name
= DECL_NAME (t
);
3868 tree
*ptr
= (tree
*)0;
3869 for (; !global_scope_p (b
); b
= b
->level_chain
)
3871 tree shadowed
= b
->type_shadowed
;
3872 for (; shadowed
; shadowed
= TREE_CHAIN (shadowed
))
3873 if (TREE_PURPOSE (shadowed
) == name
)
3875 ptr
= &TREE_VALUE (shadowed
);
3876 /* Can't break out of the loop here because sometimes
3877 a binding level will have duplicate bindings for
3878 PT names. It's gross, but I haven't time to fix it. */
3881 newval
= TREE_TYPE (t
);
3882 if (ptr
== (tree
*)0)
3884 /* @@ This shouldn't be needed. My test case "zstring.cc" trips
3885 up here if this is changed to an assertion. --KR */
3886 SET_IDENTIFIER_TYPE_VALUE (name
, t
);
3893 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
3897 /* Insert USED into the using list of USER. Set INDIRECT_flag if this
3898 directive is not directly from the source. Also find the common
3899 ancestor and let our users know about the new namespace */
3902 add_using_namespace_1 (tree user
, tree used
, bool indirect
)
3905 /* Using oneself is a no-op. */
3908 gcc_assert (TREE_CODE (user
) == NAMESPACE_DECL
);
3909 gcc_assert (TREE_CODE (used
) == NAMESPACE_DECL
);
3910 /* Check if we already have this. */
3911 t
= purpose_member (used
, DECL_NAMESPACE_USING (user
));
3915 /* Promote to direct usage. */
3916 TREE_INDIRECT_USING (t
) = 0;
3920 /* Add used to the user's using list. */
3921 DECL_NAMESPACE_USING (user
)
3922 = tree_cons (used
, namespace_ancestor (user
, used
),
3923 DECL_NAMESPACE_USING (user
));
3925 TREE_INDIRECT_USING (DECL_NAMESPACE_USING (user
)) = indirect
;
3927 /* Add user to the used's users list. */
3928 DECL_NAMESPACE_USERS (used
)
3929 = tree_cons (user
, 0, DECL_NAMESPACE_USERS (used
));
3931 /* Recursively add all namespaces used. */
3932 for (t
= DECL_NAMESPACE_USING (used
); t
; t
= TREE_CHAIN (t
))
3933 /* indirect usage */
3934 add_using_namespace_1 (user
, TREE_PURPOSE (t
), 1);
3936 /* Tell everyone using us about the new used namespaces. */
3937 for (t
= DECL_NAMESPACE_USERS (user
); t
; t
= TREE_CHAIN (t
))
3938 add_using_namespace_1 (TREE_PURPOSE (t
), used
, 1);
3941 /* Wrapper for add_using_namespace_1. */
3944 add_using_namespace (tree user
, tree used
, bool indirect
)
3946 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
3947 add_using_namespace_1 (user
, used
, indirect
);
3948 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
3951 /* Process a using-declaration not appearing in class or local scope. */
3954 do_toplevel_using_decl (tree decl
, tree scope
, tree name
)
3956 tree oldval
, oldtype
, newval
, newtype
;
3957 tree orig_decl
= decl
;
3958 cxx_binding
*binding
;
3960 decl
= validate_nonmember_using_decl (decl
, scope
, name
);
3961 if (decl
== NULL_TREE
)
3964 binding
= binding_for_name (NAMESPACE_LEVEL (current_namespace
), name
);
3966 oldval
= binding
->value
;
3967 oldtype
= binding
->type
;
3969 do_nonmember_using_decl (scope
, name
, oldval
, oldtype
, &newval
, &newtype
);
3971 /* Emit debug info. */
3972 if (!processing_template_decl
)
3973 cp_emit_debug_info_for_using (orig_decl
, current_namespace
);
3975 /* Copy declarations found. */
3977 binding
->value
= newval
;
3979 binding
->type
= newtype
;
3982 /* Process a using-directive. */
3985 do_using_directive (tree name_space
)
3987 tree context
= NULL_TREE
;
3989 if (name_space
== error_mark_node
)
3992 gcc_assert (TREE_CODE (name_space
) == NAMESPACE_DECL
);
3994 if (building_stmt_list_p ())
3995 add_stmt (build_stmt (input_location
, USING_STMT
, name_space
));
3996 name_space
= ORIGINAL_NAMESPACE (name_space
);
3998 if (!toplevel_bindings_p ())
4000 push_using_directive (name_space
);
4005 add_using_namespace (current_namespace
, name_space
, 0);
4006 if (current_namespace
!= global_namespace
)
4007 context
= current_namespace
;
4009 /* Emit debugging info. */
4010 if (!processing_template_decl
)
4011 (*debug_hooks
->imported_module_or_decl
) (name_space
, NULL_TREE
,
4016 /* Deal with a using-directive seen by the parser. Currently we only
4017 handle attributes here, since they cannot appear inside a template. */
4020 parse_using_directive (tree name_space
, tree attribs
)
4024 do_using_directive (name_space
);
4026 for (a
= attribs
; a
; a
= TREE_CHAIN (a
))
4028 tree name
= TREE_PURPOSE (a
);
4029 if (is_attribute_p ("strong", name
))
4031 if (!toplevel_bindings_p ())
4032 error ("strong using only meaningful at namespace scope");
4033 else if (name_space
!= error_mark_node
)
4035 if (!is_ancestor (current_namespace
, name_space
))
4036 error ("current namespace %qD does not enclose strongly used namespace %qD",
4037 current_namespace
, name_space
);
4038 DECL_NAMESPACE_ASSOCIATIONS (name_space
)
4039 = tree_cons (current_namespace
, 0,
4040 DECL_NAMESPACE_ASSOCIATIONS (name_space
));
4044 warning (OPT_Wattributes
, "%qD attribute directive ignored", name
);
4048 /* Like pushdecl, only it places X in the global scope if appropriate.
4049 Calls cp_finish_decl to register the variable, initializing it with
4050 *INIT, if INIT is non-NULL. */
4053 pushdecl_top_level_1 (tree x
, tree
*init
, bool is_friend
)
4055 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
4056 push_to_top_level ();
4057 x
= pushdecl_namespace_level (x
, is_friend
);
4059 cp_finish_decl (x
, *init
, false, NULL_TREE
, 0);
4060 pop_from_top_level ();
4061 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
4065 /* Like pushdecl, only it places X in the global scope if appropriate. */
4068 pushdecl_top_level (tree x
)
4070 return pushdecl_top_level_1 (x
, NULL
, false);
4073 /* Like pushdecl_top_level, but adding the IS_FRIEND parameter. */
4076 pushdecl_top_level_maybe_friend (tree x
, bool is_friend
)
4078 return pushdecl_top_level_1 (x
, NULL
, is_friend
);
4081 /* Like pushdecl, only it places X in the global scope if
4082 appropriate. Calls cp_finish_decl to register the variable,
4083 initializing it with INIT. */
4086 pushdecl_top_level_and_finish (tree x
, tree init
)
4088 return pushdecl_top_level_1 (x
, &init
, false);
4091 /* Combines two sets of overloaded functions into an OVERLOAD chain, removing
4092 duplicates. The first list becomes the tail of the result.
4094 The algorithm is O(n^2). We could get this down to O(n log n) by
4095 doing a sort on the addresses of the functions, if that becomes
4099 merge_functions (tree s1
, tree s2
)
4101 for (; s2
; s2
= OVL_NEXT (s2
))
4103 tree fn2
= OVL_CURRENT (s2
);
4106 for (fns1
= s1
; fns1
; fns1
= OVL_NEXT (fns1
))
4108 tree fn1
= OVL_CURRENT (fns1
);
4110 /* If the function from S2 is already in S1, there is no
4111 need to add it again. For `extern "C"' functions, we
4112 might have two FUNCTION_DECLs for the same function, in
4113 different namespaces, but let's leave them in in case
4114 they have different default arguments. */
4119 /* If we exhausted all of the functions in S1, FN2 is new. */
4121 s1
= build_overload (fn2
, s1
);
4126 /* Returns TRUE iff OLD and NEW are the same entity.
4128 3 [basic]/3: An entity is a value, object, reference, function,
4129 enumerator, type, class member, template, template specialization,
4130 namespace, parameter pack, or this.
4132 7.3.4 [namespace.udir]/4: If name lookup finds a declaration for a name
4133 in two different namespaces, and the declarations do not declare the
4134 same entity and do not declare functions, the use of the name is
4138 same_entity_p (tree one
, tree two
)
4144 if (TREE_CODE (one
) == TYPE_DECL
4145 && TREE_CODE (two
) == TYPE_DECL
4146 && same_type_p (TREE_TYPE (one
), TREE_TYPE (two
)))
4151 /* This should return an error not all definitions define functions.
4152 It is not an error if we find two functions with exactly the
4153 same signature, only if these are selected in overload resolution.
4154 old is the current set of bindings, new_binding the freshly-found binding.
4155 XXX Do we want to give *all* candidates in case of ambiguity?
4156 XXX In what way should I treat extern declarations?
4157 XXX I don't want to repeat the entire duplicate_decls here */
4160 ambiguous_decl (struct scope_binding
*old
, cxx_binding
*new_binding
, int flags
)
4163 gcc_assert (old
!= NULL
);
4165 /* Copy the type. */
4166 type
= new_binding
->type
;
4167 if (LOOKUP_NAMESPACES_ONLY (flags
)
4168 || (type
&& hidden_name_p (type
) && !(flags
& LOOKUP_HIDDEN
)))
4171 /* Copy the value. */
4172 val
= new_binding
->value
;
4175 if (hidden_name_p (val
) && !(flags
& LOOKUP_HIDDEN
))
4178 switch (TREE_CODE (val
))
4181 /* If we expect types or namespaces, and not templates,
4182 or this is not a template class. */
4183 if ((LOOKUP_QUALIFIERS_ONLY (flags
)
4184 && !DECL_TYPE_TEMPLATE_P (val
)))
4188 if (LOOKUP_NAMESPACES_ONLY (flags
)
4189 || (type
&& (flags
& LOOKUP_PREFER_TYPES
)))
4192 case NAMESPACE_DECL
:
4193 if (LOOKUP_TYPES_ONLY (flags
))
4197 /* Ignore built-in functions that are still anticipated. */
4198 if (LOOKUP_QUALIFIERS_ONLY (flags
))
4202 if (LOOKUP_QUALIFIERS_ONLY (flags
))
4207 /* If val is hidden, shift down any class or enumeration name. */
4216 else if (val
&& !same_entity_p (val
, old
->value
))
4218 if (is_overloaded_fn (old
->value
) && is_overloaded_fn (val
))
4219 old
->value
= merge_functions (old
->value
, val
);
4222 old
->value
= tree_cons (NULL_TREE
, old
->value
,
4223 build_tree_list (NULL_TREE
, val
));
4224 TREE_TYPE (old
->value
) = error_mark_node
;
4230 else if (type
&& old
->type
!= type
)
4232 old
->type
= tree_cons (NULL_TREE
, old
->type
,
4233 build_tree_list (NULL_TREE
, type
));
4234 TREE_TYPE (old
->type
) = error_mark_node
;
4238 /* Return the declarations that are members of the namespace NS. */
4241 cp_namespace_decls (tree ns
)
4243 return NAMESPACE_LEVEL (ns
)->names
;
4246 /* Combine prefer_type and namespaces_only into flags. */
4249 lookup_flags (int prefer_type
, int namespaces_only
)
4251 if (namespaces_only
)
4252 return LOOKUP_PREFER_NAMESPACES
;
4253 if (prefer_type
> 1)
4254 return LOOKUP_PREFER_TYPES
;
4255 if (prefer_type
> 0)
4256 return LOOKUP_PREFER_BOTH
;
4260 /* Given a lookup that returned VAL, use FLAGS to decide if we want to
4261 ignore it or not. Subroutine of lookup_name_real and
4262 lookup_type_scope. */
4265 qualify_lookup (tree val
, int flags
)
4267 if (val
== NULL_TREE
)
4269 if ((flags
& LOOKUP_PREFER_NAMESPACES
) && TREE_CODE (val
) == NAMESPACE_DECL
)
4271 if (flags
& LOOKUP_PREFER_TYPES
)
4273 tree target_val
= strip_using_decl (val
);
4274 if (TREE_CODE (target_val
) == TYPE_DECL
4275 || TREE_CODE (target_val
) == TEMPLATE_DECL
)
4278 if (flags
& (LOOKUP_PREFER_NAMESPACES
| LOOKUP_PREFER_TYPES
))
4280 /* Look through lambda things that we shouldn't be able to see. */
4281 if (is_lambda_ignored_entity (val
))
4286 /* Given a lookup that returned VAL, decide if we want to ignore it or
4287 not based on DECL_ANTICIPATED. */
4290 hidden_name_p (tree val
)
4293 && DECL_LANG_SPECIFIC (val
)
4294 && TYPE_FUNCTION_OR_TEMPLATE_DECL_P (val
)
4295 && DECL_ANTICIPATED (val
))
4300 /* Remove any hidden friend functions from a possibly overloaded set
4304 remove_hidden_names (tree fns
)
4309 if (TREE_CODE (fns
) == FUNCTION_DECL
&& hidden_name_p (fns
))
4311 else if (TREE_CODE (fns
) == OVERLOAD
)
4315 for (o
= fns
; o
; o
= OVL_NEXT (o
))
4316 if (hidden_name_p (OVL_CURRENT (o
)))
4322 for (o
= fns
; o
; o
= OVL_NEXT (o
))
4323 if (!hidden_name_p (OVL_CURRENT (o
)))
4324 n
= build_overload (OVL_CURRENT (o
), n
);
4332 /* Suggest alternatives for NAME, an IDENTIFIER_NODE for which name
4333 lookup failed. Search through all available namespaces and print out
4334 possible candidates. */
4337 suggest_alternatives_for (location_t location
, tree name
)
4339 vec
<tree
> candidates
= vNULL
;
4340 vec
<tree
> namespaces_to_search
= vNULL
;
4341 int max_to_search
= PARAM_VALUE (CXX_MAX_NAMESPACES_FOR_DIAGNOSTIC_HELP
);
4346 namespaces_to_search
.safe_push (global_namespace
);
4348 while (!namespaces_to_search
.is_empty ()
4349 && n_searched
< max_to_search
)
4351 tree scope
= namespaces_to_search
.pop ();
4352 struct scope_binding binding
= EMPTY_SCOPE_BINDING
;
4353 cp_binding_level
*level
= NAMESPACE_LEVEL (scope
);
4355 /* Look in this namespace. */
4356 qualified_lookup_using_namespace (name
, scope
, &binding
, 0);
4361 candidates
.safe_push (binding
.value
);
4363 /* Add child namespaces. */
4364 for (t
= level
->namespaces
; t
; t
= DECL_CHAIN (t
))
4365 namespaces_to_search
.safe_push (t
);
4368 /* If we stopped before we could examine all namespaces, inform the
4369 user. Do this even if we don't have any candidates, since there
4370 might be more candidates further down that we weren't able to
4372 if (n_searched
>= max_to_search
4373 && !namespaces_to_search
.is_empty ())
4375 "maximum limit of %d namespaces searched for %qE",
4376 max_to_search
, name
);
4378 namespaces_to_search
.release ();
4380 /* Nothing useful to report. */
4381 if (candidates
.is_empty ())
4384 inform_n (location
, candidates
.length (),
4385 "suggested alternative:",
4386 "suggested alternatives:");
4388 FOR_EACH_VEC_ELT (candidates
, ix
, t
)
4389 inform (location_of (t
), " %qE", t
);
4391 candidates
.release ();
4394 /* Unscoped lookup of a global: iterate over current namespaces,
4395 considering using-directives. */
4398 unqualified_namespace_lookup_1 (tree name
, int flags
)
4400 tree initial
= current_decl_namespace ();
4401 tree scope
= initial
;
4403 cp_binding_level
*level
;
4404 tree val
= NULL_TREE
;
4406 for (; !val
; scope
= CP_DECL_CONTEXT (scope
))
4408 struct scope_binding binding
= EMPTY_SCOPE_BINDING
;
4410 cp_binding_level_find_binding_for_name (NAMESPACE_LEVEL (scope
), name
);
4413 ambiguous_decl (&binding
, b
, flags
);
4415 /* Add all _DECLs seen through local using-directives. */
4416 for (level
= current_binding_level
;
4417 level
->kind
!= sk_namespace
;
4418 level
= level
->level_chain
)
4419 if (!lookup_using_namespace (name
, &binding
, level
->using_directives
,
4421 /* Give up because of error. */
4422 return error_mark_node
;
4424 /* Add all _DECLs seen through global using-directives. */
4425 /* XXX local and global using lists should work equally. */
4429 if (!lookup_using_namespace (name
, &binding
,
4430 DECL_NAMESPACE_USING (siter
),
4432 /* Give up because of error. */
4433 return error_mark_node
;
4434 if (siter
== scope
) break;
4435 siter
= CP_DECL_CONTEXT (siter
);
4438 val
= binding
.value
;
4439 if (scope
== global_namespace
)
4445 /* Wrapper for unqualified_namespace_lookup_1. */
4448 unqualified_namespace_lookup (tree name
, int flags
)
4451 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
4452 ret
= unqualified_namespace_lookup_1 (name
, flags
);
4453 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
4457 /* Look up NAME (an IDENTIFIER_NODE) in SCOPE (either a NAMESPACE_DECL
4458 or a class TYPE). If IS_TYPE_P is TRUE, then ignore non-type
4461 Returns a DECL (or OVERLOAD, or BASELINK) representing the
4462 declaration found. If no suitable declaration can be found,
4463 ERROR_MARK_NODE is returned. If COMPLAIN is true and SCOPE is
4464 neither a class-type nor a namespace a diagnostic is issued. */
4467 lookup_qualified_name (tree scope
, tree name
, bool is_type_p
, bool complain
)
4472 if (TREE_CODE (scope
) == NAMESPACE_DECL
)
4474 struct scope_binding binding
= EMPTY_SCOPE_BINDING
;
4477 flags
|= LOOKUP_PREFER_TYPES
;
4478 if (qualified_lookup_using_namespace (name
, scope
, &binding
, flags
))
4481 else if (cxx_dialect
!= cxx98
&& TREE_CODE (scope
) == ENUMERAL_TYPE
)
4482 t
= lookup_enumerator (scope
, name
);
4483 else if (is_class_type (scope
, complain
))
4484 t
= lookup_member (scope
, name
, 2, is_type_p
, tf_warning_or_error
);
4487 return error_mark_node
;
4491 /* Subroutine of unqualified_namespace_lookup:
4492 Add the bindings of NAME in used namespaces to VAL.
4493 We are currently looking for names in namespace SCOPE, so we
4494 look through USINGS for using-directives of namespaces
4495 which have SCOPE as a common ancestor with the current scope.
4496 Returns false on errors. */
4499 lookup_using_namespace (tree name
, struct scope_binding
*val
,
4500 tree usings
, tree scope
, int flags
)
4503 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
4504 /* Iterate over all used namespaces in current, searching for using
4505 directives of scope. */
4506 for (iter
= usings
; iter
; iter
= TREE_CHAIN (iter
))
4507 if (TREE_VALUE (iter
) == scope
)
4509 tree used
= ORIGINAL_NAMESPACE (TREE_PURPOSE (iter
));
4511 cp_binding_level_find_binding_for_name (NAMESPACE_LEVEL (used
), name
);
4512 /* Resolve ambiguities. */
4514 ambiguous_decl (val
, val1
, flags
);
4516 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
4517 return val
->value
!= error_mark_node
;
4520 /* Returns true iff VEC contains TARGET. */
4523 tree_vec_contains (vec
<tree
, va_gc
> *vec
, tree target
)
4527 FOR_EACH_VEC_SAFE_ELT (vec
,i
,elt
)
4534 Accepts the NAME to lookup and its qualifying SCOPE.
4535 Returns the name/type pair found into the cxx_binding *RESULT,
4536 or false on error. */
4539 qualified_lookup_using_namespace (tree name
, tree scope
,
4540 struct scope_binding
*result
, int flags
)
4542 /* Maintain a list of namespaces visited... */
4543 vec
<tree
, va_gc
> *seen
= NULL
;
4544 vec
<tree
, va_gc
> *seen_inline
= NULL
;
4545 /* ... and a list of namespace yet to see. */
4546 vec
<tree
, va_gc
> *todo
= NULL
;
4547 vec
<tree
, va_gc
> *todo_maybe
= NULL
;
4548 vec
<tree
, va_gc
> *todo_inline
= NULL
;
4550 timevar_start (TV_NAME_LOOKUP
);
4551 /* Look through namespace aliases. */
4552 scope
= ORIGINAL_NAMESPACE (scope
);
4554 /* Algorithm: Starting with SCOPE, walk through the set of used
4555 namespaces. For each used namespace, look through its inline
4556 namespace set for any bindings and usings. If no bindings are
4557 found, add any usings seen to the set of used namespaces. */
4558 vec_safe_push (todo
, scope
);
4560 while (todo
->length ())
4563 scope
= todo
->pop ();
4564 if (tree_vec_contains (seen
, scope
))
4566 vec_safe_push (seen
, scope
);
4567 vec_safe_push (todo_inline
, scope
);
4570 while (todo_inline
->length ())
4572 cxx_binding
*binding
;
4574 scope
= todo_inline
->pop ();
4575 if (tree_vec_contains (seen_inline
, scope
))
4577 vec_safe_push (seen_inline
, scope
);
4580 cp_binding_level_find_binding_for_name (NAMESPACE_LEVEL (scope
), name
);
4584 ambiguous_decl (result
, binding
, flags
);
4587 for (usings
= DECL_NAMESPACE_USING (scope
); usings
;
4588 usings
= TREE_CHAIN (usings
))
4589 if (!TREE_INDIRECT_USING (usings
))
4591 if (is_associated_namespace (scope
, TREE_PURPOSE (usings
)))
4592 vec_safe_push (todo_inline
, TREE_PURPOSE (usings
));
4594 vec_safe_push (todo_maybe
, TREE_PURPOSE (usings
));
4599 vec_safe_truncate (todo_maybe
, 0);
4601 while (vec_safe_length (todo_maybe
))
4602 vec_safe_push (todo
, todo_maybe
->pop ());
4605 vec_free (todo_maybe
);
4606 vec_free (todo_inline
);
4608 vec_free (seen_inline
);
4609 timevar_stop (TV_NAME_LOOKUP
);
4610 return result
->value
!= error_mark_node
;
4613 /* Subroutine of outer_binding.
4615 Returns TRUE if BINDING is a binding to a template parameter of
4616 SCOPE. In that case SCOPE is the scope of a primary template
4617 parameter -- in the sense of G++, i.e, a template that has its own
4620 Returns FALSE otherwise. */
4623 binding_to_template_parms_of_scope_p (cxx_binding
*binding
,
4624 cp_binding_level
*scope
)
4626 tree binding_value
, tmpl
, tinfo
;
4629 if (!binding
|| !scope
|| !scope
->this_entity
)
4632 binding_value
= binding
->value
? binding
->value
: binding
->type
;
4633 tinfo
= get_template_info (scope
->this_entity
);
4635 /* BINDING_VALUE must be a template parm. */
4636 if (binding_value
== NULL_TREE
4637 || (!DECL_P (binding_value
)
4638 || !DECL_TEMPLATE_PARM_P (binding_value
)))
4641 /* The level of BINDING_VALUE. */
4643 template_type_parameter_p (binding_value
)
4644 ? TEMPLATE_PARM_LEVEL (TEMPLATE_TYPE_PARM_INDEX
4645 (TREE_TYPE (binding_value
)))
4646 : TEMPLATE_PARM_LEVEL (DECL_INITIAL (binding_value
));
4648 /* The template of the current scope, iff said scope is a primary
4651 && PRIMARY_TEMPLATE_P (TI_TEMPLATE (tinfo
))
4652 ? TI_TEMPLATE (tinfo
)
4655 /* If the level of the parm BINDING_VALUE equals the depth of TMPL,
4656 then BINDING_VALUE is a parameter of TMPL. */
4657 return (tmpl
&& level
== TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (tmpl
)));
4660 /* Return the innermost non-namespace binding for NAME from a scope
4661 containing BINDING, or, if BINDING is NULL, the current scope.
4662 Please note that for a given template, the template parameters are
4663 considered to be in the scope containing the current scope.
4664 If CLASS_P is false, then class bindings are ignored. */
4667 outer_binding (tree name
,
4668 cxx_binding
*binding
,
4672 cp_binding_level
*scope
;
4673 cp_binding_level
*outer_scope
;
4677 scope
= binding
->scope
->level_chain
;
4678 outer
= binding
->previous
;
4682 scope
= current_binding_level
;
4683 outer
= IDENTIFIER_BINDING (name
);
4685 outer_scope
= outer
? outer
->scope
: NULL
;
4687 /* Because we create class bindings lazily, we might be missing a
4688 class binding for NAME. If there are any class binding levels
4689 between the LAST_BINDING_LEVEL and the scope in which OUTER was
4690 declared, we must lookup NAME in those class scopes. */
4692 while (scope
&& scope
!= outer_scope
&& scope
->kind
!= sk_namespace
)
4694 if (scope
->kind
== sk_class
)
4696 cxx_binding
*class_binding
;
4698 class_binding
= get_class_binding (name
, scope
);
4701 /* Thread this new class-scope binding onto the
4702 IDENTIFIER_BINDING list so that future lookups
4704 class_binding
->previous
= outer
;
4706 binding
->previous
= class_binding
;
4708 IDENTIFIER_BINDING (name
) = class_binding
;
4709 return class_binding
;
4712 /* If we are in a member template, the template parms of the member
4713 template are considered to be inside the scope of the containing
4714 class, but within G++ the class bindings are all pushed between the
4715 template parms and the function body. So if the outer binding is
4716 a template parm for the current scope, return it now rather than
4717 look for a class binding. */
4718 if (outer_scope
&& outer_scope
->kind
== sk_template_parms
4719 && binding_to_template_parms_of_scope_p (outer
, scope
))
4722 scope
= scope
->level_chain
;
4728 /* Return the innermost block-scope or class-scope value binding for
4729 NAME, or NULL_TREE if there is no such binding. */
4732 innermost_non_namespace_value (tree name
)
4734 cxx_binding
*binding
;
4735 binding
= outer_binding (name
, /*binding=*/NULL
, /*class_p=*/true);
4736 return binding
? binding
->value
: NULL_TREE
;
4739 /* Look up NAME in the current binding level and its superiors in the
4740 namespace of variables, functions and typedefs. Return a ..._DECL
4741 node of some kind representing its definition if there is only one
4742 such declaration, or return a TREE_LIST with all the overloaded
4743 definitions if there are many, or return 0 if it is undefined.
4744 Hidden name, either friend declaration or built-in function, are
4747 If PREFER_TYPE is > 0, we prefer TYPE_DECLs or namespaces.
4748 If PREFER_TYPE is > 1, we reject non-type decls (e.g. namespaces).
4749 Otherwise we prefer non-TYPE_DECLs.
4751 If NONCLASS is nonzero, bindings in class scopes are ignored. If
4752 BLOCK_P is false, bindings in block scopes are ignored. */
4755 lookup_name_real_1 (tree name
, int prefer_type
, int nonclass
, bool block_p
,
4756 int namespaces_only
, int flags
)
4759 tree val
= NULL_TREE
;
4761 /* Conversion operators are handled specially because ordinary
4762 unqualified name lookup will not find template conversion
4764 if (IDENTIFIER_TYPENAME_P (name
))
4766 cp_binding_level
*level
;
4768 for (level
= current_binding_level
;
4769 level
&& level
->kind
!= sk_namespace
;
4770 level
= level
->level_chain
)
4775 /* A conversion operator can only be declared in a class
4777 if (level
->kind
!= sk_class
)
4780 /* Lookup the conversion operator in the class. */
4781 class_type
= level
->this_entity
;
4782 operators
= lookup_fnfields (class_type
, name
, /*protect=*/0);
4790 flags
|= lookup_flags (prefer_type
, namespaces_only
);
4792 /* First, look in non-namespace scopes. */
4794 if (current_class_type
== NULL_TREE
)
4797 if (block_p
|| !nonclass
)
4798 for (iter
= outer_binding (name
, NULL
, !nonclass
);
4800 iter
= outer_binding (name
, iter
, !nonclass
))
4804 /* Skip entities we don't want. */
4805 if (LOCAL_BINDING_P (iter
) ? !block_p
: nonclass
)
4808 /* If this is the kind of thing we're looking for, we're done. */
4809 if (qualify_lookup (iter
->value
, flags
))
4810 binding
= iter
->value
;
4811 else if ((flags
& LOOKUP_PREFER_TYPES
)
4812 && qualify_lookup (iter
->type
, flags
))
4813 binding
= iter
->type
;
4815 binding
= NULL_TREE
;
4819 if (hidden_name_p (binding
))
4821 /* A non namespace-scope binding can only be hidden in the
4822 presence of a local class, due to friend declarations.
4824 In particular, consider:
4832 B* b; // error: B is hidden
4833 C* c; // OK, finds ::C
4836 B *b; // error: B is hidden
4837 C *c; // OK, finds ::C
4842 The standard says that "B" is a local class in "f"
4843 (but not nested within "A") -- but that name lookup
4844 for "B" does not find this declaration until it is
4845 declared directly with "f".
4851 If a friend declaration appears in a local class and
4852 the name specified is an unqualified name, a prior
4853 declaration is looked up without considering scopes
4854 that are outside the innermost enclosing non-class
4855 scope. For a friend function declaration, if there is
4856 no prior declaration, the program is ill-formed. For a
4857 friend class declaration, if there is no prior
4858 declaration, the class that is specified belongs to the
4859 innermost enclosing non-class scope, but if it is
4860 subsequently referenced, its name is not found by name
4861 lookup until a matching declaration is provided in the
4862 innermost enclosing nonclass scope.
4864 So just keep looking for a non-hidden binding.
4866 gcc_assert (TREE_CODE (binding
) == TYPE_DECL
);
4874 /* Now lookup in namespace scopes. */
4876 val
= unqualified_namespace_lookup (name
, flags
);
4878 /* If we have a single function from a using decl, pull it out. */
4879 if (val
&& TREE_CODE (val
) == OVERLOAD
&& !really_overloaded_fn (val
))
4880 val
= OVL_FUNCTION (val
);
4885 /* Wrapper for lookup_name_real_1. */
4888 lookup_name_real (tree name
, int prefer_type
, int nonclass
, bool block_p
,
4889 int namespaces_only
, int flags
)
4892 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
4893 ret
= lookup_name_real_1 (name
, prefer_type
, nonclass
, block_p
,
4894 namespaces_only
, flags
);
4895 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
4900 lookup_name_nonclass (tree name
)
4902 return lookup_name_real (name
, 0, 1, /*block_p=*/true, 0, 0);
4906 lookup_function_nonclass (tree name
, vec
<tree
, va_gc
> *args
, bool block_p
)
4909 lookup_arg_dependent (name
,
4910 lookup_name_real (name
, 0, 1, block_p
, 0, 0),
4915 lookup_name (tree name
)
4917 return lookup_name_real (name
, 0, 0, /*block_p=*/true, 0, 0);
4921 lookup_name_prefer_type (tree name
, int prefer_type
)
4923 return lookup_name_real (name
, prefer_type
, 0, /*block_p=*/true, 0, 0);
4926 /* Look up NAME for type used in elaborated name specifier in
4927 the scopes given by SCOPE. SCOPE can be either TS_CURRENT or
4928 TS_WITHIN_ENCLOSING_NON_CLASS. Although not implied by the
4929 name, more scopes are checked if cleanup or template parameter
4930 scope is encountered.
4932 Unlike lookup_name_real, we make sure that NAME is actually
4933 declared in the desired scope, not from inheritance, nor using
4934 directive. For using declaration, there is DR138 still waiting
4935 to be resolved. Hidden name coming from an earlier friend
4936 declaration is also returned.
4938 A TYPE_DECL best matching the NAME is returned. Catching error
4939 and issuing diagnostics are caller's responsibility. */
4942 lookup_type_scope_1 (tree name
, tag_scope scope
)
4944 cxx_binding
*iter
= NULL
;
4945 tree val
= NULL_TREE
;
4947 /* Look in non-namespace scope first. */
4948 if (current_binding_level
->kind
!= sk_namespace
)
4949 iter
= outer_binding (name
, NULL
, /*class_p=*/ true);
4950 for (; iter
; iter
= outer_binding (name
, iter
, /*class_p=*/ true))
4952 /* Check if this is the kind of thing we're looking for.
4953 If SCOPE is TS_CURRENT, also make sure it doesn't come from
4954 base class. For ITER->VALUE, we can simply use
4955 INHERITED_VALUE_BINDING_P. For ITER->TYPE, we have to use
4958 We check ITER->TYPE before ITER->VALUE in order to handle
4959 typedef struct C {} C;
4962 if (qualify_lookup (iter
->type
, LOOKUP_PREFER_TYPES
)
4963 && (scope
!= ts_current
4964 || LOCAL_BINDING_P (iter
)
4965 || DECL_CONTEXT (iter
->type
) == iter
->scope
->this_entity
))
4967 else if ((scope
!= ts_current
4968 || !INHERITED_VALUE_BINDING_P (iter
))
4969 && qualify_lookup (iter
->value
, LOOKUP_PREFER_TYPES
))
4976 /* Look in namespace scope. */
4979 iter
= cp_binding_level_find_binding_for_name
4980 (NAMESPACE_LEVEL (current_decl_namespace ()), name
);
4984 /* If this is the kind of thing we're looking for, we're done. */
4985 if (qualify_lookup (iter
->type
, LOOKUP_PREFER_TYPES
))
4987 else if (qualify_lookup (iter
->value
, LOOKUP_PREFER_TYPES
))
4993 /* Type found, check if it is in the allowed scopes, ignoring cleanup
4994 and template parameter scopes. */
4997 cp_binding_level
*b
= current_binding_level
;
5000 if (iter
->scope
== b
)
5003 if (b
->kind
== sk_cleanup
|| b
->kind
== sk_template_parms
5004 || b
->kind
== sk_function_parms
)
5006 else if (b
->kind
== sk_class
5007 && scope
== ts_within_enclosing_non_class
)
5017 /* Wrapper for lookup_type_scope_1. */
5020 lookup_type_scope (tree name
, tag_scope scope
)
5023 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
5024 ret
= lookup_type_scope_1 (name
, scope
);
5025 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
5030 /* Similar to `lookup_name' but look only in the innermost non-class
5034 lookup_name_innermost_nonclass_level_1 (tree name
)
5036 cp_binding_level
*b
;
5039 b
= innermost_nonclass_level ();
5041 if (b
->kind
== sk_namespace
)
5043 t
= IDENTIFIER_NAMESPACE_VALUE (name
);
5045 /* extern "C" function() */
5046 if (t
!= NULL_TREE
&& TREE_CODE (t
) == TREE_LIST
)
5049 else if (IDENTIFIER_BINDING (name
)
5050 && LOCAL_BINDING_P (IDENTIFIER_BINDING (name
)))
5052 cxx_binding
*binding
;
5053 binding
= IDENTIFIER_BINDING (name
);
5056 if (binding
->scope
== b
5057 && !(VAR_P (binding
->value
)
5058 && DECL_DEAD_FOR_LOCAL (binding
->value
)))
5059 return binding
->value
;
5061 if (b
->kind
== sk_cleanup
)
5071 /* Wrapper for lookup_name_innermost_nonclass_level_1. */
5074 lookup_name_innermost_nonclass_level (tree name
)
5077 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
5078 ret
= lookup_name_innermost_nonclass_level_1 (name
);
5079 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
5084 /* Returns true iff DECL is a block-scope extern declaration of a function
5088 is_local_extern (tree decl
)
5090 cxx_binding
*binding
;
5092 /* For functions, this is easy. */
5093 if (TREE_CODE (decl
) == FUNCTION_DECL
)
5094 return DECL_LOCAL_FUNCTION_P (decl
);
5098 if (!current_function_decl
)
5101 /* For variables, this is not easy. We need to look at the binding stack
5102 for the identifier to see whether the decl we have is a local. */
5103 for (binding
= IDENTIFIER_BINDING (DECL_NAME (decl
));
5104 binding
&& binding
->scope
->kind
!= sk_namespace
;
5105 binding
= binding
->previous
)
5106 if (binding
->value
== decl
)
5107 return LOCAL_BINDING_P (binding
);
5112 /* Like lookup_name_innermost_nonclass_level, but for types. */
5115 lookup_type_current_level (tree name
)
5119 timevar_start (TV_NAME_LOOKUP
);
5120 gcc_assert (current_binding_level
->kind
!= sk_namespace
);
5122 if (REAL_IDENTIFIER_TYPE_VALUE (name
) != NULL_TREE
5123 && REAL_IDENTIFIER_TYPE_VALUE (name
) != global_type_node
)
5125 cp_binding_level
*b
= current_binding_level
;
5128 if (purpose_member (name
, b
->type_shadowed
))
5130 t
= REAL_IDENTIFIER_TYPE_VALUE (name
);
5133 if (b
->kind
== sk_cleanup
)
5140 timevar_stop (TV_NAME_LOOKUP
);
5144 /* [basic.lookup.koenig] */
5145 /* A nonzero return value in the functions below indicates an error. */
5150 vec
<tree
, va_gc
> *args
;
5151 vec
<tree
, va_gc
> *namespaces
;
5152 vec
<tree
, va_gc
> *classes
;
5154 struct pointer_set_t
*fn_set
;
5157 static bool arg_assoc (struct arg_lookup
*, tree
);
5158 static bool arg_assoc_args (struct arg_lookup
*, tree
);
5159 static bool arg_assoc_args_vec (struct arg_lookup
*, vec
<tree
, va_gc
> *);
5160 static bool arg_assoc_type (struct arg_lookup
*, tree
);
5161 static bool add_function (struct arg_lookup
*, tree
);
5162 static bool arg_assoc_namespace (struct arg_lookup
*, tree
);
5163 static bool arg_assoc_class_only (struct arg_lookup
*, tree
);
5164 static bool arg_assoc_bases (struct arg_lookup
*, tree
);
5165 static bool arg_assoc_class (struct arg_lookup
*, tree
);
5166 static bool arg_assoc_template_arg (struct arg_lookup
*, tree
);
5168 /* Add a function to the lookup structure.
5169 Returns true on error. */
5172 add_function (struct arg_lookup
*k
, tree fn
)
5174 if (!is_overloaded_fn (fn
))
5175 /* All names except those of (possibly overloaded) functions and
5176 function templates are ignored. */;
5177 else if (k
->fn_set
&& pointer_set_insert (k
->fn_set
, fn
))
5178 /* It's already in the list. */;
5179 else if (!k
->functions
)
5181 else if (fn
== k
->functions
)
5185 k
->functions
= build_overload (fn
, k
->functions
);
5186 if (TREE_CODE (k
->functions
) == OVERLOAD
)
5187 OVL_ARG_DEPENDENT (k
->functions
) = true;
5193 /* Returns true iff CURRENT has declared itself to be an associated
5194 namespace of SCOPE via a strong using-directive (or transitive chain
5195 thereof). Both are namespaces. */
5198 is_associated_namespace (tree current
, tree scope
)
5200 vec
<tree
, va_gc
> *seen
= make_tree_vector ();
5201 vec
<tree
, va_gc
> *todo
= make_tree_vector ();
5207 if (scope
== current
)
5212 vec_safe_push (seen
, scope
);
5213 for (t
= DECL_NAMESPACE_ASSOCIATIONS (scope
); t
; t
= TREE_CHAIN (t
))
5214 if (!vec_member (TREE_PURPOSE (t
), seen
))
5215 vec_safe_push (todo
, TREE_PURPOSE (t
));
5216 if (!todo
->is_empty ())
5218 scope
= todo
->last ();
5228 release_tree_vector (seen
);
5229 release_tree_vector (todo
);
5234 /* Add functions of a namespace to the lookup structure.
5235 Returns true on error. */
5238 arg_assoc_namespace (struct arg_lookup
*k
, tree scope
)
5242 if (vec_member (scope
, k
->namespaces
))
5244 vec_safe_push (k
->namespaces
, scope
);
5246 /* Check out our super-users. */
5247 for (value
= DECL_NAMESPACE_ASSOCIATIONS (scope
); value
;
5248 value
= TREE_CHAIN (value
))
5249 if (arg_assoc_namespace (k
, TREE_PURPOSE (value
)))
5252 /* Also look down into inline namespaces. */
5253 for (value
= DECL_NAMESPACE_USING (scope
); value
;
5254 value
= TREE_CHAIN (value
))
5255 if (is_associated_namespace (scope
, TREE_PURPOSE (value
)))
5256 if (arg_assoc_namespace (k
, TREE_PURPOSE (value
)))
5259 value
= namespace_binding (k
->name
, scope
);
5263 for (; value
; value
= OVL_NEXT (value
))
5265 /* We don't want to find arbitrary hidden functions via argument
5266 dependent lookup. We only want to find friends of associated
5267 classes, which we'll do via arg_assoc_class. */
5268 if (hidden_name_p (OVL_CURRENT (value
)))
5271 if (add_function (k
, OVL_CURRENT (value
)))
5278 /* Adds everything associated with a template argument to the lookup
5279 structure. Returns true on error. */
5282 arg_assoc_template_arg (struct arg_lookup
*k
, tree arg
)
5284 /* [basic.lookup.koenig]
5286 If T is a template-id, its associated namespaces and classes are
5287 ... the namespaces and classes associated with the types of the
5288 template arguments provided for template type parameters
5289 (excluding template template parameters); the namespaces in which
5290 any template template arguments are defined; and the classes in
5291 which any member templates used as template template arguments
5292 are defined. [Note: non-type template arguments do not
5293 contribute to the set of associated namespaces. ] */
5295 /* Consider first template template arguments. */
5296 if (TREE_CODE (arg
) == TEMPLATE_TEMPLATE_PARM
5297 || TREE_CODE (arg
) == UNBOUND_CLASS_TEMPLATE
)
5299 else if (TREE_CODE (arg
) == TEMPLATE_DECL
)
5301 tree ctx
= CP_DECL_CONTEXT (arg
);
5303 /* It's not a member template. */
5304 if (TREE_CODE (ctx
) == NAMESPACE_DECL
)
5305 return arg_assoc_namespace (k
, ctx
);
5306 /* Otherwise, it must be member template. */
5308 return arg_assoc_class_only (k
, ctx
);
5310 /* It's an argument pack; handle it recursively. */
5311 else if (ARGUMENT_PACK_P (arg
))
5313 tree args
= ARGUMENT_PACK_ARGS (arg
);
5314 int i
, len
= TREE_VEC_LENGTH (args
);
5315 for (i
= 0; i
< len
; ++i
)
5316 if (arg_assoc_template_arg (k
, TREE_VEC_ELT (args
, i
)))
5321 /* It's not a template template argument, but it is a type template
5323 else if (TYPE_P (arg
))
5324 return arg_assoc_type (k
, arg
);
5325 /* It's a non-type template argument. */
5330 /* Adds the class and its friends to the lookup structure.
5331 Returns true on error. */
5334 arg_assoc_class_only (struct arg_lookup
*k
, tree type
)
5336 tree list
, friends
, context
;
5338 /* Backend-built structures, such as __builtin_va_list, aren't
5339 affected by all this. */
5340 if (!CLASS_TYPE_P (type
))
5343 context
= decl_namespace_context (type
);
5344 if (arg_assoc_namespace (k
, context
))
5347 complete_type (type
);
5349 /* Process friends. */
5350 for (list
= DECL_FRIENDLIST (TYPE_MAIN_DECL (type
)); list
;
5351 list
= TREE_CHAIN (list
))
5352 if (k
->name
== FRIEND_NAME (list
))
5353 for (friends
= FRIEND_DECLS (list
); friends
;
5354 friends
= TREE_CHAIN (friends
))
5356 tree fn
= TREE_VALUE (friends
);
5358 /* Only interested in global functions with potentially hidden
5359 (i.e. unqualified) declarations. */
5360 if (CP_DECL_CONTEXT (fn
) != context
)
5362 /* Template specializations are never found by name lookup.
5363 (Templates themselves can be found, but not template
5364 specializations.) */
5365 if (TREE_CODE (fn
) == FUNCTION_DECL
&& DECL_USE_TEMPLATE (fn
))
5367 if (add_function (k
, fn
))
5374 /* Adds the class and its bases to the lookup structure.
5375 Returns true on error. */
5378 arg_assoc_bases (struct arg_lookup
*k
, tree type
)
5380 if (arg_assoc_class_only (k
, type
))
5383 if (TYPE_BINFO (type
))
5385 /* Process baseclasses. */
5386 tree binfo
, base_binfo
;
5389 for (binfo
= TYPE_BINFO (type
), i
= 0;
5390 BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); i
++)
5391 if (arg_assoc_bases (k
, BINFO_TYPE (base_binfo
)))
5398 /* Adds everything associated with a class argument type to the lookup
5399 structure. Returns true on error.
5401 If T is a class type (including unions), its associated classes are: the
5402 class itself; the class of which it is a member, if any; and its direct
5403 and indirect base classes. Its associated namespaces are the namespaces
5404 of which its associated classes are members. Furthermore, if T is a
5405 class template specialization, its associated namespaces and classes
5406 also include: the namespaces and classes associated with the types of
5407 the template arguments provided for template type parameters (excluding
5408 template template parameters); the namespaces of which any template
5409 template arguments are members; and the classes of which any member
5410 templates used as template template arguments are members. [ Note:
5411 non-type template arguments do not contribute to the set of associated
5412 namespaces. --end note] */
5415 arg_assoc_class (struct arg_lookup
*k
, tree type
)
5420 /* Backend build structures, such as __builtin_va_list, aren't
5421 affected by all this. */
5422 if (!CLASS_TYPE_P (type
))
5425 if (vec_member (type
, k
->classes
))
5427 vec_safe_push (k
->classes
, type
);
5429 if (TYPE_CLASS_SCOPE_P (type
)
5430 && arg_assoc_class_only (k
, TYPE_CONTEXT (type
)))
5433 if (arg_assoc_bases (k
, type
))
5436 /* Process template arguments. */
5437 if (CLASSTYPE_TEMPLATE_INFO (type
)
5438 && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (type
)))
5440 list
= INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (type
));
5441 for (i
= 0; i
< TREE_VEC_LENGTH (list
); ++i
)
5442 if (arg_assoc_template_arg (k
, TREE_VEC_ELT (list
, i
)))
5449 /* Adds everything associated with a given type.
5450 Returns 1 on error. */
5453 arg_assoc_type (struct arg_lookup
*k
, tree type
)
5455 /* As we do not get the type of non-type dependent expressions
5456 right, we can end up with such things without a type. */
5460 if (TYPE_PTRDATAMEM_P (type
))
5462 /* Pointer to member: associate class type and value type. */
5463 if (arg_assoc_type (k
, TYPE_PTRMEM_CLASS_TYPE (type
)))
5465 return arg_assoc_type (k
, TYPE_PTRMEM_POINTED_TO_TYPE (type
));
5467 else switch (TREE_CODE (type
))
5477 case FIXED_POINT_TYPE
:
5482 if (TYPE_PTRMEMFUNC_P (type
))
5483 return arg_assoc_type (k
, TYPE_PTRMEMFUNC_FN_TYPE (type
));
5485 return arg_assoc_class (k
, type
);
5487 case REFERENCE_TYPE
:
5489 return arg_assoc_type (k
, TREE_TYPE (type
));
5491 if (TYPE_CLASS_SCOPE_P (type
)
5492 && arg_assoc_class_only (k
, TYPE_CONTEXT (type
)))
5494 return arg_assoc_namespace (k
, decl_namespace_context (type
));
5496 /* The basetype is referenced in the first arg type, so just
5499 /* Associate the parameter types. */
5500 if (arg_assoc_args (k
, TYPE_ARG_TYPES (type
)))
5502 /* Associate the return type. */
5503 return arg_assoc_type (k
, TREE_TYPE (type
));
5504 case TEMPLATE_TYPE_PARM
:
5505 case BOUND_TEMPLATE_TEMPLATE_PARM
:
5510 gcc_assert (type
== unknown_type_node
5511 || type
== init_list_type_node
);
5513 case TYPE_PACK_EXPANSION
:
5514 return arg_assoc_type (k
, PACK_EXPANSION_PATTERN (type
));
5522 /* Adds everything associated with arguments. Returns true on error. */
5525 arg_assoc_args (struct arg_lookup
*k
, tree args
)
5527 for (; args
; args
= TREE_CHAIN (args
))
5528 if (arg_assoc (k
, TREE_VALUE (args
)))
5533 /* Adds everything associated with an argument vector. Returns true
5537 arg_assoc_args_vec (struct arg_lookup
*k
, vec
<tree
, va_gc
> *args
)
5542 FOR_EACH_VEC_SAFE_ELT (args
, ix
, arg
)
5543 if (arg_assoc (k
, arg
))
5548 /* Adds everything associated with a given tree_node. Returns 1 on error. */
5551 arg_assoc (struct arg_lookup
*k
, tree n
)
5553 if (n
== error_mark_node
)
5557 return arg_assoc_type (k
, n
);
5559 if (! type_unknown_p (n
))
5560 return arg_assoc_type (k
, TREE_TYPE (n
));
5562 if (TREE_CODE (n
) == ADDR_EXPR
)
5563 n
= TREE_OPERAND (n
, 0);
5564 if (TREE_CODE (n
) == COMPONENT_REF
)
5565 n
= TREE_OPERAND (n
, 1);
5566 if (TREE_CODE (n
) == OFFSET_REF
)
5567 n
= TREE_OPERAND (n
, 1);
5568 while (TREE_CODE (n
) == TREE_LIST
)
5571 n
= BASELINK_FUNCTIONS (n
);
5573 if (TREE_CODE (n
) == FUNCTION_DECL
)
5574 return arg_assoc_type (k
, TREE_TYPE (n
));
5575 if (TREE_CODE (n
) == TEMPLATE_ID_EXPR
)
5577 /* The working paper doesn't currently say how to handle template-id
5578 arguments. The sensible thing would seem to be to handle the list
5579 of template candidates like a normal overload set, and handle the
5580 template arguments like we do for class template
5582 tree templ
= TREE_OPERAND (n
, 0);
5583 tree args
= TREE_OPERAND (n
, 1);
5586 /* First the templates. */
5587 if (arg_assoc (k
, templ
))
5590 /* Now the arguments. */
5592 for (ix
= TREE_VEC_LENGTH (args
); ix
--;)
5593 if (arg_assoc_template_arg (k
, TREE_VEC_ELT (args
, ix
)) == 1)
5596 else if (TREE_CODE (n
) == OVERLOAD
)
5598 for (; n
; n
= OVL_NEXT (n
))
5599 if (arg_assoc_type (k
, TREE_TYPE (OVL_CURRENT (n
))))
5606 /* Performs Koenig lookup depending on arguments, where fns
5607 are the functions found in normal lookup. */
5610 lookup_arg_dependent_1 (tree name
, tree fns
, vec
<tree
, va_gc
> *args
)
5612 struct arg_lookup k
;
5614 /* Remove any hidden friend functions from the list of functions
5615 found so far. They will be added back by arg_assoc_class as
5617 fns
= remove_hidden_names (fns
);
5622 k
.classes
= make_tree_vector ();
5624 /* We previously performed an optimization here by setting
5625 NAMESPACES to the current namespace when it was safe. However, DR
5626 164 says that namespaces that were already searched in the first
5627 stage of template processing are searched again (potentially
5628 picking up later definitions) in the second stage. */
5629 k
.namespaces
= make_tree_vector ();
5631 /* We used to allow duplicates and let joust discard them, but
5632 since the above change for DR 164 we end up with duplicates of
5633 all the functions found by unqualified lookup. So keep track
5634 of which ones we've seen. */
5638 /* We shouldn't be here if lookup found something other than
5639 namespace-scope functions. */
5640 gcc_assert (DECL_NAMESPACE_SCOPE_P (OVL_CURRENT (fns
)));
5641 k
.fn_set
= pointer_set_create ();
5642 for (ovl
= fns
; ovl
; ovl
= OVL_NEXT (ovl
))
5643 pointer_set_insert (k
.fn_set
, OVL_CURRENT (ovl
));
5648 arg_assoc_args_vec (&k
, args
);
5654 && !is_overloaded_fn (fns
))
5656 error ("argument dependent lookup finds %q+D", fns
);
5657 error (" in call to %qD", name
);
5658 fns
= error_mark_node
;
5661 release_tree_vector (k
.classes
);
5662 release_tree_vector (k
.namespaces
);
5664 pointer_set_destroy (k
.fn_set
);
5669 /* Wrapper for lookup_arg_dependent_1. */
5672 lookup_arg_dependent (tree name
, tree fns
, vec
<tree
, va_gc
> *args
)
5676 subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
5677 ret
= lookup_arg_dependent_1 (name
, fns
, args
);
5678 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
5683 /* Add namespace to using_directives. Return NULL_TREE if nothing was
5684 changed (i.e. there was already a directive), or the fresh
5685 TREE_LIST otherwise. */
5688 push_using_directive_1 (tree used
)
5690 tree ud
= current_binding_level
->using_directives
;
5691 tree iter
, ancestor
;
5693 /* Check if we already have this. */
5694 if (purpose_member (used
, ud
) != NULL_TREE
)
5697 ancestor
= namespace_ancestor (current_decl_namespace (), used
);
5698 ud
= current_binding_level
->using_directives
;
5699 ud
= tree_cons (used
, ancestor
, ud
);
5700 current_binding_level
->using_directives
= ud
;
5702 /* Recursively add all namespaces used. */
5703 for (iter
= DECL_NAMESPACE_USING (used
); iter
; iter
= TREE_CHAIN (iter
))
5704 push_using_directive (TREE_PURPOSE (iter
));
5709 /* Wrapper for push_using_directive_1. */
5712 push_using_directive (tree used
)
5715 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
5716 ret
= push_using_directive_1 (used
);
5717 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
5721 /* The type TYPE is being declared. If it is a class template, or a
5722 specialization of a class template, do any processing required and
5723 perform error-checking. If IS_FRIEND is nonzero, this TYPE is
5724 being declared a friend. B is the binding level at which this TYPE
5727 Returns the TYPE_DECL for TYPE, which may have been altered by this
5731 maybe_process_template_type_declaration (tree type
, int is_friend
,
5732 cp_binding_level
*b
)
5734 tree decl
= TYPE_NAME (type
);
5736 if (processing_template_parmlist
)
5737 /* You can't declare a new template type in a template parameter
5738 list. But, you can declare a non-template type:
5740 template <class A*> struct S;
5742 is a forward-declaration of `A'. */
5744 else if (b
->kind
== sk_namespace
5745 && current_binding_level
->kind
!= sk_namespace
)
5746 /* If this new type is being injected into a containing scope,
5747 then it's not a template type. */
5751 gcc_assert (MAYBE_CLASS_TYPE_P (type
)
5752 || TREE_CODE (type
) == ENUMERAL_TYPE
);
5754 if (processing_template_decl
)
5756 /* This may change after the call to
5757 push_template_decl_real, but we want the original value. */
5758 tree name
= DECL_NAME (decl
);
5760 decl
= push_template_decl_real (decl
, is_friend
);
5761 if (decl
== error_mark_node
)
5762 return error_mark_node
;
5764 /* If the current binding level is the binding level for the
5765 template parameters (see the comment in
5766 begin_template_parm_list) and the enclosing level is a class
5767 scope, and we're not looking at a friend, push the
5768 declaration of the member class into the class scope. In the
5769 friend case, push_template_decl will already have put the
5770 friend into global scope, if appropriate. */
5771 if (TREE_CODE (type
) != ENUMERAL_TYPE
5772 && !is_friend
&& b
->kind
== sk_template_parms
5773 && b
->level_chain
->kind
== sk_class
)
5775 finish_member_declaration (CLASSTYPE_TI_TEMPLATE (type
));
5777 if (!COMPLETE_TYPE_P (current_class_type
))
5779 maybe_add_class_template_decl_list (current_class_type
,
5780 type
, /*friend_p=*/0);
5781 /* Put this UTD in the table of UTDs for the class. */
5782 if (CLASSTYPE_NESTED_UTDS (current_class_type
) == NULL
)
5783 CLASSTYPE_NESTED_UTDS (current_class_type
) =
5784 binding_table_new (SCOPE_DEFAULT_HT_SIZE
);
5786 binding_table_insert
5787 (CLASSTYPE_NESTED_UTDS (current_class_type
), name
, type
);
5796 /* Push a tag name NAME for struct/class/union/enum type TYPE. In case
5797 that the NAME is a class template, the tag is processed but not pushed.
5799 The pushed scope depend on the SCOPE parameter:
5800 - When SCOPE is TS_CURRENT, put it into the inner-most non-sk_cleanup
5802 - When SCOPE is TS_GLOBAL, put it in the inner-most non-class and
5803 non-template-parameter scope. This case is needed for forward
5805 - When SCOPE is TS_WITHIN_ENCLOSING_NON_CLASS, this is similar to
5806 TS_GLOBAL case except that names within template-parameter scopes
5807 are not pushed at all.
5809 Returns TYPE upon success and ERROR_MARK_NODE otherwise. */
5812 pushtag_1 (tree name
, tree type
, tag_scope scope
)
5814 cp_binding_level
*b
;
5817 b
= current_binding_level
;
5818 while (/* Cleanup scopes are not scopes from the point of view of
5820 b
->kind
== sk_cleanup
5821 /* Neither are function parameter scopes. */
5822 || b
->kind
== sk_function_parms
5823 /* Neither are the scopes used to hold template parameters
5824 for an explicit specialization. For an ordinary template
5825 declaration, these scopes are not scopes from the point of
5826 view of the language. */
5827 || (b
->kind
== sk_template_parms
5828 && (b
->explicit_spec_p
|| scope
== ts_global
))
5829 || (b
->kind
== sk_class
5830 && (scope
!= ts_current
5831 /* We may be defining a new type in the initializer
5832 of a static member variable. We allow this when
5833 not pedantic, and it is particularly useful for
5834 type punning via an anonymous union. */
5835 || COMPLETE_TYPE_P (b
->this_entity
))))
5838 gcc_assert (identifier_p (name
));
5840 /* Do C++ gratuitous typedefing. */
5841 if (identifier_type_value_1 (name
) != type
)
5845 tree context
= TYPE_CONTEXT (type
);
5849 tree cs
= current_scope ();
5851 if (scope
== ts_current
5852 || (cs
&& TREE_CODE (cs
) == FUNCTION_DECL
))
5854 else if (cs
!= NULL_TREE
&& TYPE_P (cs
))
5855 /* When declaring a friend class of a local class, we want
5856 to inject the newly named class into the scope
5857 containing the local class, not the namespace
5859 context
= decl_function_context (get_type_decl (cs
));
5862 context
= current_namespace
;
5864 if (b
->kind
== sk_class
5865 || (b
->kind
== sk_template_parms
5866 && b
->level_chain
->kind
== sk_class
))
5869 if (current_lang_name
== lang_name_java
)
5870 TYPE_FOR_JAVA (type
) = 1;
5872 tdef
= create_implicit_typedef (name
, type
);
5873 DECL_CONTEXT (tdef
) = FROB_CONTEXT (context
);
5874 if (scope
== ts_within_enclosing_non_class
)
5876 /* This is a friend. Make this TYPE_DECL node hidden from
5877 ordinary name lookup. Its corresponding TEMPLATE_DECL
5878 will be marked in push_template_decl_real. */
5879 retrofit_lang_decl (tdef
);
5880 DECL_ANTICIPATED (tdef
) = 1;
5881 DECL_FRIEND_P (tdef
) = 1;
5884 decl
= maybe_process_template_type_declaration
5885 (type
, scope
== ts_within_enclosing_non_class
, b
);
5886 if (decl
== error_mark_node
)
5889 if (b
->kind
== sk_class
)
5891 if (!TYPE_BEING_DEFINED (current_class_type
))
5892 return error_mark_node
;
5894 if (!PROCESSING_REAL_TEMPLATE_DECL_P ())
5895 /* Put this TYPE_DECL on the TYPE_FIELDS list for the
5896 class. But if it's a member template class, we want
5897 the TEMPLATE_DECL, not the TYPE_DECL, so this is done
5899 finish_member_declaration (decl
);
5901 pushdecl_class_level (decl
);
5903 else if (b
->kind
!= sk_template_parms
)
5905 decl
= pushdecl_with_scope_1 (decl
, b
, /*is_friend=*/false);
5906 if (decl
== error_mark_node
)
5911 set_identifier_type_value_with_scope (name
, tdef
, b
);
5913 TYPE_CONTEXT (type
) = DECL_CONTEXT (decl
);
5915 /* If this is a local class, keep track of it. We need this
5916 information for name-mangling, and so that it is possible to
5917 find all function definitions in a translation unit in a
5918 convenient way. (It's otherwise tricky to find a member
5919 function definition it's only pointed to from within a local
5921 if (TYPE_FUNCTION_SCOPE_P (type
))
5923 if (processing_template_decl
)
5925 /* Push a DECL_EXPR so we call pushtag at the right time in
5926 template instantiation rather than in some nested context. */
5927 add_decl_expr (decl
);
5930 vec_safe_push (local_classes
, type
);
5933 if (b
->kind
== sk_class
5934 && !COMPLETE_TYPE_P (current_class_type
))
5936 maybe_add_class_template_decl_list (current_class_type
,
5937 type
, /*friend_p=*/0);
5939 if (CLASSTYPE_NESTED_UTDS (current_class_type
) == NULL
)
5940 CLASSTYPE_NESTED_UTDS (current_class_type
)
5941 = binding_table_new (SCOPE_DEFAULT_HT_SIZE
);
5943 binding_table_insert
5944 (CLASSTYPE_NESTED_UTDS (current_class_type
), name
, type
);
5947 decl
= TYPE_NAME (type
);
5948 gcc_assert (TREE_CODE (decl
) == TYPE_DECL
);
5950 /* Set type visibility now if this is a forward declaration. */
5951 TREE_PUBLIC (decl
) = 1;
5952 determine_visibility (decl
);
5957 /* Wrapper for pushtag_1. */
5960 pushtag (tree name
, tree type
, tag_scope scope
)
5963 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
5964 ret
= pushtag_1 (name
, type
, scope
);
5965 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
5969 /* Subroutines for reverting temporarily to top-level for instantiation
5970 of templates and such. We actually need to clear out the class- and
5971 local-value slots of all identifiers, so that only the global values
5972 are at all visible. Simply setting current_binding_level to the global
5973 scope isn't enough, because more binding levels may be pushed. */
5974 struct saved_scope
*scope_chain
;
5976 /* Return true if ID has not already been marked. */
5979 store_binding_p (tree id
)
5981 if (!id
|| !IDENTIFIER_BINDING (id
))
5984 if (IDENTIFIER_MARKED (id
))
5990 /* Add an appropriate binding to *OLD_BINDINGS which needs to already
5991 have enough space reserved. */
5994 store_binding (tree id
, vec
<cxx_saved_binding
, va_gc
> **old_bindings
)
5996 cxx_saved_binding saved
;
5998 gcc_checking_assert (store_binding_p (id
));
6000 IDENTIFIER_MARKED (id
) = 1;
6002 saved
.identifier
= id
;
6003 saved
.binding
= IDENTIFIER_BINDING (id
);
6004 saved
.real_type_value
= REAL_IDENTIFIER_TYPE_VALUE (id
);
6005 (*old_bindings
)->quick_push (saved
);
6006 IDENTIFIER_BINDING (id
) = NULL
;
6010 store_bindings (tree names
, vec
<cxx_saved_binding
, va_gc
> **old_bindings
)
6012 static vec
<tree
> bindings_need_stored
= vNULL
;
6016 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
6017 for (t
= names
; t
; t
= TREE_CHAIN (t
))
6019 if (TREE_CODE (t
) == TREE_LIST
)
6020 id
= TREE_PURPOSE (t
);
6024 if (store_binding_p (id
))
6025 bindings_need_stored
.safe_push (id
);
6027 if (!bindings_need_stored
.is_empty ())
6029 vec_safe_reserve_exact (*old_bindings
, bindings_need_stored
.length ());
6030 for (i
= 0; bindings_need_stored
.iterate (i
, &id
); ++i
)
6032 /* We can appearantly have duplicates in NAMES. */
6033 if (store_binding_p (id
))
6034 store_binding (id
, old_bindings
);
6036 bindings_need_stored
.truncate (0);
6038 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
6041 /* Like store_bindings, but NAMES is a vector of cp_class_binding
6042 objects, rather than a TREE_LIST. */
6045 store_class_bindings (vec
<cp_class_binding
, va_gc
> *names
,
6046 vec
<cxx_saved_binding
, va_gc
> **old_bindings
)
6048 static vec
<tree
> bindings_need_stored
= vNULL
;
6050 cp_class_binding
*cb
;
6052 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
6053 for (i
= 0; vec_safe_iterate (names
, i
, &cb
); ++i
)
6054 if (store_binding_p (cb
->identifier
))
6055 bindings_need_stored
.safe_push (cb
->identifier
);
6056 if (!bindings_need_stored
.is_empty ())
6059 vec_safe_reserve_exact (*old_bindings
, bindings_need_stored
.length ());
6060 for (i
= 0; bindings_need_stored
.iterate (i
, &id
); ++i
)
6061 store_binding (id
, old_bindings
);
6062 bindings_need_stored
.truncate (0);
6064 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
6068 push_to_top_level (void)
6070 struct saved_scope
*s
;
6071 cp_binding_level
*b
;
6072 cxx_saved_binding
*sb
;
6076 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
6077 s
= ggc_alloc_cleared_saved_scope ();
6079 b
= scope_chain
? current_binding_level
: 0;
6081 /* If we're in the middle of some function, save our state. */
6085 push_function_context ();
6090 if (scope_chain
&& previous_class_level
)
6091 store_class_bindings (previous_class_level
->class_shadowed
,
6094 /* Have to include the global scope, because class-scope decls
6095 aren't listed anywhere useful. */
6096 for (; b
; b
= b
->level_chain
)
6100 /* Template IDs are inserted into the global level. If they were
6101 inserted into namespace level, finish_file wouldn't find them
6102 when doing pending instantiations. Therefore, don't stop at
6103 namespace level, but continue until :: . */
6104 if (global_scope_p (b
))
6107 store_bindings (b
->names
, &s
->old_bindings
);
6108 /* We also need to check class_shadowed to save class-level type
6109 bindings, since pushclass doesn't fill in b->names. */
6110 if (b
->kind
== sk_class
)
6111 store_class_bindings (b
->class_shadowed
, &s
->old_bindings
);
6113 /* Unwind type-value slots back to top level. */
6114 for (t
= b
->type_shadowed
; t
; t
= TREE_CHAIN (t
))
6115 SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (t
), TREE_VALUE (t
));
6118 FOR_EACH_VEC_SAFE_ELT (s
->old_bindings
, i
, sb
)
6119 IDENTIFIER_MARKED (sb
->identifier
) = 0;
6121 s
->prev
= scope_chain
;
6123 s
->need_pop_function_context
= need_pop
;
6124 s
->function_decl
= current_function_decl
;
6125 s
->unevaluated_operand
= cp_unevaluated_operand
;
6126 s
->inhibit_evaluation_warnings
= c_inhibit_evaluation_warnings
;
6127 s
->x_stmt_tree
.stmts_are_full_exprs_p
= true;
6130 current_function_decl
= NULL_TREE
;
6131 vec_alloc (current_lang_base
, 10);
6132 current_lang_name
= lang_name_cplusplus
;
6133 current_namespace
= global_namespace
;
6134 push_class_stack ();
6135 cp_unevaluated_operand
= 0;
6136 c_inhibit_evaluation_warnings
= 0;
6137 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
6141 pop_from_top_level_1 (void)
6143 struct saved_scope
*s
= scope_chain
;
6144 cxx_saved_binding
*saved
;
6147 /* Clear out class-level bindings cache. */
6148 if (previous_class_level
)
6149 invalidate_class_lookup_cache ();
6152 current_lang_base
= 0;
6154 scope_chain
= s
->prev
;
6155 FOR_EACH_VEC_SAFE_ELT (s
->old_bindings
, i
, saved
)
6157 tree id
= saved
->identifier
;
6159 IDENTIFIER_BINDING (id
) = saved
->binding
;
6160 SET_IDENTIFIER_TYPE_VALUE (id
, saved
->real_type_value
);
6163 /* If we were in the middle of compiling a function, restore our
6165 if (s
->need_pop_function_context
)
6166 pop_function_context ();
6167 current_function_decl
= s
->function_decl
;
6168 cp_unevaluated_operand
= s
->unevaluated_operand
;
6169 c_inhibit_evaluation_warnings
= s
->inhibit_evaluation_warnings
;
6172 /* Wrapper for pop_from_top_level_1. */
6175 pop_from_top_level (void)
6177 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
6178 pop_from_top_level_1 ();
6179 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
6183 /* Pop off extraneous binding levels left over due to syntax errors.
6185 We don't pop past namespaces, as they might be valid. */
6188 pop_everything (void)
6190 if (ENABLE_SCOPE_CHECKING
)
6191 verbatim ("XXX entering pop_everything ()\n");
6192 while (!toplevel_bindings_p ())
6194 if (current_binding_level
->kind
== sk_class
)
6195 pop_nested_class ();
6199 if (ENABLE_SCOPE_CHECKING
)
6200 verbatim ("XXX leaving pop_everything ()\n");
6203 /* Emit debugging information for using declarations and directives.
6204 If input tree is overloaded fn then emit debug info for all
6208 cp_emit_debug_info_for_using (tree t
, tree context
)
6210 /* Don't try to emit any debug information if we have errors. */
6214 /* Ignore this FUNCTION_DECL if it refers to a builtin declaration
6215 of a builtin function. */
6216 if (TREE_CODE (t
) == FUNCTION_DECL
6217 && DECL_EXTERNAL (t
)
6218 && DECL_BUILT_IN (t
))
6221 /* Do not supply context to imported_module_or_decl, if
6222 it is a global namespace. */
6223 if (context
== global_namespace
)
6224 context
= NULL_TREE
;
6227 t
= BASELINK_FUNCTIONS (t
);
6229 /* FIXME: Handle TEMPLATE_DECLs. */
6230 for (t
= OVL_CURRENT (t
); t
; t
= OVL_NEXT (t
))
6231 if (TREE_CODE (t
) != TEMPLATE_DECL
)
6233 if (building_stmt_list_p ())
6234 add_stmt (build_stmt (input_location
, USING_STMT
, t
));
6236 (*debug_hooks
->imported_module_or_decl
) (t
, NULL_TREE
, context
, false);
6240 #include "gt-cp-name-lookup.h"