1 /* Definitions for C++ name lookup routines.
2 Copyright (C) 2003-2016 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"
26 #include "stringpool.h"
27 #include "print-tree.h"
30 #include "c-family/c-pragma.h"
33 /* The bindings for a particular name in a particular scope. */
35 struct scope_binding
{
39 #define EMPTY_SCOPE_BINDING { NULL_TREE, NULL_TREE }
41 static cp_binding_level
*innermost_nonclass_level (void);
42 static cxx_binding
*binding_for_name (cp_binding_level
*, tree
);
43 static tree
push_overloaded_decl (tree
, int, bool);
44 static bool lookup_using_namespace (tree
, struct scope_binding
*, tree
,
46 static bool qualified_lookup_using_namespace (tree
, tree
,
47 struct scope_binding
*, int);
48 static tree
lookup_type_current_level (tree
);
49 static tree
push_using_directive (tree
);
50 static tree
lookup_extern_c_fun_in_all_ns (tree
);
51 static void diagnose_name_conflict (tree
, tree
);
53 /* The :: namespace. */
55 tree global_namespace
;
57 /* The name of the anonymous namespace, throughout this translation
59 static GTY(()) tree anonymous_namespace_name
;
61 /* Initialize anonymous_namespace_name if necessary, and return it. */
64 get_anonymous_namespace_name (void)
66 if (!anonymous_namespace_name
)
68 /* We used to use get_file_function_name here, but that isn't
69 necessary now that anonymous namespace typeinfos
70 are !TREE_PUBLIC, and thus compared by address. */
71 /* The demangler expects anonymous namespaces to be called
72 something starting with '_GLOBAL__N_'. */
73 anonymous_namespace_name
= get_identifier ("_GLOBAL__N_1");
75 return anonymous_namespace_name
;
78 /* Compute the chain index of a binding_entry given the HASH value of its
79 name and the total COUNT of chains. COUNT is assumed to be a power
82 #define ENTRY_INDEX(HASH, COUNT) (((HASH) >> 3) & ((COUNT) - 1))
84 /* A free list of "binding_entry"s awaiting for re-use. */
86 static GTY((deletable
)) binding_entry free_binding_entry
= NULL
;
88 /* Create a binding_entry object for (NAME, TYPE). */
90 static inline binding_entry
91 binding_entry_make (tree name
, tree type
)
95 if (free_binding_entry
)
97 entry
= free_binding_entry
;
98 free_binding_entry
= entry
->chain
;
101 entry
= ggc_alloc
<binding_entry_s
> ();
110 /* Put ENTRY back on the free list. */
113 binding_entry_free (binding_entry entry
)
117 entry
->chain
= free_binding_entry
;
118 free_binding_entry
= entry
;
122 /* The datatype used to implement the mapping from names to types at
124 struct GTY(()) binding_table_s
{
125 /* Array of chains of "binding_entry"s */
126 binding_entry
* GTY((length ("%h.chain_count"))) chain
;
128 /* The number of chains in this table. This is the length of the
129 member "chain" considered as an array. */
132 /* Number of "binding_entry"s in this table. */
136 /* Construct TABLE with an initial CHAIN_COUNT. */
139 binding_table_construct (binding_table table
, size_t chain_count
)
141 table
->chain_count
= chain_count
;
142 table
->entry_count
= 0;
143 table
->chain
= ggc_cleared_vec_alloc
<binding_entry
> (table
->chain_count
);
146 /* Make TABLE's entries ready for reuse. */
149 binding_table_free (binding_table table
)
157 for (i
= 0, count
= table
->chain_count
; i
< count
; ++i
)
159 binding_entry temp
= table
->chain
[i
];
162 binding_entry entry
= temp
;
164 binding_entry_free (entry
);
166 table
->chain
[i
] = NULL
;
168 table
->entry_count
= 0;
172 /* Allocate a table with CHAIN_COUNT, assumed to be a power of two. */
174 static inline binding_table
175 binding_table_new (size_t chain_count
)
177 binding_table table
= ggc_alloc
<binding_table_s
> ();
179 binding_table_construct (table
, chain_count
);
183 /* Expand TABLE to twice its current chain_count. */
186 binding_table_expand (binding_table table
)
188 const size_t old_chain_count
= table
->chain_count
;
189 const size_t old_entry_count
= table
->entry_count
;
190 const size_t new_chain_count
= 2 * old_chain_count
;
191 binding_entry
*old_chains
= table
->chain
;
194 binding_table_construct (table
, new_chain_count
);
195 for (i
= 0; i
< old_chain_count
; ++i
)
197 binding_entry entry
= old_chains
[i
];
198 for (; entry
!= NULL
; entry
= old_chains
[i
])
200 const unsigned int hash
= IDENTIFIER_HASH_VALUE (entry
->name
);
201 const size_t j
= ENTRY_INDEX (hash
, new_chain_count
);
203 old_chains
[i
] = entry
->chain
;
204 entry
->chain
= table
->chain
[j
];
205 table
->chain
[j
] = entry
;
208 table
->entry_count
= old_entry_count
;
211 /* Insert a binding for NAME to TYPE into TABLE. */
214 binding_table_insert (binding_table table
, tree name
, tree type
)
216 const unsigned int hash
= IDENTIFIER_HASH_VALUE (name
);
217 const size_t i
= ENTRY_INDEX (hash
, table
->chain_count
);
218 binding_entry entry
= binding_entry_make (name
, type
);
220 entry
->chain
= table
->chain
[i
];
221 table
->chain
[i
] = entry
;
222 ++table
->entry_count
;
224 if (3 * table
->chain_count
< 5 * table
->entry_count
)
225 binding_table_expand (table
);
228 /* Return the binding_entry, if any, that maps NAME. */
231 binding_table_find (binding_table table
, tree name
)
233 const unsigned int hash
= IDENTIFIER_HASH_VALUE (name
);
234 binding_entry entry
= table
->chain
[ENTRY_INDEX (hash
, table
->chain_count
)];
236 while (entry
!= NULL
&& entry
->name
!= name
)
237 entry
= entry
->chain
;
242 /* Apply PROC -- with DATA -- to all entries in TABLE. */
245 binding_table_foreach (binding_table table
, bt_foreach_proc proc
, void *data
)
253 chain_count
= table
->chain_count
;
254 for (i
= 0; i
< chain_count
; ++i
)
256 binding_entry entry
= table
->chain
[i
];
257 for (; entry
!= NULL
; entry
= entry
->chain
)
262 #ifndef ENABLE_SCOPE_CHECKING
263 # define ENABLE_SCOPE_CHECKING 0
265 # define ENABLE_SCOPE_CHECKING 1
268 /* A free list of "cxx_binding"s, connected by their PREVIOUS. */
270 static GTY((deletable
)) cxx_binding
*free_bindings
;
272 /* Initialize VALUE and TYPE field for BINDING, and set the PREVIOUS
276 cxx_binding_init (cxx_binding
*binding
, tree value
, tree type
)
278 binding
->value
= value
;
279 binding
->type
= type
;
280 binding
->previous
= NULL
;
283 /* (GC)-allocate a binding object with VALUE and TYPE member initialized. */
286 cxx_binding_make (tree value
, tree type
)
288 cxx_binding
*binding
;
291 binding
= free_bindings
;
292 free_bindings
= binding
->previous
;
295 binding
= ggc_alloc
<cxx_binding
> ();
297 cxx_binding_init (binding
, value
, type
);
302 /* Put BINDING back on the free list. */
305 cxx_binding_free (cxx_binding
*binding
)
307 binding
->scope
= NULL
;
308 binding
->previous
= free_bindings
;
309 free_bindings
= binding
;
312 /* Create a new binding for NAME (with the indicated VALUE and TYPE
313 bindings) in the class scope indicated by SCOPE. */
316 new_class_binding (tree name
, tree value
, tree type
, cp_binding_level
*scope
)
318 cp_class_binding cb
= {cxx_binding_make (value
, type
), name
};
319 cxx_binding
*binding
= cb
.base
;
320 vec_safe_push (scope
->class_shadowed
, cb
);
321 binding
->scope
= scope
;
325 /* Make DECL the innermost binding for ID. The LEVEL is the binding
326 level at which this declaration is being bound. */
329 push_binding (tree id
, tree decl
, cp_binding_level
* level
)
331 cxx_binding
*binding
;
333 if (level
!= class_binding_level
)
335 binding
= cxx_binding_make (decl
, NULL_TREE
);
336 binding
->scope
= level
;
339 binding
= new_class_binding (id
, decl
, /*type=*/NULL_TREE
, level
);
341 /* Now, fill in the binding information. */
342 binding
->previous
= IDENTIFIER_BINDING (id
);
343 INHERITED_VALUE_BINDING_P (binding
) = 0;
344 LOCAL_BINDING_P (binding
) = (level
!= class_binding_level
);
346 /* And put it on the front of the list of bindings for ID. */
347 IDENTIFIER_BINDING (id
) = binding
;
350 /* Remove the binding for DECL which should be the innermost binding
354 pop_binding (tree id
, tree decl
)
356 cxx_binding
*binding
;
359 /* It's easiest to write the loops that call this function without
360 checking whether or not the entities involved have names. We
361 get here for such an entity. */
364 /* Get the innermost binding for ID. */
365 binding
= IDENTIFIER_BINDING (id
);
367 /* The name should be bound. */
368 gcc_assert (binding
!= NULL
);
370 /* The DECL will be either the ordinary binding or the type
371 binding for this identifier. Remove that binding. */
372 if (binding
->value
== decl
)
373 binding
->value
= NULL_TREE
;
376 gcc_assert (binding
->type
== decl
);
377 binding
->type
= NULL_TREE
;
380 if (!binding
->value
&& !binding
->type
)
382 /* We're completely done with the innermost binding for this
383 identifier. Unhook it from the list of bindings. */
384 IDENTIFIER_BINDING (id
) = binding
->previous
;
386 /* Add it to the free list. */
387 cxx_binding_free (binding
);
391 /* Remove the bindings for the decls of the current level and leave
392 the current scope. */
395 pop_bindings_and_leave_scope (void)
397 for (tree t
= getdecls (); t
; t
= DECL_CHAIN (t
))
398 pop_binding (DECL_NAME (t
), t
);
402 /* Strip non dependent using declarations. If DECL is dependent,
403 surreptitiously create a typename_type and return it. */
406 strip_using_decl (tree decl
)
408 if (decl
== NULL_TREE
)
411 while (TREE_CODE (decl
) == USING_DECL
&& !DECL_DEPENDENT_P (decl
))
412 decl
= USING_DECL_DECLS (decl
);
414 if (TREE_CODE (decl
) == USING_DECL
&& DECL_DEPENDENT_P (decl
)
415 && USING_DECL_TYPENAME_P (decl
))
417 /* We have found a type introduced by a using
418 declaration at class scope that refers to a dependent
421 using typename :: [opt] nested-name-specifier unqualified-id ;
423 decl
= make_typename_type (TREE_TYPE (decl
),
425 typename_type
, tf_error
);
426 if (decl
!= error_mark_node
)
427 decl
= TYPE_NAME (decl
);
433 /* BINDING records an existing declaration for a name in the current scope.
434 But, DECL is another declaration for that same identifier in the
435 same scope. This is the `struct stat' hack whereby a non-typedef
436 class name or enum-name can be bound at the same level as some other
440 A class name (9.1) or enumeration name (7.2) can be hidden by the
441 name of an object, function, or enumerator declared in the same scope.
442 If a class or enumeration name and an object, function, or enumerator
443 are declared in the same scope (in any order) with the same name, the
444 class or enumeration name is hidden wherever the object, function, or
445 enumerator name is visible.
447 It's the responsibility of the caller to check that
448 inserting this name is valid here. Returns nonzero if the new binding
452 supplement_binding_1 (cxx_binding
*binding
, tree decl
)
454 tree bval
= binding
->value
;
456 tree target_bval
= strip_using_decl (bval
);
457 tree target_decl
= strip_using_decl (decl
);
459 if (TREE_CODE (target_decl
) == TYPE_DECL
&& DECL_ARTIFICIAL (target_decl
)
460 && target_decl
!= target_bval
461 && (TREE_CODE (target_bval
) != TYPE_DECL
462 /* We allow pushing an enum multiple times in a class
463 template in order to handle late matching of underlying
464 type on an opaque-enum-declaration followed by an
466 || (processing_template_decl
467 && TREE_CODE (TREE_TYPE (target_decl
)) == ENUMERAL_TYPE
468 && TREE_CODE (TREE_TYPE (target_bval
)) == ENUMERAL_TYPE
469 && (dependent_type_p (ENUM_UNDERLYING_TYPE
470 (TREE_TYPE (target_decl
)))
471 || dependent_type_p (ENUM_UNDERLYING_TYPE
472 (TREE_TYPE (target_bval
)))))))
473 /* The new name is the type name. */
474 binding
->type
= decl
;
475 else if (/* TARGET_BVAL is null when push_class_level_binding moves
476 an inherited type-binding out of the way to make room
477 for a new value binding. */
479 /* TARGET_BVAL is error_mark_node when TARGET_DECL's name
480 has been used in a non-class scope prior declaration.
481 In that case, we should have already issued a
482 diagnostic; for graceful error recovery purpose, pretend
483 this was the intended declaration for that name. */
484 || target_bval
== error_mark_node
485 /* If TARGET_BVAL is anticipated but has not yet been
486 declared, pretend it is not there at all. */
487 || (TREE_CODE (target_bval
) == FUNCTION_DECL
488 && DECL_ANTICIPATED (target_bval
)
489 && !DECL_HIDDEN_FRIEND_P (target_bval
)))
490 binding
->value
= decl
;
491 else if (TREE_CODE (target_bval
) == TYPE_DECL
492 && DECL_ARTIFICIAL (target_bval
)
493 && target_decl
!= target_bval
494 && (TREE_CODE (target_decl
) != TYPE_DECL
495 || same_type_p (TREE_TYPE (target_decl
),
496 TREE_TYPE (target_bval
))))
498 /* The old binding was a type name. It was placed in
499 VALUE field because it was thought, at the point it was
500 declared, to be the only entity with such a name. Move the
501 type name into the type slot; it is now hidden by the new
503 binding
->type
= bval
;
504 binding
->value
= decl
;
505 binding
->value_is_inherited
= false;
507 else if (TREE_CODE (target_bval
) == TYPE_DECL
508 && TREE_CODE (target_decl
) == TYPE_DECL
509 && DECL_NAME (target_decl
) == DECL_NAME (target_bval
)
510 && binding
->scope
->kind
!= sk_class
511 && (same_type_p (TREE_TYPE (target_decl
), TREE_TYPE (target_bval
))
512 /* If either type involves template parameters, we must
513 wait until instantiation. */
514 || uses_template_parms (TREE_TYPE (target_decl
))
515 || uses_template_parms (TREE_TYPE (target_bval
))))
516 /* We have two typedef-names, both naming the same type to have
517 the same name. In general, this is OK because of:
521 In a given scope, a typedef specifier can be used to redefine
522 the name of any type declared in that scope to refer to the
523 type to which it already refers.
525 However, in class scopes, this rule does not apply due to the
526 stricter language in [class.mem] prohibiting redeclarations of
529 /* There can be two block-scope declarations of the same variable,
530 so long as they are `extern' declarations. However, there cannot
531 be two declarations of the same static data member:
535 A member shall not be declared twice in the
536 member-specification. */
537 else if (VAR_P (target_decl
)
538 && VAR_P (target_bval
)
539 && DECL_EXTERNAL (target_decl
) && DECL_EXTERNAL (target_bval
)
540 && !DECL_CLASS_SCOPE_P (target_decl
))
542 duplicate_decls (decl
, binding
->value
, /*newdecl_is_friend=*/false);
545 else if (TREE_CODE (decl
) == NAMESPACE_DECL
546 && TREE_CODE (bval
) == NAMESPACE_DECL
547 && DECL_NAMESPACE_ALIAS (decl
)
548 && DECL_NAMESPACE_ALIAS (bval
)
549 && ORIGINAL_NAMESPACE (bval
) == ORIGINAL_NAMESPACE (decl
))
552 In a declarative region, a namespace-alias-definition can be
553 used to redefine a namespace-alias declared in that declarative
554 region to refer only to the namespace to which it already
557 else if (maybe_remove_implicit_alias (bval
))
559 /* There was a mangling compatibility alias using this mangled name,
560 but now we have a real decl that wants to use it instead. */
561 binding
->value
= decl
;
565 diagnose_name_conflict (decl
, bval
);
572 /* Diagnose a name conflict between DECL and BVAL. */
575 diagnose_name_conflict (tree decl
, tree bval
)
577 if (TREE_CODE (decl
) == TREE_CODE (bval
)
578 && (TREE_CODE (decl
) != TYPE_DECL
579 || (DECL_ARTIFICIAL (decl
) && DECL_ARTIFICIAL (bval
))
580 || (!DECL_ARTIFICIAL (decl
) && !DECL_ARTIFICIAL (bval
)))
581 && !is_overloaded_fn (decl
))
582 error ("redeclaration of %q#D", decl
);
584 error ("%q#D conflicts with a previous declaration", decl
);
586 inform (location_of (bval
), "previous declaration %q#D", bval
);
589 /* Wrapper for supplement_binding_1. */
592 supplement_binding (cxx_binding
*binding
, tree decl
)
595 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
596 ret
= supplement_binding_1 (binding
, decl
);
597 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
601 /* Add DECL to the list of things declared in B. */
604 add_decl_to_level (tree decl
, cp_binding_level
*b
)
606 /* We used to record virtual tables as if they were ordinary
607 variables, but no longer do so. */
608 gcc_assert (!(VAR_P (decl
) && DECL_VIRTUAL_P (decl
)));
610 if (TREE_CODE (decl
) == NAMESPACE_DECL
611 && !DECL_NAMESPACE_ALIAS (decl
))
613 DECL_CHAIN (decl
) = b
->namespaces
;
614 b
->namespaces
= decl
;
618 /* We build up the list in reverse order, and reverse it later if
620 TREE_CHAIN (decl
) = b
->names
;
623 /* If appropriate, add decl to separate list of statics. We
624 include extern variables because they might turn out to be
625 static later. It's OK for this list to contain a few false
627 if (b
->kind
== sk_namespace
)
629 && (TREE_STATIC (decl
) || DECL_EXTERNAL (decl
)))
630 || (TREE_CODE (decl
) == FUNCTION_DECL
631 && (!TREE_PUBLIC (decl
)
632 || decl_anon_ns_mem_p (decl
)
633 || DECL_DECLARED_INLINE_P (decl
))))
634 vec_safe_push (b
->static_decls
, decl
);
638 /* Record a decl-node X as belonging to the current lexical scope.
639 Check for errors (such as an incompatible declaration for the same
640 name already seen in the same scope). IS_FRIEND is true if X is
641 declared as a friend.
643 Returns either X or an old decl for the same name.
644 If an old decl is returned, it may have been smashed
645 to agree with what X says. */
648 pushdecl_maybe_friend_1 (tree x
, bool is_friend
)
652 int need_new_binding
;
654 if (x
== error_mark_node
)
655 return error_mark_node
;
657 need_new_binding
= 1;
659 if (DECL_TEMPLATE_PARM_P (x
))
660 /* Template parameters have no context; they are not X::T even
661 when declared within a class or namespace. */
665 if (current_function_decl
&& x
!= current_function_decl
666 /* A local declaration for a function doesn't constitute
668 && TREE_CODE (x
) != FUNCTION_DECL
669 /* A local declaration for an `extern' variable is in the
670 scope of the current namespace, not the current
672 && !(VAR_P (x
) && DECL_EXTERNAL (x
))
673 /* When parsing the parameter list of a function declarator,
674 don't set DECL_CONTEXT to an enclosing function. When we
675 push the PARM_DECLs in order to process the function body,
676 current_binding_level->this_entity will be set. */
677 && !(TREE_CODE (x
) == PARM_DECL
678 && current_binding_level
->kind
== sk_function_parms
679 && current_binding_level
->this_entity
== NULL
)
680 && !DECL_CONTEXT (x
))
681 DECL_CONTEXT (x
) = current_function_decl
;
683 /* If this is the declaration for a namespace-scope function,
684 but the declaration itself is in a local scope, mark the
686 if (TREE_CODE (x
) == FUNCTION_DECL
687 && DECL_NAMESPACE_SCOPE_P (x
)
688 && current_function_decl
689 && x
!= current_function_decl
)
690 DECL_LOCAL_FUNCTION_P (x
) = 1;
693 name
= DECL_NAME (x
);
696 int different_binding_level
= 0;
698 if (TREE_CODE (name
) == TEMPLATE_ID_EXPR
)
699 name
= TREE_OPERAND (name
, 0);
701 /* In case this decl was explicitly namespace-qualified, look it
702 up in its namespace context. */
703 if (DECL_NAMESPACE_SCOPE_P (x
) && namespace_bindings_p ())
704 t
= namespace_binding (name
, DECL_CONTEXT (x
));
706 t
= lookup_name_innermost_nonclass_level (name
);
708 /* [basic.link] If there is a visible declaration of an entity
709 with linkage having the same name and type, ignoring entities
710 declared outside the innermost enclosing namespace scope, the
711 block scope declaration declares that same entity and
712 receives the linkage of the previous declaration. */
713 if (! t
&& current_function_decl
&& x
!= current_function_decl
714 && VAR_OR_FUNCTION_DECL_P (x
)
715 && DECL_EXTERNAL (x
))
717 /* Look in block scope. */
718 t
= innermost_non_namespace_value (name
);
719 /* Or in the innermost namespace. */
721 t
= namespace_binding (name
, DECL_CONTEXT (x
));
722 /* Does it have linkage? Note that if this isn't a DECL, it's an
723 OVERLOAD, which is OK. */
724 if (t
&& DECL_P (t
) && ! (TREE_STATIC (t
) || DECL_EXTERNAL (t
)))
727 different_binding_level
= 1;
730 /* If we are declaring a function, and the result of name-lookup
731 was an OVERLOAD, look for an overloaded instance that is
732 actually the same as the function we are declaring. (If
733 there is one, we have to merge our declaration with the
734 previous declaration.) */
735 if (t
&& TREE_CODE (t
) == OVERLOAD
)
739 if (TREE_CODE (x
) == FUNCTION_DECL
)
740 for (match
= t
; match
; match
= OVL_NEXT (match
))
742 if (decls_match (OVL_CURRENT (match
), x
))
746 /* Just choose one. */
750 t
= OVL_CURRENT (match
);
755 if (t
&& t
!= error_mark_node
)
757 if (different_binding_level
)
759 if (decls_match (x
, t
))
760 /* The standard only says that the local extern
761 inherits linkage from the previous decl; in
762 particular, default args are not shared. Add
763 the decl into a hash table to make sure only
764 the previous decl in this case is seen by the
767 struct cxx_int_tree_map
*h
;
769 TREE_PUBLIC (x
) = TREE_PUBLIC (t
);
771 if (cp_function_chain
->extern_decl_map
== NULL
)
772 cp_function_chain
->extern_decl_map
773 = hash_table
<cxx_int_tree_map_hasher
>::create_ggc (20);
775 h
= ggc_alloc
<cxx_int_tree_map
> ();
776 h
->uid
= DECL_UID (x
);
778 cxx_int_tree_map
**loc
= cp_function_chain
->extern_decl_map
779 ->find_slot (h
, INSERT
);
783 else if (TREE_CODE (t
) == PARM_DECL
)
785 /* Check for duplicate params. */
786 tree d
= duplicate_decls (x
, t
, is_friend
);
790 else if ((DECL_EXTERN_C_FUNCTION_P (x
)
791 || DECL_FUNCTION_TEMPLATE_P (x
))
792 && is_overloaded_fn (t
))
793 /* Don't do anything just yet. */;
794 else if (t
== wchar_decl_node
)
796 if (! DECL_IN_SYSTEM_HEADER (x
))
797 pedwarn (input_location
, OPT_Wpedantic
, "redeclaration of %<wchar_t%> as %qT",
800 /* Throw away the redeclaration. */
805 tree olddecl
= duplicate_decls (x
, t
, is_friend
);
807 /* If the redeclaration failed, we can stop at this
809 if (olddecl
== error_mark_node
)
810 return error_mark_node
;
814 if (TREE_CODE (t
) == TYPE_DECL
)
815 SET_IDENTIFIER_TYPE_VALUE (name
, TREE_TYPE (t
));
819 else if (DECL_MAIN_P (x
) && TREE_CODE (t
) == FUNCTION_DECL
)
821 /* A redeclaration of main, but not a duplicate of the
826 This function shall not be overloaded. */
827 error ("invalid redeclaration of %q+D", t
);
829 /* We don't try to push this declaration since that
836 /* If x has C linkage-specification, (extern "C"),
837 lookup its binding, in case it's already bound to an object.
838 The lookup is done in all namespaces.
839 If we find an existing binding, make sure it has the same
840 exception specification as x, otherwise, bail in error [7.5, 7.6]. */
841 if ((TREE_CODE (x
) == FUNCTION_DECL
)
842 && DECL_EXTERN_C_P (x
)
843 /* We should ignore declarations happening in system headers. */
844 && !DECL_ARTIFICIAL (x
)
845 && !DECL_IN_SYSTEM_HEADER (x
))
847 tree previous
= lookup_extern_c_fun_in_all_ns (x
);
849 && !DECL_ARTIFICIAL (previous
)
850 && !DECL_IN_SYSTEM_HEADER (previous
)
851 && DECL_CONTEXT (previous
) != DECL_CONTEXT (x
))
853 /* In case either x or previous is declared to throw an exception,
854 make sure both exception specifications are equal. */
855 if (decls_match (x
, previous
))
857 tree x_exception_spec
= NULL_TREE
;
858 tree previous_exception_spec
= NULL_TREE
;
861 TYPE_RAISES_EXCEPTIONS (TREE_TYPE (x
));
862 previous_exception_spec
=
863 TYPE_RAISES_EXCEPTIONS (TREE_TYPE (previous
));
864 if (!comp_except_specs (previous_exception_spec
,
868 pedwarn (input_location
, 0,
869 "declaration of %q#D with C language linkage",
871 pedwarn (DECL_SOURCE_LOCATION (previous
), 0,
872 "conflicts with previous declaration %q#D",
874 pedwarn (input_location
, 0,
875 "due to different exception specifications");
876 return error_mark_node
;
878 if (DECL_ASSEMBLER_NAME_SET_P (previous
))
879 SET_DECL_ASSEMBLER_NAME (x
,
880 DECL_ASSEMBLER_NAME (previous
));
884 pedwarn (input_location
, 0,
885 "declaration of %q#D with C language linkage", x
);
886 pedwarn (DECL_SOURCE_LOCATION (previous
), 0,
887 "conflicts with previous declaration %q#D",
893 check_template_shadow (x
);
895 /* If this is a function conjured up by the back end, massage it
896 so it looks friendly. */
897 if (DECL_NON_THUNK_FUNCTION_P (x
) && ! DECL_LANG_SPECIFIC (x
))
899 retrofit_lang_decl (x
);
900 SET_DECL_LANGUAGE (x
, lang_c
);
904 if (DECL_NON_THUNK_FUNCTION_P (x
) && ! DECL_FUNCTION_MEMBER_P (x
))
906 t
= push_overloaded_decl (x
, PUSH_LOCAL
, is_friend
);
907 if (!namespace_bindings_p ())
908 /* We do not need to create a binding for this name;
909 push_overloaded_decl will have already done so if
911 need_new_binding
= 0;
913 else if (DECL_FUNCTION_TEMPLATE_P (x
) && DECL_NAMESPACE_SCOPE_P (x
))
915 t
= push_overloaded_decl (x
, PUSH_GLOBAL
, is_friend
);
917 add_decl_to_level (x
, NAMESPACE_LEVEL (CP_DECL_CONTEXT (t
)));
920 if (DECL_DECLARES_FUNCTION_P (t
))
922 check_default_args (t
);
924 if (is_friend
&& t
== x
&& !flag_friend_injection
)
926 /* This is a new friend declaration of a function or a
927 function template, so hide it from ordinary function
929 DECL_ANTICIPATED (t
) = 1;
930 DECL_HIDDEN_FRIEND_P (t
) = 1;
934 if (t
!= x
|| DECL_FUNCTION_TEMPLATE_P (t
))
937 /* If declaring a type as a typedef, copy the type (unless we're
938 at line 0), and install this TYPE_DECL as the new type's typedef
939 name. See the extensive comment of set_underlying_type (). */
940 if (TREE_CODE (x
) == TYPE_DECL
)
942 tree type
= TREE_TYPE (x
);
944 if (DECL_IS_BUILTIN (x
)
945 || (TREE_TYPE (x
) != error_mark_node
946 && TYPE_NAME (type
) != x
947 /* We don't want to copy the type when all we're
948 doing is making a TYPE_DECL for the purposes of
950 && (!TYPE_NAME (type
)
951 || TYPE_NAME (type
) != DECL_ABSTRACT_ORIGIN (x
))))
952 set_underlying_type (x
);
954 if (type
!= error_mark_node
955 && TYPE_IDENTIFIER (type
))
956 set_identifier_type_value (DECL_NAME (x
), x
);
958 /* If this is a locally defined typedef in a function that
959 is not a template instantation, record it to implement
960 -Wunused-local-typedefs. */
961 if (!instantiating_current_function_p ())
962 record_locally_defined_typedef (x
);
965 /* Multiple external decls of the same identifier ought to match.
967 We get warnings about inline functions where they are defined.
968 We get warnings about other functions from push_overloaded_decl.
970 Avoid duplicate warnings where they are used. */
971 if (TREE_PUBLIC (x
) && TREE_CODE (x
) != FUNCTION_DECL
)
975 decl
= IDENTIFIER_NAMESPACE_VALUE (name
);
976 if (decl
&& TREE_CODE (decl
) == OVERLOAD
)
977 decl
= OVL_FUNCTION (decl
);
979 if (decl
&& decl
!= error_mark_node
980 && (DECL_EXTERNAL (decl
) || TREE_PUBLIC (decl
))
981 /* If different sort of thing, we already gave an error. */
982 && TREE_CODE (decl
) == TREE_CODE (x
)
983 && !comptypes (TREE_TYPE (x
), TREE_TYPE (decl
),
984 COMPARE_REDECLARATION
))
986 if (permerror (input_location
, "type mismatch with previous "
987 "external decl of %q#D", x
))
988 inform (DECL_SOURCE_LOCATION (decl
),
989 "previous external decl of %q#D", decl
);
993 /* This name is new in its binding level.
994 Install the new declaration and return it. */
995 if (namespace_bindings_p ())
997 /* Install a global value. */
999 /* If the first global decl has external linkage,
1000 warn if we later see static one. */
1001 if (IDENTIFIER_GLOBAL_VALUE (name
) == NULL_TREE
&& TREE_PUBLIC (x
))
1002 TREE_PUBLIC (name
) = 1;
1004 /* Bind the name for the entity. */
1005 if (!(TREE_CODE (x
) == TYPE_DECL
&& DECL_ARTIFICIAL (x
)
1007 && (TREE_CODE (x
) == TYPE_DECL
1009 || TREE_CODE (x
) == NAMESPACE_DECL
1010 || TREE_CODE (x
) == CONST_DECL
1011 || TREE_CODE (x
) == TEMPLATE_DECL
))
1012 SET_IDENTIFIER_NAMESPACE_VALUE (name
, x
);
1014 /* If new decl is `static' and an `extern' was seen previously,
1016 if (x
!= NULL_TREE
&& t
!= NULL_TREE
&& decls_match (x
, t
))
1017 warn_extern_redeclared_static (x
, t
);
1021 /* Here to install a non-global value. */
1022 tree oldglobal
= IDENTIFIER_NAMESPACE_VALUE (name
);
1023 tree oldlocal
= NULL_TREE
;
1024 cp_binding_level
*oldscope
= NULL
;
1025 cxx_binding
*oldbinding
= outer_binding (name
, NULL
, true);
1028 oldlocal
= oldbinding
->value
;
1029 oldscope
= oldbinding
->scope
;
1032 if (need_new_binding
)
1034 push_local_binding (name
, x
, 0);
1035 /* Because push_local_binding will hook X on to the
1036 current_binding_level's name list, we don't want to
1037 do that again below. */
1038 need_new_binding
= 0;
1041 /* If this is a TYPE_DECL, push it into the type value slot. */
1042 if (TREE_CODE (x
) == TYPE_DECL
)
1043 set_identifier_type_value (name
, x
);
1045 /* Clear out any TYPE_DECL shadowed by a namespace so that
1046 we won't think this is a type. The C struct hack doesn't
1047 go through namespaces. */
1048 if (TREE_CODE (x
) == NAMESPACE_DECL
)
1049 set_identifier_type_value (name
, NULL_TREE
);
1057 && DECL_DEAD_FOR_LOCAL (oldlocal
))
1058 oldlocal
= DECL_SHADOWED_FOR_VAR (oldlocal
);
1060 if (oldlocal
== NULL_TREE
)
1061 oldlocal
= IDENTIFIER_NAMESPACE_VALUE (DECL_NAME (d
));
1064 /* If this is an extern function declaration, see if we
1065 have a global definition or declaration for the function. */
1066 if (oldlocal
== NULL_TREE
1067 && DECL_EXTERNAL (x
)
1068 && oldglobal
!= NULL_TREE
1069 && TREE_CODE (x
) == FUNCTION_DECL
1070 && TREE_CODE (oldglobal
) == FUNCTION_DECL
)
1072 /* We have one. Their types must agree. */
1073 if (decls_match (x
, oldglobal
))
1077 warning (0, "extern declaration of %q#D doesn%'t match", x
);
1078 warning_at (DECL_SOURCE_LOCATION (oldglobal
), 0,
1079 "global declaration %q#D", oldglobal
);
1082 /* If we have a local external declaration,
1083 and no file-scope declaration has yet been seen,
1084 then if we later have a file-scope decl it must not be static. */
1085 if (oldlocal
== NULL_TREE
1086 && oldglobal
== NULL_TREE
1087 && DECL_EXTERNAL (x
)
1089 TREE_PUBLIC (name
) = 1;
1091 /* Don't complain about the parms we push and then pop
1092 while tentatively parsing a function declarator. */
1093 if (TREE_CODE (x
) == PARM_DECL
&& DECL_CONTEXT (x
) == NULL_TREE
)
1096 /* Warn if shadowing an argument at the top level of the body. */
1097 else if (oldlocal
!= NULL_TREE
&& !DECL_EXTERNAL (x
)
1098 /* Inline decls shadow nothing. */
1099 && !DECL_FROM_INLINE (x
)
1100 && (TREE_CODE (oldlocal
) == PARM_DECL
1102 /* If the old decl is a type decl, only warn if the
1103 old decl is an explicit typedef or if both the old
1104 and new decls are type decls. */
1105 || (TREE_CODE (oldlocal
) == TYPE_DECL
1106 && (!DECL_ARTIFICIAL (oldlocal
)
1107 || TREE_CODE (x
) == TYPE_DECL
)))
1108 /* Don't check for internally generated vars unless
1109 it's an implicit typedef (see create_implicit_typedef
1111 && (!DECL_ARTIFICIAL (x
) || DECL_IMPLICIT_TYPEDEF_P (x
)))
1113 bool nowarn
= false;
1115 /* Don't complain if it's from an enclosing function. */
1116 if (DECL_CONTEXT (oldlocal
) == current_function_decl
1117 && TREE_CODE (x
) != PARM_DECL
1118 && TREE_CODE (oldlocal
) == PARM_DECL
)
1120 /* Go to where the parms should be and see if we find
1122 cp_binding_level
*b
= current_binding_level
->level_chain
;
1124 if (FUNCTION_NEEDS_BODY_BLOCK (current_function_decl
))
1125 /* Skip the ctor/dtor cleanup level. */
1129 if (b
->kind
== sk_function_parms
)
1131 error ("declaration of %q#D shadows a parameter", x
);
1136 /* The local structure or class can't use parameters of
1137 the containing function anyway. */
1138 if (DECL_CONTEXT (oldlocal
) != current_function_decl
)
1140 cp_binding_level
*scope
= current_binding_level
;
1141 tree context
= DECL_CONTEXT (oldlocal
);
1142 for (; scope
; scope
= scope
->level_chain
)
1144 if (scope
->kind
== sk_function_parms
1145 && scope
->this_entity
== context
)
1147 if (scope
->kind
== sk_class
1148 && !LAMBDA_TYPE_P (scope
->this_entity
))
1155 /* Error if redeclaring a local declared in a
1156 for-init-statement or in the condition of an if or
1157 switch statement when the new declaration is in the
1158 outermost block of the controlled statement.
1159 Redeclaring a variable from a for or while condition is
1160 detected elsewhere. */
1161 else if (VAR_P (oldlocal
)
1162 && oldscope
== current_binding_level
->level_chain
1163 && (oldscope
->kind
== sk_cond
1164 || oldscope
->kind
== sk_for
))
1166 error ("redeclaration of %q#D", x
);
1167 inform (DECL_SOURCE_LOCATION (oldlocal
),
1168 "%q#D previously declared here", oldlocal
);
1172 3.3.3/3: The name declared in an exception-declaration (...)
1173 shall not be redeclared in the outermost block of the handler.
1174 3.3.3/2: A parameter name shall not be redeclared (...) in
1175 the outermost block of any handler associated with a
1177 3.4.1/15: The function parameter names shall not be redeclared
1178 in the exception-declaration nor in the outermost block of a
1179 handler for the function-try-block. */
1180 else if ((VAR_P (oldlocal
)
1181 && oldscope
== current_binding_level
->level_chain
1182 && oldscope
->kind
== sk_catch
)
1183 || (TREE_CODE (oldlocal
) == PARM_DECL
1184 && (current_binding_level
->kind
== sk_catch
1185 || (current_binding_level
->level_chain
->kind
1187 && in_function_try_handler
))
1189 if (permerror (input_location
, "redeclaration of %q#D", x
))
1190 inform (DECL_SOURCE_LOCATION (oldlocal
),
1191 "%q#D previously declared here", oldlocal
);
1195 if (warn_shadow
&& !nowarn
)
1199 if (TREE_CODE (oldlocal
) == PARM_DECL
)
1200 warned
= warning_at (input_location
, OPT_Wshadow
,
1201 "declaration of %q#D shadows a parameter", x
);
1202 else if (is_capture_proxy (oldlocal
))
1203 warned
= warning_at (input_location
, OPT_Wshadow
,
1204 "declaration of %qD shadows a lambda capture",
1207 warned
= warning_at (input_location
, OPT_Wshadow
,
1208 "declaration of %qD shadows a previous local",
1212 inform (DECL_SOURCE_LOCATION (oldlocal
),
1213 "shadowed declaration is here");
1217 /* Maybe warn if shadowing something else. */
1218 else if (warn_shadow
&& !DECL_EXTERNAL (x
)
1219 /* No shadow warnings for internally generated vars unless
1220 it's an implicit typedef (see create_implicit_typedef
1222 && (! DECL_ARTIFICIAL (x
) || DECL_IMPLICIT_TYPEDEF_P (x
))
1223 /* No shadow warnings for vars made for inlining. */
1224 && ! DECL_FROM_INLINE (x
))
1228 if (nonlambda_method_basetype ())
1229 member
= lookup_member (current_nonlambda_class_type (),
1232 /*want_type=*/false,
1233 tf_warning_or_error
);
1237 if (member
&& !TREE_STATIC (member
))
1239 if (BASELINK_P (member
))
1240 member
= BASELINK_FUNCTIONS (member
);
1241 member
= OVL_CURRENT (member
);
1243 /* Do not warn if a variable shadows a function, unless
1244 the variable is a function or a pointer-to-function. */
1245 if (TREE_CODE (member
) != FUNCTION_DECL
1246 || TREE_CODE (x
) == FUNCTION_DECL
1247 || TYPE_PTRFN_P (TREE_TYPE (x
))
1248 || TYPE_PTRMEMFUNC_P (TREE_TYPE (x
)))
1250 if (warning_at (input_location
, OPT_Wshadow
,
1251 "declaration of %qD shadows a member of %qT",
1252 x
, current_nonlambda_class_type ())
1254 inform (DECL_SOURCE_LOCATION (member
),
1255 "shadowed declaration is here");
1258 else if (oldglobal
!= NULL_TREE
1259 && (VAR_P (oldglobal
)
1260 /* If the old decl is a type decl, only warn if the
1261 old decl is an explicit typedef or if both the
1262 old and new decls are type decls. */
1263 || (TREE_CODE (oldglobal
) == TYPE_DECL
1264 && (!DECL_ARTIFICIAL (oldglobal
)
1265 || TREE_CODE (x
) == TYPE_DECL
)))
1266 && !instantiating_current_function_p ())
1267 /* XXX shadow warnings in outer-more namespaces */
1269 if (warning_at (input_location
, OPT_Wshadow
,
1270 "declaration of %qD shadows a "
1271 "global declaration", x
))
1272 inform (DECL_SOURCE_LOCATION (oldglobal
),
1273 "shadowed declaration is here");
1279 maybe_register_incomplete_var (x
);
1282 if (need_new_binding
)
1283 add_decl_to_level (x
,
1284 DECL_NAMESPACE_SCOPE_P (x
)
1285 ? NAMESPACE_LEVEL (CP_DECL_CONTEXT (x
))
1286 : current_binding_level
);
1291 /* Wrapper for pushdecl_maybe_friend_1. */
1294 pushdecl_maybe_friend (tree x
, bool is_friend
)
1297 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
1298 ret
= pushdecl_maybe_friend_1 (x
, is_friend
);
1299 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
1303 /* Record a decl-node X as belonging to the current lexical scope. */
1308 return pushdecl_maybe_friend (x
, false);
1311 /* Enter DECL into the symbol table, if that's appropriate. Returns
1312 DECL, or a modified version thereof. */
1315 maybe_push_decl (tree decl
)
1317 tree type
= TREE_TYPE (decl
);
1319 /* Add this decl to the current binding level, but not if it comes
1320 from another scope, e.g. a static member variable. TEM may equal
1321 DECL or it may be a previous decl of the same name. */
1322 if (decl
== error_mark_node
1323 || (TREE_CODE (decl
) != PARM_DECL
1324 && DECL_CONTEXT (decl
) != NULL_TREE
1325 /* Definitions of namespace members outside their namespace are
1327 && !DECL_NAMESPACE_SCOPE_P (decl
))
1328 || (TREE_CODE (decl
) == TEMPLATE_DECL
&& !namespace_bindings_p ())
1329 || type
== unknown_type_node
1330 /* The declaration of a template specialization does not affect
1331 the functions available for overload resolution, so we do not
1333 || (TREE_CODE (decl
) == FUNCTION_DECL
1334 && DECL_TEMPLATE_SPECIALIZATION (decl
)))
1337 return pushdecl (decl
);
1340 /* Bind DECL to ID in the current_binding_level, assumed to be a local
1341 binding level. If PUSH_USING is set in FLAGS, we know that DECL
1342 doesn't really belong to this binding level, that it got here
1343 through a using-declaration. */
1346 push_local_binding (tree id
, tree decl
, int flags
)
1348 cp_binding_level
*b
;
1350 /* Skip over any local classes. This makes sense if we call
1351 push_local_binding with a friend decl of a local class. */
1352 b
= innermost_nonclass_level ();
1354 if (lookup_name_innermost_nonclass_level (id
))
1356 /* Supplement the existing binding. */
1357 if (!supplement_binding (IDENTIFIER_BINDING (id
), decl
))
1358 /* It didn't work. Something else must be bound at this
1359 level. Do not add DECL to the list of things to pop
1364 /* Create a new binding. */
1365 push_binding (id
, decl
, b
);
1367 if (TREE_CODE (decl
) == OVERLOAD
|| (flags
& PUSH_USING
))
1368 /* We must put the OVERLOAD into a TREE_LIST since the
1369 TREE_CHAIN of an OVERLOAD is already used. Similarly for
1370 decls that got here through a using-declaration. */
1371 decl
= build_tree_list (NULL_TREE
, decl
);
1373 /* And put DECL on the list of things declared by the current
1375 add_decl_to_level (decl
, b
);
1378 /* Check to see whether or not DECL is a variable that would have been
1379 in scope under the ARM, but is not in scope under the ANSI/ISO
1380 standard. If so, issue an error message. If name lookup would
1381 work in both cases, but return a different result, this function
1382 returns the result of ANSI/ISO lookup. Otherwise, it returns
1386 check_for_out_of_scope_variable (tree decl
)
1390 /* We only care about out of scope variables. */
1391 if (!(VAR_P (decl
) && DECL_DEAD_FOR_LOCAL (decl
)))
1394 shadowed
= DECL_HAS_SHADOWED_FOR_VAR_P (decl
)
1395 ? DECL_SHADOWED_FOR_VAR (decl
) : NULL_TREE
;
1396 while (shadowed
!= NULL_TREE
&& VAR_P (shadowed
)
1397 && DECL_DEAD_FOR_LOCAL (shadowed
))
1398 shadowed
= DECL_HAS_SHADOWED_FOR_VAR_P (shadowed
)
1399 ? DECL_SHADOWED_FOR_VAR (shadowed
) : NULL_TREE
;
1401 shadowed
= IDENTIFIER_NAMESPACE_VALUE (DECL_NAME (decl
));
1404 if (!DECL_ERROR_REPORTED (decl
))
1406 warning (0, "name lookup of %qD changed", DECL_NAME (decl
));
1407 warning_at (DECL_SOURCE_LOCATION (shadowed
), 0,
1408 " matches this %qD under ISO standard rules",
1410 warning_at (DECL_SOURCE_LOCATION (decl
), 0,
1411 " matches this %qD under old rules", decl
);
1412 DECL_ERROR_REPORTED (decl
) = 1;
1417 /* If we have already complained about this declaration, there's no
1418 need to do it again. */
1419 if (DECL_ERROR_REPORTED (decl
))
1422 DECL_ERROR_REPORTED (decl
) = 1;
1424 if (TREE_TYPE (decl
) == error_mark_node
)
1427 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TREE_TYPE (decl
)))
1429 error ("name lookup of %qD changed for ISO %<for%> scoping",
1431 error (" cannot use obsolete binding at %q+D because "
1432 "it has a destructor", decl
);
1433 return error_mark_node
;
1437 permerror (input_location
, "name lookup of %qD changed for ISO %<for%> scoping",
1439 if (flag_permissive
)
1440 permerror (DECL_SOURCE_LOCATION (decl
),
1441 " using obsolete binding at %qD", decl
);
1447 inform (input_location
, "(if you use %<-fpermissive%> G++ will accept your code)");
1456 /* true means unconditionally make a BLOCK for the next level pushed. */
1458 static bool keep_next_level_flag
;
1460 static int binding_depth
= 0;
1467 for (i
= 0; i
< depth
* 2; i
++)
1471 /* Return a string describing the kind of SCOPE we have. */
1473 cp_binding_level_descriptor (cp_binding_level
*scope
)
1475 /* The order of this table must match the "scope_kind"
1477 static const char* scope_kind_names
[] = {
1483 "function-parameter-scope",
1486 "template-parameter-scope",
1487 "template-explicit-spec-scope"
1489 const scope_kind kind
= scope
->explicit_spec_p
1490 ? sk_template_spec
: scope
->kind
;
1492 return scope_kind_names
[kind
];
1495 /* Output a debugging information about SCOPE when performing
1498 cp_binding_level_debug (cp_binding_level
*scope
, int line
, const char *action
)
1500 const char *desc
= cp_binding_level_descriptor (scope
);
1501 if (scope
->this_entity
)
1502 verbatim ("%s %s(%E) %p %d\n", action
, desc
,
1503 scope
->this_entity
, (void *) scope
, line
);
1505 verbatim ("%s %s %p %d\n", action
, desc
, (void *) scope
, line
);
1508 /* Return the estimated initial size of the hashtable of a NAMESPACE
1511 static inline size_t
1512 namespace_scope_ht_size (tree ns
)
1514 tree name
= DECL_NAME (ns
);
1516 return name
== std_identifier
1517 ? NAMESPACE_STD_HT_SIZE
1518 : (name
== global_scope_name
1519 ? GLOBAL_SCOPE_HT_SIZE
1520 : NAMESPACE_ORDINARY_HT_SIZE
);
1523 /* A chain of binding_level structures awaiting reuse. */
1525 static GTY((deletable
)) cp_binding_level
*free_binding_level
;
1527 /* Insert SCOPE as the innermost binding level. */
1530 push_binding_level (cp_binding_level
*scope
)
1532 /* Add it to the front of currently active scopes stack. */
1533 scope
->level_chain
= current_binding_level
;
1534 current_binding_level
= scope
;
1535 keep_next_level_flag
= false;
1537 if (ENABLE_SCOPE_CHECKING
)
1539 scope
->binding_depth
= binding_depth
;
1540 indent (binding_depth
);
1541 cp_binding_level_debug (scope
, LOCATION_LINE (input_location
),
1547 /* Create a new KIND scope and make it the top of the active scopes stack.
1548 ENTITY is the scope of the associated C++ entity (namespace, class,
1549 function, C++0x enumeration); it is NULL otherwise. */
1552 begin_scope (scope_kind kind
, tree entity
)
1554 cp_binding_level
*scope
;
1556 /* Reuse or create a struct for this binding level. */
1557 if (!ENABLE_SCOPE_CHECKING
&& free_binding_level
)
1559 scope
= free_binding_level
;
1560 free_binding_level
= scope
->level_chain
;
1561 memset (scope
, 0, sizeof (cp_binding_level
));
1564 scope
= ggc_cleared_alloc
<cp_binding_level
> ();
1566 scope
->this_entity
= entity
;
1567 scope
->more_cleanups_ok
= true;
1574 case sk_template_spec
:
1575 scope
->explicit_spec_p
= true;
1576 kind
= sk_template_parms
;
1578 case sk_template_parms
:
1585 case sk_scoped_enum
:
1586 case sk_function_parms
:
1587 case sk_transaction
:
1589 scope
->keep
= keep_next_level_flag
;
1593 NAMESPACE_LEVEL (entity
) = scope
;
1594 vec_alloc (scope
->static_decls
,
1595 (DECL_NAME (entity
) == std_identifier
1596 || DECL_NAME (entity
) == global_scope_name
) ? 200 : 10);
1600 /* Should not happen. */
1606 push_binding_level (scope
);
1611 /* We're about to leave current scope. Pop the top of the stack of
1612 currently active scopes. Return the enclosing scope, now active. */
1617 cp_binding_level
*scope
= current_binding_level
;
1619 if (scope
->kind
== sk_namespace
&& class_binding_level
)
1620 current_binding_level
= class_binding_level
;
1622 /* We cannot leave a scope, if there are none left. */
1623 if (NAMESPACE_LEVEL (global_namespace
))
1624 gcc_assert (!global_scope_p (scope
));
1626 if (ENABLE_SCOPE_CHECKING
)
1628 indent (--binding_depth
);
1629 cp_binding_level_debug (scope
, LOCATION_LINE (input_location
),
1633 /* Move one nesting level up. */
1634 current_binding_level
= scope
->level_chain
;
1636 /* Namespace-scopes are left most probably temporarily, not
1637 completely; they can be reopened later, e.g. in namespace-extension
1638 or any name binding activity that requires us to resume a
1639 namespace. For classes, we cache some binding levels. For other
1640 scopes, we just make the structure available for reuse. */
1641 if (scope
->kind
!= sk_namespace
1642 && scope
->kind
!= sk_class
)
1644 scope
->level_chain
= free_binding_level
;
1645 gcc_assert (!ENABLE_SCOPE_CHECKING
1646 || scope
->binding_depth
== binding_depth
);
1647 free_binding_level
= scope
;
1650 if (scope
->kind
== sk_class
)
1652 /* Reset DEFINING_CLASS_P to allow for reuse of a
1653 class-defining scope in a non-defining context. */
1654 scope
->defining_class_p
= 0;
1656 /* Find the innermost enclosing class scope, and reset
1657 CLASS_BINDING_LEVEL appropriately. */
1658 class_binding_level
= NULL
;
1659 for (scope
= current_binding_level
; scope
; scope
= scope
->level_chain
)
1660 if (scope
->kind
== sk_class
)
1662 class_binding_level
= scope
;
1667 return current_binding_level
;
1671 resume_scope (cp_binding_level
* b
)
1673 /* Resuming binding levels is meant only for namespaces,
1674 and those cannot nest into classes. */
1675 gcc_assert (!class_binding_level
);
1676 /* Also, resuming a non-directly nested namespace is a no-no. */
1677 gcc_assert (b
->level_chain
== current_binding_level
);
1678 current_binding_level
= b
;
1679 if (ENABLE_SCOPE_CHECKING
)
1681 b
->binding_depth
= binding_depth
;
1682 indent (binding_depth
);
1683 cp_binding_level_debug (b
, LOCATION_LINE (input_location
), "resume");
1688 /* Return the innermost binding level that is not for a class scope. */
1690 static cp_binding_level
*
1691 innermost_nonclass_level (void)
1693 cp_binding_level
*b
;
1695 b
= current_binding_level
;
1696 while (b
->kind
== sk_class
)
1702 /* We're defining an object of type TYPE. If it needs a cleanup, but
1703 we're not allowed to add any more objects with cleanups to the current
1704 scope, create a new binding level. */
1707 maybe_push_cleanup_level (tree type
)
1709 if (type
!= error_mark_node
1710 && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
)
1711 && current_binding_level
->more_cleanups_ok
== 0)
1713 begin_scope (sk_cleanup
, NULL
);
1714 current_binding_level
->statement_list
= push_stmt_list ();
1718 /* Return true if we are in the global binding level. */
1721 global_bindings_p (void)
1723 return global_scope_p (current_binding_level
);
1726 /* True if we are currently in a toplevel binding level. This
1727 means either the global binding level or a namespace in a toplevel
1728 binding level. Since there are no non-toplevel namespace levels,
1729 this really means any namespace or template parameter level. We
1730 also include a class whose context is toplevel. */
1733 toplevel_bindings_p (void)
1735 cp_binding_level
*b
= innermost_nonclass_level ();
1737 return b
->kind
== sk_namespace
|| b
->kind
== sk_template_parms
;
1740 /* True if this is a namespace scope, or if we are defining a class
1741 which is itself at namespace scope, or whose enclosing class is
1742 such a class, etc. */
1745 namespace_bindings_p (void)
1747 cp_binding_level
*b
= innermost_nonclass_level ();
1749 return b
->kind
== sk_namespace
;
1752 /* True if the innermost non-class scope is a block scope. */
1755 local_bindings_p (void)
1757 cp_binding_level
*b
= innermost_nonclass_level ();
1758 return b
->kind
< sk_function_parms
|| b
->kind
== sk_omp
;
1761 /* True if the current level needs to have a BLOCK made. */
1766 return (current_binding_level
->blocks
!= NULL_TREE
1767 || current_binding_level
->keep
1768 || current_binding_level
->kind
== sk_cleanup
1769 || current_binding_level
->names
!= NULL_TREE
1770 || current_binding_level
->using_directives
);
1773 /* Returns the kind of the innermost scope. */
1776 innermost_scope_kind (void)
1778 return current_binding_level
->kind
;
1781 /* Returns true if this scope was created to store template parameters. */
1784 template_parm_scope_p (void)
1786 return innermost_scope_kind () == sk_template_parms
;
1789 /* If KEEP is true, make a BLOCK node for the next binding level,
1790 unconditionally. Otherwise, use the normal logic to decide whether
1791 or not to create a BLOCK. */
1794 keep_next_level (bool keep
)
1796 keep_next_level_flag
= keep
;
1799 /* Return the list of declarations of the current level.
1800 Note that this list is in reverse order unless/until
1801 you nreverse it; and when you do nreverse it, you must
1802 store the result back using `storedecls' or you will lose. */
1807 return current_binding_level
->names
;
1810 /* Return how many function prototypes we are currently nested inside. */
1813 function_parm_depth (void)
1816 cp_binding_level
*b
;
1818 for (b
= current_binding_level
;
1819 b
->kind
== sk_function_parms
;
1826 /* For debugging. */
1827 static int no_print_functions
= 0;
1828 static int no_print_builtins
= 0;
1831 print_binding_level (cp_binding_level
* lvl
)
1835 fprintf (stderr
, " blocks=%p", (void *) lvl
->blocks
);
1836 if (lvl
->more_cleanups_ok
)
1837 fprintf (stderr
, " more-cleanups-ok");
1838 if (lvl
->have_cleanups
)
1839 fprintf (stderr
, " have-cleanups");
1840 fprintf (stderr
, "\n");
1843 fprintf (stderr
, " names:\t");
1844 /* We can probably fit 3 names to a line? */
1845 for (t
= lvl
->names
; t
; t
= TREE_CHAIN (t
))
1847 if (no_print_functions
&& (TREE_CODE (t
) == FUNCTION_DECL
))
1849 if (no_print_builtins
1850 && (TREE_CODE (t
) == TYPE_DECL
)
1851 && DECL_IS_BUILTIN (t
))
1854 /* Function decls tend to have longer names. */
1855 if (TREE_CODE (t
) == FUNCTION_DECL
)
1862 fprintf (stderr
, "\n\t");
1865 print_node_brief (stderr
, "", t
, 0);
1866 if (t
== error_mark_node
)
1870 fprintf (stderr
, "\n");
1872 if (vec_safe_length (lvl
->class_shadowed
))
1875 cp_class_binding
*b
;
1876 fprintf (stderr
, " class-shadowed:");
1877 FOR_EACH_VEC_ELT (*lvl
->class_shadowed
, i
, b
)
1878 fprintf (stderr
, " %s ", IDENTIFIER_POINTER (b
->identifier
));
1879 fprintf (stderr
, "\n");
1881 if (lvl
->type_shadowed
)
1883 fprintf (stderr
, " type-shadowed:");
1884 for (t
= lvl
->type_shadowed
; t
; t
= TREE_CHAIN (t
))
1886 fprintf (stderr
, " %s ", IDENTIFIER_POINTER (TREE_PURPOSE (t
)));
1888 fprintf (stderr
, "\n");
1893 debug (cp_binding_level
&ref
)
1895 print_binding_level (&ref
);
1899 debug (cp_binding_level
*ptr
)
1904 fprintf (stderr
, "<nil>\n");
1909 print_other_binding_stack (cp_binding_level
*stack
)
1911 cp_binding_level
*level
;
1912 for (level
= stack
; !global_scope_p (level
); level
= level
->level_chain
)
1914 fprintf (stderr
, "binding level %p\n", (void *) level
);
1915 print_binding_level (level
);
1920 print_binding_stack (void)
1922 cp_binding_level
*b
;
1923 fprintf (stderr
, "current_binding_level=%p\n"
1924 "class_binding_level=%p\n"
1925 "NAMESPACE_LEVEL (global_namespace)=%p\n",
1926 (void *) current_binding_level
, (void *) class_binding_level
,
1927 (void *) NAMESPACE_LEVEL (global_namespace
));
1928 if (class_binding_level
)
1930 for (b
= class_binding_level
; b
; b
= b
->level_chain
)
1931 if (b
== current_binding_level
)
1934 b
= class_binding_level
;
1936 b
= current_binding_level
;
1939 b
= current_binding_level
;
1940 print_other_binding_stack (b
);
1941 fprintf (stderr
, "global:\n");
1942 print_binding_level (NAMESPACE_LEVEL (global_namespace
));
1945 /* Return the type associated with ID. */
1948 identifier_type_value_1 (tree id
)
1950 /* There is no type with that name, anywhere. */
1951 if (REAL_IDENTIFIER_TYPE_VALUE (id
) == NULL_TREE
)
1953 /* This is not the type marker, but the real thing. */
1954 if (REAL_IDENTIFIER_TYPE_VALUE (id
) != global_type_node
)
1955 return REAL_IDENTIFIER_TYPE_VALUE (id
);
1956 /* Have to search for it. It must be on the global level, now.
1957 Ask lookup_name not to return non-types. */
1958 id
= lookup_name_real (id
, 2, 1, /*block_p=*/true, 0, 0);
1960 return TREE_TYPE (id
);
1964 /* Wrapper for identifier_type_value_1. */
1967 identifier_type_value (tree id
)
1970 timevar_start (TV_NAME_LOOKUP
);
1971 ret
= identifier_type_value_1 (id
);
1972 timevar_stop (TV_NAME_LOOKUP
);
1977 /* Return the IDENTIFIER_GLOBAL_VALUE of T, for use in common code, since
1978 the definition of IDENTIFIER_GLOBAL_VALUE is different for C and C++. */
1981 identifier_global_value (tree t
)
1983 return IDENTIFIER_GLOBAL_VALUE (t
);
1986 /* Push a definition of struct, union or enum tag named ID. into
1987 binding_level B. DECL is a TYPE_DECL for the type. We assume that
1988 the tag ID is not already defined. */
1991 set_identifier_type_value_with_scope (tree id
, tree decl
, cp_binding_level
*b
)
1995 if (b
->kind
!= sk_namespace
)
1997 /* Shadow the marker, not the real thing, so that the marker
1998 gets restored later. */
1999 tree old_type_value
= REAL_IDENTIFIER_TYPE_VALUE (id
);
2001 = tree_cons (id
, old_type_value
, b
->type_shadowed
);
2002 type
= decl
? TREE_TYPE (decl
) : NULL_TREE
;
2003 TREE_TYPE (b
->type_shadowed
) = type
;
2007 cxx_binding
*binding
=
2008 binding_for_name (NAMESPACE_LEVEL (current_namespace
), id
);
2011 supplement_binding (binding
, decl
);
2013 binding
->value
= decl
;
2015 /* Store marker instead of real type. */
2016 type
= global_type_node
;
2018 SET_IDENTIFIER_TYPE_VALUE (id
, type
);
2021 /* As set_identifier_type_value_with_scope, but using
2022 current_binding_level. */
2025 set_identifier_type_value (tree id
, tree decl
)
2027 set_identifier_type_value_with_scope (id
, decl
, current_binding_level
);
2030 /* Return the name for the constructor (or destructor) for the
2031 specified class TYPE. When given a template, this routine doesn't
2032 lose the specialization. */
2035 constructor_name_full (tree type
)
2037 return TYPE_IDENTIFIER (TYPE_MAIN_VARIANT (type
));
2040 /* Return the name for the constructor (or destructor) for the
2041 specified class. When given a template, return the plain
2042 unspecialized name. */
2045 constructor_name (tree type
)
2048 name
= constructor_name_full (type
);
2049 if (IDENTIFIER_TEMPLATE (name
))
2050 name
= IDENTIFIER_TEMPLATE (name
);
2054 /* Returns TRUE if NAME is the name for the constructor for TYPE,
2055 which must be a class type. */
2058 constructor_name_p (tree name
, tree type
)
2062 gcc_assert (MAYBE_CLASS_TYPE_P (type
));
2067 if (!identifier_p (name
))
2070 /* These don't have names. */
2071 if (TREE_CODE (type
) == DECLTYPE_TYPE
2072 || TREE_CODE (type
) == TYPEOF_TYPE
)
2075 ctor_name
= constructor_name_full (type
);
2076 if (name
== ctor_name
)
2078 if (IDENTIFIER_TEMPLATE (ctor_name
)
2079 && name
== IDENTIFIER_TEMPLATE (ctor_name
))
2084 /* Counter used to create anonymous type names. */
2086 static GTY(()) int anon_cnt
;
2088 /* Return an IDENTIFIER which can be used as a name for
2089 anonymous structs and unions. */
2092 make_anon_name (void)
2096 sprintf (buf
, anon_aggrname_format (), anon_cnt
++);
2097 return get_identifier (buf
);
2100 /* This code is practically identical to that for creating
2101 anonymous names, but is just used for lambdas instead. This isn't really
2102 necessary, but it's convenient to avoid treating lambdas like other
2105 static GTY(()) int lambda_cnt
= 0;
2108 make_lambda_name (void)
2112 sprintf (buf
, LAMBDANAME_FORMAT
, lambda_cnt
++);
2113 return get_identifier (buf
);
2116 /* Return (from the stack of) the BINDING, if any, established at SCOPE. */
2118 static inline cxx_binding
*
2119 find_binding (cp_binding_level
*scope
, cxx_binding
*binding
)
2121 for (; binding
!= NULL
; binding
= binding
->previous
)
2122 if (binding
->scope
== scope
)
2125 return (cxx_binding
*)0;
2128 /* Return the binding for NAME in SCOPE, if any. Otherwise, return NULL. */
2130 static inline cxx_binding
*
2131 cp_binding_level_find_binding_for_name (cp_binding_level
*scope
, tree name
)
2133 cxx_binding
*b
= IDENTIFIER_NAMESPACE_BINDINGS (name
);
2136 /* Fold-in case where NAME is used only once. */
2137 if (scope
== b
->scope
&& b
->previous
== NULL
)
2139 return find_binding (scope
, b
);
2144 /* Always returns a binding for name in scope. If no binding is
2145 found, make a new one. */
2147 static cxx_binding
*
2148 binding_for_name (cp_binding_level
*scope
, tree name
)
2150 cxx_binding
*result
;
2152 result
= cp_binding_level_find_binding_for_name (scope
, name
);
2155 /* Not found, make a new one. */
2156 result
= cxx_binding_make (NULL
, NULL
);
2157 result
->previous
= IDENTIFIER_NAMESPACE_BINDINGS (name
);
2158 result
->scope
= scope
;
2159 result
->is_local
= false;
2160 result
->value_is_inherited
= false;
2161 IDENTIFIER_NAMESPACE_BINDINGS (name
) = result
;
2165 /* Walk through the bindings associated to the name of FUNCTION,
2166 and return the first declaration of a function with a
2167 "C" linkage specification, a.k.a 'extern "C"'.
2168 This function looks for the binding, regardless of which scope it
2169 has been defined in. It basically looks in all the known scopes.
2170 Note that this function does not lookup for bindings of builtin functions
2171 or for functions declared in system headers. */
2173 lookup_extern_c_fun_in_all_ns (tree function
)
2178 gcc_assert (function
&& TREE_CODE (function
) == FUNCTION_DECL
);
2180 name
= DECL_NAME (function
);
2181 gcc_assert (name
&& identifier_p (name
));
2183 for (iter
= IDENTIFIER_NAMESPACE_BINDINGS (name
);
2185 iter
= iter
->previous
)
2188 for (ovl
= iter
->value
; ovl
; ovl
= OVL_NEXT (ovl
))
2190 tree decl
= OVL_CURRENT (ovl
);
2192 && TREE_CODE (decl
) == FUNCTION_DECL
2193 && DECL_EXTERN_C_P (decl
)
2194 && !DECL_ARTIFICIAL (decl
))
2203 /* Returns a list of C-linkage decls with the name NAME. */
2206 c_linkage_bindings (tree name
)
2208 tree decls
= NULL_TREE
;
2211 for (iter
= IDENTIFIER_NAMESPACE_BINDINGS (name
);
2213 iter
= iter
->previous
)
2216 for (ovl
= iter
->value
; ovl
; ovl
= OVL_NEXT (ovl
))
2218 tree decl
= OVL_CURRENT (ovl
);
2220 && DECL_EXTERN_C_P (decl
)
2221 && !DECL_ARTIFICIAL (decl
))
2223 if (decls
== NULL_TREE
)
2226 decls
= tree_cons (NULL_TREE
, decl
, decls
);
2233 /* Insert another USING_DECL into the current binding level, returning
2234 this declaration. If this is a redeclaration, do nothing, and
2235 return NULL_TREE if this not in namespace scope (in namespace
2236 scope, a using decl might extend any previous bindings). */
2239 push_using_decl_1 (tree scope
, tree name
)
2243 gcc_assert (TREE_CODE (scope
) == NAMESPACE_DECL
);
2244 gcc_assert (identifier_p (name
));
2245 for (decl
= current_binding_level
->usings
; decl
; decl
= DECL_CHAIN (decl
))
2246 if (USING_DECL_SCOPE (decl
) == scope
&& DECL_NAME (decl
) == name
)
2249 return namespace_bindings_p () ? decl
: NULL_TREE
;
2250 decl
= build_lang_decl (USING_DECL
, name
, NULL_TREE
);
2251 USING_DECL_SCOPE (decl
) = scope
;
2252 DECL_CHAIN (decl
) = current_binding_level
->usings
;
2253 current_binding_level
->usings
= decl
;
2257 /* Wrapper for push_using_decl_1. */
2260 push_using_decl (tree scope
, tree name
)
2263 timevar_start (TV_NAME_LOOKUP
);
2264 ret
= push_using_decl_1 (scope
, name
);
2265 timevar_stop (TV_NAME_LOOKUP
);
2269 /* Same as pushdecl, but define X in binding-level LEVEL. We rely on the
2270 caller to set DECL_CONTEXT properly.
2272 Note that this must only be used when X will be the new innermost
2273 binding for its name, as we tack it onto the front of IDENTIFIER_BINDING
2274 without checking to see if the current IDENTIFIER_BINDING comes from a
2275 closer binding level than LEVEL. */
2278 pushdecl_with_scope_1 (tree x
, cp_binding_level
*level
, bool is_friend
)
2280 cp_binding_level
*b
;
2281 tree function_decl
= current_function_decl
;
2283 current_function_decl
= NULL_TREE
;
2284 if (level
->kind
== sk_class
)
2286 b
= class_binding_level
;
2287 class_binding_level
= level
;
2288 pushdecl_class_level (x
);
2289 class_binding_level
= b
;
2293 b
= current_binding_level
;
2294 current_binding_level
= level
;
2295 x
= pushdecl_maybe_friend (x
, is_friend
);
2296 current_binding_level
= b
;
2298 current_function_decl
= function_decl
;
2302 /* Wrapper for pushdecl_with_scope_1. */
2305 pushdecl_with_scope (tree x
, cp_binding_level
*level
, bool is_friend
)
2308 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
2309 ret
= pushdecl_with_scope_1 (x
, level
, is_friend
);
2310 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
2314 /* Helper function for push_overloaded_decl_1 and do_nonmember_using_decl.
2315 Compares the parameter-type-lists of DECL1 and DECL2 and returns false
2316 if they are different. If the DECLs are template functions, the return
2317 types and the template parameter lists are compared too (DR 565). */
2320 compparms_for_decl_and_using_decl (tree decl1
, tree decl2
)
2322 if (!compparms (TYPE_ARG_TYPES (TREE_TYPE (decl1
)),
2323 TYPE_ARG_TYPES (TREE_TYPE (decl2
))))
2326 if (! DECL_FUNCTION_TEMPLATE_P (decl1
)
2327 || ! DECL_FUNCTION_TEMPLATE_P (decl2
))
2330 return (comp_template_parms (DECL_TEMPLATE_PARMS (decl1
),
2331 DECL_TEMPLATE_PARMS (decl2
))
2332 && same_type_p (TREE_TYPE (TREE_TYPE (decl1
)),
2333 TREE_TYPE (TREE_TYPE (decl2
))));
2336 /* DECL is a FUNCTION_DECL for a non-member function, which may have
2337 other definitions already in place. We get around this by making
2338 the value of the identifier point to a list of all the things that
2339 want to be referenced by that name. It is then up to the users of
2340 that name to decide what to do with that list.
2342 DECL may also be a TEMPLATE_DECL, with a FUNCTION_DECL in its
2343 DECL_TEMPLATE_RESULT. It is dealt with the same way.
2345 FLAGS is a bitwise-or of the following values:
2346 PUSH_LOCAL: Bind DECL in the current scope, rather than at
2348 PUSH_USING: DECL is being pushed as the result of a using
2351 IS_FRIEND is true if this is a friend declaration.
2353 The value returned may be a previous declaration if we guessed wrong
2354 about what language DECL should belong to (C or C++). Otherwise,
2355 it's always DECL (and never something that's not a _DECL). */
2358 push_overloaded_decl_1 (tree decl
, int flags
, bool is_friend
)
2360 tree name
= DECL_NAME (decl
);
2363 int doing_global
= (namespace_bindings_p () || !(flags
& PUSH_LOCAL
));
2366 old
= namespace_binding (name
, DECL_CONTEXT (decl
));
2368 old
= lookup_name_innermost_nonclass_level (name
);
2372 if (TREE_CODE (old
) == TYPE_DECL
&& DECL_ARTIFICIAL (old
))
2374 tree t
= TREE_TYPE (old
);
2375 if (MAYBE_CLASS_TYPE_P (t
) && warn_shadow
2376 && (! DECL_IN_SYSTEM_HEADER (decl
)
2377 || ! DECL_IN_SYSTEM_HEADER (old
)))
2378 warning (OPT_Wshadow
, "%q#D hides constructor for %q#T", decl
, t
);
2381 else if (is_overloaded_fn (old
))
2385 for (tmp
= old
; tmp
; tmp
= OVL_NEXT (tmp
))
2387 tree fn
= OVL_CURRENT (tmp
);
2390 if (TREE_CODE (tmp
) == OVERLOAD
&& OVL_USED (tmp
)
2391 && !(flags
& PUSH_USING
)
2392 && compparms_for_decl_and_using_decl (fn
, decl
)
2393 && ! decls_match (fn
, decl
))
2394 diagnose_name_conflict (decl
, fn
);
2396 dup
= duplicate_decls (decl
, fn
, is_friend
);
2397 /* If DECL was a redeclaration of FN -- even an invalid
2398 one -- pass that information along to our caller. */
2399 if (dup
== fn
|| dup
== error_mark_node
)
2403 /* We don't overload implicit built-ins. duplicate_decls()
2404 may fail to merge the decls if the new decl is e.g. a
2405 template function. */
2406 if (TREE_CODE (old
) == FUNCTION_DECL
2407 && DECL_ANTICIPATED (old
)
2408 && !DECL_HIDDEN_FRIEND_P (old
))
2411 else if (old
== error_mark_node
)
2412 /* Ignore the undefined symbol marker. */
2416 error ("previous non-function declaration %q+#D", old
);
2417 error ("conflicts with function declaration %q#D", decl
);
2422 if (old
|| TREE_CODE (decl
) == TEMPLATE_DECL
2423 /* If it's a using declaration, we always need to build an OVERLOAD,
2424 because it's the only way to remember that the declaration comes
2425 from 'using', and have the lookup behave correctly. */
2426 || (flags
& PUSH_USING
))
2428 if (old
&& TREE_CODE (old
) != OVERLOAD
)
2429 new_binding
= ovl_cons (decl
, ovl_cons (old
, NULL_TREE
));
2431 new_binding
= ovl_cons (decl
, old
);
2432 if (flags
& PUSH_USING
)
2433 OVL_USED (new_binding
) = 1;
2436 /* NAME is not ambiguous. */
2440 set_namespace_binding (name
, current_namespace
, new_binding
);
2443 /* We only create an OVERLOAD if there was a previous binding at
2444 this level, or if decl is a template. In the former case, we
2445 need to remove the old binding and replace it with the new
2446 binding. We must also run through the NAMES on the binding
2447 level where the name was bound to update the chain. */
2449 if (TREE_CODE (new_binding
) == OVERLOAD
&& old
)
2453 for (d
= &IDENTIFIER_BINDING (name
)->scope
->names
;
2455 d
= &TREE_CHAIN (*d
))
2457 || (TREE_CODE (*d
) == TREE_LIST
2458 && TREE_VALUE (*d
) == old
))
2460 if (TREE_CODE (*d
) == TREE_LIST
)
2461 /* Just replace the old binding with the new. */
2462 TREE_VALUE (*d
) = new_binding
;
2464 /* Build a TREE_LIST to wrap the OVERLOAD. */
2465 *d
= tree_cons (NULL_TREE
, new_binding
,
2468 /* And update the cxx_binding node. */
2469 IDENTIFIER_BINDING (name
)->value
= new_binding
;
2473 /* We should always find a previous binding in this case. */
2477 /* Install the new binding. */
2478 push_local_binding (name
, new_binding
, flags
);
2484 /* Wrapper for push_overloaded_decl_1. */
2487 push_overloaded_decl (tree decl
, int flags
, bool is_friend
)
2490 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
2491 ret
= push_overloaded_decl_1 (decl
, flags
, is_friend
);
2492 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
2496 /* Check a non-member using-declaration. Return the name and scope
2497 being used, and the USING_DECL, or NULL_TREE on failure. */
2500 validate_nonmember_using_decl (tree decl
, tree scope
, tree name
)
2502 /* [namespace.udecl]
2503 A using-declaration for a class member shall be a
2504 member-declaration. */
2507 error ("%qT is not a namespace or unscoped enum", scope
);
2510 else if (scope
== error_mark_node
)
2513 if (TREE_CODE (decl
) == TEMPLATE_ID_EXPR
)
2516 A using-declaration shall not name a template-id. */
2517 error ("a using-declaration cannot specify a template-id. "
2518 "Try %<using %D%>", name
);
2522 if (TREE_CODE (decl
) == NAMESPACE_DECL
)
2524 error ("namespace %qD not allowed in using-declaration", decl
);
2528 if (TREE_CODE (decl
) == SCOPE_REF
)
2530 /* It's a nested name with template parameter dependent scope.
2531 This can only be using-declaration for class member. */
2532 error ("%qT is not a namespace", TREE_OPERAND (decl
, 0));
2536 if (is_overloaded_fn (decl
))
2537 decl
= get_first_fn (decl
);
2539 gcc_assert (DECL_P (decl
));
2541 /* Make a USING_DECL. */
2542 tree using_decl
= push_using_decl (scope
, name
);
2544 if (using_decl
== NULL_TREE
2545 && at_function_scope_p ()
2547 /* C++11 7.3.3/10. */
2548 error ("%qD is already declared in this scope", name
);
2553 /* Process local and global using-declarations. */
2556 do_nonmember_using_decl (tree scope
, tree name
, tree oldval
, tree oldtype
,
2557 tree
*newval
, tree
*newtype
)
2559 struct scope_binding decls
= EMPTY_SCOPE_BINDING
;
2561 *newval
= *newtype
= NULL_TREE
;
2562 if (!qualified_lookup_using_namespace (name
, scope
, &decls
, 0))
2566 if (!decls
.value
&& !decls
.type
)
2568 error ("%qD not declared", name
);
2572 /* Shift the old and new bindings around so we're comparing class and
2573 enumeration names to each other. */
2574 if (oldval
&& DECL_IMPLICIT_TYPEDEF_P (oldval
))
2580 if (decls
.value
&& DECL_IMPLICIT_TYPEDEF_P (decls
.value
))
2582 decls
.type
= decls
.value
;
2583 decls
.value
= NULL_TREE
;
2588 /* Check for using functions. */
2589 if (is_overloaded_fn (decls
.value
))
2593 if (oldval
&& !is_overloaded_fn (oldval
))
2595 error ("%qD is already declared in this scope", name
);
2600 for (tmp
= decls
.value
; tmp
; tmp
= OVL_NEXT (tmp
))
2602 tree new_fn
= OVL_CURRENT (tmp
);
2604 /* Don't import functions that haven't been declared. */
2605 if (DECL_ANTICIPATED (new_fn
))
2608 /* [namespace.udecl]
2610 If a function declaration in namespace scope or block
2611 scope has the same name and the same parameter types as a
2612 function introduced by a using declaration the program is
2614 for (tmp1
= oldval
; tmp1
; tmp1
= OVL_NEXT (tmp1
))
2616 tree old_fn
= OVL_CURRENT (tmp1
);
2618 if (new_fn
== old_fn
)
2619 /* The function already exists in the current namespace. */
2621 else if (TREE_CODE (tmp1
) == OVERLOAD
&& OVL_USED (tmp1
))
2622 continue; /* this is a using decl */
2623 else if (compparms_for_decl_and_using_decl (new_fn
, old_fn
))
2625 /* There was already a non-using declaration in
2626 this scope with the same parameter types. If both
2627 are the same extern "C" functions, that's ok. */
2628 if (DECL_ANTICIPATED (old_fn
)
2629 && !DECL_HIDDEN_FRIEND_P (old_fn
))
2630 /* Ignore anticipated built-ins. */;
2631 else if (decls_match (new_fn
, old_fn
))
2635 diagnose_name_conflict (new_fn
, old_fn
);
2641 /* If we broke out of the loop, there's no reason to add
2642 this function to the using declarations for this
2647 /* If we are adding to an existing OVERLOAD, then we no
2648 longer know the type of the set of functions. */
2649 if (*newval
&& TREE_CODE (*newval
) == OVERLOAD
)
2650 TREE_TYPE (*newval
) = unknown_type_node
;
2651 /* Add this new function to the set. */
2652 *newval
= build_overload (OVL_CURRENT (tmp
), *newval
);
2653 /* If there is only one function, then we use its type. (A
2654 using-declaration naming a single function can be used in
2655 contexts where overload resolution cannot be
2657 if (TREE_CODE (*newval
) != OVERLOAD
)
2659 *newval
= ovl_cons (*newval
, NULL_TREE
);
2660 TREE_TYPE (*newval
) = TREE_TYPE (OVL_CURRENT (tmp
));
2662 OVL_USED (*newval
) = 1;
2667 /* If we're declaring a non-function and OLDVAL is an anticipated
2668 built-in, just pretend it isn't there. */
2670 && TREE_CODE (oldval
) == FUNCTION_DECL
2671 && DECL_ANTICIPATED (oldval
)
2672 && !DECL_HIDDEN_FRIEND_P (oldval
))
2675 *newval
= decls
.value
;
2676 if (oldval
&& !decls_match (*newval
, oldval
))
2677 error ("%qD is already declared in this scope", name
);
2683 if (decls
.type
&& TREE_CODE (decls
.type
) == TREE_LIST
)
2685 error ("reference to %qD is ambiguous", name
);
2686 print_candidates (decls
.type
);
2690 *newtype
= decls
.type
;
2691 if (oldtype
&& *newtype
&& !decls_match (oldtype
, *newtype
))
2692 error ("%qD is already declared in this scope", name
);
2695 /* If *newval is empty, shift any class or enumeration name down. */
2699 *newtype
= NULL_TREE
;
2703 /* Process a using-declaration at function scope. */
2706 do_local_using_decl (tree decl
, tree scope
, tree name
)
2708 tree oldval
, oldtype
, newval
, newtype
;
2709 tree orig_decl
= decl
;
2711 decl
= validate_nonmember_using_decl (decl
, scope
, name
);
2712 if (decl
== NULL_TREE
)
2715 if (building_stmt_list_p ()
2716 && at_function_scope_p ())
2717 add_decl_expr (decl
);
2719 oldval
= lookup_name_innermost_nonclass_level (name
);
2720 oldtype
= lookup_type_current_level (name
);
2722 do_nonmember_using_decl (scope
, name
, oldval
, oldtype
, &newval
, &newtype
);
2726 if (is_overloaded_fn (newval
))
2730 /* We only need to push declarations for those functions
2731 that were not already bound in the current level.
2732 The old value might be NULL_TREE, it might be a single
2733 function, or an OVERLOAD. */
2734 if (oldval
&& TREE_CODE (oldval
) == OVERLOAD
)
2735 term
= OVL_FUNCTION (oldval
);
2738 for (fn
= newval
; fn
&& OVL_CURRENT (fn
) != term
;
2740 push_overloaded_decl (OVL_CURRENT (fn
),
2741 PUSH_LOCAL
| PUSH_USING
,
2745 push_local_binding (name
, newval
, PUSH_USING
);
2749 push_local_binding (name
, newtype
, PUSH_USING
);
2750 set_identifier_type_value (name
, newtype
);
2753 /* Emit debug info. */
2754 if (!processing_template_decl
)
2755 cp_emit_debug_info_for_using (orig_decl
, current_scope());
2758 /* Returns true if ROOT (a namespace, class, or function) encloses
2759 CHILD. CHILD may be either a class type or a namespace. */
2762 is_ancestor (tree root
, tree child
)
2764 gcc_assert ((TREE_CODE (root
) == NAMESPACE_DECL
2765 || TREE_CODE (root
) == FUNCTION_DECL
2766 || CLASS_TYPE_P (root
)));
2767 gcc_assert ((TREE_CODE (child
) == NAMESPACE_DECL
2768 || CLASS_TYPE_P (child
)));
2770 /* The global namespace encloses everything. */
2771 if (root
== global_namespace
)
2776 /* If we've run out of scopes, stop. */
2779 /* If we've reached the ROOT, it encloses CHILD. */
2782 /* Go out one level. */
2784 child
= TYPE_NAME (child
);
2785 child
= DECL_CONTEXT (child
);
2789 /* Enter the class or namespace scope indicated by T suitable for name
2790 lookup. T can be arbitrary scope, not necessary nested inside the
2791 current scope. Returns a non-null scope to pop iff pop_scope
2792 should be called later to exit this scope. */
2797 if (TREE_CODE (t
) == NAMESPACE_DECL
)
2798 push_decl_namespace (t
);
2799 else if (CLASS_TYPE_P (t
))
2801 if (!at_class_scope_p ()
2802 || !same_type_p (current_class_type
, t
))
2803 push_nested_class (t
);
2805 /* T is the same as the current scope. There is therefore no
2806 need to re-enter the scope. Since we are not actually
2807 pushing a new scope, our caller should not call
2815 /* Leave scope pushed by push_scope. */
2822 if (TREE_CODE (t
) == NAMESPACE_DECL
)
2823 pop_decl_namespace ();
2824 else if CLASS_TYPE_P (t
)
2825 pop_nested_class ();
2828 /* Subroutine of push_inner_scope. */
2831 push_inner_scope_r (tree outer
, tree inner
)
2836 || (TREE_CODE (inner
) != NAMESPACE_DECL
&& !CLASS_TYPE_P (inner
)))
2839 prev
= CP_DECL_CONTEXT (TREE_CODE (inner
) == NAMESPACE_DECL
? inner
: TYPE_NAME (inner
));
2841 push_inner_scope_r (outer
, prev
);
2842 if (TREE_CODE (inner
) == NAMESPACE_DECL
)
2844 cp_binding_level
*save_template_parm
= 0;
2845 /* Temporary take out template parameter scopes. They are saved
2846 in reversed order in save_template_parm. */
2847 while (current_binding_level
->kind
== sk_template_parms
)
2849 cp_binding_level
*b
= current_binding_level
;
2850 current_binding_level
= b
->level_chain
;
2851 b
->level_chain
= save_template_parm
;
2852 save_template_parm
= b
;
2855 resume_scope (NAMESPACE_LEVEL (inner
));
2856 current_namespace
= inner
;
2858 /* Restore template parameter scopes. */
2859 while (save_template_parm
)
2861 cp_binding_level
*b
= save_template_parm
;
2862 save_template_parm
= b
->level_chain
;
2863 b
->level_chain
= current_binding_level
;
2864 current_binding_level
= b
;
2871 /* Enter the scope INNER from current scope. INNER must be a scope
2872 nested inside current scope. This works with both name lookup and
2873 pushing name into scope. In case a template parameter scope is present,
2874 namespace is pushed under the template parameter scope according to
2875 name lookup rule in 14.6.1/6.
2877 Return the former current scope suitable for pop_inner_scope. */
2880 push_inner_scope (tree inner
)
2882 tree outer
= current_scope ();
2884 outer
= current_namespace
;
2886 push_inner_scope_r (outer
, inner
);
2890 /* Exit the current scope INNER back to scope OUTER. */
2893 pop_inner_scope (tree outer
, tree inner
)
2896 || (TREE_CODE (inner
) != NAMESPACE_DECL
&& !CLASS_TYPE_P (inner
)))
2899 while (outer
!= inner
)
2901 if (TREE_CODE (inner
) == NAMESPACE_DECL
)
2903 cp_binding_level
*save_template_parm
= 0;
2904 /* Temporary take out template parameter scopes. They are saved
2905 in reversed order in save_template_parm. */
2906 while (current_binding_level
->kind
== sk_template_parms
)
2908 cp_binding_level
*b
= current_binding_level
;
2909 current_binding_level
= b
->level_chain
;
2910 b
->level_chain
= save_template_parm
;
2911 save_template_parm
= b
;
2916 /* Restore template parameter scopes. */
2917 while (save_template_parm
)
2919 cp_binding_level
*b
= save_template_parm
;
2920 save_template_parm
= b
->level_chain
;
2921 b
->level_chain
= current_binding_level
;
2922 current_binding_level
= b
;
2928 inner
= CP_DECL_CONTEXT (TREE_CODE (inner
) == NAMESPACE_DECL
? inner
: TYPE_NAME (inner
));
2932 /* Do a pushlevel for class declarations. */
2935 pushlevel_class (void)
2937 class_binding_level
= begin_scope (sk_class
, current_class_type
);
2940 /* ...and a poplevel for class declarations. */
2943 poplevel_class (void)
2945 cp_binding_level
*level
= class_binding_level
;
2946 cp_class_binding
*cb
;
2950 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
2951 gcc_assert (level
!= 0);
2953 /* If we're leaving a toplevel class, cache its binding level. */
2954 if (current_class_depth
== 1)
2955 previous_class_level
= level
;
2956 for (shadowed
= level
->type_shadowed
;
2958 shadowed
= TREE_CHAIN (shadowed
))
2959 SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (shadowed
), TREE_VALUE (shadowed
));
2961 /* Remove the bindings for all of the class-level declarations. */
2962 if (level
->class_shadowed
)
2964 FOR_EACH_VEC_ELT (*level
->class_shadowed
, i
, cb
)
2966 IDENTIFIER_BINDING (cb
->identifier
) = cb
->base
->previous
;
2967 cxx_binding_free (cb
->base
);
2969 ggc_free (level
->class_shadowed
);
2970 level
->class_shadowed
= NULL
;
2973 /* Now, pop out of the binding level which we created up in the
2974 `pushlevel_class' routine. */
2975 gcc_assert (current_binding_level
== level
);
2977 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
2980 /* Set INHERITED_VALUE_BINDING_P on BINDING to true or false, as
2981 appropriate. DECL is the value to which a name has just been
2982 bound. CLASS_TYPE is the class in which the lookup occurred. */
2985 set_inherited_value_binding_p (cxx_binding
*binding
, tree decl
,
2988 if (binding
->value
== decl
&& TREE_CODE (decl
) != TREE_LIST
)
2992 if (TREE_CODE (decl
) == OVERLOAD
)
2993 context
= ovl_scope (decl
);
2996 gcc_assert (DECL_P (decl
));
2997 context
= context_for_name_lookup (decl
);
3000 if (is_properly_derived_from (class_type
, context
))
3001 INHERITED_VALUE_BINDING_P (binding
) = 1;
3003 INHERITED_VALUE_BINDING_P (binding
) = 0;
3005 else if (binding
->value
== decl
)
3006 /* We only encounter a TREE_LIST when there is an ambiguity in the
3007 base classes. Such an ambiguity can be overridden by a
3008 definition in this class. */
3009 INHERITED_VALUE_BINDING_P (binding
) = 1;
3011 INHERITED_VALUE_BINDING_P (binding
) = 0;
3014 /* Make the declaration of X appear in CLASS scope. */
3017 pushdecl_class_level (tree x
)
3020 bool is_valid
= true;
3023 /* Do nothing if we're adding to an outer lambda closure type,
3024 outer_binding will add it later if it's needed. */
3025 if (current_class_type
!= class_binding_level
->this_entity
)
3028 subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
3029 /* Get the name of X. */
3030 if (TREE_CODE (x
) == OVERLOAD
)
3031 name
= DECL_NAME (get_first_fn (x
));
3033 name
= DECL_NAME (x
);
3037 is_valid
= push_class_level_binding (name
, x
);
3038 if (TREE_CODE (x
) == TYPE_DECL
)
3039 set_identifier_type_value (name
, x
);
3041 else if (ANON_AGGR_TYPE_P (TREE_TYPE (x
)))
3043 /* If X is an anonymous aggregate, all of its members are
3044 treated as if they were members of the class containing the
3045 aggregate, for naming purposes. */
3048 for (f
= TYPE_FIELDS (TREE_TYPE (x
)); f
; f
= DECL_CHAIN (f
))
3050 location_t save_location
= input_location
;
3051 input_location
= DECL_SOURCE_LOCATION (f
);
3052 if (!pushdecl_class_level (f
))
3054 input_location
= save_location
;
3057 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
3061 /* Return the BINDING (if any) for NAME in SCOPE, which is a class
3062 scope. If the value returned is non-NULL, and the PREVIOUS field
3063 is not set, callers must set the PREVIOUS field explicitly. */
3065 static cxx_binding
*
3066 get_class_binding (tree name
, cp_binding_level
*scope
)
3071 cxx_binding
*binding
;
3073 class_type
= scope
->this_entity
;
3075 /* Get the type binding. */
3076 type_binding
= lookup_member (class_type
, name
,
3077 /*protect=*/2, /*want_type=*/true,
3078 tf_warning_or_error
);
3079 /* Get the value binding. */
3080 value_binding
= lookup_member (class_type
, name
,
3081 /*protect=*/2, /*want_type=*/false,
3082 tf_warning_or_error
);
3085 && (TREE_CODE (value_binding
) == TYPE_DECL
3086 || DECL_CLASS_TEMPLATE_P (value_binding
)
3087 || (TREE_CODE (value_binding
) == TREE_LIST
3088 && TREE_TYPE (value_binding
) == error_mark_node
3089 && (TREE_CODE (TREE_VALUE (value_binding
))
3091 /* We found a type binding, even when looking for a non-type
3092 binding. This means that we already processed this binding
3095 else if (value_binding
)
3097 if (TREE_CODE (value_binding
) == TREE_LIST
3098 && TREE_TYPE (value_binding
) == error_mark_node
)
3099 /* NAME is ambiguous. */
3101 else if (BASELINK_P (value_binding
))
3102 /* NAME is some overloaded functions. */
3103 value_binding
= BASELINK_FUNCTIONS (value_binding
);
3106 /* If we found either a type binding or a value binding, create a
3107 new binding object. */
3108 if (type_binding
|| value_binding
)
3110 binding
= new_class_binding (name
,
3114 /* This is a class-scope binding, not a block-scope binding. */
3115 LOCAL_BINDING_P (binding
) = 0;
3116 set_inherited_value_binding_p (binding
, value_binding
, class_type
);
3124 /* Make the declaration(s) of X appear in CLASS scope under the name
3125 NAME. Returns true if the binding is valid. */
3128 push_class_level_binding_1 (tree name
, tree x
)
3130 cxx_binding
*binding
;
3134 /* The class_binding_level will be NULL if x is a template
3135 parameter name in a member template. */
3136 if (!class_binding_level
)
3139 if (name
== error_mark_node
)
3142 /* Can happen for an erroneous declaration (c++/60384). */
3143 if (!identifier_p (name
))
3145 gcc_assert (errorcount
|| sorrycount
);
3149 /* Check for invalid member names. But don't worry about a default
3150 argument-scope lambda being pushed after the class is complete. */
3151 gcc_assert (TYPE_BEING_DEFINED (current_class_type
)
3152 || LAMBDA_TYPE_P (TREE_TYPE (decl
)));
3153 /* Check that we're pushing into the right binding level. */
3154 gcc_assert (current_class_type
== class_binding_level
->this_entity
);
3156 /* We could have been passed a tree list if this is an ambiguous
3157 declaration. If so, pull the declaration out because
3158 check_template_shadow will not handle a TREE_LIST. */
3159 if (TREE_CODE (decl
) == TREE_LIST
3160 && TREE_TYPE (decl
) == error_mark_node
)
3161 decl
= TREE_VALUE (decl
);
3163 if (!check_template_shadow (decl
))
3168 If T is the name of a class, then each of the following shall
3169 have a name different from T:
3171 -- every static data member of class T;
3173 -- every member of class T that is itself a type;
3175 -- every enumerator of every member of class T that is an
3178 -- every member of every anonymous union that is a member of
3181 (Non-static data members were also forbidden to have the same
3182 name as T until TC1.) */
3184 || TREE_CODE (x
) == CONST_DECL
3185 || (TREE_CODE (x
) == TYPE_DECL
3186 && !DECL_SELF_REFERENCE_P (x
))
3187 /* A data member of an anonymous union. */
3188 || (TREE_CODE (x
) == FIELD_DECL
3189 && DECL_CONTEXT (x
) != current_class_type
))
3190 && DECL_NAME (x
) == constructor_name (current_class_type
))
3192 tree scope
= context_for_name_lookup (x
);
3193 if (TYPE_P (scope
) && same_type_p (scope
, current_class_type
))
3195 error ("%qD has the same name as the class in which it is "
3202 /* Get the current binding for NAME in this class, if any. */
3203 binding
= IDENTIFIER_BINDING (name
);
3204 if (!binding
|| binding
->scope
!= class_binding_level
)
3206 binding
= get_class_binding (name
, class_binding_level
);
3207 /* If a new binding was created, put it at the front of the
3208 IDENTIFIER_BINDING list. */
3211 binding
->previous
= IDENTIFIER_BINDING (name
);
3212 IDENTIFIER_BINDING (name
) = binding
;
3216 /* If there is already a binding, then we may need to update the
3218 if (binding
&& binding
->value
)
3220 tree bval
= binding
->value
;
3221 tree old_decl
= NULL_TREE
;
3222 tree target_decl
= strip_using_decl (decl
);
3223 tree target_bval
= strip_using_decl (bval
);
3225 if (INHERITED_VALUE_BINDING_P (binding
))
3227 /* If the old binding was from a base class, and was for a
3228 tag name, slide it over to make room for the new binding.
3229 The old binding is still visible if explicitly qualified
3230 with a class-key. */
3231 if (TREE_CODE (target_bval
) == TYPE_DECL
3232 && DECL_ARTIFICIAL (target_bval
)
3233 && !(TREE_CODE (target_decl
) == TYPE_DECL
3234 && DECL_ARTIFICIAL (target_decl
)))
3236 old_decl
= binding
->type
;
3237 binding
->type
= bval
;
3238 binding
->value
= NULL_TREE
;
3239 INHERITED_VALUE_BINDING_P (binding
) = 0;
3244 /* Any inherited type declaration is hidden by the type
3245 declaration in the derived class. */
3246 if (TREE_CODE (target_decl
) == TYPE_DECL
3247 && DECL_ARTIFICIAL (target_decl
))
3248 binding
->type
= NULL_TREE
;
3251 else if (TREE_CODE (target_decl
) == OVERLOAD
3252 && is_overloaded_fn (target_bval
))
3254 else if (TREE_CODE (decl
) == USING_DECL
3255 && TREE_CODE (bval
) == USING_DECL
3256 && same_type_p (USING_DECL_SCOPE (decl
),
3257 USING_DECL_SCOPE (bval
)))
3258 /* This is a using redeclaration that will be diagnosed later
3259 in supplement_binding */
3261 else if (TREE_CODE (decl
) == USING_DECL
3262 && TREE_CODE (bval
) == USING_DECL
3263 && DECL_DEPENDENT_P (decl
)
3264 && DECL_DEPENDENT_P (bval
))
3266 else if (TREE_CODE (decl
) == USING_DECL
3267 && is_overloaded_fn (target_bval
))
3269 else if (TREE_CODE (bval
) == USING_DECL
3270 && is_overloaded_fn (target_decl
))
3273 if (old_decl
&& binding
->scope
== class_binding_level
)
3276 /* It is always safe to clear INHERITED_VALUE_BINDING_P
3277 here. This function is only used to register bindings
3278 from with the class definition itself. */
3279 INHERITED_VALUE_BINDING_P (binding
) = 0;
3284 /* Note that we declared this value so that we can issue an error if
3285 this is an invalid redeclaration of a name already used for some
3287 note_name_declared_in_class (name
, decl
);
3289 /* If we didn't replace an existing binding, put the binding on the
3290 stack of bindings for the identifier, and update the shadowed
3292 if (binding
&& binding
->scope
== class_binding_level
)
3293 /* Supplement the existing binding. */
3294 ok
= supplement_binding (binding
, decl
);
3297 /* Create a new binding. */
3298 push_binding (name
, decl
, class_binding_level
);
3305 /* Wrapper for push_class_level_binding_1. */
3308 push_class_level_binding (tree name
, tree x
)
3311 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
3312 ret
= push_class_level_binding_1 (name
, x
);
3313 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
3317 /* Process "using SCOPE::NAME" in a class scope. Return the
3318 USING_DECL created. */
3321 do_class_using_decl (tree scope
, tree name
)
3323 /* The USING_DECL returned by this function. */
3325 /* The declaration (or declarations) name by this using
3326 declaration. NULL if we are in a template and cannot figure out
3327 what has been named. */
3329 /* True if SCOPE is a dependent type. */
3330 bool scope_dependent_p
;
3331 /* True if SCOPE::NAME is dependent. */
3332 bool name_dependent_p
;
3333 /* True if any of the bases of CURRENT_CLASS_TYPE are dependent. */
3334 bool bases_dependent_p
;
3339 if (name
== error_mark_node
)
3342 if (!scope
|| !TYPE_P (scope
))
3344 error ("using-declaration for non-member at class scope");
3348 /* Make sure the name is not invalid */
3349 if (TREE_CODE (name
) == BIT_NOT_EXPR
)
3351 error ("%<%T::%D%> names destructor", scope
, name
);
3354 /* Using T::T declares inheriting ctors, even if T is a typedef. */
3355 if (MAYBE_CLASS_TYPE_P (scope
)
3356 && (name
== TYPE_IDENTIFIER (scope
)
3357 || constructor_name_p (name
, scope
)))
3359 maybe_warn_cpp0x (CPP0X_INHERITING_CTORS
);
3360 name
= ctor_identifier
;
3362 if (constructor_name_p (name
, current_class_type
))
3364 error ("%<%T::%D%> names constructor in %qT",
3365 scope
, name
, current_class_type
);
3369 scope_dependent_p
= dependent_scope_p (scope
);
3370 name_dependent_p
= (scope_dependent_p
3371 || (IDENTIFIER_TYPENAME_P (name
)
3372 && dependent_type_p (TREE_TYPE (name
))));
3374 bases_dependent_p
= false;
3375 if (processing_template_decl
)
3376 for (binfo
= TYPE_BINFO (current_class_type
), i
= 0;
3377 BINFO_BASE_ITERATE (binfo
, i
, base_binfo
);
3379 if (dependent_type_p (TREE_TYPE (base_binfo
)))
3381 bases_dependent_p
= true;
3387 /* From [namespace.udecl]:
3389 A using-declaration used as a member-declaration shall refer to a
3390 member of a base class of the class being defined.
3392 In general, we cannot check this constraint in a template because
3393 we do not know the entire set of base classes of the current
3394 class type. Morover, if SCOPE is dependent, it might match a
3395 non-dependent base. */
3397 if (!scope_dependent_p
)
3400 binfo
= lookup_base (current_class_type
, scope
, ba_any
, &b_kind
,
3401 tf_warning_or_error
);
3402 if (b_kind
< bk_proper_base
)
3404 if (!bases_dependent_p
|| b_kind
== bk_same_type
)
3406 error_not_base_type (scope
, current_class_type
);
3410 else if (!name_dependent_p
)
3412 decl
= lookup_member (binfo
, name
, 0, false, tf_warning_or_error
);
3415 error ("no members matching %<%T::%D%> in %q#T", scope
, name
,
3419 /* The binfo from which the functions came does not matter. */
3420 if (BASELINK_P (decl
))
3421 decl
= BASELINK_FUNCTIONS (decl
);
3425 value
= build_lang_decl (USING_DECL
, name
, NULL_TREE
);
3426 USING_DECL_DECLS (value
) = decl
;
3427 USING_DECL_SCOPE (value
) = scope
;
3428 DECL_DEPENDENT_P (value
) = !decl
;
3434 /* Return the binding value for name in scope. */
3438 namespace_binding_1 (tree name
, tree scope
)
3440 cxx_binding
*binding
;
3442 if (SCOPE_FILE_SCOPE_P (scope
))
3443 scope
= global_namespace
;
3445 /* Unnecessary for the global namespace because it can't be an alias. */
3446 scope
= ORIGINAL_NAMESPACE (scope
);
3448 binding
= cp_binding_level_find_binding_for_name (NAMESPACE_LEVEL (scope
), name
);
3450 return binding
? binding
->value
: NULL_TREE
;
3454 namespace_binding (tree name
, tree scope
)
3457 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
3458 ret
= namespace_binding_1 (name
, scope
);
3459 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
3463 /* Set the binding value for name in scope. */
3466 set_namespace_binding_1 (tree name
, tree scope
, tree val
)
3470 if (scope
== NULL_TREE
)
3471 scope
= global_namespace
;
3472 b
= binding_for_name (NAMESPACE_LEVEL (scope
), name
);
3473 if (!b
->value
|| TREE_CODE (val
) == OVERLOAD
|| val
== error_mark_node
)
3476 supplement_binding (b
, val
);
3479 /* Wrapper for set_namespace_binding_1. */
3482 set_namespace_binding (tree name
, tree scope
, tree val
)
3484 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
3485 set_namespace_binding_1 (name
, scope
, val
);
3486 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
3489 /* Set the context of a declaration to scope. Complain if we are not
3493 set_decl_namespace (tree decl
, tree scope
, bool friendp
)
3497 /* Get rid of namespace aliases. */
3498 scope
= ORIGINAL_NAMESPACE (scope
);
3500 /* It is ok for friends to be qualified in parallel space. */
3501 if (!friendp
&& !is_ancestor (current_namespace
, scope
))
3502 error ("declaration of %qD not in a namespace surrounding %qD",
3504 DECL_CONTEXT (decl
) = FROB_CONTEXT (scope
);
3506 /* Writing "int N::i" to declare a variable within "N" is invalid. */
3507 if (scope
== current_namespace
)
3509 if (at_namespace_scope_p ())
3510 error ("explicit qualification in declaration of %qD",
3515 /* See whether this has been declared in the namespace. */
3516 old
= lookup_qualified_name (scope
, DECL_NAME (decl
), /*type*/false,
3517 /*complain*/true, /*hidden*/true);
3518 if (old
== error_mark_node
)
3519 /* No old declaration at all. */
3521 /* If it's a TREE_LIST, the result of the lookup was ambiguous. */
3522 if (TREE_CODE (old
) == TREE_LIST
)
3524 error ("reference to %qD is ambiguous", decl
);
3525 print_candidates (old
);
3528 if (!is_overloaded_fn (decl
))
3530 /* We might have found OLD in an inline namespace inside SCOPE. */
3531 if (TREE_CODE (decl
) == TREE_CODE (old
))
3532 DECL_CONTEXT (decl
) = DECL_CONTEXT (old
);
3533 /* Don't compare non-function decls with decls_match here, since
3534 it can't check for the correct constness at this
3535 point. pushdecl will find those errors later. */
3538 /* Since decl is a function, old should contain a function decl. */
3539 if (!is_overloaded_fn (old
))
3541 /* A template can be explicitly specialized in any namespace. */
3542 if (processing_explicit_instantiation
)
3544 if (processing_template_decl
|| processing_specialization
)
3545 /* We have not yet called push_template_decl to turn a
3546 FUNCTION_DECL into a TEMPLATE_DECL, so the declarations won't
3547 match. But, we'll check later, when we construct the
3550 /* Instantiations or specializations of templates may be declared as
3551 friends in any namespace. */
3552 if (friendp
&& DECL_USE_TEMPLATE (decl
))
3554 if (is_overloaded_fn (old
))
3556 tree found
= NULL_TREE
;
3558 for (; elt
; elt
= OVL_NEXT (elt
))
3560 tree ofn
= OVL_CURRENT (elt
);
3561 /* Adjust DECL_CONTEXT first so decls_match will return true
3562 if DECL will match a declaration in an inline namespace. */
3563 DECL_CONTEXT (decl
) = DECL_CONTEXT (ofn
);
3564 if (decls_match (decl
, ofn
))
3566 if (found
&& !decls_match (found
, ofn
))
3568 DECL_CONTEXT (decl
) = FROB_CONTEXT (scope
);
3569 error ("reference to %qD is ambiguous", decl
);
3570 print_candidates (old
);
3578 if (!is_associated_namespace (scope
, CP_DECL_CONTEXT (found
)))
3580 if (DECL_HIDDEN_FRIEND_P (found
))
3582 pedwarn (DECL_SOURCE_LOCATION (decl
), 0,
3583 "%qD has not been declared within %D", decl
, scope
);
3584 inform (DECL_SOURCE_LOCATION (found
), "only here as a friend");
3586 DECL_CONTEXT (decl
) = DECL_CONTEXT (found
);
3592 DECL_CONTEXT (decl
) = DECL_CONTEXT (old
);
3593 if (decls_match (decl
, old
))
3597 /* It didn't work, go back to the explicit scope. */
3598 DECL_CONTEXT (decl
) = FROB_CONTEXT (scope
);
3600 error ("%qD should have been declared inside %qD", decl
, scope
);
3603 /* Return the namespace where the current declaration is declared. */
3606 current_decl_namespace (void)
3609 /* If we have been pushed into a different namespace, use it. */
3610 if (!vec_safe_is_empty (decl_namespace_list
))
3611 return decl_namespace_list
->last ();
3613 if (current_class_type
)
3614 result
= decl_namespace_context (current_class_type
);
3615 else if (current_function_decl
)
3616 result
= decl_namespace_context (current_function_decl
);
3618 result
= current_namespace
;
3622 /* Process any ATTRIBUTES on a namespace definition. Returns true if
3623 attribute visibility is seen. */
3626 handle_namespace_attrs (tree ns
, tree attributes
)
3629 bool saw_vis
= false;
3631 for (d
= attributes
; d
; d
= TREE_CHAIN (d
))
3633 tree name
= get_attribute_name (d
);
3634 tree args
= TREE_VALUE (d
);
3636 if (is_attribute_p ("visibility", name
))
3638 /* attribute visibility is a property of the syntactic block
3639 rather than the namespace as a whole, so we don't touch the
3640 NAMESPACE_DECL at all. */
3641 tree x
= args
? TREE_VALUE (args
) : NULL_TREE
;
3642 if (x
== NULL_TREE
|| TREE_CODE (x
) != STRING_CST
|| TREE_CHAIN (args
))
3644 warning (OPT_Wattributes
,
3645 "%qD attribute requires a single NTBS argument",
3650 if (!TREE_PUBLIC (ns
))
3651 warning (OPT_Wattributes
,
3652 "%qD attribute is meaningless since members of the "
3653 "anonymous namespace get local symbols", name
);
3655 push_visibility (TREE_STRING_POINTER (x
), 1);
3658 else if (is_attribute_p ("abi_tag", name
))
3660 if (!DECL_NAMESPACE_ASSOCIATIONS (ns
))
3662 warning (OPT_Wattributes
, "ignoring %qD attribute on non-inline "
3666 if (!DECL_NAME (ns
))
3668 warning (OPT_Wattributes
, "ignoring %qD attribute on anonymous "
3674 tree dn
= DECL_NAME (ns
);
3675 args
= build_string (IDENTIFIER_LENGTH (dn
) + 1,
3676 IDENTIFIER_POINTER (dn
));
3677 TREE_TYPE (args
) = char_array_type_node
;
3678 args
= fix_string_type (args
);
3679 args
= build_tree_list (NULL_TREE
, args
);
3681 if (check_abi_tag_args (args
, name
))
3682 DECL_ATTRIBUTES (ns
) = tree_cons (name
, args
,
3683 DECL_ATTRIBUTES (ns
));
3687 warning (OPT_Wattributes
, "%qD attribute directive ignored",
3696 /* Push into the scope of the NAME namespace. If NAME is NULL_TREE, then we
3697 select a name that is unique to this compilation unit. */
3700 push_namespace (tree name
)
3703 bool need_new
= true;
3704 bool implicit_use
= false;
3707 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
3709 /* We should not get here if the global_namespace is not yet constructed
3710 nor if NAME designates the global namespace: The global scope is
3711 constructed elsewhere. */
3712 gcc_assert (global_namespace
!= NULL
&& name
!= global_scope_name
);
3716 name
= get_anonymous_namespace_name();
3717 d
= IDENTIFIER_NAMESPACE_VALUE (name
);
3719 /* Reopening anonymous namespace. */
3721 implicit_use
= true;
3725 /* Check whether this is an extended namespace definition. */
3726 d
= IDENTIFIER_NAMESPACE_VALUE (name
);
3727 if (d
!= NULL_TREE
&& TREE_CODE (d
) == NAMESPACE_DECL
)
3729 tree dna
= DECL_NAMESPACE_ALIAS (d
);
3732 /* We do some error recovery for, eg, the redeclaration
3739 However, in nasty cases like:
3747 we just error out below, in duplicate_decls. */
3748 if (NAMESPACE_LEVEL (dna
)->level_chain
3749 == current_binding_level
)
3751 error ("namespace alias %qD not allowed here, "
3752 "assuming %qD", d
, dna
);
3764 /* Make a new namespace, binding the name to it. */
3765 d
= build_lang_decl (NAMESPACE_DECL
, name
, void_type_node
);
3766 DECL_CONTEXT (d
) = FROB_CONTEXT (current_namespace
);
3767 /* The name of this namespace is not visible to other translation
3768 units if it is an anonymous namespace or member thereof. */
3769 if (anon
|| decl_anon_ns_mem_p (current_namespace
))
3770 TREE_PUBLIC (d
) = 0;
3772 TREE_PUBLIC (d
) = 1;
3776 /* Clear DECL_NAME for the benefit of debugging back ends. */
3777 SET_DECL_ASSEMBLER_NAME (d
, name
);
3778 DECL_NAME (d
) = NULL_TREE
;
3780 begin_scope (sk_namespace
, d
);
3783 resume_scope (NAMESPACE_LEVEL (d
));
3786 do_using_directive (d
);
3787 /* Enter the name space. */
3788 current_namespace
= d
;
3790 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
3793 /* Pop from the scope of the current namespace. */
3796 pop_namespace (void)
3798 gcc_assert (current_namespace
!= global_namespace
);
3799 current_namespace
= CP_DECL_CONTEXT (current_namespace
);
3800 /* The binding level is not popped, as it might be re-opened later. */
3804 /* Push into the scope of the namespace NS, even if it is deeply
3805 nested within another namespace. */
3808 push_nested_namespace (tree ns
)
3810 if (ns
== global_namespace
)
3811 push_to_top_level ();
3814 push_nested_namespace (CP_DECL_CONTEXT (ns
));
3815 push_namespace (DECL_NAME (ns
));
3819 /* Pop back from the scope of the namespace NS, which was previously
3820 entered with push_nested_namespace. */
3823 pop_nested_namespace (tree ns
)
3825 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
3826 gcc_assert (current_namespace
== ns
);
3827 while (ns
!= global_namespace
)
3830 ns
= CP_DECL_CONTEXT (ns
);
3833 pop_from_top_level ();
3834 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
3837 /* Temporarily set the namespace for the current declaration. */
3840 push_decl_namespace (tree decl
)
3842 if (TREE_CODE (decl
) != NAMESPACE_DECL
)
3843 decl
= decl_namespace_context (decl
);
3844 vec_safe_push (decl_namespace_list
, ORIGINAL_NAMESPACE (decl
));
3847 /* [namespace.memdef]/2 */
3850 pop_decl_namespace (void)
3852 decl_namespace_list
->pop ();
3855 /* Return the namespace that is the common ancestor
3856 of two given namespaces. */
3859 namespace_ancestor_1 (tree ns1
, tree ns2
)
3862 if (is_ancestor (ns1
, ns2
))
3865 nsr
= namespace_ancestor_1 (CP_DECL_CONTEXT (ns1
), ns2
);
3869 /* Wrapper for namespace_ancestor_1. */
3872 namespace_ancestor (tree ns1
, tree ns2
)
3875 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
3876 nsr
= namespace_ancestor_1 (ns1
, ns2
);
3877 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
3881 /* Process a namespace-alias declaration. */
3884 do_namespace_alias (tree alias
, tree name_space
)
3886 if (name_space
== error_mark_node
)
3889 gcc_assert (TREE_CODE (name_space
) == NAMESPACE_DECL
);
3891 name_space
= ORIGINAL_NAMESPACE (name_space
);
3893 /* Build the alias. */
3894 alias
= build_lang_decl (NAMESPACE_DECL
, alias
, void_type_node
);
3895 DECL_NAMESPACE_ALIAS (alias
) = name_space
;
3896 DECL_EXTERNAL (alias
) = 1;
3897 DECL_CONTEXT (alias
) = FROB_CONTEXT (current_scope ());
3900 /* Emit debug info for namespace alias. */
3901 if (!building_stmt_list_p ())
3902 (*debug_hooks
->early_global_decl
) (alias
);
3905 /* Like pushdecl, only it places X in the current namespace,
3909 pushdecl_namespace_level (tree x
, bool is_friend
)
3911 cp_binding_level
*b
= current_binding_level
;
3914 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
3915 t
= pushdecl_with_scope (x
, NAMESPACE_LEVEL (current_namespace
), is_friend
);
3917 /* Now, the type_shadowed stack may screw us. Munge it so it does
3919 if (TREE_CODE (t
) == TYPE_DECL
)
3921 tree name
= DECL_NAME (t
);
3923 tree
*ptr
= (tree
*)0;
3924 for (; !global_scope_p (b
); b
= b
->level_chain
)
3926 tree shadowed
= b
->type_shadowed
;
3927 for (; shadowed
; shadowed
= TREE_CHAIN (shadowed
))
3928 if (TREE_PURPOSE (shadowed
) == name
)
3930 ptr
= &TREE_VALUE (shadowed
);
3931 /* Can't break out of the loop here because sometimes
3932 a binding level will have duplicate bindings for
3933 PT names. It's gross, but I haven't time to fix it. */
3936 newval
= TREE_TYPE (t
);
3937 if (ptr
== (tree
*)0)
3939 /* @@ This shouldn't be needed. My test case "zstring.cc" trips
3940 up here if this is changed to an assertion. --KR */
3941 SET_IDENTIFIER_TYPE_VALUE (name
, t
);
3948 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
3952 /* Insert USED into the using list of USER. Set INDIRECT_flag if this
3953 directive is not directly from the source. Also find the common
3954 ancestor and let our users know about the new namespace */
3957 add_using_namespace_1 (tree user
, tree used
, bool indirect
)
3960 /* Using oneself is a no-op. */
3963 gcc_assert (TREE_CODE (user
) == NAMESPACE_DECL
);
3964 gcc_assert (TREE_CODE (used
) == NAMESPACE_DECL
);
3965 /* Check if we already have this. */
3966 t
= purpose_member (used
, DECL_NAMESPACE_USING (user
));
3970 /* Promote to direct usage. */
3971 TREE_INDIRECT_USING (t
) = 0;
3975 /* Add used to the user's using list. */
3976 DECL_NAMESPACE_USING (user
)
3977 = tree_cons (used
, namespace_ancestor (user
, used
),
3978 DECL_NAMESPACE_USING (user
));
3980 TREE_INDIRECT_USING (DECL_NAMESPACE_USING (user
)) = indirect
;
3982 /* Add user to the used's users list. */
3983 DECL_NAMESPACE_USERS (used
)
3984 = tree_cons (user
, 0, DECL_NAMESPACE_USERS (used
));
3986 /* Recursively add all namespaces used. */
3987 for (t
= DECL_NAMESPACE_USING (used
); t
; t
= TREE_CHAIN (t
))
3988 /* indirect usage */
3989 add_using_namespace_1 (user
, TREE_PURPOSE (t
), 1);
3991 /* Tell everyone using us about the new used namespaces. */
3992 for (t
= DECL_NAMESPACE_USERS (user
); t
; t
= TREE_CHAIN (t
))
3993 add_using_namespace_1 (TREE_PURPOSE (t
), used
, 1);
3996 /* Wrapper for add_using_namespace_1. */
3999 add_using_namespace (tree user
, tree used
, bool indirect
)
4001 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
4002 add_using_namespace_1 (user
, used
, indirect
);
4003 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
4006 /* Process a using-declaration not appearing in class or local scope. */
4009 do_toplevel_using_decl (tree decl
, tree scope
, tree name
)
4011 tree oldval
, oldtype
, newval
, newtype
;
4012 tree orig_decl
= decl
;
4013 cxx_binding
*binding
;
4015 decl
= validate_nonmember_using_decl (decl
, scope
, name
);
4016 if (decl
== NULL_TREE
)
4019 binding
= binding_for_name (NAMESPACE_LEVEL (current_namespace
), name
);
4021 oldval
= binding
->value
;
4022 oldtype
= binding
->type
;
4024 do_nonmember_using_decl (scope
, name
, oldval
, oldtype
, &newval
, &newtype
);
4026 /* Emit debug info. */
4027 if (!processing_template_decl
)
4028 cp_emit_debug_info_for_using (orig_decl
, current_namespace
);
4030 /* Copy declarations found. */
4032 binding
->value
= newval
;
4034 binding
->type
= newtype
;
4037 /* Process a using-directive. */
4040 do_using_directive (tree name_space
)
4042 tree context
= NULL_TREE
;
4044 if (name_space
== error_mark_node
)
4047 gcc_assert (TREE_CODE (name_space
) == NAMESPACE_DECL
);
4049 if (building_stmt_list_p ())
4050 add_stmt (build_stmt (input_location
, USING_STMT
, name_space
));
4051 name_space
= ORIGINAL_NAMESPACE (name_space
);
4053 if (!toplevel_bindings_p ())
4055 push_using_directive (name_space
);
4060 add_using_namespace (current_namespace
, name_space
, 0);
4061 if (current_namespace
!= global_namespace
)
4062 context
= current_namespace
;
4064 /* Emit debugging info. */
4065 if (!processing_template_decl
)
4066 (*debug_hooks
->imported_module_or_decl
) (name_space
, NULL_TREE
,
4071 /* Deal with a using-directive seen by the parser. Currently we only
4072 handle attributes here, since they cannot appear inside a template. */
4075 parse_using_directive (tree name_space
, tree attribs
)
4077 do_using_directive (name_space
);
4079 if (attribs
== error_mark_node
)
4082 for (tree a
= attribs
; a
; a
= TREE_CHAIN (a
))
4084 tree name
= get_attribute_name (a
);
4085 if (is_attribute_p ("strong", name
))
4087 if (!toplevel_bindings_p ())
4088 error ("strong using only meaningful at namespace scope");
4089 else if (name_space
!= error_mark_node
)
4091 if (!is_ancestor (current_namespace
, name_space
))
4092 error ("current namespace %qD does not enclose strongly used namespace %qD",
4093 current_namespace
, name_space
);
4094 DECL_NAMESPACE_ASSOCIATIONS (name_space
)
4095 = tree_cons (current_namespace
, 0,
4096 DECL_NAMESPACE_ASSOCIATIONS (name_space
));
4100 warning (OPT_Wattributes
, "%qD attribute directive ignored", name
);
4104 /* Like pushdecl, only it places X in the global scope if appropriate.
4105 Calls cp_finish_decl to register the variable, initializing it with
4106 *INIT, if INIT is non-NULL. */
4109 pushdecl_top_level_1 (tree x
, tree
*init
, bool is_friend
)
4111 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
4112 push_to_top_level ();
4113 x
= pushdecl_namespace_level (x
, is_friend
);
4115 cp_finish_decl (x
, *init
, false, NULL_TREE
, 0);
4116 pop_from_top_level ();
4117 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
4121 /* Like pushdecl, only it places X in the global scope if appropriate. */
4124 pushdecl_top_level (tree x
)
4126 return pushdecl_top_level_1 (x
, NULL
, false);
4129 /* Like pushdecl_top_level, but adding the IS_FRIEND parameter. */
4132 pushdecl_top_level_maybe_friend (tree x
, bool is_friend
)
4134 return pushdecl_top_level_1 (x
, NULL
, is_friend
);
4137 /* Like pushdecl, only it places X in the global scope if
4138 appropriate. Calls cp_finish_decl to register the variable,
4139 initializing it with INIT. */
4142 pushdecl_top_level_and_finish (tree x
, tree init
)
4144 return pushdecl_top_level_1 (x
, &init
, false);
4147 /* Combines two sets of overloaded functions into an OVERLOAD chain, removing
4148 duplicates. The first list becomes the tail of the result.
4150 The algorithm is O(n^2). We could get this down to O(n log n) by
4151 doing a sort on the addresses of the functions, if that becomes
4155 merge_functions (tree s1
, tree s2
)
4157 for (; s2
; s2
= OVL_NEXT (s2
))
4159 tree fn2
= OVL_CURRENT (s2
);
4162 for (fns1
= s1
; fns1
; fns1
= OVL_NEXT (fns1
))
4164 tree fn1
= OVL_CURRENT (fns1
);
4166 /* If the function from S2 is already in S1, there is no
4167 need to add it again. For `extern "C"' functions, we
4168 might have two FUNCTION_DECLs for the same function, in
4169 different namespaces, but let's leave them in case
4170 they have different default arguments. */
4175 /* If we exhausted all of the functions in S1, FN2 is new. */
4177 s1
= build_overload (fn2
, s1
);
4182 /* Returns TRUE iff OLD and NEW are the same entity.
4184 3 [basic]/3: An entity is a value, object, reference, function,
4185 enumerator, type, class member, template, template specialization,
4186 namespace, parameter pack, or this.
4188 7.3.4 [namespace.udir]/4: If name lookup finds a declaration for a name
4189 in two different namespaces, and the declarations do not declare the
4190 same entity and do not declare functions, the use of the name is
4194 same_entity_p (tree one
, tree two
)
4200 if (TREE_CODE (one
) == TYPE_DECL
4201 && TREE_CODE (two
) == TYPE_DECL
4202 && same_type_p (TREE_TYPE (one
), TREE_TYPE (two
)))
4207 /* This should return an error not all definitions define functions.
4208 It is not an error if we find two functions with exactly the
4209 same signature, only if these are selected in overload resolution.
4210 old is the current set of bindings, new_binding the freshly-found binding.
4211 XXX Do we want to give *all* candidates in case of ambiguity?
4212 XXX In what way should I treat extern declarations?
4213 XXX I don't want to repeat the entire duplicate_decls here */
4216 ambiguous_decl (struct scope_binding
*old
, cxx_binding
*new_binding
, int flags
)
4219 gcc_assert (old
!= NULL
);
4221 /* Copy the type. */
4222 type
= new_binding
->type
;
4223 if (LOOKUP_NAMESPACES_ONLY (flags
)
4224 || (type
&& hidden_name_p (type
) && !(flags
& LOOKUP_HIDDEN
)))
4227 /* Copy the value. */
4228 val
= new_binding
->value
;
4231 if (!(flags
& LOOKUP_HIDDEN
))
4232 val
= remove_hidden_names (val
);
4234 switch (TREE_CODE (val
))
4237 /* If we expect types or namespaces, and not templates,
4238 or this is not a template class. */
4239 if ((LOOKUP_QUALIFIERS_ONLY (flags
)
4240 && !DECL_TYPE_TEMPLATE_P (val
)))
4244 if (LOOKUP_NAMESPACES_ONLY (flags
)
4245 || (type
&& (flags
& LOOKUP_PREFER_TYPES
)))
4248 case NAMESPACE_DECL
:
4249 if (LOOKUP_TYPES_ONLY (flags
))
4253 /* Ignore built-in functions that are still anticipated. */
4254 if (LOOKUP_QUALIFIERS_ONLY (flags
))
4258 if (LOOKUP_QUALIFIERS_ONLY (flags
))
4263 /* If val is hidden, shift down any class or enumeration name. */
4272 else if (val
&& !same_entity_p (val
, old
->value
))
4274 if (is_overloaded_fn (old
->value
) && is_overloaded_fn (val
))
4275 old
->value
= merge_functions (old
->value
, val
);
4278 old
->value
= tree_cons (NULL_TREE
, old
->value
,
4279 build_tree_list (NULL_TREE
, val
));
4280 TREE_TYPE (old
->value
) = error_mark_node
;
4286 else if (type
&& old
->type
!= type
)
4288 old
->type
= tree_cons (NULL_TREE
, old
->type
,
4289 build_tree_list (NULL_TREE
, type
));
4290 TREE_TYPE (old
->type
) = error_mark_node
;
4294 /* Return the declarations that are members of the namespace NS. */
4297 cp_namespace_decls (tree ns
)
4299 return NAMESPACE_LEVEL (ns
)->names
;
4302 /* Combine prefer_type and namespaces_only into flags. */
4305 lookup_flags (int prefer_type
, int namespaces_only
)
4307 if (namespaces_only
)
4308 return LOOKUP_PREFER_NAMESPACES
;
4309 if (prefer_type
> 1)
4310 return LOOKUP_PREFER_TYPES
;
4311 if (prefer_type
> 0)
4312 return LOOKUP_PREFER_BOTH
;
4316 /* Given a lookup that returned VAL, use FLAGS to decide if we want to
4317 ignore it or not. Subroutine of lookup_name_real and
4318 lookup_type_scope. */
4321 qualify_lookup (tree val
, int flags
)
4323 if (val
== NULL_TREE
)
4325 if ((flags
& LOOKUP_PREFER_NAMESPACES
) && TREE_CODE (val
) == NAMESPACE_DECL
)
4327 if (flags
& LOOKUP_PREFER_TYPES
)
4329 tree target_val
= strip_using_decl (val
);
4330 if (TREE_CODE (target_val
) == TYPE_DECL
4331 || TREE_CODE (target_val
) == TEMPLATE_DECL
)
4334 if (flags
& (LOOKUP_PREFER_NAMESPACES
| LOOKUP_PREFER_TYPES
))
4336 /* Look through lambda things that we shouldn't be able to see. */
4337 if (is_lambda_ignored_entity (val
))
4342 /* Given a lookup that returned VAL, decide if we want to ignore it or
4343 not based on DECL_ANTICIPATED. */
4346 hidden_name_p (tree val
)
4349 && DECL_LANG_SPECIFIC (val
)
4350 && TYPE_FUNCTION_OR_TEMPLATE_DECL_P (val
)
4351 && DECL_ANTICIPATED (val
))
4353 if (TREE_CODE (val
) == OVERLOAD
)
4355 for (tree o
= val
; o
; o
= OVL_CHAIN (o
))
4356 if (!hidden_name_p (OVL_FUNCTION (o
)))
4363 /* Remove any hidden declarations from a possibly overloaded set
4367 remove_hidden_names (tree fns
)
4372 if (DECL_P (fns
) && hidden_name_p (fns
))
4374 else if (TREE_CODE (fns
) == OVERLOAD
)
4378 for (o
= fns
; o
; o
= OVL_NEXT (o
))
4379 if (hidden_name_p (OVL_CURRENT (o
)))
4385 for (o
= fns
; o
; o
= OVL_NEXT (o
))
4386 if (!hidden_name_p (OVL_CURRENT (o
)))
4387 n
= build_overload (OVL_CURRENT (o
), n
);
4395 /* Suggest alternatives for NAME, an IDENTIFIER_NODE for which name
4396 lookup failed. Search through all available namespaces and print out
4397 possible candidates. */
4400 suggest_alternatives_for (location_t location
, tree name
)
4402 vec
<tree
> candidates
= vNULL
;
4403 vec
<tree
> namespaces_to_search
= vNULL
;
4404 int max_to_search
= PARAM_VALUE (CXX_MAX_NAMESPACES_FOR_DIAGNOSTIC_HELP
);
4409 namespaces_to_search
.safe_push (global_namespace
);
4411 while (!namespaces_to_search
.is_empty ()
4412 && n_searched
< max_to_search
)
4414 tree scope
= namespaces_to_search
.pop ();
4415 struct scope_binding binding
= EMPTY_SCOPE_BINDING
;
4416 cp_binding_level
*level
= NAMESPACE_LEVEL (scope
);
4418 /* Look in this namespace. */
4419 qualified_lookup_using_namespace (name
, scope
, &binding
, 0);
4424 candidates
.safe_push (binding
.value
);
4426 /* Add child namespaces. */
4427 for (t
= level
->namespaces
; t
; t
= DECL_CHAIN (t
))
4428 namespaces_to_search
.safe_push (t
);
4431 /* If we stopped before we could examine all namespaces, inform the
4432 user. Do this even if we don't have any candidates, since there
4433 might be more candidates further down that we weren't able to
4435 if (n_searched
>= max_to_search
4436 && !namespaces_to_search
.is_empty ())
4438 "maximum limit of %d namespaces searched for %qE",
4439 max_to_search
, name
);
4441 namespaces_to_search
.release ();
4443 /* Nothing useful to report. */
4444 if (candidates
.is_empty ())
4447 inform_n (location
, candidates
.length (),
4448 "suggested alternative:",
4449 "suggested alternatives:");
4451 FOR_EACH_VEC_ELT (candidates
, ix
, t
)
4452 inform (location_of (t
), " %qE", t
);
4454 candidates
.release ();
4457 /* Unscoped lookup of a global: iterate over current namespaces,
4458 considering using-directives. */
4461 unqualified_namespace_lookup_1 (tree name
, int flags
)
4463 tree initial
= current_decl_namespace ();
4464 tree scope
= initial
;
4466 cp_binding_level
*level
;
4467 tree val
= NULL_TREE
;
4469 for (; !val
; scope
= CP_DECL_CONTEXT (scope
))
4471 struct scope_binding binding
= EMPTY_SCOPE_BINDING
;
4473 cp_binding_level_find_binding_for_name (NAMESPACE_LEVEL (scope
), name
);
4476 ambiguous_decl (&binding
, b
, flags
);
4478 /* Add all _DECLs seen through local using-directives. */
4479 for (level
= current_binding_level
;
4480 level
->kind
!= sk_namespace
;
4481 level
= level
->level_chain
)
4482 if (!lookup_using_namespace (name
, &binding
, level
->using_directives
,
4484 /* Give up because of error. */
4485 return error_mark_node
;
4487 /* Add all _DECLs seen through global using-directives. */
4488 /* XXX local and global using lists should work equally. */
4492 if (!lookup_using_namespace (name
, &binding
,
4493 DECL_NAMESPACE_USING (siter
),
4495 /* Give up because of error. */
4496 return error_mark_node
;
4497 if (siter
== scope
) break;
4498 siter
= CP_DECL_CONTEXT (siter
);
4501 val
= binding
.value
;
4502 if (scope
== global_namespace
)
4508 /* Wrapper for unqualified_namespace_lookup_1. */
4511 unqualified_namespace_lookup (tree name
, int flags
)
4514 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
4515 ret
= unqualified_namespace_lookup_1 (name
, flags
);
4516 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
4520 /* Look up NAME (an IDENTIFIER_NODE) in SCOPE (either a NAMESPACE_DECL
4521 or a class TYPE). If IS_TYPE_P is TRUE, then ignore non-type
4524 Returns a DECL (or OVERLOAD, or BASELINK) representing the
4525 declaration found. If no suitable declaration can be found,
4526 ERROR_MARK_NODE is returned. If COMPLAIN is true and SCOPE is
4527 neither a class-type nor a namespace a diagnostic is issued. */
4530 lookup_qualified_name (tree scope
, tree name
, bool is_type_p
, bool complain
,
4537 flags
|= LOOKUP_HIDDEN
;
4539 if (TREE_CODE (scope
) == NAMESPACE_DECL
)
4541 struct scope_binding binding
= EMPTY_SCOPE_BINDING
;
4544 flags
|= LOOKUP_PREFER_TYPES
;
4545 if (qualified_lookup_using_namespace (name
, scope
, &binding
, flags
))
4548 else if (cxx_dialect
!= cxx98
&& TREE_CODE (scope
) == ENUMERAL_TYPE
)
4549 t
= lookup_enumerator (scope
, name
);
4550 else if (is_class_type (scope
, complain
))
4551 t
= lookup_member (scope
, name
, 2, is_type_p
, tf_warning_or_error
);
4554 return error_mark_node
;
4558 /* Subroutine of unqualified_namespace_lookup:
4559 Add the bindings of NAME in used namespaces to VAL.
4560 We are currently looking for names in namespace SCOPE, so we
4561 look through USINGS for using-directives of namespaces
4562 which have SCOPE as a common ancestor with the current scope.
4563 Returns false on errors. */
4566 lookup_using_namespace (tree name
, struct scope_binding
*val
,
4567 tree usings
, tree scope
, int flags
)
4570 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
4571 /* Iterate over all used namespaces in current, searching for using
4572 directives of scope. */
4573 for (iter
= usings
; iter
; iter
= TREE_CHAIN (iter
))
4574 if (TREE_VALUE (iter
) == scope
)
4576 tree used
= ORIGINAL_NAMESPACE (TREE_PURPOSE (iter
));
4578 cp_binding_level_find_binding_for_name (NAMESPACE_LEVEL (used
), name
);
4579 /* Resolve ambiguities. */
4581 ambiguous_decl (val
, val1
, flags
);
4583 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
4584 return val
->value
!= error_mark_node
;
4587 /* Returns true iff VEC contains TARGET. */
4590 tree_vec_contains (vec
<tree
, va_gc
> *vec
, tree target
)
4594 FOR_EACH_VEC_SAFE_ELT (vec
,i
,elt
)
4601 Accepts the NAME to lookup and its qualifying SCOPE.
4602 Returns the name/type pair found into the cxx_binding *RESULT,
4603 or false on error. */
4606 qualified_lookup_using_namespace (tree name
, tree scope
,
4607 struct scope_binding
*result
, int flags
)
4609 /* Maintain a list of namespaces visited... */
4610 vec
<tree
, va_gc
> *seen
= NULL
;
4611 vec
<tree
, va_gc
> *seen_inline
= NULL
;
4612 /* ... and a list of namespace yet to see. */
4613 vec
<tree
, va_gc
> *todo
= NULL
;
4614 vec
<tree
, va_gc
> *todo_maybe
= NULL
;
4615 vec
<tree
, va_gc
> *todo_inline
= NULL
;
4617 timevar_start (TV_NAME_LOOKUP
);
4618 /* Look through namespace aliases. */
4619 scope
= ORIGINAL_NAMESPACE (scope
);
4621 /* Algorithm: Starting with SCOPE, walk through the set of used
4622 namespaces. For each used namespace, look through its inline
4623 namespace set for any bindings and usings. If no bindings are
4624 found, add any usings seen to the set of used namespaces. */
4625 vec_safe_push (todo
, scope
);
4627 while (todo
->length ())
4630 scope
= todo
->pop ();
4631 if (tree_vec_contains (seen
, scope
))
4633 vec_safe_push (seen
, scope
);
4634 vec_safe_push (todo_inline
, scope
);
4637 while (todo_inline
->length ())
4639 cxx_binding
*binding
;
4641 scope
= todo_inline
->pop ();
4642 if (tree_vec_contains (seen_inline
, scope
))
4644 vec_safe_push (seen_inline
, scope
);
4647 cp_binding_level_find_binding_for_name (NAMESPACE_LEVEL (scope
), name
);
4650 ambiguous_decl (result
, binding
, flags
);
4651 if (result
->type
|| result
->value
)
4655 for (usings
= DECL_NAMESPACE_USING (scope
); usings
;
4656 usings
= TREE_CHAIN (usings
))
4657 if (!TREE_INDIRECT_USING (usings
))
4659 if (is_associated_namespace (scope
, TREE_PURPOSE (usings
)))
4660 vec_safe_push (todo_inline
, TREE_PURPOSE (usings
));
4662 vec_safe_push (todo_maybe
, TREE_PURPOSE (usings
));
4667 vec_safe_truncate (todo_maybe
, 0);
4669 while (vec_safe_length (todo_maybe
))
4670 vec_safe_push (todo
, todo_maybe
->pop ());
4673 vec_free (todo_maybe
);
4674 vec_free (todo_inline
);
4676 vec_free (seen_inline
);
4677 timevar_stop (TV_NAME_LOOKUP
);
4678 return result
->value
!= error_mark_node
;
4681 /* Subroutine of outer_binding.
4683 Returns TRUE if BINDING is a binding to a template parameter of
4684 SCOPE. In that case SCOPE is the scope of a primary template
4685 parameter -- in the sense of G++, i.e, a template that has its own
4688 Returns FALSE otherwise. */
4691 binding_to_template_parms_of_scope_p (cxx_binding
*binding
,
4692 cp_binding_level
*scope
)
4694 tree binding_value
, tmpl
, tinfo
;
4697 if (!binding
|| !scope
|| !scope
->this_entity
)
4700 binding_value
= binding
->value
? binding
->value
: binding
->type
;
4701 tinfo
= get_template_info (scope
->this_entity
);
4703 /* BINDING_VALUE must be a template parm. */
4704 if (binding_value
== NULL_TREE
4705 || (!DECL_P (binding_value
)
4706 || !DECL_TEMPLATE_PARM_P (binding_value
)))
4709 /* The level of BINDING_VALUE. */
4711 template_type_parameter_p (binding_value
)
4712 ? TEMPLATE_PARM_LEVEL (TEMPLATE_TYPE_PARM_INDEX
4713 (TREE_TYPE (binding_value
)))
4714 : TEMPLATE_PARM_LEVEL (DECL_INITIAL (binding_value
));
4716 /* The template of the current scope, iff said scope is a primary
4719 && PRIMARY_TEMPLATE_P (TI_TEMPLATE (tinfo
))
4720 ? TI_TEMPLATE (tinfo
)
4723 /* If the level of the parm BINDING_VALUE equals the depth of TMPL,
4724 then BINDING_VALUE is a parameter of TMPL. */
4725 return (tmpl
&& level
== TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (tmpl
)));
4728 /* Return the innermost non-namespace binding for NAME from a scope
4729 containing BINDING, or, if BINDING is NULL, the current scope.
4730 Please note that for a given template, the template parameters are
4731 considered to be in the scope containing the current scope.
4732 If CLASS_P is false, then class bindings are ignored. */
4735 outer_binding (tree name
,
4736 cxx_binding
*binding
,
4740 cp_binding_level
*scope
;
4741 cp_binding_level
*outer_scope
;
4745 scope
= binding
->scope
->level_chain
;
4746 outer
= binding
->previous
;
4750 scope
= current_binding_level
;
4751 outer
= IDENTIFIER_BINDING (name
);
4753 outer_scope
= outer
? outer
->scope
: NULL
;
4755 /* Because we create class bindings lazily, we might be missing a
4756 class binding for NAME. If there are any class binding levels
4757 between the LAST_BINDING_LEVEL and the scope in which OUTER was
4758 declared, we must lookup NAME in those class scopes. */
4760 while (scope
&& scope
!= outer_scope
&& scope
->kind
!= sk_namespace
)
4762 if (scope
->kind
== sk_class
)
4764 cxx_binding
*class_binding
;
4766 class_binding
= get_class_binding (name
, scope
);
4769 /* Thread this new class-scope binding onto the
4770 IDENTIFIER_BINDING list so that future lookups
4772 class_binding
->previous
= outer
;
4774 binding
->previous
= class_binding
;
4776 IDENTIFIER_BINDING (name
) = class_binding
;
4777 return class_binding
;
4780 /* If we are in a member template, the template parms of the member
4781 template are considered to be inside the scope of the containing
4782 class, but within G++ the class bindings are all pushed between the
4783 template parms and the function body. So if the outer binding is
4784 a template parm for the current scope, return it now rather than
4785 look for a class binding. */
4786 if (outer_scope
&& outer_scope
->kind
== sk_template_parms
4787 && binding_to_template_parms_of_scope_p (outer
, scope
))
4790 scope
= scope
->level_chain
;
4796 /* Return the innermost block-scope or class-scope value binding for
4797 NAME, or NULL_TREE if there is no such binding. */
4800 innermost_non_namespace_value (tree name
)
4802 cxx_binding
*binding
;
4803 binding
= outer_binding (name
, /*binding=*/NULL
, /*class_p=*/true);
4804 return binding
? binding
->value
: NULL_TREE
;
4807 /* Look up NAME in the current binding level and its superiors in the
4808 namespace of variables, functions and typedefs. Return a ..._DECL
4809 node of some kind representing its definition if there is only one
4810 such declaration, or return a TREE_LIST with all the overloaded
4811 definitions if there are many, or return 0 if it is undefined.
4812 Hidden name, either friend declaration or built-in function, are
4815 If PREFER_TYPE is > 0, we prefer TYPE_DECLs or namespaces.
4816 If PREFER_TYPE is > 1, we reject non-type decls (e.g. namespaces).
4817 Otherwise we prefer non-TYPE_DECLs.
4819 If NONCLASS is nonzero, bindings in class scopes are ignored. If
4820 BLOCK_P is false, bindings in block scopes are ignored. */
4823 lookup_name_real_1 (tree name
, int prefer_type
, int nonclass
, bool block_p
,
4824 int namespaces_only
, int flags
)
4827 tree val
= NULL_TREE
;
4829 /* Conversion operators are handled specially because ordinary
4830 unqualified name lookup will not find template conversion
4832 if (IDENTIFIER_TYPENAME_P (name
))
4834 cp_binding_level
*level
;
4836 for (level
= current_binding_level
;
4837 level
&& level
->kind
!= sk_namespace
;
4838 level
= level
->level_chain
)
4843 /* A conversion operator can only be declared in a class
4845 if (level
->kind
!= sk_class
)
4848 /* Lookup the conversion operator in the class. */
4849 class_type
= level
->this_entity
;
4850 operators
= lookup_fnfields (class_type
, name
, /*protect=*/0);
4858 flags
|= lookup_flags (prefer_type
, namespaces_only
);
4860 /* First, look in non-namespace scopes. */
4862 if (current_class_type
== NULL_TREE
)
4865 if (block_p
|| !nonclass
)
4866 for (iter
= outer_binding (name
, NULL
, !nonclass
);
4868 iter
= outer_binding (name
, iter
, !nonclass
))
4872 /* Skip entities we don't want. */
4873 if (LOCAL_BINDING_P (iter
) ? !block_p
: nonclass
)
4876 /* If this is the kind of thing we're looking for, we're done. */
4877 if (qualify_lookup (iter
->value
, flags
))
4878 binding
= iter
->value
;
4879 else if ((flags
& LOOKUP_PREFER_TYPES
)
4880 && qualify_lookup (iter
->type
, flags
))
4881 binding
= iter
->type
;
4883 binding
= NULL_TREE
;
4887 if (hidden_name_p (binding
))
4889 /* A non namespace-scope binding can only be hidden in the
4890 presence of a local class, due to friend declarations.
4892 In particular, consider:
4900 B* b; // error: B is hidden
4901 C* c; // OK, finds ::C
4904 B *b; // error: B is hidden
4905 C *c; // OK, finds ::C
4910 The standard says that "B" is a local class in "f"
4911 (but not nested within "A") -- but that name lookup
4912 for "B" does not find this declaration until it is
4913 declared directly with "f".
4919 If a friend declaration appears in a local class and
4920 the name specified is an unqualified name, a prior
4921 declaration is looked up without considering scopes
4922 that are outside the innermost enclosing non-class
4923 scope. For a friend function declaration, if there is
4924 no prior declaration, the program is ill-formed. For a
4925 friend class declaration, if there is no prior
4926 declaration, the class that is specified belongs to the
4927 innermost enclosing non-class scope, but if it is
4928 subsequently referenced, its name is not found by name
4929 lookup until a matching declaration is provided in the
4930 innermost enclosing nonclass scope.
4932 So just keep looking for a non-hidden binding.
4934 gcc_assert (TREE_CODE (binding
) == TYPE_DECL
);
4942 /* Now lookup in namespace scopes. */
4944 val
= unqualified_namespace_lookup (name
, flags
);
4946 /* Anticipated built-ins and friends aren't found by normal lookup. */
4947 if (val
&& !(flags
& LOOKUP_HIDDEN
))
4948 val
= remove_hidden_names (val
);
4950 /* If we have a single function from a using decl, pull it out. */
4951 if (val
&& TREE_CODE (val
) == OVERLOAD
&& !really_overloaded_fn (val
))
4952 val
= OVL_FUNCTION (val
);
4957 /* Wrapper for lookup_name_real_1. */
4960 lookup_name_real (tree name
, int prefer_type
, int nonclass
, bool block_p
,
4961 int namespaces_only
, int flags
)
4964 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
4965 ret
= lookup_name_real_1 (name
, prefer_type
, nonclass
, block_p
,
4966 namespaces_only
, flags
);
4967 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
4972 lookup_name_nonclass (tree name
)
4974 return lookup_name_real (name
, 0, 1, /*block_p=*/true, 0, 0);
4978 lookup_function_nonclass (tree name
, vec
<tree
, va_gc
> *args
, bool block_p
)
4981 lookup_arg_dependent (name
,
4982 lookup_name_real (name
, 0, 1, block_p
, 0, 0),
4987 lookup_name (tree name
)
4989 return lookup_name_real (name
, 0, 0, /*block_p=*/true, 0, 0);
4993 lookup_name_prefer_type (tree name
, int prefer_type
)
4995 return lookup_name_real (name
, prefer_type
, 0, /*block_p=*/true, 0, 0);
4998 /* Look up NAME for type used in elaborated name specifier in
4999 the scopes given by SCOPE. SCOPE can be either TS_CURRENT or
5000 TS_WITHIN_ENCLOSING_NON_CLASS. Although not implied by the
5001 name, more scopes are checked if cleanup or template parameter
5002 scope is encountered.
5004 Unlike lookup_name_real, we make sure that NAME is actually
5005 declared in the desired scope, not from inheritance, nor using
5006 directive. For using declaration, there is DR138 still waiting
5007 to be resolved. Hidden name coming from an earlier friend
5008 declaration is also returned.
5010 A TYPE_DECL best matching the NAME is returned. Catching error
5011 and issuing diagnostics are caller's responsibility. */
5014 lookup_type_scope_1 (tree name
, tag_scope scope
)
5016 cxx_binding
*iter
= NULL
;
5017 tree val
= NULL_TREE
;
5019 /* Look in non-namespace scope first. */
5020 if (current_binding_level
->kind
!= sk_namespace
)
5021 iter
= outer_binding (name
, NULL
, /*class_p=*/ true);
5022 for (; iter
; iter
= outer_binding (name
, iter
, /*class_p=*/ true))
5024 /* Check if this is the kind of thing we're looking for.
5025 If SCOPE is TS_CURRENT, also make sure it doesn't come from
5026 base class. For ITER->VALUE, we can simply use
5027 INHERITED_VALUE_BINDING_P. For ITER->TYPE, we have to use
5030 We check ITER->TYPE before ITER->VALUE in order to handle
5031 typedef struct C {} C;
5034 if (qualify_lookup (iter
->type
, LOOKUP_PREFER_TYPES
)
5035 && (scope
!= ts_current
5036 || LOCAL_BINDING_P (iter
)
5037 || DECL_CONTEXT (iter
->type
) == iter
->scope
->this_entity
))
5039 else if ((scope
!= ts_current
5040 || !INHERITED_VALUE_BINDING_P (iter
))
5041 && qualify_lookup (iter
->value
, LOOKUP_PREFER_TYPES
))
5048 /* Look in namespace scope. */
5051 iter
= cp_binding_level_find_binding_for_name
5052 (NAMESPACE_LEVEL (current_decl_namespace ()), name
);
5056 /* If this is the kind of thing we're looking for, we're done. */
5057 if (qualify_lookup (iter
->type
, LOOKUP_PREFER_TYPES
))
5059 else if (qualify_lookup (iter
->value
, LOOKUP_PREFER_TYPES
))
5065 /* Type found, check if it is in the allowed scopes, ignoring cleanup
5066 and template parameter scopes. */
5069 cp_binding_level
*b
= current_binding_level
;
5072 if (iter
->scope
== b
)
5075 if (b
->kind
== sk_cleanup
|| b
->kind
== sk_template_parms
5076 || b
->kind
== sk_function_parms
)
5078 else if (b
->kind
== sk_class
5079 && scope
== ts_within_enclosing_non_class
)
5089 /* Wrapper for lookup_type_scope_1. */
5092 lookup_type_scope (tree name
, tag_scope scope
)
5095 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
5096 ret
= lookup_type_scope_1 (name
, scope
);
5097 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
5102 /* Similar to `lookup_name' but look only in the innermost non-class
5106 lookup_name_innermost_nonclass_level_1 (tree name
)
5108 cp_binding_level
*b
;
5111 b
= innermost_nonclass_level ();
5113 if (b
->kind
== sk_namespace
)
5115 t
= IDENTIFIER_NAMESPACE_VALUE (name
);
5117 /* extern "C" function() */
5118 if (t
!= NULL_TREE
&& TREE_CODE (t
) == TREE_LIST
)
5121 else if (IDENTIFIER_BINDING (name
)
5122 && LOCAL_BINDING_P (IDENTIFIER_BINDING (name
)))
5124 cxx_binding
*binding
;
5125 binding
= IDENTIFIER_BINDING (name
);
5128 if (binding
->scope
== b
5129 && !(VAR_P (binding
->value
)
5130 && DECL_DEAD_FOR_LOCAL (binding
->value
)))
5131 return binding
->value
;
5133 if (b
->kind
== sk_cleanup
)
5143 /* Wrapper for lookup_name_innermost_nonclass_level_1. */
5146 lookup_name_innermost_nonclass_level (tree name
)
5149 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
5150 ret
= lookup_name_innermost_nonclass_level_1 (name
);
5151 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
5156 /* Returns true iff DECL is a block-scope extern declaration of a function
5160 is_local_extern (tree decl
)
5162 cxx_binding
*binding
;
5164 /* For functions, this is easy. */
5165 if (TREE_CODE (decl
) == FUNCTION_DECL
)
5166 return DECL_LOCAL_FUNCTION_P (decl
);
5170 if (!current_function_decl
)
5173 /* For variables, this is not easy. We need to look at the binding stack
5174 for the identifier to see whether the decl we have is a local. */
5175 for (binding
= IDENTIFIER_BINDING (DECL_NAME (decl
));
5176 binding
&& binding
->scope
->kind
!= sk_namespace
;
5177 binding
= binding
->previous
)
5178 if (binding
->value
== decl
)
5179 return LOCAL_BINDING_P (binding
);
5184 /* Like lookup_name_innermost_nonclass_level, but for types. */
5187 lookup_type_current_level (tree name
)
5191 timevar_start (TV_NAME_LOOKUP
);
5192 gcc_assert (current_binding_level
->kind
!= sk_namespace
);
5194 if (REAL_IDENTIFIER_TYPE_VALUE (name
) != NULL_TREE
5195 && REAL_IDENTIFIER_TYPE_VALUE (name
) != global_type_node
)
5197 cp_binding_level
*b
= current_binding_level
;
5200 if (purpose_member (name
, b
->type_shadowed
))
5202 t
= REAL_IDENTIFIER_TYPE_VALUE (name
);
5205 if (b
->kind
== sk_cleanup
)
5212 timevar_stop (TV_NAME_LOOKUP
);
5216 /* [basic.lookup.koenig] */
5217 /* A nonzero return value in the functions below indicates an error. */
5222 vec
<tree
, va_gc
> *args
;
5223 vec
<tree
, va_gc
> *namespaces
;
5224 vec
<tree
, va_gc
> *classes
;
5226 hash_set
<tree
> *fn_set
;
5229 static bool arg_assoc (struct arg_lookup
*, tree
);
5230 static bool arg_assoc_args (struct arg_lookup
*, tree
);
5231 static bool arg_assoc_args_vec (struct arg_lookup
*, vec
<tree
, va_gc
> *);
5232 static bool arg_assoc_type (struct arg_lookup
*, tree
);
5233 static bool add_function (struct arg_lookup
*, tree
);
5234 static bool arg_assoc_namespace (struct arg_lookup
*, tree
);
5235 static bool arg_assoc_class_only (struct arg_lookup
*, tree
);
5236 static bool arg_assoc_bases (struct arg_lookup
*, tree
);
5237 static bool arg_assoc_class (struct arg_lookup
*, tree
);
5238 static bool arg_assoc_template_arg (struct arg_lookup
*, tree
);
5240 /* Add a function to the lookup structure.
5241 Returns true on error. */
5244 add_function (struct arg_lookup
*k
, tree fn
)
5246 if (!is_overloaded_fn (fn
))
5247 /* All names except those of (possibly overloaded) functions and
5248 function templates are ignored. */;
5249 else if (k
->fn_set
&& k
->fn_set
->add (fn
))
5250 /* It's already in the list. */;
5251 else if (!k
->functions
)
5253 else if (fn
== k
->functions
)
5257 k
->functions
= build_overload (fn
, k
->functions
);
5258 if (TREE_CODE (k
->functions
) == OVERLOAD
)
5259 OVL_ARG_DEPENDENT (k
->functions
) = true;
5265 /* Returns true iff CURRENT has declared itself to be an associated
5266 namespace of SCOPE via a strong using-directive (or transitive chain
5267 thereof). Both are namespaces. */
5270 is_associated_namespace (tree current
, tree scope
)
5272 vec
<tree
, va_gc
> *seen
= make_tree_vector ();
5273 vec
<tree
, va_gc
> *todo
= make_tree_vector ();
5279 if (scope
== current
)
5284 vec_safe_push (seen
, scope
);
5285 for (t
= DECL_NAMESPACE_ASSOCIATIONS (scope
); t
; t
= TREE_CHAIN (t
))
5286 if (!vec_member (TREE_PURPOSE (t
), seen
))
5287 vec_safe_push (todo
, TREE_PURPOSE (t
));
5288 if (!todo
->is_empty ())
5290 scope
= todo
->last ();
5300 release_tree_vector (seen
);
5301 release_tree_vector (todo
);
5306 /* Add functions of a namespace to the lookup structure.
5307 Returns true on error. */
5310 arg_assoc_namespace (struct arg_lookup
*k
, tree scope
)
5314 if (vec_member (scope
, k
->namespaces
))
5316 vec_safe_push (k
->namespaces
, scope
);
5318 /* Check out our super-users. */
5319 for (value
= DECL_NAMESPACE_ASSOCIATIONS (scope
); value
;
5320 value
= TREE_CHAIN (value
))
5321 if (arg_assoc_namespace (k
, TREE_PURPOSE (value
)))
5324 /* Also look down into inline namespaces. */
5325 for (value
= DECL_NAMESPACE_USING (scope
); value
;
5326 value
= TREE_CHAIN (value
))
5327 if (is_associated_namespace (scope
, TREE_PURPOSE (value
)))
5328 if (arg_assoc_namespace (k
, TREE_PURPOSE (value
)))
5331 value
= namespace_binding (k
->name
, scope
);
5335 for (; value
; value
= OVL_NEXT (value
))
5337 /* We don't want to find arbitrary hidden functions via argument
5338 dependent lookup. We only want to find friends of associated
5339 classes, which we'll do via arg_assoc_class. */
5340 if (hidden_name_p (OVL_CURRENT (value
)))
5343 if (add_function (k
, OVL_CURRENT (value
)))
5350 /* Adds everything associated with a template argument to the lookup
5351 structure. Returns true on error. */
5354 arg_assoc_template_arg (struct arg_lookup
*k
, tree arg
)
5356 /* [basic.lookup.koenig]
5358 If T is a template-id, its associated namespaces and classes are
5359 ... the namespaces and classes associated with the types of the
5360 template arguments provided for template type parameters
5361 (excluding template template parameters); the namespaces in which
5362 any template template arguments are defined; and the classes in
5363 which any member templates used as template template arguments
5364 are defined. [Note: non-type template arguments do not
5365 contribute to the set of associated namespaces. ] */
5367 /* Consider first template template arguments. */
5368 if (TREE_CODE (arg
) == TEMPLATE_TEMPLATE_PARM
5369 || TREE_CODE (arg
) == UNBOUND_CLASS_TEMPLATE
)
5371 else if (TREE_CODE (arg
) == TEMPLATE_DECL
)
5373 tree ctx
= CP_DECL_CONTEXT (arg
);
5375 /* It's not a member template. */
5376 if (TREE_CODE (ctx
) == NAMESPACE_DECL
)
5377 return arg_assoc_namespace (k
, ctx
);
5378 /* Otherwise, it must be member template. */
5380 return arg_assoc_class_only (k
, ctx
);
5382 /* It's an argument pack; handle it recursively. */
5383 else if (ARGUMENT_PACK_P (arg
))
5385 tree args
= ARGUMENT_PACK_ARGS (arg
);
5386 int i
, len
= TREE_VEC_LENGTH (args
);
5387 for (i
= 0; i
< len
; ++i
)
5388 if (arg_assoc_template_arg (k
, TREE_VEC_ELT (args
, i
)))
5393 /* It's not a template template argument, but it is a type template
5395 else if (TYPE_P (arg
))
5396 return arg_assoc_type (k
, arg
);
5397 /* It's a non-type template argument. */
5402 /* Adds the class and its friends to the lookup structure.
5403 Returns true on error. */
5406 arg_assoc_class_only (struct arg_lookup
*k
, tree type
)
5408 tree list
, friends
, context
;
5410 /* Backend-built structures, such as __builtin_va_list, aren't
5411 affected by all this. */
5412 if (!CLASS_TYPE_P (type
))
5415 context
= decl_namespace_context (type
);
5416 if (arg_assoc_namespace (k
, context
))
5419 complete_type (type
);
5421 /* Process friends. */
5422 for (list
= DECL_FRIENDLIST (TYPE_MAIN_DECL (type
)); list
;
5423 list
= TREE_CHAIN (list
))
5424 if (k
->name
== FRIEND_NAME (list
))
5425 for (friends
= FRIEND_DECLS (list
); friends
;
5426 friends
= TREE_CHAIN (friends
))
5428 tree fn
= TREE_VALUE (friends
);
5430 /* Only interested in global functions with potentially hidden
5431 (i.e. unqualified) declarations. */
5432 if (CP_DECL_CONTEXT (fn
) != context
)
5434 /* Template specializations are never found by name lookup.
5435 (Templates themselves can be found, but not template
5436 specializations.) */
5437 if (TREE_CODE (fn
) == FUNCTION_DECL
&& DECL_USE_TEMPLATE (fn
))
5439 if (add_function (k
, fn
))
5446 /* Adds the class and its bases to the lookup structure.
5447 Returns true on error. */
5450 arg_assoc_bases (struct arg_lookup
*k
, tree type
)
5452 if (arg_assoc_class_only (k
, type
))
5455 if (TYPE_BINFO (type
))
5457 /* Process baseclasses. */
5458 tree binfo
, base_binfo
;
5461 for (binfo
= TYPE_BINFO (type
), i
= 0;
5462 BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); i
++)
5463 if (arg_assoc_bases (k
, BINFO_TYPE (base_binfo
)))
5470 /* Adds everything associated with a class argument type to the lookup
5471 structure. Returns true on error.
5473 If T is a class type (including unions), its associated classes are: the
5474 class itself; the class of which it is a member, if any; and its direct
5475 and indirect base classes. Its associated namespaces are the namespaces
5476 of which its associated classes are members. Furthermore, if T is a
5477 class template specialization, its associated namespaces and classes
5478 also include: the namespaces and classes associated with the types of
5479 the template arguments provided for template type parameters (excluding
5480 template template parameters); the namespaces of which any template
5481 template arguments are members; and the classes of which any member
5482 templates used as template template arguments are members. [ Note:
5483 non-type template arguments do not contribute to the set of associated
5484 namespaces. --end note] */
5487 arg_assoc_class (struct arg_lookup
*k
, tree type
)
5492 /* Backend build structures, such as __builtin_va_list, aren't
5493 affected by all this. */
5494 if (!CLASS_TYPE_P (type
))
5497 if (vec_member (type
, k
->classes
))
5499 vec_safe_push (k
->classes
, type
);
5501 if (TYPE_CLASS_SCOPE_P (type
)
5502 && arg_assoc_class_only (k
, TYPE_CONTEXT (type
)))
5505 if (arg_assoc_bases (k
, type
))
5508 /* Process template arguments. */
5509 if (CLASSTYPE_TEMPLATE_INFO (type
)
5510 && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (type
)))
5512 list
= INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (type
));
5513 for (i
= 0; i
< TREE_VEC_LENGTH (list
); ++i
)
5514 if (arg_assoc_template_arg (k
, TREE_VEC_ELT (list
, i
)))
5521 /* Adds everything associated with a given type.
5522 Returns 1 on error. */
5525 arg_assoc_type (struct arg_lookup
*k
, tree type
)
5527 /* As we do not get the type of non-type dependent expressions
5528 right, we can end up with such things without a type. */
5532 if (TYPE_PTRDATAMEM_P (type
))
5534 /* Pointer to member: associate class type and value type. */
5535 if (arg_assoc_type (k
, TYPE_PTRMEM_CLASS_TYPE (type
)))
5537 return arg_assoc_type (k
, TYPE_PTRMEM_POINTED_TO_TYPE (type
));
5539 else switch (TREE_CODE (type
))
5549 case FIXED_POINT_TYPE
:
5554 if (TYPE_PTRMEMFUNC_P (type
))
5555 return arg_assoc_type (k
, TYPE_PTRMEMFUNC_FN_TYPE (type
));
5557 return arg_assoc_class (k
, type
);
5559 case REFERENCE_TYPE
:
5561 return arg_assoc_type (k
, TREE_TYPE (type
));
5563 if (TYPE_CLASS_SCOPE_P (type
)
5564 && arg_assoc_class_only (k
, TYPE_CONTEXT (type
)))
5566 return arg_assoc_namespace (k
, decl_namespace_context (type
));
5568 /* The basetype is referenced in the first arg type, so just
5571 /* Associate the parameter types. */
5572 if (arg_assoc_args (k
, TYPE_ARG_TYPES (type
)))
5574 /* Associate the return type. */
5575 return arg_assoc_type (k
, TREE_TYPE (type
));
5576 case TEMPLATE_TYPE_PARM
:
5577 case BOUND_TEMPLATE_TEMPLATE_PARM
:
5582 gcc_assert (type
== unknown_type_node
5583 || type
== init_list_type_node
);
5585 case TYPE_PACK_EXPANSION
:
5586 return arg_assoc_type (k
, PACK_EXPANSION_PATTERN (type
));
5594 /* Adds everything associated with arguments. Returns true on error. */
5597 arg_assoc_args (struct arg_lookup
*k
, tree args
)
5599 for (; args
; args
= TREE_CHAIN (args
))
5600 if (arg_assoc (k
, TREE_VALUE (args
)))
5605 /* Adds everything associated with an argument vector. Returns true
5609 arg_assoc_args_vec (struct arg_lookup
*k
, vec
<tree
, va_gc
> *args
)
5614 FOR_EACH_VEC_SAFE_ELT (args
, ix
, arg
)
5615 if (arg_assoc (k
, arg
))
5620 /* Adds everything associated with a given tree_node. Returns 1 on error. */
5623 arg_assoc (struct arg_lookup
*k
, tree n
)
5625 if (n
== error_mark_node
)
5629 return arg_assoc_type (k
, n
);
5631 if (! type_unknown_p (n
))
5632 return arg_assoc_type (k
, TREE_TYPE (n
));
5634 if (TREE_CODE (n
) == ADDR_EXPR
)
5635 n
= TREE_OPERAND (n
, 0);
5636 if (TREE_CODE (n
) == COMPONENT_REF
)
5637 n
= TREE_OPERAND (n
, 1);
5638 if (TREE_CODE (n
) == OFFSET_REF
)
5639 n
= TREE_OPERAND (n
, 1);
5640 while (TREE_CODE (n
) == TREE_LIST
)
5643 n
= BASELINK_FUNCTIONS (n
);
5645 if (TREE_CODE (n
) == FUNCTION_DECL
)
5646 return arg_assoc_type (k
, TREE_TYPE (n
));
5647 if (TREE_CODE (n
) == TEMPLATE_ID_EXPR
)
5649 /* The working paper doesn't currently say how to handle template-id
5650 arguments. The sensible thing would seem to be to handle the list
5651 of template candidates like a normal overload set, and handle the
5652 template arguments like we do for class template
5654 tree templ
= TREE_OPERAND (n
, 0);
5655 tree args
= TREE_OPERAND (n
, 1);
5658 /* First the templates. */
5659 if (arg_assoc (k
, templ
))
5662 /* Now the arguments. */
5664 for (ix
= TREE_VEC_LENGTH (args
); ix
--;)
5665 if (arg_assoc_template_arg (k
, TREE_VEC_ELT (args
, ix
)) == 1)
5668 else if (TREE_CODE (n
) == OVERLOAD
)
5670 for (; n
; n
= OVL_NEXT (n
))
5671 if (arg_assoc_type (k
, TREE_TYPE (OVL_CURRENT (n
))))
5678 /* Performs Koenig lookup depending on arguments, where fns
5679 are the functions found in normal lookup. */
5682 lookup_arg_dependent_1 (tree name
, tree fns
, vec
<tree
, va_gc
> *args
)
5684 struct arg_lookup k
;
5686 /* Remove any hidden friend functions from the list of functions
5687 found so far. They will be added back by arg_assoc_class as
5689 fns
= remove_hidden_names (fns
);
5694 k
.classes
= make_tree_vector ();
5696 /* We previously performed an optimization here by setting
5697 NAMESPACES to the current namespace when it was safe. However, DR
5698 164 says that namespaces that were already searched in the first
5699 stage of template processing are searched again (potentially
5700 picking up later definitions) in the second stage. */
5701 k
.namespaces
= make_tree_vector ();
5703 /* We used to allow duplicates and let joust discard them, but
5704 since the above change for DR 164 we end up with duplicates of
5705 all the functions found by unqualified lookup. So keep track
5706 of which ones we've seen. */
5710 /* We shouldn't be here if lookup found something other than
5711 namespace-scope functions. */
5712 gcc_assert (DECL_NAMESPACE_SCOPE_P (OVL_CURRENT (fns
)));
5713 k
.fn_set
= new hash_set
<tree
>;
5714 for (ovl
= fns
; ovl
; ovl
= OVL_NEXT (ovl
))
5715 k
.fn_set
->add (OVL_CURRENT (ovl
));
5720 arg_assoc_args_vec (&k
, args
);
5726 && !is_overloaded_fn (fns
))
5728 error ("argument dependent lookup finds %q+D", fns
);
5729 error (" in call to %qD", name
);
5730 fns
= error_mark_node
;
5733 release_tree_vector (k
.classes
);
5734 release_tree_vector (k
.namespaces
);
5740 /* Wrapper for lookup_arg_dependent_1. */
5743 lookup_arg_dependent (tree name
, tree fns
, vec
<tree
, va_gc
> *args
)
5747 subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
5748 ret
= lookup_arg_dependent_1 (name
, fns
, args
);
5749 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
5754 /* Add namespace to using_directives. Return NULL_TREE if nothing was
5755 changed (i.e. there was already a directive), or the fresh
5756 TREE_LIST otherwise. */
5759 push_using_directive_1 (tree used
)
5761 tree ud
= current_binding_level
->using_directives
;
5762 tree iter
, ancestor
;
5764 /* Check if we already have this. */
5765 if (purpose_member (used
, ud
) != NULL_TREE
)
5768 ancestor
= namespace_ancestor (current_decl_namespace (), used
);
5769 ud
= current_binding_level
->using_directives
;
5770 ud
= tree_cons (used
, ancestor
, ud
);
5771 current_binding_level
->using_directives
= ud
;
5773 /* Recursively add all namespaces used. */
5774 for (iter
= DECL_NAMESPACE_USING (used
); iter
; iter
= TREE_CHAIN (iter
))
5775 push_using_directive (TREE_PURPOSE (iter
));
5780 /* Wrapper for push_using_directive_1. */
5783 push_using_directive (tree used
)
5786 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
5787 ret
= push_using_directive_1 (used
);
5788 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
5792 /* The type TYPE is being declared. If it is a class template, or a
5793 specialization of a class template, do any processing required and
5794 perform error-checking. If IS_FRIEND is nonzero, this TYPE is
5795 being declared a friend. B is the binding level at which this TYPE
5798 Returns the TYPE_DECL for TYPE, which may have been altered by this
5802 maybe_process_template_type_declaration (tree type
, int is_friend
,
5803 cp_binding_level
*b
)
5805 tree decl
= TYPE_NAME (type
);
5807 if (processing_template_parmlist
)
5808 /* You can't declare a new template type in a template parameter
5809 list. But, you can declare a non-template type:
5811 template <class A*> struct S;
5813 is a forward-declaration of `A'. */
5815 else if (b
->kind
== sk_namespace
5816 && current_binding_level
->kind
!= sk_namespace
)
5817 /* If this new type is being injected into a containing scope,
5818 then it's not a template type. */
5822 gcc_assert (MAYBE_CLASS_TYPE_P (type
)
5823 || TREE_CODE (type
) == ENUMERAL_TYPE
);
5825 if (processing_template_decl
)
5827 /* This may change after the call to
5828 push_template_decl_real, but we want the original value. */
5829 tree name
= DECL_NAME (decl
);
5831 decl
= push_template_decl_real (decl
, is_friend
);
5832 if (decl
== error_mark_node
)
5833 return error_mark_node
;
5835 /* If the current binding level is the binding level for the
5836 template parameters (see the comment in
5837 begin_template_parm_list) and the enclosing level is a class
5838 scope, and we're not looking at a friend, push the
5839 declaration of the member class into the class scope. In the
5840 friend case, push_template_decl will already have put the
5841 friend into global scope, if appropriate. */
5842 if (TREE_CODE (type
) != ENUMERAL_TYPE
5843 && !is_friend
&& b
->kind
== sk_template_parms
5844 && b
->level_chain
->kind
== sk_class
)
5846 finish_member_declaration (CLASSTYPE_TI_TEMPLATE (type
));
5848 if (!COMPLETE_TYPE_P (current_class_type
))
5850 maybe_add_class_template_decl_list (current_class_type
,
5851 type
, /*friend_p=*/0);
5852 /* Put this UTD in the table of UTDs for the class. */
5853 if (CLASSTYPE_NESTED_UTDS (current_class_type
) == NULL
)
5854 CLASSTYPE_NESTED_UTDS (current_class_type
) =
5855 binding_table_new (SCOPE_DEFAULT_HT_SIZE
);
5857 binding_table_insert
5858 (CLASSTYPE_NESTED_UTDS (current_class_type
), name
, type
);
5867 /* Push a tag name NAME for struct/class/union/enum type TYPE. In case
5868 that the NAME is a class template, the tag is processed but not pushed.
5870 The pushed scope depend on the SCOPE parameter:
5871 - When SCOPE is TS_CURRENT, put it into the inner-most non-sk_cleanup
5873 - When SCOPE is TS_GLOBAL, put it in the inner-most non-class and
5874 non-template-parameter scope. This case is needed for forward
5876 - When SCOPE is TS_WITHIN_ENCLOSING_NON_CLASS, this is similar to
5877 TS_GLOBAL case except that names within template-parameter scopes
5878 are not pushed at all.
5880 Returns TYPE upon success and ERROR_MARK_NODE otherwise. */
5883 pushtag_1 (tree name
, tree type
, tag_scope scope
)
5885 cp_binding_level
*b
;
5888 b
= current_binding_level
;
5889 while (/* Cleanup scopes are not scopes from the point of view of
5891 b
->kind
== sk_cleanup
5892 /* Neither are function parameter scopes. */
5893 || b
->kind
== sk_function_parms
5894 /* Neither are the scopes used to hold template parameters
5895 for an explicit specialization. For an ordinary template
5896 declaration, these scopes are not scopes from the point of
5897 view of the language. */
5898 || (b
->kind
== sk_template_parms
5899 && (b
->explicit_spec_p
|| scope
== ts_global
))
5900 || (b
->kind
== sk_class
5901 && (scope
!= ts_current
5902 /* We may be defining a new type in the initializer
5903 of a static member variable. We allow this when
5904 not pedantic, and it is particularly useful for
5905 type punning via an anonymous union. */
5906 || COMPLETE_TYPE_P (b
->this_entity
))))
5909 gcc_assert (identifier_p (name
));
5911 /* Do C++ gratuitous typedefing. */
5912 if (identifier_type_value_1 (name
) != type
)
5916 tree context
= TYPE_CONTEXT (type
);
5920 tree cs
= current_scope ();
5922 if (scope
== ts_current
5923 || (cs
&& TREE_CODE (cs
) == FUNCTION_DECL
))
5925 else if (cs
!= NULL_TREE
&& TYPE_P (cs
))
5926 /* When declaring a friend class of a local class, we want
5927 to inject the newly named class into the scope
5928 containing the local class, not the namespace
5930 context
= decl_function_context (get_type_decl (cs
));
5933 context
= current_namespace
;
5935 if (b
->kind
== sk_class
5936 || (b
->kind
== sk_template_parms
5937 && b
->level_chain
->kind
== sk_class
))
5940 if (current_lang_name
== lang_name_java
)
5941 TYPE_FOR_JAVA (type
) = 1;
5943 tdef
= create_implicit_typedef (name
, type
);
5944 DECL_CONTEXT (tdef
) = FROB_CONTEXT (context
);
5945 if (scope
== ts_within_enclosing_non_class
)
5947 /* This is a friend. Make this TYPE_DECL node hidden from
5948 ordinary name lookup. Its corresponding TEMPLATE_DECL
5949 will be marked in push_template_decl_real. */
5950 retrofit_lang_decl (tdef
);
5951 DECL_ANTICIPATED (tdef
) = 1;
5952 DECL_FRIEND_P (tdef
) = 1;
5955 decl
= maybe_process_template_type_declaration
5956 (type
, scope
== ts_within_enclosing_non_class
, b
);
5957 if (decl
== error_mark_node
)
5960 if (b
->kind
== sk_class
)
5962 if (!TYPE_BEING_DEFINED (current_class_type
))
5963 return error_mark_node
;
5965 if (!PROCESSING_REAL_TEMPLATE_DECL_P ())
5966 /* Put this TYPE_DECL on the TYPE_FIELDS list for the
5967 class. But if it's a member template class, we want
5968 the TEMPLATE_DECL, not the TYPE_DECL, so this is done
5970 finish_member_declaration (decl
);
5972 pushdecl_class_level (decl
);
5974 else if (b
->kind
!= sk_template_parms
)
5976 decl
= pushdecl_with_scope_1 (decl
, b
, /*is_friend=*/false);
5977 if (decl
== error_mark_node
)
5982 set_identifier_type_value_with_scope (name
, tdef
, b
);
5984 TYPE_CONTEXT (type
) = DECL_CONTEXT (decl
);
5986 /* If this is a local class, keep track of it. We need this
5987 information for name-mangling, and so that it is possible to
5988 find all function definitions in a translation unit in a
5989 convenient way. (It's otherwise tricky to find a member
5990 function definition it's only pointed to from within a local
5992 if (TYPE_FUNCTION_SCOPE_P (type
))
5994 if (processing_template_decl
)
5996 /* Push a DECL_EXPR so we call pushtag at the right time in
5997 template instantiation rather than in some nested context. */
5998 add_decl_expr (decl
);
6001 vec_safe_push (local_classes
, type
);
6004 if (b
->kind
== sk_class
6005 && !COMPLETE_TYPE_P (current_class_type
))
6007 maybe_add_class_template_decl_list (current_class_type
,
6008 type
, /*friend_p=*/0);
6010 if (CLASSTYPE_NESTED_UTDS (current_class_type
) == NULL
)
6011 CLASSTYPE_NESTED_UTDS (current_class_type
)
6012 = binding_table_new (SCOPE_DEFAULT_HT_SIZE
);
6014 binding_table_insert
6015 (CLASSTYPE_NESTED_UTDS (current_class_type
), name
, type
);
6018 decl
= TYPE_NAME (type
);
6019 gcc_assert (TREE_CODE (decl
) == TYPE_DECL
);
6021 /* Set type visibility now if this is a forward declaration. */
6022 TREE_PUBLIC (decl
) = 1;
6023 determine_visibility (decl
);
6028 /* Wrapper for pushtag_1. */
6031 pushtag (tree name
, tree type
, tag_scope scope
)
6034 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
6035 ret
= pushtag_1 (name
, type
, scope
);
6036 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
6040 /* Subroutines for reverting temporarily to top-level for instantiation
6041 of templates and such. We actually need to clear out the class- and
6042 local-value slots of all identifiers, so that only the global values
6043 are at all visible. Simply setting current_binding_level to the global
6044 scope isn't enough, because more binding levels may be pushed. */
6045 struct saved_scope
*scope_chain
;
6047 /* Return true if ID has not already been marked. */
6050 store_binding_p (tree id
)
6052 if (!id
|| !IDENTIFIER_BINDING (id
))
6055 if (IDENTIFIER_MARKED (id
))
6061 /* Add an appropriate binding to *OLD_BINDINGS which needs to already
6062 have enough space reserved. */
6065 store_binding (tree id
, vec
<cxx_saved_binding
, va_gc
> **old_bindings
)
6067 cxx_saved_binding saved
;
6069 gcc_checking_assert (store_binding_p (id
));
6071 IDENTIFIER_MARKED (id
) = 1;
6073 saved
.identifier
= id
;
6074 saved
.binding
= IDENTIFIER_BINDING (id
);
6075 saved
.real_type_value
= REAL_IDENTIFIER_TYPE_VALUE (id
);
6076 (*old_bindings
)->quick_push (saved
);
6077 IDENTIFIER_BINDING (id
) = NULL
;
6081 store_bindings (tree names
, vec
<cxx_saved_binding
, va_gc
> **old_bindings
)
6083 static vec
<tree
> bindings_need_stored
= vNULL
;
6087 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
6088 for (t
= names
; t
; t
= TREE_CHAIN (t
))
6090 if (TREE_CODE (t
) == TREE_LIST
)
6091 id
= TREE_PURPOSE (t
);
6095 if (store_binding_p (id
))
6096 bindings_need_stored
.safe_push (id
);
6098 if (!bindings_need_stored
.is_empty ())
6100 vec_safe_reserve_exact (*old_bindings
, bindings_need_stored
.length ());
6101 for (i
= 0; bindings_need_stored
.iterate (i
, &id
); ++i
)
6103 /* We can appearantly have duplicates in NAMES. */
6104 if (store_binding_p (id
))
6105 store_binding (id
, old_bindings
);
6107 bindings_need_stored
.truncate (0);
6109 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
6112 /* Like store_bindings, but NAMES is a vector of cp_class_binding
6113 objects, rather than a TREE_LIST. */
6116 store_class_bindings (vec
<cp_class_binding
, va_gc
> *names
,
6117 vec
<cxx_saved_binding
, va_gc
> **old_bindings
)
6119 static vec
<tree
> bindings_need_stored
= vNULL
;
6121 cp_class_binding
*cb
;
6123 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
6124 for (i
= 0; vec_safe_iterate (names
, i
, &cb
); ++i
)
6125 if (store_binding_p (cb
->identifier
))
6126 bindings_need_stored
.safe_push (cb
->identifier
);
6127 if (!bindings_need_stored
.is_empty ())
6130 vec_safe_reserve_exact (*old_bindings
, bindings_need_stored
.length ());
6131 for (i
= 0; bindings_need_stored
.iterate (i
, &id
); ++i
)
6132 store_binding (id
, old_bindings
);
6133 bindings_need_stored
.truncate (0);
6135 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
6138 /* A chain of saved_scope structures awaiting reuse. */
6140 static GTY((deletable
)) struct saved_scope
*free_saved_scope
;
6143 push_to_top_level (void)
6145 struct saved_scope
*s
;
6146 cp_binding_level
*b
;
6147 cxx_saved_binding
*sb
;
6151 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
6153 /* Reuse or create a new structure for this saved scope. */
6154 if (free_saved_scope
!= NULL
)
6156 s
= free_saved_scope
;
6157 free_saved_scope
= s
->prev
;
6159 vec
<cxx_saved_binding
, va_gc
> *old_bindings
= s
->old_bindings
;
6160 memset (s
, 0, sizeof (*s
));
6161 /* Also reuse the structure's old_bindings vector. */
6162 vec_safe_truncate (old_bindings
, 0);
6163 s
->old_bindings
= old_bindings
;
6166 s
= ggc_cleared_alloc
<saved_scope
> ();
6168 b
= scope_chain
? current_binding_level
: 0;
6170 /* If we're in the middle of some function, save our state. */
6174 push_function_context ();
6179 if (scope_chain
&& previous_class_level
)
6180 store_class_bindings (previous_class_level
->class_shadowed
,
6183 /* Have to include the global scope, because class-scope decls
6184 aren't listed anywhere useful. */
6185 for (; b
; b
= b
->level_chain
)
6189 /* Template IDs are inserted into the global level. If they were
6190 inserted into namespace level, finish_file wouldn't find them
6191 when doing pending instantiations. Therefore, don't stop at
6192 namespace level, but continue until :: . */
6193 if (global_scope_p (b
))
6196 store_bindings (b
->names
, &s
->old_bindings
);
6197 /* We also need to check class_shadowed to save class-level type
6198 bindings, since pushclass doesn't fill in b->names. */
6199 if (b
->kind
== sk_class
)
6200 store_class_bindings (b
->class_shadowed
, &s
->old_bindings
);
6202 /* Unwind type-value slots back to top level. */
6203 for (t
= b
->type_shadowed
; t
; t
= TREE_CHAIN (t
))
6204 SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (t
), TREE_VALUE (t
));
6207 FOR_EACH_VEC_SAFE_ELT (s
->old_bindings
, i
, sb
)
6208 IDENTIFIER_MARKED (sb
->identifier
) = 0;
6210 s
->prev
= scope_chain
;
6212 s
->need_pop_function_context
= need_pop
;
6213 s
->function_decl
= current_function_decl
;
6214 s
->unevaluated_operand
= cp_unevaluated_operand
;
6215 s
->inhibit_evaluation_warnings
= c_inhibit_evaluation_warnings
;
6216 s
->x_stmt_tree
.stmts_are_full_exprs_p
= true;
6219 current_function_decl
= NULL_TREE
;
6220 vec_alloc (current_lang_base
, 10);
6221 current_lang_name
= lang_name_cplusplus
;
6222 current_namespace
= global_namespace
;
6223 push_class_stack ();
6224 cp_unevaluated_operand
= 0;
6225 c_inhibit_evaluation_warnings
= 0;
6226 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
6230 pop_from_top_level_1 (void)
6232 struct saved_scope
*s
= scope_chain
;
6233 cxx_saved_binding
*saved
;
6236 /* Clear out class-level bindings cache. */
6237 if (previous_class_level
)
6238 invalidate_class_lookup_cache ();
6241 current_lang_base
= 0;
6243 scope_chain
= s
->prev
;
6244 FOR_EACH_VEC_SAFE_ELT (s
->old_bindings
, i
, saved
)
6246 tree id
= saved
->identifier
;
6248 IDENTIFIER_BINDING (id
) = saved
->binding
;
6249 SET_IDENTIFIER_TYPE_VALUE (id
, saved
->real_type_value
);
6252 /* If we were in the middle of compiling a function, restore our
6254 if (s
->need_pop_function_context
)
6255 pop_function_context ();
6256 current_function_decl
= s
->function_decl
;
6257 cp_unevaluated_operand
= s
->unevaluated_operand
;
6258 c_inhibit_evaluation_warnings
= s
->inhibit_evaluation_warnings
;
6260 /* Make this saved_scope structure available for reuse by
6261 push_to_top_level. */
6262 s
->prev
= free_saved_scope
;
6263 free_saved_scope
= s
;
6266 /* Wrapper for pop_from_top_level_1. */
6269 pop_from_top_level (void)
6271 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
6272 pop_from_top_level_1 ();
6273 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
6277 /* Pop off extraneous binding levels left over due to syntax errors.
6279 We don't pop past namespaces, as they might be valid. */
6282 pop_everything (void)
6284 if (ENABLE_SCOPE_CHECKING
)
6285 verbatim ("XXX entering pop_everything ()\n");
6286 while (!toplevel_bindings_p ())
6288 if (current_binding_level
->kind
== sk_class
)
6289 pop_nested_class ();
6293 if (ENABLE_SCOPE_CHECKING
)
6294 verbatim ("XXX leaving pop_everything ()\n");
6297 /* Emit debugging information for using declarations and directives.
6298 If input tree is overloaded fn then emit debug info for all
6302 cp_emit_debug_info_for_using (tree t
, tree context
)
6304 /* Don't try to emit any debug information if we have errors. */
6308 /* Ignore this FUNCTION_DECL if it refers to a builtin declaration
6309 of a builtin function. */
6310 if (TREE_CODE (t
) == FUNCTION_DECL
6311 && DECL_EXTERNAL (t
)
6312 && DECL_BUILT_IN (t
))
6315 /* Do not supply context to imported_module_or_decl, if
6316 it is a global namespace. */
6317 if (context
== global_namespace
)
6318 context
= NULL_TREE
;
6321 t
= BASELINK_FUNCTIONS (t
);
6323 /* FIXME: Handle TEMPLATE_DECLs. */
6324 for (t
= OVL_CURRENT (t
); t
; t
= OVL_NEXT (t
))
6325 if (TREE_CODE (t
) != TEMPLATE_DECL
)
6327 if (building_stmt_list_p ())
6328 add_stmt (build_stmt (input_location
, USING_STMT
, t
));
6330 (*debug_hooks
->imported_module_or_decl
) (t
, NULL_TREE
, context
, false);
6334 #include "gt-cp-name-lookup.h"