1 /* Definitions for C++ name lookup routines.
2 Copyright (C) 2003-2015 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"
28 #include "stringpool.h"
29 #include "print-tree.h"
32 #include "name-lookup.h"
34 #include "diagnostic-core.h"
37 #include "c-family/c-pragma.h"
40 /* The bindings for a particular name in a particular scope. */
42 struct scope_binding
{
46 #define EMPTY_SCOPE_BINDING { NULL_TREE, NULL_TREE }
48 static cp_binding_level
*innermost_nonclass_level (void);
49 static cxx_binding
*binding_for_name (cp_binding_level
*, tree
);
50 static tree
push_overloaded_decl (tree
, int, bool);
51 static bool lookup_using_namespace (tree
, struct scope_binding
*, tree
,
53 static bool qualified_lookup_using_namespace (tree
, tree
,
54 struct scope_binding
*, int);
55 static tree
lookup_type_current_level (tree
);
56 static tree
push_using_directive (tree
);
57 static tree
lookup_extern_c_fun_in_all_ns (tree
);
58 static void diagnose_name_conflict (tree
, tree
);
60 /* The :: namespace. */
62 tree global_namespace
;
64 /* The name of the anonymous namespace, throughout this translation
66 static GTY(()) tree anonymous_namespace_name
;
68 /* Initialize anonymous_namespace_name if necessary, and return it. */
71 get_anonymous_namespace_name (void)
73 if (!anonymous_namespace_name
)
75 /* We used to use get_file_function_name here, but that isn't
76 necessary now that anonymous namespace typeinfos
77 are !TREE_PUBLIC, and thus compared by address. */
78 /* The demangler expects anonymous namespaces to be called
79 something starting with '_GLOBAL__N_'. */
80 anonymous_namespace_name
= get_identifier ("_GLOBAL__N_1");
82 return anonymous_namespace_name
;
85 /* Compute the chain index of a binding_entry given the HASH value of its
86 name and the total COUNT of chains. COUNT is assumed to be a power
89 #define ENTRY_INDEX(HASH, COUNT) (((HASH) >> 3) & ((COUNT) - 1))
91 /* A free list of "binding_entry"s awaiting for re-use. */
93 static GTY((deletable
)) binding_entry free_binding_entry
= NULL
;
95 /* Create a binding_entry object for (NAME, TYPE). */
97 static inline binding_entry
98 binding_entry_make (tree name
, tree type
)
102 if (free_binding_entry
)
104 entry
= free_binding_entry
;
105 free_binding_entry
= entry
->chain
;
108 entry
= ggc_alloc
<binding_entry_s
> ();
117 /* Put ENTRY back on the free list. */
120 binding_entry_free (binding_entry entry
)
124 entry
->chain
= free_binding_entry
;
125 free_binding_entry
= entry
;
129 /* The datatype used to implement the mapping from names to types at
131 struct GTY(()) binding_table_s
{
132 /* Array of chains of "binding_entry"s */
133 binding_entry
* GTY((length ("%h.chain_count"))) chain
;
135 /* The number of chains in this table. This is the length of the
136 member "chain" considered as an array. */
139 /* Number of "binding_entry"s in this table. */
143 /* Construct TABLE with an initial CHAIN_COUNT. */
146 binding_table_construct (binding_table table
, size_t chain_count
)
148 table
->chain_count
= chain_count
;
149 table
->entry_count
= 0;
150 table
->chain
= ggc_cleared_vec_alloc
<binding_entry
> (table
->chain_count
);
153 /* Make TABLE's entries ready for reuse. */
156 binding_table_free (binding_table table
)
164 for (i
= 0, count
= table
->chain_count
; i
< count
; ++i
)
166 binding_entry temp
= table
->chain
[i
];
169 binding_entry entry
= temp
;
171 binding_entry_free (entry
);
173 table
->chain
[i
] = NULL
;
175 table
->entry_count
= 0;
179 /* Allocate a table with CHAIN_COUNT, assumed to be a power of two. */
181 static inline binding_table
182 binding_table_new (size_t chain_count
)
184 binding_table table
= ggc_alloc
<binding_table_s
> ();
186 binding_table_construct (table
, chain_count
);
190 /* Expand TABLE to twice its current chain_count. */
193 binding_table_expand (binding_table table
)
195 const size_t old_chain_count
= table
->chain_count
;
196 const size_t old_entry_count
= table
->entry_count
;
197 const size_t new_chain_count
= 2 * old_chain_count
;
198 binding_entry
*old_chains
= table
->chain
;
201 binding_table_construct (table
, new_chain_count
);
202 for (i
= 0; i
< old_chain_count
; ++i
)
204 binding_entry entry
= old_chains
[i
];
205 for (; entry
!= NULL
; entry
= old_chains
[i
])
207 const unsigned int hash
= IDENTIFIER_HASH_VALUE (entry
->name
);
208 const size_t j
= ENTRY_INDEX (hash
, new_chain_count
);
210 old_chains
[i
] = entry
->chain
;
211 entry
->chain
= table
->chain
[j
];
212 table
->chain
[j
] = entry
;
215 table
->entry_count
= old_entry_count
;
218 /* Insert a binding for NAME to TYPE into TABLE. */
221 binding_table_insert (binding_table table
, tree name
, tree type
)
223 const unsigned int hash
= IDENTIFIER_HASH_VALUE (name
);
224 const size_t i
= ENTRY_INDEX (hash
, table
->chain_count
);
225 binding_entry entry
= binding_entry_make (name
, type
);
227 entry
->chain
= table
->chain
[i
];
228 table
->chain
[i
] = entry
;
229 ++table
->entry_count
;
231 if (3 * table
->chain_count
< 5 * table
->entry_count
)
232 binding_table_expand (table
);
235 /* Return the binding_entry, if any, that maps NAME. */
238 binding_table_find (binding_table table
, tree name
)
240 const unsigned int hash
= IDENTIFIER_HASH_VALUE (name
);
241 binding_entry entry
= table
->chain
[ENTRY_INDEX (hash
, table
->chain_count
)];
243 while (entry
!= NULL
&& entry
->name
!= name
)
244 entry
= entry
->chain
;
249 /* Apply PROC -- with DATA -- to all entries in TABLE. */
252 binding_table_foreach (binding_table table
, bt_foreach_proc proc
, void *data
)
260 chain_count
= table
->chain_count
;
261 for (i
= 0; i
< chain_count
; ++i
)
263 binding_entry entry
= table
->chain
[i
];
264 for (; entry
!= NULL
; entry
= entry
->chain
)
269 #ifndef ENABLE_SCOPE_CHECKING
270 # define ENABLE_SCOPE_CHECKING 0
272 # define ENABLE_SCOPE_CHECKING 1
275 /* A free list of "cxx_binding"s, connected by their PREVIOUS. */
277 static GTY((deletable
)) cxx_binding
*free_bindings
;
279 /* Initialize VALUE and TYPE field for BINDING, and set the PREVIOUS
283 cxx_binding_init (cxx_binding
*binding
, tree value
, tree type
)
285 binding
->value
= value
;
286 binding
->type
= type
;
287 binding
->previous
= NULL
;
290 /* (GC)-allocate a binding object with VALUE and TYPE member initialized. */
293 cxx_binding_make (tree value
, tree type
)
295 cxx_binding
*binding
;
298 binding
= free_bindings
;
299 free_bindings
= binding
->previous
;
302 binding
= ggc_alloc
<cxx_binding
> ();
304 cxx_binding_init (binding
, value
, type
);
309 /* Put BINDING back on the free list. */
312 cxx_binding_free (cxx_binding
*binding
)
314 binding
->scope
= NULL
;
315 binding
->previous
= free_bindings
;
316 free_bindings
= binding
;
319 /* Create a new binding for NAME (with the indicated VALUE and TYPE
320 bindings) in the class scope indicated by SCOPE. */
323 new_class_binding (tree name
, tree value
, tree type
, cp_binding_level
*scope
)
325 cp_class_binding cb
= {cxx_binding_make (value
, type
), name
};
326 cxx_binding
*binding
= cb
.base
;
327 vec_safe_push (scope
->class_shadowed
, cb
);
328 binding
->scope
= scope
;
332 /* Make DECL the innermost binding for ID. The LEVEL is the binding
333 level at which this declaration is being bound. */
336 push_binding (tree id
, tree decl
, cp_binding_level
* level
)
338 cxx_binding
*binding
;
340 if (level
!= class_binding_level
)
342 binding
= cxx_binding_make (decl
, NULL_TREE
);
343 binding
->scope
= level
;
346 binding
= new_class_binding (id
, decl
, /*type=*/NULL_TREE
, level
);
348 /* Now, fill in the binding information. */
349 binding
->previous
= IDENTIFIER_BINDING (id
);
350 INHERITED_VALUE_BINDING_P (binding
) = 0;
351 LOCAL_BINDING_P (binding
) = (level
!= class_binding_level
);
353 /* And put it on the front of the list of bindings for ID. */
354 IDENTIFIER_BINDING (id
) = binding
;
357 /* Remove the binding for DECL which should be the innermost binding
361 pop_binding (tree id
, tree decl
)
363 cxx_binding
*binding
;
366 /* It's easiest to write the loops that call this function without
367 checking whether or not the entities involved have names. We
368 get here for such an entity. */
371 /* Get the innermost binding for ID. */
372 binding
= IDENTIFIER_BINDING (id
);
374 /* The name should be bound. */
375 gcc_assert (binding
!= NULL
);
377 /* The DECL will be either the ordinary binding or the type
378 binding for this identifier. Remove that binding. */
379 if (binding
->value
== decl
)
380 binding
->value
= NULL_TREE
;
383 gcc_assert (binding
->type
== decl
);
384 binding
->type
= NULL_TREE
;
387 if (!binding
->value
&& !binding
->type
)
389 /* We're completely done with the innermost binding for this
390 identifier. Unhook it from the list of bindings. */
391 IDENTIFIER_BINDING (id
) = binding
->previous
;
393 /* Add it to the free list. */
394 cxx_binding_free (binding
);
398 /* Remove the bindings for the decls of the current level and leave
399 the current scope. */
402 pop_bindings_and_leave_scope (void)
404 for (tree t
= getdecls (); t
; t
= DECL_CHAIN (t
))
405 pop_binding (DECL_NAME (t
), t
);
409 /* Strip non dependent using declarations. If DECL is dependent,
410 surreptitiously create a typename_type and return it. */
413 strip_using_decl (tree decl
)
415 if (decl
== NULL_TREE
)
418 while (TREE_CODE (decl
) == USING_DECL
&& !DECL_DEPENDENT_P (decl
))
419 decl
= USING_DECL_DECLS (decl
);
421 if (TREE_CODE (decl
) == USING_DECL
&& DECL_DEPENDENT_P (decl
)
422 && USING_DECL_TYPENAME_P (decl
))
424 /* We have found a type introduced by a using
425 declaration at class scope that refers to a dependent
428 using typename :: [opt] nested-name-specifier unqualified-id ;
430 decl
= make_typename_type (TREE_TYPE (decl
),
432 typename_type
, tf_error
);
433 if (decl
!= error_mark_node
)
434 decl
= TYPE_NAME (decl
);
440 /* BINDING records an existing declaration for a name in the current scope.
441 But, DECL is another declaration for that same identifier in the
442 same scope. This is the `struct stat' hack whereby a non-typedef
443 class name or enum-name can be bound at the same level as some other
447 A class name (9.1) or enumeration name (7.2) can be hidden by the
448 name of an object, function, or enumerator declared in the same scope.
449 If a class or enumeration name and an object, function, or enumerator
450 are declared in the same scope (in any order) with the same name, the
451 class or enumeration name is hidden wherever the object, function, or
452 enumerator name is visible.
454 It's the responsibility of the caller to check that
455 inserting this name is valid here. Returns nonzero if the new binding
459 supplement_binding_1 (cxx_binding
*binding
, tree decl
)
461 tree bval
= binding
->value
;
463 tree target_bval
= strip_using_decl (bval
);
464 tree target_decl
= strip_using_decl (decl
);
466 if (TREE_CODE (target_decl
) == TYPE_DECL
&& DECL_ARTIFICIAL (target_decl
)
467 && target_decl
!= target_bval
468 && (TREE_CODE (target_bval
) != TYPE_DECL
469 /* We allow pushing an enum multiple times in a class
470 template in order to handle late matching of underlying
471 type on an opaque-enum-declaration followed by an
473 || (processing_template_decl
474 && TREE_CODE (TREE_TYPE (target_decl
)) == ENUMERAL_TYPE
475 && TREE_CODE (TREE_TYPE (target_bval
)) == ENUMERAL_TYPE
476 && (dependent_type_p (ENUM_UNDERLYING_TYPE
477 (TREE_TYPE (target_decl
)))
478 || dependent_type_p (ENUM_UNDERLYING_TYPE
479 (TREE_TYPE (target_bval
)))))))
480 /* The new name is the type name. */
481 binding
->type
= decl
;
482 else if (/* TARGET_BVAL is null when push_class_level_binding moves
483 an inherited type-binding out of the way to make room
484 for a new value binding. */
486 /* TARGET_BVAL is error_mark_node when TARGET_DECL's name
487 has been used in a non-class scope prior declaration.
488 In that case, we should have already issued a
489 diagnostic; for graceful error recovery purpose, pretend
490 this was the intended declaration for that name. */
491 || target_bval
== error_mark_node
492 /* If TARGET_BVAL is anticipated but has not yet been
493 declared, pretend it is not there at all. */
494 || (TREE_CODE (target_bval
) == FUNCTION_DECL
495 && DECL_ANTICIPATED (target_bval
)
496 && !DECL_HIDDEN_FRIEND_P (target_bval
)))
497 binding
->value
= decl
;
498 else if (TREE_CODE (target_bval
) == TYPE_DECL
499 && DECL_ARTIFICIAL (target_bval
)
500 && target_decl
!= target_bval
501 && (TREE_CODE (target_decl
) != TYPE_DECL
502 || same_type_p (TREE_TYPE (target_decl
),
503 TREE_TYPE (target_bval
))))
505 /* The old binding was a type name. It was placed in
506 VALUE field because it was thought, at the point it was
507 declared, to be the only entity with such a name. Move the
508 type name into the type slot; it is now hidden by the new
510 binding
->type
= bval
;
511 binding
->value
= decl
;
512 binding
->value_is_inherited
= false;
514 else if (TREE_CODE (target_bval
) == TYPE_DECL
515 && TREE_CODE (target_decl
) == TYPE_DECL
516 && DECL_NAME (target_decl
) == DECL_NAME (target_bval
)
517 && binding
->scope
->kind
!= sk_class
518 && (same_type_p (TREE_TYPE (target_decl
), TREE_TYPE (target_bval
))
519 /* If either type involves template parameters, we must
520 wait until instantiation. */
521 || uses_template_parms (TREE_TYPE (target_decl
))
522 || uses_template_parms (TREE_TYPE (target_bval
))))
523 /* We have two typedef-names, both naming the same type to have
524 the same name. In general, this is OK because of:
528 In a given scope, a typedef specifier can be used to redefine
529 the name of any type declared in that scope to refer to the
530 type to which it already refers.
532 However, in class scopes, this rule does not apply due to the
533 stricter language in [class.mem] prohibiting redeclarations of
536 /* There can be two block-scope declarations of the same variable,
537 so long as they are `extern' declarations. However, there cannot
538 be two declarations of the same static data member:
542 A member shall not be declared twice in the
543 member-specification. */
544 else if (VAR_P (target_decl
)
545 && VAR_P (target_bval
)
546 && DECL_EXTERNAL (target_decl
) && DECL_EXTERNAL (target_bval
)
547 && !DECL_CLASS_SCOPE_P (target_decl
))
549 duplicate_decls (decl
, binding
->value
, /*newdecl_is_friend=*/false);
552 else if (TREE_CODE (decl
) == NAMESPACE_DECL
553 && TREE_CODE (bval
) == NAMESPACE_DECL
554 && DECL_NAMESPACE_ALIAS (decl
)
555 && DECL_NAMESPACE_ALIAS (bval
)
556 && ORIGINAL_NAMESPACE (bval
) == ORIGINAL_NAMESPACE (decl
))
559 In a declarative region, a namespace-alias-definition can be
560 used to redefine a namespace-alias declared in that declarative
561 region to refer only to the namespace to which it already
564 else if (maybe_remove_implicit_alias (bval
))
566 /* There was a mangling compatibility alias using this mangled name,
567 but now we have a real decl that wants to use it instead. */
568 binding
->value
= decl
;
572 diagnose_name_conflict (decl
, bval
);
579 /* Diagnose a name conflict between DECL and BVAL. */
582 diagnose_name_conflict (tree decl
, tree bval
)
584 if (TREE_CODE (decl
) == TREE_CODE (bval
)
585 && (TREE_CODE (decl
) != TYPE_DECL
586 || (DECL_ARTIFICIAL (decl
) && DECL_ARTIFICIAL (bval
))
587 || (!DECL_ARTIFICIAL (decl
) && !DECL_ARTIFICIAL (bval
)))
588 && !is_overloaded_fn (decl
))
589 error ("redeclaration of %q#D", decl
);
591 error ("%q#D conflicts with a previous declaration", decl
);
593 inform (location_of (bval
), "previous declaration %q#D", bval
);
596 /* Wrapper for supplement_binding_1. */
599 supplement_binding (cxx_binding
*binding
, tree decl
)
602 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
603 ret
= supplement_binding_1 (binding
, decl
);
604 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
608 /* Add DECL to the list of things declared in B. */
611 add_decl_to_level (tree decl
, cp_binding_level
*b
)
613 /* We used to record virtual tables as if they were ordinary
614 variables, but no longer do so. */
615 gcc_assert (!(VAR_P (decl
) && DECL_VIRTUAL_P (decl
)));
617 if (TREE_CODE (decl
) == NAMESPACE_DECL
618 && !DECL_NAMESPACE_ALIAS (decl
))
620 DECL_CHAIN (decl
) = b
->namespaces
;
621 b
->namespaces
= decl
;
625 /* We build up the list in reverse order, and reverse it later if
627 TREE_CHAIN (decl
) = b
->names
;
630 /* If appropriate, add decl to separate list of statics. We
631 include extern variables because they might turn out to be
632 static later. It's OK for this list to contain a few false
634 if (b
->kind
== sk_namespace
)
636 && (TREE_STATIC (decl
) || DECL_EXTERNAL (decl
)))
637 || (TREE_CODE (decl
) == FUNCTION_DECL
638 && (!TREE_PUBLIC (decl
)
639 || decl_anon_ns_mem_p (decl
)
640 || DECL_DECLARED_INLINE_P (decl
))))
641 vec_safe_push (b
->static_decls
, decl
);
645 /* Record a decl-node X as belonging to the current lexical scope.
646 Check for errors (such as an incompatible declaration for the same
647 name already seen in the same scope). IS_FRIEND is true if X is
648 declared as a friend.
650 Returns either X or an old decl for the same name.
651 If an old decl is returned, it may have been smashed
652 to agree with what X says. */
655 pushdecl_maybe_friend_1 (tree x
, bool is_friend
)
659 int need_new_binding
;
661 if (x
== error_mark_node
)
662 return error_mark_node
;
664 need_new_binding
= 1;
666 if (DECL_TEMPLATE_PARM_P (x
))
667 /* Template parameters have no context; they are not X::T even
668 when declared within a class or namespace. */
672 if (current_function_decl
&& x
!= current_function_decl
673 /* A local declaration for a function doesn't constitute
675 && TREE_CODE (x
) != FUNCTION_DECL
676 /* A local declaration for an `extern' variable is in the
677 scope of the current namespace, not the current
679 && !(VAR_P (x
) && DECL_EXTERNAL (x
))
680 /* When parsing the parameter list of a function declarator,
681 don't set DECL_CONTEXT to an enclosing function. When we
682 push the PARM_DECLs in order to process the function body,
683 current_binding_level->this_entity will be set. */
684 && !(TREE_CODE (x
) == PARM_DECL
685 && current_binding_level
->kind
== sk_function_parms
686 && current_binding_level
->this_entity
== NULL
)
687 && !DECL_CONTEXT (x
))
688 DECL_CONTEXT (x
) = current_function_decl
;
690 /* If this is the declaration for a namespace-scope function,
691 but the declaration itself is in a local scope, mark the
693 if (TREE_CODE (x
) == FUNCTION_DECL
694 && DECL_NAMESPACE_SCOPE_P (x
)
695 && current_function_decl
696 && x
!= current_function_decl
)
697 DECL_LOCAL_FUNCTION_P (x
) = 1;
700 name
= DECL_NAME (x
);
703 int different_binding_level
= 0;
705 if (TREE_CODE (name
) == TEMPLATE_ID_EXPR
)
706 name
= TREE_OPERAND (name
, 0);
708 /* In case this decl was explicitly namespace-qualified, look it
709 up in its namespace context. */
710 if (DECL_NAMESPACE_SCOPE_P (x
) && namespace_bindings_p ())
711 t
= namespace_binding (name
, DECL_CONTEXT (x
));
713 t
= lookup_name_innermost_nonclass_level (name
);
715 /* [basic.link] If there is a visible declaration of an entity
716 with linkage having the same name and type, ignoring entities
717 declared outside the innermost enclosing namespace scope, the
718 block scope declaration declares that same entity and
719 receives the linkage of the previous declaration. */
720 if (! t
&& current_function_decl
&& x
!= current_function_decl
721 && VAR_OR_FUNCTION_DECL_P (x
)
722 && DECL_EXTERNAL (x
))
724 /* Look in block scope. */
725 t
= innermost_non_namespace_value (name
);
726 /* Or in the innermost namespace. */
728 t
= namespace_binding (name
, DECL_CONTEXT (x
));
729 /* Does it have linkage? Note that if this isn't a DECL, it's an
730 OVERLOAD, which is OK. */
731 if (t
&& DECL_P (t
) && ! (TREE_STATIC (t
) || DECL_EXTERNAL (t
)))
734 different_binding_level
= 1;
737 /* If we are declaring a function, and the result of name-lookup
738 was an OVERLOAD, look for an overloaded instance that is
739 actually the same as the function we are declaring. (If
740 there is one, we have to merge our declaration with the
741 previous declaration.) */
742 if (t
&& TREE_CODE (t
) == OVERLOAD
)
746 if (TREE_CODE (x
) == FUNCTION_DECL
)
747 for (match
= t
; match
; match
= OVL_NEXT (match
))
749 if (decls_match (OVL_CURRENT (match
), x
))
753 /* Just choose one. */
757 t
= OVL_CURRENT (match
);
762 if (t
&& t
!= error_mark_node
)
764 if (different_binding_level
)
766 if (decls_match (x
, t
))
767 /* The standard only says that the local extern
768 inherits linkage from the previous decl; in
769 particular, default args are not shared. Add
770 the decl into a hash table to make sure only
771 the previous decl in this case is seen by the
774 struct cxx_int_tree_map
*h
;
776 TREE_PUBLIC (x
) = TREE_PUBLIC (t
);
778 if (cp_function_chain
->extern_decl_map
== NULL
)
779 cp_function_chain
->extern_decl_map
780 = hash_table
<cxx_int_tree_map_hasher
>::create_ggc (20);
782 h
= ggc_alloc
<cxx_int_tree_map
> ();
783 h
->uid
= DECL_UID (x
);
785 cxx_int_tree_map
**loc
= cp_function_chain
->extern_decl_map
786 ->find_slot (h
, INSERT
);
790 else if (TREE_CODE (t
) == PARM_DECL
)
792 /* Check for duplicate params. */
793 tree d
= duplicate_decls (x
, t
, is_friend
);
797 else if ((DECL_EXTERN_C_FUNCTION_P (x
)
798 || DECL_FUNCTION_TEMPLATE_P (x
))
799 && is_overloaded_fn (t
))
800 /* Don't do anything just yet. */;
801 else if (t
== wchar_decl_node
)
803 if (! DECL_IN_SYSTEM_HEADER (x
))
804 pedwarn (input_location
, OPT_Wpedantic
, "redeclaration of %<wchar_t%> as %qT",
807 /* Throw away the redeclaration. */
812 tree olddecl
= duplicate_decls (x
, t
, is_friend
);
814 /* If the redeclaration failed, we can stop at this
816 if (olddecl
== error_mark_node
)
817 return error_mark_node
;
821 if (TREE_CODE (t
) == TYPE_DECL
)
822 SET_IDENTIFIER_TYPE_VALUE (name
, TREE_TYPE (t
));
826 else if (DECL_MAIN_P (x
) && TREE_CODE (t
) == FUNCTION_DECL
)
828 /* A redeclaration of main, but not a duplicate of the
833 This function shall not be overloaded. */
834 error ("invalid redeclaration of %q+D", t
);
836 /* We don't try to push this declaration since that
843 /* If x has C linkage-specification, (extern "C"),
844 lookup its binding, in case it's already bound to an object.
845 The lookup is done in all namespaces.
846 If we find an existing binding, make sure it has the same
847 exception specification as x, otherwise, bail in error [7.5, 7.6]. */
848 if ((TREE_CODE (x
) == FUNCTION_DECL
)
849 && DECL_EXTERN_C_P (x
)
850 /* We should ignore declarations happening in system headers. */
851 && !DECL_ARTIFICIAL (x
)
852 && !DECL_IN_SYSTEM_HEADER (x
))
854 tree previous
= lookup_extern_c_fun_in_all_ns (x
);
856 && !DECL_ARTIFICIAL (previous
)
857 && !DECL_IN_SYSTEM_HEADER (previous
)
858 && DECL_CONTEXT (previous
) != DECL_CONTEXT (x
))
860 /* In case either x or previous is declared to throw an exception,
861 make sure both exception specifications are equal. */
862 if (decls_match (x
, previous
))
864 tree x_exception_spec
= NULL_TREE
;
865 tree previous_exception_spec
= NULL_TREE
;
868 TYPE_RAISES_EXCEPTIONS (TREE_TYPE (x
));
869 previous_exception_spec
=
870 TYPE_RAISES_EXCEPTIONS (TREE_TYPE (previous
));
871 if (!comp_except_specs (previous_exception_spec
,
875 pedwarn (input_location
, 0,
876 "declaration of %q#D with C language linkage",
878 pedwarn (DECL_SOURCE_LOCATION (previous
), 0,
879 "conflicts with previous declaration %q#D",
881 pedwarn (input_location
, 0,
882 "due to different exception specifications");
883 return error_mark_node
;
885 if (DECL_ASSEMBLER_NAME_SET_P (previous
))
886 SET_DECL_ASSEMBLER_NAME (x
,
887 DECL_ASSEMBLER_NAME (previous
));
891 pedwarn (input_location
, 0,
892 "declaration of %q#D with C language linkage", x
);
893 pedwarn (DECL_SOURCE_LOCATION (previous
), 0,
894 "conflicts with previous declaration %q#D",
900 check_template_shadow (x
);
902 /* If this is a function conjured up by the back end, massage it
903 so it looks friendly. */
904 if (DECL_NON_THUNK_FUNCTION_P (x
) && ! DECL_LANG_SPECIFIC (x
))
906 retrofit_lang_decl (x
);
907 SET_DECL_LANGUAGE (x
, lang_c
);
911 if (DECL_NON_THUNK_FUNCTION_P (x
) && ! DECL_FUNCTION_MEMBER_P (x
))
913 t
= push_overloaded_decl (x
, PUSH_LOCAL
, is_friend
);
914 if (!namespace_bindings_p ())
915 /* We do not need to create a binding for this name;
916 push_overloaded_decl will have already done so if
918 need_new_binding
= 0;
920 else if (DECL_FUNCTION_TEMPLATE_P (x
) && DECL_NAMESPACE_SCOPE_P (x
))
922 t
= push_overloaded_decl (x
, PUSH_GLOBAL
, is_friend
);
924 add_decl_to_level (x
, NAMESPACE_LEVEL (CP_DECL_CONTEXT (t
)));
927 if (DECL_DECLARES_FUNCTION_P (t
))
929 check_default_args (t
);
931 if (is_friend
&& t
== x
&& !flag_friend_injection
)
933 /* This is a new friend declaration of a function or a
934 function template, so hide it from ordinary function
936 DECL_ANTICIPATED (t
) = 1;
937 DECL_HIDDEN_FRIEND_P (t
) = 1;
941 if (t
!= x
|| DECL_FUNCTION_TEMPLATE_P (t
))
944 /* If declaring a type as a typedef, copy the type (unless we're
945 at line 0), and install this TYPE_DECL as the new type's typedef
946 name. See the extensive comment of set_underlying_type (). */
947 if (TREE_CODE (x
) == TYPE_DECL
)
949 tree type
= TREE_TYPE (x
);
951 if (DECL_IS_BUILTIN (x
)
952 || (TREE_TYPE (x
) != error_mark_node
953 && TYPE_NAME (type
) != x
954 /* We don't want to copy the type when all we're
955 doing is making a TYPE_DECL for the purposes of
957 && (!TYPE_NAME (type
)
958 || TYPE_NAME (type
) != DECL_ABSTRACT_ORIGIN (x
))))
959 set_underlying_type (x
);
961 if (type
!= error_mark_node
962 && TYPE_IDENTIFIER (type
))
963 set_identifier_type_value (DECL_NAME (x
), x
);
965 /* If this is a locally defined typedef in a function that
966 is not a template instantation, record it to implement
967 -Wunused-local-typedefs. */
968 if (!instantiating_current_function_p ())
969 record_locally_defined_typedef (x
);
972 /* Multiple external decls of the same identifier ought to match.
974 We get warnings about inline functions where they are defined.
975 We get warnings about other functions from push_overloaded_decl.
977 Avoid duplicate warnings where they are used. */
978 if (TREE_PUBLIC (x
) && TREE_CODE (x
) != FUNCTION_DECL
)
982 decl
= IDENTIFIER_NAMESPACE_VALUE (name
);
983 if (decl
&& TREE_CODE (decl
) == OVERLOAD
)
984 decl
= OVL_FUNCTION (decl
);
986 if (decl
&& decl
!= error_mark_node
987 && (DECL_EXTERNAL (decl
) || TREE_PUBLIC (decl
))
988 /* If different sort of thing, we already gave an error. */
989 && TREE_CODE (decl
) == TREE_CODE (x
)
990 && !comptypes (TREE_TYPE (x
), TREE_TYPE (decl
),
991 COMPARE_REDECLARATION
))
993 if (permerror (input_location
, "type mismatch with previous "
994 "external decl of %q#D", x
))
995 inform (DECL_SOURCE_LOCATION (decl
),
996 "previous external decl of %q#D", decl
);
1000 /* This name is new in its binding level.
1001 Install the new declaration and return it. */
1002 if (namespace_bindings_p ())
1004 /* Install a global value. */
1006 /* If the first global decl has external linkage,
1007 warn if we later see static one. */
1008 if (IDENTIFIER_GLOBAL_VALUE (name
) == NULL_TREE
&& TREE_PUBLIC (x
))
1009 TREE_PUBLIC (name
) = 1;
1011 /* Bind the name for the entity. */
1012 if (!(TREE_CODE (x
) == TYPE_DECL
&& DECL_ARTIFICIAL (x
)
1014 && (TREE_CODE (x
) == TYPE_DECL
1016 || TREE_CODE (x
) == NAMESPACE_DECL
1017 || TREE_CODE (x
) == CONST_DECL
1018 || TREE_CODE (x
) == TEMPLATE_DECL
))
1019 SET_IDENTIFIER_NAMESPACE_VALUE (name
, x
);
1021 /* If new decl is `static' and an `extern' was seen previously,
1023 if (x
!= NULL_TREE
&& t
!= NULL_TREE
&& decls_match (x
, t
))
1024 warn_extern_redeclared_static (x
, t
);
1028 /* Here to install a non-global value. */
1029 tree oldglobal
= IDENTIFIER_NAMESPACE_VALUE (name
);
1030 tree oldlocal
= NULL_TREE
;
1031 cp_binding_level
*oldscope
= NULL
;
1032 cxx_binding
*oldbinding
= outer_binding (name
, NULL
, true);
1035 oldlocal
= oldbinding
->value
;
1036 oldscope
= oldbinding
->scope
;
1039 if (need_new_binding
)
1041 push_local_binding (name
, x
, 0);
1042 /* Because push_local_binding will hook X on to the
1043 current_binding_level's name list, we don't want to
1044 do that again below. */
1045 need_new_binding
= 0;
1048 /* If this is a TYPE_DECL, push it into the type value slot. */
1049 if (TREE_CODE (x
) == TYPE_DECL
)
1050 set_identifier_type_value (name
, x
);
1052 /* Clear out any TYPE_DECL shadowed by a namespace so that
1053 we won't think this is a type. The C struct hack doesn't
1054 go through namespaces. */
1055 if (TREE_CODE (x
) == NAMESPACE_DECL
)
1056 set_identifier_type_value (name
, NULL_TREE
);
1064 && DECL_DEAD_FOR_LOCAL (oldlocal
))
1065 oldlocal
= DECL_SHADOWED_FOR_VAR (oldlocal
);
1067 if (oldlocal
== NULL_TREE
)
1068 oldlocal
= IDENTIFIER_NAMESPACE_VALUE (DECL_NAME (d
));
1071 /* If this is an extern function declaration, see if we
1072 have a global definition or declaration for the function. */
1073 if (oldlocal
== NULL_TREE
1074 && DECL_EXTERNAL (x
)
1075 && oldglobal
!= NULL_TREE
1076 && TREE_CODE (x
) == FUNCTION_DECL
1077 && TREE_CODE (oldglobal
) == FUNCTION_DECL
)
1079 /* We have one. Their types must agree. */
1080 if (decls_match (x
, oldglobal
))
1084 warning (0, "extern declaration of %q#D doesn%'t match", x
);
1085 warning_at (DECL_SOURCE_LOCATION (oldglobal
), 0,
1086 "global declaration %q#D", oldglobal
);
1089 /* If we have a local external declaration,
1090 and no file-scope declaration has yet been seen,
1091 then if we later have a file-scope decl it must not be static. */
1092 if (oldlocal
== NULL_TREE
1093 && oldglobal
== NULL_TREE
1094 && DECL_EXTERNAL (x
)
1096 TREE_PUBLIC (name
) = 1;
1098 /* Don't complain about the parms we push and then pop
1099 while tentatively parsing a function declarator. */
1100 if (TREE_CODE (x
) == PARM_DECL
&& DECL_CONTEXT (x
) == NULL_TREE
)
1103 /* Warn if shadowing an argument at the top level of the body. */
1104 else if (oldlocal
!= NULL_TREE
&& !DECL_EXTERNAL (x
)
1105 /* Inline decls shadow nothing. */
1106 && !DECL_FROM_INLINE (x
)
1107 && (TREE_CODE (oldlocal
) == PARM_DECL
1109 /* If the old decl is a type decl, only warn if the
1110 old decl is an explicit typedef or if both the old
1111 and new decls are type decls. */
1112 || (TREE_CODE (oldlocal
) == TYPE_DECL
1113 && (!DECL_ARTIFICIAL (oldlocal
)
1114 || TREE_CODE (x
) == TYPE_DECL
)))
1115 /* Don't check for internally generated vars unless
1116 it's an implicit typedef (see create_implicit_typedef
1118 && (!DECL_ARTIFICIAL (x
) || DECL_IMPLICIT_TYPEDEF_P (x
)))
1120 bool nowarn
= false;
1122 /* Don't complain if it's from an enclosing function. */
1123 if (DECL_CONTEXT (oldlocal
) == current_function_decl
1124 && TREE_CODE (x
) != PARM_DECL
1125 && TREE_CODE (oldlocal
) == PARM_DECL
)
1127 /* Go to where the parms should be and see if we find
1129 cp_binding_level
*b
= current_binding_level
->level_chain
;
1131 if (FUNCTION_NEEDS_BODY_BLOCK (current_function_decl
))
1132 /* Skip the ctor/dtor cleanup level. */
1136 if (b
->kind
== sk_function_parms
)
1138 error ("declaration of %q#D shadows a parameter", x
);
1143 /* The local structure or class can't use parameters of
1144 the containing function anyway. */
1145 if (DECL_CONTEXT (oldlocal
) != current_function_decl
)
1147 cp_binding_level
*scope
= current_binding_level
;
1148 tree context
= DECL_CONTEXT (oldlocal
);
1149 for (; scope
; scope
= scope
->level_chain
)
1151 if (scope
->kind
== sk_function_parms
1152 && scope
->this_entity
== context
)
1154 if (scope
->kind
== sk_class
1155 && !LAMBDA_TYPE_P (scope
->this_entity
))
1162 /* Error if redeclaring a local declared in a
1163 for-init-statement or in the condition of an if or
1164 switch statement when the new declaration is in the
1165 outermost block of the controlled statement.
1166 Redeclaring a variable from a for or while condition is
1167 detected elsewhere. */
1168 else if (VAR_P (oldlocal
)
1169 && oldscope
== current_binding_level
->level_chain
1170 && (oldscope
->kind
== sk_cond
1171 || oldscope
->kind
== sk_for
))
1173 error ("redeclaration of %q#D", x
);
1174 inform (DECL_SOURCE_LOCATION (oldlocal
),
1175 "%q#D previously declared here", oldlocal
);
1179 3.3.3/3: The name declared in an exception-declaration (...)
1180 shall not be redeclared in the outermost block of the handler.
1181 3.3.3/2: A parameter name shall not be redeclared (...) in
1182 the outermost block of any handler associated with a
1184 3.4.1/15: The function parameter names shall not be redeclared
1185 in the exception-declaration nor in the outermost block of a
1186 handler for the function-try-block. */
1187 else if ((VAR_P (oldlocal
)
1188 && oldscope
== current_binding_level
->level_chain
1189 && oldscope
->kind
== sk_catch
)
1190 || (TREE_CODE (oldlocal
) == PARM_DECL
1191 && (current_binding_level
->kind
== sk_catch
1192 || (current_binding_level
->level_chain
->kind
1194 && in_function_try_handler
))
1196 if (permerror (input_location
, "redeclaration of %q#D", x
))
1197 inform (DECL_SOURCE_LOCATION (oldlocal
),
1198 "%q#D previously declared here", oldlocal
);
1202 if (warn_shadow
&& !nowarn
)
1206 if (TREE_CODE (oldlocal
) == PARM_DECL
)
1207 warned
= warning_at (input_location
, OPT_Wshadow
,
1208 "declaration of %q#D shadows a parameter", x
);
1209 else if (is_capture_proxy (oldlocal
))
1210 warned
= warning_at (input_location
, OPT_Wshadow
,
1211 "declaration of %qD shadows a lambda capture",
1214 warned
= warning_at (input_location
, OPT_Wshadow
,
1215 "declaration of %qD shadows a previous local",
1219 inform (DECL_SOURCE_LOCATION (oldlocal
),
1220 "shadowed declaration is here");
1224 /* Maybe warn if shadowing something else. */
1225 else if (warn_shadow
&& !DECL_EXTERNAL (x
)
1226 /* No shadow warnings for internally generated vars unless
1227 it's an implicit typedef (see create_implicit_typedef
1229 && (! DECL_ARTIFICIAL (x
) || DECL_IMPLICIT_TYPEDEF_P (x
))
1230 /* No shadow warnings for vars made for inlining. */
1231 && ! DECL_FROM_INLINE (x
))
1235 if (nonlambda_method_basetype ())
1236 member
= lookup_member (current_nonlambda_class_type (),
1239 /*want_type=*/false,
1240 tf_warning_or_error
);
1244 if (member
&& !TREE_STATIC (member
))
1246 if (BASELINK_P (member
))
1247 member
= BASELINK_FUNCTIONS (member
);
1248 member
= OVL_CURRENT (member
);
1250 /* Do not warn if a variable shadows a function, unless
1251 the variable is a function or a pointer-to-function. */
1252 if (TREE_CODE (member
) != FUNCTION_DECL
1253 || TREE_CODE (x
) == FUNCTION_DECL
1254 || TYPE_PTRFN_P (TREE_TYPE (x
))
1255 || TYPE_PTRMEMFUNC_P (TREE_TYPE (x
)))
1257 if (warning_at (input_location
, OPT_Wshadow
,
1258 "declaration of %qD shadows a member of %qT",
1259 x
, current_nonlambda_class_type ())
1261 inform (DECL_SOURCE_LOCATION (member
),
1262 "shadowed declaration is here");
1265 else if (oldglobal
!= NULL_TREE
1266 && (VAR_P (oldglobal
)
1267 /* If the old decl is a type decl, only warn if the
1268 old decl is an explicit typedef or if both the
1269 old and new decls are type decls. */
1270 || (TREE_CODE (oldglobal
) == TYPE_DECL
1271 && (!DECL_ARTIFICIAL (oldglobal
)
1272 || TREE_CODE (x
) == TYPE_DECL
)))
1273 && !instantiating_current_function_p ())
1274 /* XXX shadow warnings in outer-more namespaces */
1276 if (warning_at (input_location
, OPT_Wshadow
,
1277 "declaration of %qD shadows a "
1278 "global declaration", x
))
1279 inform (DECL_SOURCE_LOCATION (oldglobal
),
1280 "shadowed declaration is here");
1286 maybe_register_incomplete_var (x
);
1289 if (need_new_binding
)
1290 add_decl_to_level (x
,
1291 DECL_NAMESPACE_SCOPE_P (x
)
1292 ? NAMESPACE_LEVEL (CP_DECL_CONTEXT (x
))
1293 : current_binding_level
);
1298 /* Wrapper for pushdecl_maybe_friend_1. */
1301 pushdecl_maybe_friend (tree x
, bool is_friend
)
1304 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
1305 ret
= pushdecl_maybe_friend_1 (x
, is_friend
);
1306 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
1310 /* Record a decl-node X as belonging to the current lexical scope. */
1315 return pushdecl_maybe_friend (x
, false);
1318 /* Enter DECL into the symbol table, if that's appropriate. Returns
1319 DECL, or a modified version thereof. */
1322 maybe_push_decl (tree decl
)
1324 tree type
= TREE_TYPE (decl
);
1326 /* Add this decl to the current binding level, but not if it comes
1327 from another scope, e.g. a static member variable. TEM may equal
1328 DECL or it may be a previous decl of the same name. */
1329 if (decl
== error_mark_node
1330 || (TREE_CODE (decl
) != PARM_DECL
1331 && DECL_CONTEXT (decl
) != NULL_TREE
1332 /* Definitions of namespace members outside their namespace are
1334 && !DECL_NAMESPACE_SCOPE_P (decl
))
1335 || (TREE_CODE (decl
) == TEMPLATE_DECL
&& !namespace_bindings_p ())
1336 || type
== unknown_type_node
1337 /* The declaration of a template specialization does not affect
1338 the functions available for overload resolution, so we do not
1340 || (TREE_CODE (decl
) == FUNCTION_DECL
1341 && DECL_TEMPLATE_SPECIALIZATION (decl
)))
1344 return pushdecl (decl
);
1347 /* Bind DECL to ID in the current_binding_level, assumed to be a local
1348 binding level. If PUSH_USING is set in FLAGS, we know that DECL
1349 doesn't really belong to this binding level, that it got here
1350 through a using-declaration. */
1353 push_local_binding (tree id
, tree decl
, int flags
)
1355 cp_binding_level
*b
;
1357 /* Skip over any local classes. This makes sense if we call
1358 push_local_binding with a friend decl of a local class. */
1359 b
= innermost_nonclass_level ();
1361 if (lookup_name_innermost_nonclass_level (id
))
1363 /* Supplement the existing binding. */
1364 if (!supplement_binding (IDENTIFIER_BINDING (id
), decl
))
1365 /* It didn't work. Something else must be bound at this
1366 level. Do not add DECL to the list of things to pop
1371 /* Create a new binding. */
1372 push_binding (id
, decl
, b
);
1374 if (TREE_CODE (decl
) == OVERLOAD
|| (flags
& PUSH_USING
))
1375 /* We must put the OVERLOAD into a TREE_LIST since the
1376 TREE_CHAIN of an OVERLOAD is already used. Similarly for
1377 decls that got here through a using-declaration. */
1378 decl
= build_tree_list (NULL_TREE
, decl
);
1380 /* And put DECL on the list of things declared by the current
1382 add_decl_to_level (decl
, b
);
1385 /* Check to see whether or not DECL is a variable that would have been
1386 in scope under the ARM, but is not in scope under the ANSI/ISO
1387 standard. If so, issue an error message. If name lookup would
1388 work in both cases, but return a different result, this function
1389 returns the result of ANSI/ISO lookup. Otherwise, it returns
1393 check_for_out_of_scope_variable (tree decl
)
1397 /* We only care about out of scope variables. */
1398 if (!(VAR_P (decl
) && DECL_DEAD_FOR_LOCAL (decl
)))
1401 shadowed
= DECL_HAS_SHADOWED_FOR_VAR_P (decl
)
1402 ? DECL_SHADOWED_FOR_VAR (decl
) : NULL_TREE
;
1403 while (shadowed
!= NULL_TREE
&& VAR_P (shadowed
)
1404 && DECL_DEAD_FOR_LOCAL (shadowed
))
1405 shadowed
= DECL_HAS_SHADOWED_FOR_VAR_P (shadowed
)
1406 ? DECL_SHADOWED_FOR_VAR (shadowed
) : NULL_TREE
;
1408 shadowed
= IDENTIFIER_NAMESPACE_VALUE (DECL_NAME (decl
));
1411 if (!DECL_ERROR_REPORTED (decl
))
1413 warning (0, "name lookup of %qD changed", DECL_NAME (decl
));
1414 warning_at (DECL_SOURCE_LOCATION (shadowed
), 0,
1415 " matches this %qD under ISO standard rules",
1417 warning_at (DECL_SOURCE_LOCATION (decl
), 0,
1418 " matches this %qD under old rules", decl
);
1419 DECL_ERROR_REPORTED (decl
) = 1;
1424 /* If we have already complained about this declaration, there's no
1425 need to do it again. */
1426 if (DECL_ERROR_REPORTED (decl
))
1429 DECL_ERROR_REPORTED (decl
) = 1;
1431 if (TREE_TYPE (decl
) == error_mark_node
)
1434 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TREE_TYPE (decl
)))
1436 error ("name lookup of %qD changed for ISO %<for%> scoping",
1438 error (" cannot use obsolete binding at %q+D because "
1439 "it has a destructor", decl
);
1440 return error_mark_node
;
1444 permerror (input_location
, "name lookup of %qD changed for ISO %<for%> scoping",
1446 if (flag_permissive
)
1447 permerror (DECL_SOURCE_LOCATION (decl
),
1448 " using obsolete binding at %qD", decl
);
1454 inform (input_location
, "(if you use %<-fpermissive%> G++ will accept your code)");
1463 /* true means unconditionally make a BLOCK for the next level pushed. */
1465 static bool keep_next_level_flag
;
1467 static int binding_depth
= 0;
1474 for (i
= 0; i
< depth
* 2; i
++)
1478 /* Return a string describing the kind of SCOPE we have. */
1480 cp_binding_level_descriptor (cp_binding_level
*scope
)
1482 /* The order of this table must match the "scope_kind"
1484 static const char* scope_kind_names
[] = {
1490 "function-parameter-scope",
1493 "template-parameter-scope",
1494 "template-explicit-spec-scope"
1496 const scope_kind kind
= scope
->explicit_spec_p
1497 ? sk_template_spec
: scope
->kind
;
1499 return scope_kind_names
[kind
];
1502 /* Output a debugging information about SCOPE when performing
1505 cp_binding_level_debug (cp_binding_level
*scope
, int line
, const char *action
)
1507 const char *desc
= cp_binding_level_descriptor (scope
);
1508 if (scope
->this_entity
)
1509 verbatim ("%s %s(%E) %p %d\n", action
, desc
,
1510 scope
->this_entity
, (void *) scope
, line
);
1512 verbatim ("%s %s %p %d\n", action
, desc
, (void *) scope
, line
);
1515 /* Return the estimated initial size of the hashtable of a NAMESPACE
1518 static inline size_t
1519 namespace_scope_ht_size (tree ns
)
1521 tree name
= DECL_NAME (ns
);
1523 return name
== std_identifier
1524 ? NAMESPACE_STD_HT_SIZE
1525 : (name
== global_scope_name
1526 ? GLOBAL_SCOPE_HT_SIZE
1527 : NAMESPACE_ORDINARY_HT_SIZE
);
1530 /* A chain of binding_level structures awaiting reuse. */
1532 static GTY((deletable
)) cp_binding_level
*free_binding_level
;
1534 /* Insert SCOPE as the innermost binding level. */
1537 push_binding_level (cp_binding_level
*scope
)
1539 /* Add it to the front of currently active scopes stack. */
1540 scope
->level_chain
= current_binding_level
;
1541 current_binding_level
= scope
;
1542 keep_next_level_flag
= false;
1544 if (ENABLE_SCOPE_CHECKING
)
1546 scope
->binding_depth
= binding_depth
;
1547 indent (binding_depth
);
1548 cp_binding_level_debug (scope
, LOCATION_LINE (input_location
),
1554 /* Create a new KIND scope and make it the top of the active scopes stack.
1555 ENTITY is the scope of the associated C++ entity (namespace, class,
1556 function, C++0x enumeration); it is NULL otherwise. */
1559 begin_scope (scope_kind kind
, tree entity
)
1561 cp_binding_level
*scope
;
1563 /* Reuse or create a struct for this binding level. */
1564 if (!ENABLE_SCOPE_CHECKING
&& free_binding_level
)
1566 scope
= free_binding_level
;
1567 memset (scope
, 0, sizeof (cp_binding_level
));
1568 free_binding_level
= scope
->level_chain
;
1571 scope
= ggc_cleared_alloc
<cp_binding_level
> ();
1573 scope
->this_entity
= entity
;
1574 scope
->more_cleanups_ok
= true;
1581 case sk_template_spec
:
1582 scope
->explicit_spec_p
= true;
1583 kind
= sk_template_parms
;
1585 case sk_template_parms
:
1592 case sk_scoped_enum
:
1593 case sk_function_parms
:
1594 case sk_transaction
:
1596 scope
->keep
= keep_next_level_flag
;
1600 NAMESPACE_LEVEL (entity
) = scope
;
1601 vec_alloc (scope
->static_decls
,
1602 (DECL_NAME (entity
) == std_identifier
1603 || DECL_NAME (entity
) == global_scope_name
) ? 200 : 10);
1607 /* Should not happen. */
1613 push_binding_level (scope
);
1618 /* We're about to leave current scope. Pop the top of the stack of
1619 currently active scopes. Return the enclosing scope, now active. */
1624 cp_binding_level
*scope
= current_binding_level
;
1626 if (scope
->kind
== sk_namespace
&& class_binding_level
)
1627 current_binding_level
= class_binding_level
;
1629 /* We cannot leave a scope, if there are none left. */
1630 if (NAMESPACE_LEVEL (global_namespace
))
1631 gcc_assert (!global_scope_p (scope
));
1633 if (ENABLE_SCOPE_CHECKING
)
1635 indent (--binding_depth
);
1636 cp_binding_level_debug (scope
, LOCATION_LINE (input_location
),
1640 /* Move one nesting level up. */
1641 current_binding_level
= scope
->level_chain
;
1643 /* Namespace-scopes are left most probably temporarily, not
1644 completely; they can be reopened later, e.g. in namespace-extension
1645 or any name binding activity that requires us to resume a
1646 namespace. For classes, we cache some binding levels. For other
1647 scopes, we just make the structure available for reuse. */
1648 if (scope
->kind
!= sk_namespace
1649 && scope
->kind
!= sk_class
)
1651 scope
->level_chain
= free_binding_level
;
1652 gcc_assert (!ENABLE_SCOPE_CHECKING
1653 || scope
->binding_depth
== binding_depth
);
1654 free_binding_level
= scope
;
1657 if (scope
->kind
== sk_class
)
1659 /* Reset DEFINING_CLASS_P to allow for reuse of a
1660 class-defining scope in a non-defining context. */
1661 scope
->defining_class_p
= 0;
1663 /* Find the innermost enclosing class scope, and reset
1664 CLASS_BINDING_LEVEL appropriately. */
1665 class_binding_level
= NULL
;
1666 for (scope
= current_binding_level
; scope
; scope
= scope
->level_chain
)
1667 if (scope
->kind
== sk_class
)
1669 class_binding_level
= scope
;
1674 return current_binding_level
;
1678 resume_scope (cp_binding_level
* b
)
1680 /* Resuming binding levels is meant only for namespaces,
1681 and those cannot nest into classes. */
1682 gcc_assert (!class_binding_level
);
1683 /* Also, resuming a non-directly nested namespace is a no-no. */
1684 gcc_assert (b
->level_chain
== current_binding_level
);
1685 current_binding_level
= b
;
1686 if (ENABLE_SCOPE_CHECKING
)
1688 b
->binding_depth
= binding_depth
;
1689 indent (binding_depth
);
1690 cp_binding_level_debug (b
, LOCATION_LINE (input_location
), "resume");
1695 /* Return the innermost binding level that is not for a class scope. */
1697 static cp_binding_level
*
1698 innermost_nonclass_level (void)
1700 cp_binding_level
*b
;
1702 b
= current_binding_level
;
1703 while (b
->kind
== sk_class
)
1709 /* We're defining an object of type TYPE. If it needs a cleanup, but
1710 we're not allowed to add any more objects with cleanups to the current
1711 scope, create a new binding level. */
1714 maybe_push_cleanup_level (tree type
)
1716 if (type
!= error_mark_node
1717 && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
)
1718 && current_binding_level
->more_cleanups_ok
== 0)
1720 begin_scope (sk_cleanup
, NULL
);
1721 current_binding_level
->statement_list
= push_stmt_list ();
1725 /* Return true if we are in the global binding level. */
1728 global_bindings_p (void)
1730 return global_scope_p (current_binding_level
);
1733 /* True if we are currently in a toplevel binding level. This
1734 means either the global binding level or a namespace in a toplevel
1735 binding level. Since there are no non-toplevel namespace levels,
1736 this really means any namespace or template parameter level. We
1737 also include a class whose context is toplevel. */
1740 toplevel_bindings_p (void)
1742 cp_binding_level
*b
= innermost_nonclass_level ();
1744 return b
->kind
== sk_namespace
|| b
->kind
== sk_template_parms
;
1747 /* True if this is a namespace scope, or if we are defining a class
1748 which is itself at namespace scope, or whose enclosing class is
1749 such a class, etc. */
1752 namespace_bindings_p (void)
1754 cp_binding_level
*b
= innermost_nonclass_level ();
1756 return b
->kind
== sk_namespace
;
1759 /* True if the innermost non-class scope is a block scope. */
1762 local_bindings_p (void)
1764 cp_binding_level
*b
= innermost_nonclass_level ();
1765 return b
->kind
< sk_function_parms
|| b
->kind
== sk_omp
;
1768 /* True if the current level needs to have a BLOCK made. */
1773 return (current_binding_level
->blocks
!= NULL_TREE
1774 || current_binding_level
->keep
1775 || current_binding_level
->kind
== sk_cleanup
1776 || current_binding_level
->names
!= NULL_TREE
1777 || current_binding_level
->using_directives
);
1780 /* Returns the kind of the innermost scope. */
1783 innermost_scope_kind (void)
1785 return current_binding_level
->kind
;
1788 /* Returns true if this scope was created to store template parameters. */
1791 template_parm_scope_p (void)
1793 return innermost_scope_kind () == sk_template_parms
;
1796 /* If KEEP is true, make a BLOCK node for the next binding level,
1797 unconditionally. Otherwise, use the normal logic to decide whether
1798 or not to create a BLOCK. */
1801 keep_next_level (bool keep
)
1803 keep_next_level_flag
= keep
;
1806 /* Return the list of declarations of the current level.
1807 Note that this list is in reverse order unless/until
1808 you nreverse it; and when you do nreverse it, you must
1809 store the result back using `storedecls' or you will lose. */
1814 return current_binding_level
->names
;
1817 /* Return how many function prototypes we are currently nested inside. */
1820 function_parm_depth (void)
1823 cp_binding_level
*b
;
1825 for (b
= current_binding_level
;
1826 b
->kind
== sk_function_parms
;
1833 /* For debugging. */
1834 static int no_print_functions
= 0;
1835 static int no_print_builtins
= 0;
1838 print_binding_level (cp_binding_level
* lvl
)
1842 fprintf (stderr
, " blocks=%p", (void *) lvl
->blocks
);
1843 if (lvl
->more_cleanups_ok
)
1844 fprintf (stderr
, " more-cleanups-ok");
1845 if (lvl
->have_cleanups
)
1846 fprintf (stderr
, " have-cleanups");
1847 fprintf (stderr
, "\n");
1850 fprintf (stderr
, " names:\t");
1851 /* We can probably fit 3 names to a line? */
1852 for (t
= lvl
->names
; t
; t
= TREE_CHAIN (t
))
1854 if (no_print_functions
&& (TREE_CODE (t
) == FUNCTION_DECL
))
1856 if (no_print_builtins
1857 && (TREE_CODE (t
) == TYPE_DECL
)
1858 && DECL_IS_BUILTIN (t
))
1861 /* Function decls tend to have longer names. */
1862 if (TREE_CODE (t
) == FUNCTION_DECL
)
1869 fprintf (stderr
, "\n\t");
1872 print_node_brief (stderr
, "", t
, 0);
1873 if (t
== error_mark_node
)
1877 fprintf (stderr
, "\n");
1879 if (vec_safe_length (lvl
->class_shadowed
))
1882 cp_class_binding
*b
;
1883 fprintf (stderr
, " class-shadowed:");
1884 FOR_EACH_VEC_ELT (*lvl
->class_shadowed
, i
, b
)
1885 fprintf (stderr
, " %s ", IDENTIFIER_POINTER (b
->identifier
));
1886 fprintf (stderr
, "\n");
1888 if (lvl
->type_shadowed
)
1890 fprintf (stderr
, " type-shadowed:");
1891 for (t
= lvl
->type_shadowed
; t
; t
= TREE_CHAIN (t
))
1893 fprintf (stderr
, " %s ", IDENTIFIER_POINTER (TREE_PURPOSE (t
)));
1895 fprintf (stderr
, "\n");
1900 debug (cp_binding_level
&ref
)
1902 print_binding_level (&ref
);
1906 debug (cp_binding_level
*ptr
)
1911 fprintf (stderr
, "<nil>\n");
1916 print_other_binding_stack (cp_binding_level
*stack
)
1918 cp_binding_level
*level
;
1919 for (level
= stack
; !global_scope_p (level
); level
= level
->level_chain
)
1921 fprintf (stderr
, "binding level %p\n", (void *) level
);
1922 print_binding_level (level
);
1927 print_binding_stack (void)
1929 cp_binding_level
*b
;
1930 fprintf (stderr
, "current_binding_level=%p\n"
1931 "class_binding_level=%p\n"
1932 "NAMESPACE_LEVEL (global_namespace)=%p\n",
1933 (void *) current_binding_level
, (void *) class_binding_level
,
1934 (void *) NAMESPACE_LEVEL (global_namespace
));
1935 if (class_binding_level
)
1937 for (b
= class_binding_level
; b
; b
= b
->level_chain
)
1938 if (b
== current_binding_level
)
1941 b
= class_binding_level
;
1943 b
= current_binding_level
;
1946 b
= current_binding_level
;
1947 print_other_binding_stack (b
);
1948 fprintf (stderr
, "global:\n");
1949 print_binding_level (NAMESPACE_LEVEL (global_namespace
));
1952 /* Return the type associated with ID. */
1955 identifier_type_value_1 (tree id
)
1957 /* There is no type with that name, anywhere. */
1958 if (REAL_IDENTIFIER_TYPE_VALUE (id
) == NULL_TREE
)
1960 /* This is not the type marker, but the real thing. */
1961 if (REAL_IDENTIFIER_TYPE_VALUE (id
) != global_type_node
)
1962 return REAL_IDENTIFIER_TYPE_VALUE (id
);
1963 /* Have to search for it. It must be on the global level, now.
1964 Ask lookup_name not to return non-types. */
1965 id
= lookup_name_real (id
, 2, 1, /*block_p=*/true, 0, 0);
1967 return TREE_TYPE (id
);
1971 /* Wrapper for identifier_type_value_1. */
1974 identifier_type_value (tree id
)
1977 timevar_start (TV_NAME_LOOKUP
);
1978 ret
= identifier_type_value_1 (id
);
1979 timevar_stop (TV_NAME_LOOKUP
);
1984 /* Return the IDENTIFIER_GLOBAL_VALUE of T, for use in common code, since
1985 the definition of IDENTIFIER_GLOBAL_VALUE is different for C and C++. */
1988 identifier_global_value (tree t
)
1990 return IDENTIFIER_GLOBAL_VALUE (t
);
1993 /* Push a definition of struct, union or enum tag named ID. into
1994 binding_level B. DECL is a TYPE_DECL for the type. We assume that
1995 the tag ID is not already defined. */
1998 set_identifier_type_value_with_scope (tree id
, tree decl
, cp_binding_level
*b
)
2002 if (b
->kind
!= sk_namespace
)
2004 /* Shadow the marker, not the real thing, so that the marker
2005 gets restored later. */
2006 tree old_type_value
= REAL_IDENTIFIER_TYPE_VALUE (id
);
2008 = tree_cons (id
, old_type_value
, b
->type_shadowed
);
2009 type
= decl
? TREE_TYPE (decl
) : NULL_TREE
;
2010 TREE_TYPE (b
->type_shadowed
) = type
;
2014 cxx_binding
*binding
=
2015 binding_for_name (NAMESPACE_LEVEL (current_namespace
), id
);
2018 supplement_binding (binding
, decl
);
2020 binding
->value
= decl
;
2022 /* Store marker instead of real type. */
2023 type
= global_type_node
;
2025 SET_IDENTIFIER_TYPE_VALUE (id
, type
);
2028 /* As set_identifier_type_value_with_scope, but using
2029 current_binding_level. */
2032 set_identifier_type_value (tree id
, tree decl
)
2034 set_identifier_type_value_with_scope (id
, decl
, current_binding_level
);
2037 /* Return the name for the constructor (or destructor) for the
2038 specified class TYPE. When given a template, this routine doesn't
2039 lose the specialization. */
2042 constructor_name_full (tree type
)
2044 return TYPE_IDENTIFIER (TYPE_MAIN_VARIANT (type
));
2047 /* Return the name for the constructor (or destructor) for the
2048 specified class. When given a template, return the plain
2049 unspecialized name. */
2052 constructor_name (tree type
)
2055 name
= constructor_name_full (type
);
2056 if (IDENTIFIER_TEMPLATE (name
))
2057 name
= IDENTIFIER_TEMPLATE (name
);
2061 /* Returns TRUE if NAME is the name for the constructor for TYPE,
2062 which must be a class type. */
2065 constructor_name_p (tree name
, tree type
)
2069 gcc_assert (MAYBE_CLASS_TYPE_P (type
));
2074 if (!identifier_p (name
))
2077 /* These don't have names. */
2078 if (TREE_CODE (type
) == DECLTYPE_TYPE
2079 || TREE_CODE (type
) == TYPEOF_TYPE
)
2082 ctor_name
= constructor_name_full (type
);
2083 if (name
== ctor_name
)
2085 if (IDENTIFIER_TEMPLATE (ctor_name
)
2086 && name
== IDENTIFIER_TEMPLATE (ctor_name
))
2091 /* Counter used to create anonymous type names. */
2093 static GTY(()) int anon_cnt
;
2095 /* Return an IDENTIFIER which can be used as a name for
2096 anonymous structs and unions. */
2099 make_anon_name (void)
2103 sprintf (buf
, anon_aggrname_format (), anon_cnt
++);
2104 return get_identifier (buf
);
2107 /* This code is practically identical to that for creating
2108 anonymous names, but is just used for lambdas instead. This isn't really
2109 necessary, but it's convenient to avoid treating lambdas like other
2112 static GTY(()) int lambda_cnt
= 0;
2115 make_lambda_name (void)
2119 sprintf (buf
, LAMBDANAME_FORMAT
, lambda_cnt
++);
2120 return get_identifier (buf
);
2123 /* Return (from the stack of) the BINDING, if any, established at SCOPE. */
2125 static inline cxx_binding
*
2126 find_binding (cp_binding_level
*scope
, cxx_binding
*binding
)
2128 for (; binding
!= NULL
; binding
= binding
->previous
)
2129 if (binding
->scope
== scope
)
2132 return (cxx_binding
*)0;
2135 /* Return the binding for NAME in SCOPE, if any. Otherwise, return NULL. */
2137 static inline cxx_binding
*
2138 cp_binding_level_find_binding_for_name (cp_binding_level
*scope
, tree name
)
2140 cxx_binding
*b
= IDENTIFIER_NAMESPACE_BINDINGS (name
);
2143 /* Fold-in case where NAME is used only once. */
2144 if (scope
== b
->scope
&& b
->previous
== NULL
)
2146 return find_binding (scope
, b
);
2151 /* Always returns a binding for name in scope. If no binding is
2152 found, make a new one. */
2154 static cxx_binding
*
2155 binding_for_name (cp_binding_level
*scope
, tree name
)
2157 cxx_binding
*result
;
2159 result
= cp_binding_level_find_binding_for_name (scope
, name
);
2162 /* Not found, make a new one. */
2163 result
= cxx_binding_make (NULL
, NULL
);
2164 result
->previous
= IDENTIFIER_NAMESPACE_BINDINGS (name
);
2165 result
->scope
= scope
;
2166 result
->is_local
= false;
2167 result
->value_is_inherited
= false;
2168 IDENTIFIER_NAMESPACE_BINDINGS (name
) = result
;
2172 /* Walk through the bindings associated to the name of FUNCTION,
2173 and return the first declaration of a function with a
2174 "C" linkage specification, a.k.a 'extern "C"'.
2175 This function looks for the binding, regardless of which scope it
2176 has been defined in. It basically looks in all the known scopes.
2177 Note that this function does not lookup for bindings of builtin functions
2178 or for functions declared in system headers. */
2180 lookup_extern_c_fun_in_all_ns (tree function
)
2185 gcc_assert (function
&& TREE_CODE (function
) == FUNCTION_DECL
);
2187 name
= DECL_NAME (function
);
2188 gcc_assert (name
&& identifier_p (name
));
2190 for (iter
= IDENTIFIER_NAMESPACE_BINDINGS (name
);
2192 iter
= iter
->previous
)
2195 for (ovl
= iter
->value
; ovl
; ovl
= OVL_NEXT (ovl
))
2197 tree decl
= OVL_CURRENT (ovl
);
2199 && TREE_CODE (decl
) == FUNCTION_DECL
2200 && DECL_EXTERN_C_P (decl
)
2201 && !DECL_ARTIFICIAL (decl
))
2210 /* Returns a list of C-linkage decls with the name NAME. */
2213 c_linkage_bindings (tree name
)
2215 tree decls
= NULL_TREE
;
2218 for (iter
= IDENTIFIER_NAMESPACE_BINDINGS (name
);
2220 iter
= iter
->previous
)
2223 for (ovl
= iter
->value
; ovl
; ovl
= OVL_NEXT (ovl
))
2225 tree decl
= OVL_CURRENT (ovl
);
2227 && DECL_EXTERN_C_P (decl
)
2228 && !DECL_ARTIFICIAL (decl
))
2230 if (decls
== NULL_TREE
)
2233 decls
= tree_cons (NULL_TREE
, decl
, decls
);
2240 /* Insert another USING_DECL into the current binding level, returning
2241 this declaration. If this is a redeclaration, do nothing, and
2242 return NULL_TREE if this not in namespace scope (in namespace
2243 scope, a using decl might extend any previous bindings). */
2246 push_using_decl_1 (tree scope
, tree name
)
2250 gcc_assert (TREE_CODE (scope
) == NAMESPACE_DECL
);
2251 gcc_assert (identifier_p (name
));
2252 for (decl
= current_binding_level
->usings
; decl
; decl
= DECL_CHAIN (decl
))
2253 if (USING_DECL_SCOPE (decl
) == scope
&& DECL_NAME (decl
) == name
)
2256 return namespace_bindings_p () ? decl
: NULL_TREE
;
2257 decl
= build_lang_decl (USING_DECL
, name
, NULL_TREE
);
2258 USING_DECL_SCOPE (decl
) = scope
;
2259 DECL_CHAIN (decl
) = current_binding_level
->usings
;
2260 current_binding_level
->usings
= decl
;
2264 /* Wrapper for push_using_decl_1. */
2267 push_using_decl (tree scope
, tree name
)
2270 timevar_start (TV_NAME_LOOKUP
);
2271 ret
= push_using_decl_1 (scope
, name
);
2272 timevar_stop (TV_NAME_LOOKUP
);
2276 /* Same as pushdecl, but define X in binding-level LEVEL. We rely on the
2277 caller to set DECL_CONTEXT properly.
2279 Note that this must only be used when X will be the new innermost
2280 binding for its name, as we tack it onto the front of IDENTIFIER_BINDING
2281 without checking to see if the current IDENTIFIER_BINDING comes from a
2282 closer binding level than LEVEL. */
2285 pushdecl_with_scope_1 (tree x
, cp_binding_level
*level
, bool is_friend
)
2287 cp_binding_level
*b
;
2288 tree function_decl
= current_function_decl
;
2290 current_function_decl
= NULL_TREE
;
2291 if (level
->kind
== sk_class
)
2293 b
= class_binding_level
;
2294 class_binding_level
= level
;
2295 pushdecl_class_level (x
);
2296 class_binding_level
= b
;
2300 b
= current_binding_level
;
2301 current_binding_level
= level
;
2302 x
= pushdecl_maybe_friend (x
, is_friend
);
2303 current_binding_level
= b
;
2305 current_function_decl
= function_decl
;
2309 /* Wrapper for pushdecl_with_scope_1. */
2312 pushdecl_with_scope (tree x
, cp_binding_level
*level
, bool is_friend
)
2315 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
2316 ret
= pushdecl_with_scope_1 (x
, level
, is_friend
);
2317 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
2321 /* Helper function for push_overloaded_decl_1 and do_nonmember_using_decl.
2322 Compares the parameter-type-lists of DECL1 and DECL2 and returns false
2323 if they are different. If the DECLs are template functions, the return
2324 types and the template parameter lists are compared too (DR 565). */
2327 compparms_for_decl_and_using_decl (tree decl1
, tree decl2
)
2329 if (!compparms (TYPE_ARG_TYPES (TREE_TYPE (decl1
)),
2330 TYPE_ARG_TYPES (TREE_TYPE (decl2
))))
2333 if (! DECL_FUNCTION_TEMPLATE_P (decl1
)
2334 || ! DECL_FUNCTION_TEMPLATE_P (decl2
))
2337 return (comp_template_parms (DECL_TEMPLATE_PARMS (decl1
),
2338 DECL_TEMPLATE_PARMS (decl2
))
2339 && same_type_p (TREE_TYPE (TREE_TYPE (decl1
)),
2340 TREE_TYPE (TREE_TYPE (decl2
))));
2343 /* DECL is a FUNCTION_DECL for a non-member function, which may have
2344 other definitions already in place. We get around this by making
2345 the value of the identifier point to a list of all the things that
2346 want to be referenced by that name. It is then up to the users of
2347 that name to decide what to do with that list.
2349 DECL may also be a TEMPLATE_DECL, with a FUNCTION_DECL in its
2350 DECL_TEMPLATE_RESULT. It is dealt with the same way.
2352 FLAGS is a bitwise-or of the following values:
2353 PUSH_LOCAL: Bind DECL in the current scope, rather than at
2355 PUSH_USING: DECL is being pushed as the result of a using
2358 IS_FRIEND is true if this is a friend declaration.
2360 The value returned may be a previous declaration if we guessed wrong
2361 about what language DECL should belong to (C or C++). Otherwise,
2362 it's always DECL (and never something that's not a _DECL). */
2365 push_overloaded_decl_1 (tree decl
, int flags
, bool is_friend
)
2367 tree name
= DECL_NAME (decl
);
2370 int doing_global
= (namespace_bindings_p () || !(flags
& PUSH_LOCAL
));
2373 old
= namespace_binding (name
, DECL_CONTEXT (decl
));
2375 old
= lookup_name_innermost_nonclass_level (name
);
2379 if (TREE_CODE (old
) == TYPE_DECL
&& DECL_ARTIFICIAL (old
))
2381 tree t
= TREE_TYPE (old
);
2382 if (MAYBE_CLASS_TYPE_P (t
) && warn_shadow
2383 && (! DECL_IN_SYSTEM_HEADER (decl
)
2384 || ! DECL_IN_SYSTEM_HEADER (old
)))
2385 warning (OPT_Wshadow
, "%q#D hides constructor for %q#T", decl
, t
);
2388 else if (is_overloaded_fn (old
))
2392 for (tmp
= old
; tmp
; tmp
= OVL_NEXT (tmp
))
2394 tree fn
= OVL_CURRENT (tmp
);
2397 if (TREE_CODE (tmp
) == OVERLOAD
&& OVL_USED (tmp
)
2398 && !(flags
& PUSH_USING
)
2399 && compparms_for_decl_and_using_decl (fn
, decl
)
2400 && ! decls_match (fn
, decl
))
2401 diagnose_name_conflict (decl
, fn
);
2403 dup
= duplicate_decls (decl
, fn
, is_friend
);
2404 /* If DECL was a redeclaration of FN -- even an invalid
2405 one -- pass that information along to our caller. */
2406 if (dup
== fn
|| dup
== error_mark_node
)
2410 /* We don't overload implicit built-ins. duplicate_decls()
2411 may fail to merge the decls if the new decl is e.g. a
2412 template function. */
2413 if (TREE_CODE (old
) == FUNCTION_DECL
2414 && DECL_ANTICIPATED (old
)
2415 && !DECL_HIDDEN_FRIEND_P (old
))
2418 else if (old
== error_mark_node
)
2419 /* Ignore the undefined symbol marker. */
2423 error ("previous non-function declaration %q+#D", old
);
2424 error ("conflicts with function declaration %q#D", decl
);
2429 if (old
|| TREE_CODE (decl
) == TEMPLATE_DECL
2430 /* If it's a using declaration, we always need to build an OVERLOAD,
2431 because it's the only way to remember that the declaration comes
2432 from 'using', and have the lookup behave correctly. */
2433 || (flags
& PUSH_USING
))
2435 if (old
&& TREE_CODE (old
) != OVERLOAD
)
2436 new_binding
= ovl_cons (decl
, ovl_cons (old
, NULL_TREE
));
2438 new_binding
= ovl_cons (decl
, old
);
2439 if (flags
& PUSH_USING
)
2440 OVL_USED (new_binding
) = 1;
2443 /* NAME is not ambiguous. */
2447 set_namespace_binding (name
, current_namespace
, new_binding
);
2450 /* We only create an OVERLOAD if there was a previous binding at
2451 this level, or if decl is a template. In the former case, we
2452 need to remove the old binding and replace it with the new
2453 binding. We must also run through the NAMES on the binding
2454 level where the name was bound to update the chain. */
2456 if (TREE_CODE (new_binding
) == OVERLOAD
&& old
)
2460 for (d
= &IDENTIFIER_BINDING (name
)->scope
->names
;
2462 d
= &TREE_CHAIN (*d
))
2464 || (TREE_CODE (*d
) == TREE_LIST
2465 && TREE_VALUE (*d
) == old
))
2467 if (TREE_CODE (*d
) == TREE_LIST
)
2468 /* Just replace the old binding with the new. */
2469 TREE_VALUE (*d
) = new_binding
;
2471 /* Build a TREE_LIST to wrap the OVERLOAD. */
2472 *d
= tree_cons (NULL_TREE
, new_binding
,
2475 /* And update the cxx_binding node. */
2476 IDENTIFIER_BINDING (name
)->value
= new_binding
;
2480 /* We should always find a previous binding in this case. */
2484 /* Install the new binding. */
2485 push_local_binding (name
, new_binding
, flags
);
2491 /* Wrapper for push_overloaded_decl_1. */
2494 push_overloaded_decl (tree decl
, int flags
, bool is_friend
)
2497 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
2498 ret
= push_overloaded_decl_1 (decl
, flags
, is_friend
);
2499 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
2503 /* Check a non-member using-declaration. Return the name and scope
2504 being used, and the USING_DECL, or NULL_TREE on failure. */
2507 validate_nonmember_using_decl (tree decl
, tree scope
, tree name
)
2509 /* [namespace.udecl]
2510 A using-declaration for a class member shall be a
2511 member-declaration. */
2514 error ("%qT is not a namespace or unscoped enum", scope
);
2517 else if (scope
== error_mark_node
)
2520 if (TREE_CODE (decl
) == TEMPLATE_ID_EXPR
)
2523 A using-declaration shall not name a template-id. */
2524 error ("a using-declaration cannot specify a template-id. "
2525 "Try %<using %D%>", name
);
2529 if (TREE_CODE (decl
) == NAMESPACE_DECL
)
2531 error ("namespace %qD not allowed in using-declaration", decl
);
2535 if (TREE_CODE (decl
) == SCOPE_REF
)
2537 /* It's a nested name with template parameter dependent scope.
2538 This can only be using-declaration for class member. */
2539 error ("%qT is not a namespace", TREE_OPERAND (decl
, 0));
2543 if (is_overloaded_fn (decl
))
2544 decl
= get_first_fn (decl
);
2546 gcc_assert (DECL_P (decl
));
2548 /* Make a USING_DECL. */
2549 tree using_decl
= push_using_decl (scope
, name
);
2551 if (using_decl
== NULL_TREE
2552 && at_function_scope_p ()
2554 /* C++11 7.3.3/10. */
2555 error ("%qD is already declared in this scope", name
);
2560 /* Process local and global using-declarations. */
2563 do_nonmember_using_decl (tree scope
, tree name
, tree oldval
, tree oldtype
,
2564 tree
*newval
, tree
*newtype
)
2566 struct scope_binding decls
= EMPTY_SCOPE_BINDING
;
2568 *newval
= *newtype
= NULL_TREE
;
2569 if (!qualified_lookup_using_namespace (name
, scope
, &decls
, 0))
2573 if (!decls
.value
&& !decls
.type
)
2575 error ("%qD not declared", name
);
2579 /* Shift the old and new bindings around so we're comparing class and
2580 enumeration names to each other. */
2581 if (oldval
&& DECL_IMPLICIT_TYPEDEF_P (oldval
))
2587 if (decls
.value
&& DECL_IMPLICIT_TYPEDEF_P (decls
.value
))
2589 decls
.type
= decls
.value
;
2590 decls
.value
= NULL_TREE
;
2593 /* It is impossible to overload a built-in function; any explicit
2594 declaration eliminates the built-in declaration. So, if OLDVAL
2595 is a built-in, then we can just pretend it isn't there. */
2597 && TREE_CODE (oldval
) == FUNCTION_DECL
2598 && DECL_ANTICIPATED (oldval
)
2599 && !DECL_HIDDEN_FRIEND_P (oldval
))
2604 /* Check for using functions. */
2605 if (is_overloaded_fn (decls
.value
))
2609 if (oldval
&& !is_overloaded_fn (oldval
))
2611 error ("%qD is already declared in this scope", name
);
2616 for (tmp
= decls
.value
; tmp
; tmp
= OVL_NEXT (tmp
))
2618 tree new_fn
= OVL_CURRENT (tmp
);
2620 /* [namespace.udecl]
2622 If a function declaration in namespace scope or block
2623 scope has the same name and the same parameter types as a
2624 function introduced by a using declaration the program is
2626 for (tmp1
= oldval
; tmp1
; tmp1
= OVL_NEXT (tmp1
))
2628 tree old_fn
= OVL_CURRENT (tmp1
);
2630 if (new_fn
== old_fn
)
2631 /* The function already exists in the current namespace. */
2633 else if (TREE_CODE (tmp1
) == OVERLOAD
&& OVL_USED (tmp1
))
2634 continue; /* this is a using decl */
2635 else if (compparms_for_decl_and_using_decl (new_fn
, old_fn
))
2637 gcc_assert (!DECL_ANTICIPATED (old_fn
)
2638 || DECL_HIDDEN_FRIEND_P (old_fn
));
2640 /* There was already a non-using declaration in
2641 this scope with the same parameter types. If both
2642 are the same extern "C" functions, that's ok. */
2643 if (decls_match (new_fn
, old_fn
))
2647 diagnose_name_conflict (new_fn
, old_fn
);
2653 /* If we broke out of the loop, there's no reason to add
2654 this function to the using declarations for this
2659 /* If we are adding to an existing OVERLOAD, then we no
2660 longer know the type of the set of functions. */
2661 if (*newval
&& TREE_CODE (*newval
) == OVERLOAD
)
2662 TREE_TYPE (*newval
) = unknown_type_node
;
2663 /* Add this new function to the set. */
2664 *newval
= build_overload (OVL_CURRENT (tmp
), *newval
);
2665 /* If there is only one function, then we use its type. (A
2666 using-declaration naming a single function can be used in
2667 contexts where overload resolution cannot be
2669 if (TREE_CODE (*newval
) != OVERLOAD
)
2671 *newval
= ovl_cons (*newval
, NULL_TREE
);
2672 TREE_TYPE (*newval
) = TREE_TYPE (OVL_CURRENT (tmp
));
2674 OVL_USED (*newval
) = 1;
2679 *newval
= decls
.value
;
2680 if (oldval
&& !decls_match (*newval
, oldval
))
2681 error ("%qD is already declared in this scope", name
);
2687 if (decls
.type
&& TREE_CODE (decls
.type
) == TREE_LIST
)
2689 error ("reference to %qD is ambiguous", name
);
2690 print_candidates (decls
.type
);
2694 *newtype
= decls
.type
;
2695 if (oldtype
&& *newtype
&& !decls_match (oldtype
, *newtype
))
2696 error ("%qD is already declared in this scope", name
);
2699 /* If *newval is empty, shift any class or enumeration name down. */
2703 *newtype
= NULL_TREE
;
2707 /* Process a using-declaration at function scope. */
2710 do_local_using_decl (tree decl
, tree scope
, tree name
)
2712 tree oldval
, oldtype
, newval
, newtype
;
2713 tree orig_decl
= decl
;
2715 decl
= validate_nonmember_using_decl (decl
, scope
, name
);
2716 if (decl
== NULL_TREE
)
2719 if (building_stmt_list_p ()
2720 && at_function_scope_p ())
2721 add_decl_expr (decl
);
2723 oldval
= lookup_name_innermost_nonclass_level (name
);
2724 oldtype
= lookup_type_current_level (name
);
2726 do_nonmember_using_decl (scope
, name
, oldval
, oldtype
, &newval
, &newtype
);
2730 if (is_overloaded_fn (newval
))
2734 /* We only need to push declarations for those functions
2735 that were not already bound in the current level.
2736 The old value might be NULL_TREE, it might be a single
2737 function, or an OVERLOAD. */
2738 if (oldval
&& TREE_CODE (oldval
) == OVERLOAD
)
2739 term
= OVL_FUNCTION (oldval
);
2742 for (fn
= newval
; fn
&& OVL_CURRENT (fn
) != term
;
2744 push_overloaded_decl (OVL_CURRENT (fn
),
2745 PUSH_LOCAL
| PUSH_USING
,
2749 push_local_binding (name
, newval
, PUSH_USING
);
2753 push_local_binding (name
, newtype
, PUSH_USING
);
2754 set_identifier_type_value (name
, newtype
);
2757 /* Emit debug info. */
2758 if (!processing_template_decl
)
2759 cp_emit_debug_info_for_using (orig_decl
, current_scope());
2762 /* Returns true if ROOT (a namespace, class, or function) encloses
2763 CHILD. CHILD may be either a class type or a namespace. */
2766 is_ancestor (tree root
, tree child
)
2768 gcc_assert ((TREE_CODE (root
) == NAMESPACE_DECL
2769 || TREE_CODE (root
) == FUNCTION_DECL
2770 || CLASS_TYPE_P (root
)));
2771 gcc_assert ((TREE_CODE (child
) == NAMESPACE_DECL
2772 || CLASS_TYPE_P (child
)));
2774 /* The global namespace encloses everything. */
2775 if (root
== global_namespace
)
2780 /* If we've run out of scopes, stop. */
2783 /* If we've reached the ROOT, it encloses CHILD. */
2786 /* Go out one level. */
2788 child
= TYPE_NAME (child
);
2789 child
= DECL_CONTEXT (child
);
2793 /* Enter the class or namespace scope indicated by T suitable for name
2794 lookup. T can be arbitrary scope, not necessary nested inside the
2795 current scope. Returns a non-null scope to pop iff pop_scope
2796 should be called later to exit this scope. */
2801 if (TREE_CODE (t
) == NAMESPACE_DECL
)
2802 push_decl_namespace (t
);
2803 else if (CLASS_TYPE_P (t
))
2805 if (!at_class_scope_p ()
2806 || !same_type_p (current_class_type
, t
))
2807 push_nested_class (t
);
2809 /* T is the same as the current scope. There is therefore no
2810 need to re-enter the scope. Since we are not actually
2811 pushing a new scope, our caller should not call
2819 /* Leave scope pushed by push_scope. */
2826 if (TREE_CODE (t
) == NAMESPACE_DECL
)
2827 pop_decl_namespace ();
2828 else if CLASS_TYPE_P (t
)
2829 pop_nested_class ();
2832 /* Subroutine of push_inner_scope. */
2835 push_inner_scope_r (tree outer
, tree inner
)
2840 || (TREE_CODE (inner
) != NAMESPACE_DECL
&& !CLASS_TYPE_P (inner
)))
2843 prev
= CP_DECL_CONTEXT (TREE_CODE (inner
) == NAMESPACE_DECL
? inner
: TYPE_NAME (inner
));
2845 push_inner_scope_r (outer
, prev
);
2846 if (TREE_CODE (inner
) == NAMESPACE_DECL
)
2848 cp_binding_level
*save_template_parm
= 0;
2849 /* Temporary take out template parameter scopes. They are saved
2850 in reversed order in save_template_parm. */
2851 while (current_binding_level
->kind
== sk_template_parms
)
2853 cp_binding_level
*b
= current_binding_level
;
2854 current_binding_level
= b
->level_chain
;
2855 b
->level_chain
= save_template_parm
;
2856 save_template_parm
= b
;
2859 resume_scope (NAMESPACE_LEVEL (inner
));
2860 current_namespace
= inner
;
2862 /* Restore template parameter scopes. */
2863 while (save_template_parm
)
2865 cp_binding_level
*b
= save_template_parm
;
2866 save_template_parm
= b
->level_chain
;
2867 b
->level_chain
= current_binding_level
;
2868 current_binding_level
= b
;
2875 /* Enter the scope INNER from current scope. INNER must be a scope
2876 nested inside current scope. This works with both name lookup and
2877 pushing name into scope. In case a template parameter scope is present,
2878 namespace is pushed under the template parameter scope according to
2879 name lookup rule in 14.6.1/6.
2881 Return the former current scope suitable for pop_inner_scope. */
2884 push_inner_scope (tree inner
)
2886 tree outer
= current_scope ();
2888 outer
= current_namespace
;
2890 push_inner_scope_r (outer
, inner
);
2894 /* Exit the current scope INNER back to scope OUTER. */
2897 pop_inner_scope (tree outer
, tree inner
)
2900 || (TREE_CODE (inner
) != NAMESPACE_DECL
&& !CLASS_TYPE_P (inner
)))
2903 while (outer
!= inner
)
2905 if (TREE_CODE (inner
) == NAMESPACE_DECL
)
2907 cp_binding_level
*save_template_parm
= 0;
2908 /* Temporary take out template parameter scopes. They are saved
2909 in reversed order in save_template_parm. */
2910 while (current_binding_level
->kind
== sk_template_parms
)
2912 cp_binding_level
*b
= current_binding_level
;
2913 current_binding_level
= b
->level_chain
;
2914 b
->level_chain
= save_template_parm
;
2915 save_template_parm
= b
;
2920 /* Restore template parameter scopes. */
2921 while (save_template_parm
)
2923 cp_binding_level
*b
= save_template_parm
;
2924 save_template_parm
= b
->level_chain
;
2925 b
->level_chain
= current_binding_level
;
2926 current_binding_level
= b
;
2932 inner
= CP_DECL_CONTEXT (TREE_CODE (inner
) == NAMESPACE_DECL
? inner
: TYPE_NAME (inner
));
2936 /* Do a pushlevel for class declarations. */
2939 pushlevel_class (void)
2941 class_binding_level
= begin_scope (sk_class
, current_class_type
);
2944 /* ...and a poplevel for class declarations. */
2947 poplevel_class (void)
2949 cp_binding_level
*level
= class_binding_level
;
2950 cp_class_binding
*cb
;
2954 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
2955 gcc_assert (level
!= 0);
2957 /* If we're leaving a toplevel class, cache its binding level. */
2958 if (current_class_depth
== 1)
2959 previous_class_level
= level
;
2960 for (shadowed
= level
->type_shadowed
;
2962 shadowed
= TREE_CHAIN (shadowed
))
2963 SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (shadowed
), TREE_VALUE (shadowed
));
2965 /* Remove the bindings for all of the class-level declarations. */
2966 if (level
->class_shadowed
)
2968 FOR_EACH_VEC_ELT (*level
->class_shadowed
, i
, cb
)
2970 IDENTIFIER_BINDING (cb
->identifier
) = cb
->base
->previous
;
2971 cxx_binding_free (cb
->base
);
2973 ggc_free (level
->class_shadowed
);
2974 level
->class_shadowed
= NULL
;
2977 /* Now, pop out of the binding level which we created up in the
2978 `pushlevel_class' routine. */
2979 gcc_assert (current_binding_level
== level
);
2981 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
2984 /* Set INHERITED_VALUE_BINDING_P on BINDING to true or false, as
2985 appropriate. DECL is the value to which a name has just been
2986 bound. CLASS_TYPE is the class in which the lookup occurred. */
2989 set_inherited_value_binding_p (cxx_binding
*binding
, tree decl
,
2992 if (binding
->value
== decl
&& TREE_CODE (decl
) != TREE_LIST
)
2996 if (TREE_CODE (decl
) == OVERLOAD
)
2997 context
= ovl_scope (decl
);
3000 gcc_assert (DECL_P (decl
));
3001 context
= context_for_name_lookup (decl
);
3004 if (is_properly_derived_from (class_type
, context
))
3005 INHERITED_VALUE_BINDING_P (binding
) = 1;
3007 INHERITED_VALUE_BINDING_P (binding
) = 0;
3009 else if (binding
->value
== decl
)
3010 /* We only encounter a TREE_LIST when there is an ambiguity in the
3011 base classes. Such an ambiguity can be overridden by a
3012 definition in this class. */
3013 INHERITED_VALUE_BINDING_P (binding
) = 1;
3015 INHERITED_VALUE_BINDING_P (binding
) = 0;
3018 /* Make the declaration of X appear in CLASS scope. */
3021 pushdecl_class_level (tree x
)
3024 bool is_valid
= true;
3027 /* Do nothing if we're adding to an outer lambda closure type,
3028 outer_binding will add it later if it's needed. */
3029 if (current_class_type
!= class_binding_level
->this_entity
)
3032 subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
3033 /* Get the name of X. */
3034 if (TREE_CODE (x
) == OVERLOAD
)
3035 name
= DECL_NAME (get_first_fn (x
));
3037 name
= DECL_NAME (x
);
3041 is_valid
= push_class_level_binding (name
, x
);
3042 if (TREE_CODE (x
) == TYPE_DECL
)
3043 set_identifier_type_value (name
, x
);
3045 else if (ANON_AGGR_TYPE_P (TREE_TYPE (x
)))
3047 /* If X is an anonymous aggregate, all of its members are
3048 treated as if they were members of the class containing the
3049 aggregate, for naming purposes. */
3052 for (f
= TYPE_FIELDS (TREE_TYPE (x
)); f
; f
= DECL_CHAIN (f
))
3054 location_t save_location
= input_location
;
3055 input_location
= DECL_SOURCE_LOCATION (f
);
3056 if (!pushdecl_class_level (f
))
3058 input_location
= save_location
;
3061 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
3065 /* Return the BINDING (if any) for NAME in SCOPE, which is a class
3066 scope. If the value returned is non-NULL, and the PREVIOUS field
3067 is not set, callers must set the PREVIOUS field explicitly. */
3069 static cxx_binding
*
3070 get_class_binding (tree name
, cp_binding_level
*scope
)
3075 cxx_binding
*binding
;
3077 class_type
= scope
->this_entity
;
3079 /* Get the type binding. */
3080 type_binding
= lookup_member (class_type
, name
,
3081 /*protect=*/2, /*want_type=*/true,
3082 tf_warning_or_error
);
3083 /* Get the value binding. */
3084 value_binding
= lookup_member (class_type
, name
,
3085 /*protect=*/2, /*want_type=*/false,
3086 tf_warning_or_error
);
3089 && (TREE_CODE (value_binding
) == TYPE_DECL
3090 || DECL_CLASS_TEMPLATE_P (value_binding
)
3091 || (TREE_CODE (value_binding
) == TREE_LIST
3092 && TREE_TYPE (value_binding
) == error_mark_node
3093 && (TREE_CODE (TREE_VALUE (value_binding
))
3095 /* We found a type binding, even when looking for a non-type
3096 binding. This means that we already processed this binding
3099 else if (value_binding
)
3101 if (TREE_CODE (value_binding
) == TREE_LIST
3102 && TREE_TYPE (value_binding
) == error_mark_node
)
3103 /* NAME is ambiguous. */
3105 else if (BASELINK_P (value_binding
))
3106 /* NAME is some overloaded functions. */
3107 value_binding
= BASELINK_FUNCTIONS (value_binding
);
3110 /* If we found either a type binding or a value binding, create a
3111 new binding object. */
3112 if (type_binding
|| value_binding
)
3114 binding
= new_class_binding (name
,
3118 /* This is a class-scope binding, not a block-scope binding. */
3119 LOCAL_BINDING_P (binding
) = 0;
3120 set_inherited_value_binding_p (binding
, value_binding
, class_type
);
3128 /* Make the declaration(s) of X appear in CLASS scope under the name
3129 NAME. Returns true if the binding is valid. */
3132 push_class_level_binding_1 (tree name
, tree x
)
3134 cxx_binding
*binding
;
3138 /* The class_binding_level will be NULL if x is a template
3139 parameter name in a member template. */
3140 if (!class_binding_level
)
3143 if (name
== error_mark_node
)
3146 /* Can happen for an erroneous declaration (c++/60384). */
3147 if (!identifier_p (name
))
3149 gcc_assert (errorcount
|| sorrycount
);
3153 /* Check for invalid member names. But don't worry about a default
3154 argument-scope lambda being pushed after the class is complete. */
3155 gcc_assert (TYPE_BEING_DEFINED (current_class_type
)
3156 || LAMBDA_TYPE_P (TREE_TYPE (decl
)));
3157 /* Check that we're pushing into the right binding level. */
3158 gcc_assert (current_class_type
== class_binding_level
->this_entity
);
3160 /* We could have been passed a tree list if this is an ambiguous
3161 declaration. If so, pull the declaration out because
3162 check_template_shadow will not handle a TREE_LIST. */
3163 if (TREE_CODE (decl
) == TREE_LIST
3164 && TREE_TYPE (decl
) == error_mark_node
)
3165 decl
= TREE_VALUE (decl
);
3167 if (!check_template_shadow (decl
))
3172 If T is the name of a class, then each of the following shall
3173 have a name different from T:
3175 -- every static data member of class T;
3177 -- every member of class T that is itself a type;
3179 -- every enumerator of every member of class T that is an
3182 -- every member of every anonymous union that is a member of
3185 (Non-static data members were also forbidden to have the same
3186 name as T until TC1.) */
3188 || TREE_CODE (x
) == CONST_DECL
3189 || (TREE_CODE (x
) == TYPE_DECL
3190 && !DECL_SELF_REFERENCE_P (x
))
3191 /* A data member of an anonymous union. */
3192 || (TREE_CODE (x
) == FIELD_DECL
3193 && DECL_CONTEXT (x
) != current_class_type
))
3194 && DECL_NAME (x
) == constructor_name (current_class_type
))
3196 tree scope
= context_for_name_lookup (x
);
3197 if (TYPE_P (scope
) && same_type_p (scope
, current_class_type
))
3199 error ("%qD has the same name as the class in which it is "
3206 /* Get the current binding for NAME in this class, if any. */
3207 binding
= IDENTIFIER_BINDING (name
);
3208 if (!binding
|| binding
->scope
!= class_binding_level
)
3210 binding
= get_class_binding (name
, class_binding_level
);
3211 /* If a new binding was created, put it at the front of the
3212 IDENTIFIER_BINDING list. */
3215 binding
->previous
= IDENTIFIER_BINDING (name
);
3216 IDENTIFIER_BINDING (name
) = binding
;
3220 /* If there is already a binding, then we may need to update the
3222 if (binding
&& binding
->value
)
3224 tree bval
= binding
->value
;
3225 tree old_decl
= NULL_TREE
;
3226 tree target_decl
= strip_using_decl (decl
);
3227 tree target_bval
= strip_using_decl (bval
);
3229 if (INHERITED_VALUE_BINDING_P (binding
))
3231 /* If the old binding was from a base class, and was for a
3232 tag name, slide it over to make room for the new binding.
3233 The old binding is still visible if explicitly qualified
3234 with a class-key. */
3235 if (TREE_CODE (target_bval
) == TYPE_DECL
3236 && DECL_ARTIFICIAL (target_bval
)
3237 && !(TREE_CODE (target_decl
) == TYPE_DECL
3238 && DECL_ARTIFICIAL (target_decl
)))
3240 old_decl
= binding
->type
;
3241 binding
->type
= bval
;
3242 binding
->value
= NULL_TREE
;
3243 INHERITED_VALUE_BINDING_P (binding
) = 0;
3248 /* Any inherited type declaration is hidden by the type
3249 declaration in the derived class. */
3250 if (TREE_CODE (target_decl
) == TYPE_DECL
3251 && DECL_ARTIFICIAL (target_decl
))
3252 binding
->type
= NULL_TREE
;
3255 else if (TREE_CODE (target_decl
) == OVERLOAD
3256 && is_overloaded_fn (target_bval
))
3258 else if (TREE_CODE (decl
) == USING_DECL
3259 && TREE_CODE (bval
) == USING_DECL
3260 && same_type_p (USING_DECL_SCOPE (decl
),
3261 USING_DECL_SCOPE (bval
)))
3262 /* This is a using redeclaration that will be diagnosed later
3263 in supplement_binding */
3265 else if (TREE_CODE (decl
) == USING_DECL
3266 && TREE_CODE (bval
) == USING_DECL
3267 && DECL_DEPENDENT_P (decl
)
3268 && DECL_DEPENDENT_P (bval
))
3270 else if (TREE_CODE (decl
) == USING_DECL
3271 && is_overloaded_fn (target_bval
))
3273 else if (TREE_CODE (bval
) == USING_DECL
3274 && is_overloaded_fn (target_decl
))
3277 if (old_decl
&& binding
->scope
== class_binding_level
)
3280 /* It is always safe to clear INHERITED_VALUE_BINDING_P
3281 here. This function is only used to register bindings
3282 from with the class definition itself. */
3283 INHERITED_VALUE_BINDING_P (binding
) = 0;
3288 /* Note that we declared this value so that we can issue an error if
3289 this is an invalid redeclaration of a name already used for some
3291 note_name_declared_in_class (name
, decl
);
3293 /* If we didn't replace an existing binding, put the binding on the
3294 stack of bindings for the identifier, and update the shadowed
3296 if (binding
&& binding
->scope
== class_binding_level
)
3297 /* Supplement the existing binding. */
3298 ok
= supplement_binding (binding
, decl
);
3301 /* Create a new binding. */
3302 push_binding (name
, decl
, class_binding_level
);
3309 /* Wrapper for push_class_level_binding_1. */
3312 push_class_level_binding (tree name
, tree x
)
3315 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
3316 ret
= push_class_level_binding_1 (name
, x
);
3317 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
3321 /* Process "using SCOPE::NAME" in a class scope. Return the
3322 USING_DECL created. */
3325 do_class_using_decl (tree scope
, tree name
)
3327 /* The USING_DECL returned by this function. */
3329 /* The declaration (or declarations) name by this using
3330 declaration. NULL if we are in a template and cannot figure out
3331 what has been named. */
3333 /* True if SCOPE is a dependent type. */
3334 bool scope_dependent_p
;
3335 /* True if SCOPE::NAME is dependent. */
3336 bool name_dependent_p
;
3337 /* True if any of the bases of CURRENT_CLASS_TYPE are dependent. */
3338 bool bases_dependent_p
;
3343 if (name
== error_mark_node
)
3346 if (!scope
|| !TYPE_P (scope
))
3348 error ("using-declaration for non-member at class scope");
3352 /* Make sure the name is not invalid */
3353 if (TREE_CODE (name
) == BIT_NOT_EXPR
)
3355 error ("%<%T::%D%> names destructor", scope
, name
);
3358 /* Using T::T declares inheriting ctors, even if T is a typedef. */
3359 if (MAYBE_CLASS_TYPE_P (scope
)
3360 && (name
== TYPE_IDENTIFIER (scope
)
3361 || constructor_name_p (name
, scope
)))
3363 maybe_warn_cpp0x (CPP0X_INHERITING_CTORS
);
3364 name
= ctor_identifier
;
3366 if (constructor_name_p (name
, current_class_type
))
3368 error ("%<%T::%D%> names constructor in %qT",
3369 scope
, name
, current_class_type
);
3373 scope_dependent_p
= dependent_scope_p (scope
);
3374 name_dependent_p
= (scope_dependent_p
3375 || (IDENTIFIER_TYPENAME_P (name
)
3376 && dependent_type_p (TREE_TYPE (name
))));
3378 bases_dependent_p
= false;
3379 if (processing_template_decl
)
3380 for (binfo
= TYPE_BINFO (current_class_type
), i
= 0;
3381 BINFO_BASE_ITERATE (binfo
, i
, base_binfo
);
3383 if (dependent_type_p (TREE_TYPE (base_binfo
)))
3385 bases_dependent_p
= true;
3391 /* From [namespace.udecl]:
3393 A using-declaration used as a member-declaration shall refer to a
3394 member of a base class of the class being defined.
3396 In general, we cannot check this constraint in a template because
3397 we do not know the entire set of base classes of the current
3398 class type. Morover, if SCOPE is dependent, it might match a
3399 non-dependent base. */
3401 if (!scope_dependent_p
)
3404 binfo
= lookup_base (current_class_type
, scope
, ba_any
, &b_kind
,
3405 tf_warning_or_error
);
3406 if (b_kind
< bk_proper_base
)
3408 if (!bases_dependent_p
|| b_kind
== bk_same_type
)
3410 error_not_base_type (scope
, current_class_type
);
3414 else if (!name_dependent_p
)
3416 decl
= lookup_member (binfo
, name
, 0, false, tf_warning_or_error
);
3419 error ("no members matching %<%T::%D%> in %q#T", scope
, name
,
3423 /* The binfo from which the functions came does not matter. */
3424 if (BASELINK_P (decl
))
3425 decl
= BASELINK_FUNCTIONS (decl
);
3429 value
= build_lang_decl (USING_DECL
, name
, NULL_TREE
);
3430 USING_DECL_DECLS (value
) = decl
;
3431 USING_DECL_SCOPE (value
) = scope
;
3432 DECL_DEPENDENT_P (value
) = !decl
;
3438 /* Return the binding value for name in scope. */
3442 namespace_binding_1 (tree name
, tree scope
)
3444 cxx_binding
*binding
;
3446 if (SCOPE_FILE_SCOPE_P (scope
))
3447 scope
= global_namespace
;
3449 /* Unnecessary for the global namespace because it can't be an alias. */
3450 scope
= ORIGINAL_NAMESPACE (scope
);
3452 binding
= cp_binding_level_find_binding_for_name (NAMESPACE_LEVEL (scope
), name
);
3454 return binding
? binding
->value
: NULL_TREE
;
3458 namespace_binding (tree name
, tree scope
)
3461 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
3462 ret
= namespace_binding_1 (name
, scope
);
3463 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
3467 /* Set the binding value for name in scope. */
3470 set_namespace_binding_1 (tree name
, tree scope
, tree val
)
3474 if (scope
== NULL_TREE
)
3475 scope
= global_namespace
;
3476 b
= binding_for_name (NAMESPACE_LEVEL (scope
), name
);
3477 if (!b
->value
|| TREE_CODE (val
) == OVERLOAD
|| val
== error_mark_node
)
3480 supplement_binding (b
, val
);
3483 /* Wrapper for set_namespace_binding_1. */
3486 set_namespace_binding (tree name
, tree scope
, tree val
)
3488 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
3489 set_namespace_binding_1 (name
, scope
, val
);
3490 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
3493 /* Set the context of a declaration to scope. Complain if we are not
3497 set_decl_namespace (tree decl
, tree scope
, bool friendp
)
3501 /* Get rid of namespace aliases. */
3502 scope
= ORIGINAL_NAMESPACE (scope
);
3504 /* It is ok for friends to be qualified in parallel space. */
3505 if (!friendp
&& !is_ancestor (current_namespace
, scope
))
3506 error ("declaration of %qD not in a namespace surrounding %qD",
3508 DECL_CONTEXT (decl
) = FROB_CONTEXT (scope
);
3510 /* Writing "int N::i" to declare a variable within "N" is invalid. */
3511 if (scope
== current_namespace
)
3513 if (at_namespace_scope_p ())
3514 error ("explicit qualification in declaration of %qD",
3519 /* See whether this has been declared in the namespace. */
3520 old
= lookup_qualified_name (scope
, DECL_NAME (decl
), false, true);
3521 if (old
== error_mark_node
)
3522 /* No old declaration at all. */
3524 /* If it's a TREE_LIST, the result of the lookup was ambiguous. */
3525 if (TREE_CODE (old
) == TREE_LIST
)
3527 error ("reference to %qD is ambiguous", decl
);
3528 print_candidates (old
);
3531 if (!is_overloaded_fn (decl
))
3533 /* We might have found OLD in an inline namespace inside SCOPE. */
3534 if (TREE_CODE (decl
) == TREE_CODE (old
))
3535 DECL_CONTEXT (decl
) = DECL_CONTEXT (old
);
3536 /* Don't compare non-function decls with decls_match here, since
3537 it can't check for the correct constness at this
3538 point. pushdecl will find those errors later. */
3541 /* Since decl is a function, old should contain a function decl. */
3542 if (!is_overloaded_fn (old
))
3544 /* A template can be explicitly specialized in any namespace. */
3545 if (processing_explicit_instantiation
)
3547 if (processing_template_decl
|| processing_specialization
)
3548 /* We have not yet called push_template_decl to turn a
3549 FUNCTION_DECL into a TEMPLATE_DECL, so the declarations won't
3550 match. But, we'll check later, when we construct the
3553 /* Instantiations or specializations of templates may be declared as
3554 friends in any namespace. */
3555 if (friendp
&& DECL_USE_TEMPLATE (decl
))
3557 if (is_overloaded_fn (old
))
3559 tree found
= NULL_TREE
;
3561 for (; elt
; elt
= OVL_NEXT (elt
))
3563 tree ofn
= OVL_CURRENT (elt
);
3564 /* Adjust DECL_CONTEXT first so decls_match will return true
3565 if DECL will match a declaration in an inline namespace. */
3566 DECL_CONTEXT (decl
) = DECL_CONTEXT (ofn
);
3567 if (decls_match (decl
, ofn
))
3569 if (found
&& !decls_match (found
, ofn
))
3571 DECL_CONTEXT (decl
) = FROB_CONTEXT (scope
);
3572 error ("reference to %qD is ambiguous", decl
);
3573 print_candidates (old
);
3581 if (!is_associated_namespace (scope
, CP_DECL_CONTEXT (found
)))
3583 DECL_CONTEXT (decl
) = DECL_CONTEXT (found
);
3589 DECL_CONTEXT (decl
) = DECL_CONTEXT (old
);
3590 if (decls_match (decl
, old
))
3594 /* It didn't work, go back to the explicit scope. */
3595 DECL_CONTEXT (decl
) = FROB_CONTEXT (scope
);
3597 error ("%qD should have been declared inside %qD", decl
, scope
);
3600 /* Return the namespace where the current declaration is declared. */
3603 current_decl_namespace (void)
3606 /* If we have been pushed into a different namespace, use it. */
3607 if (!vec_safe_is_empty (decl_namespace_list
))
3608 return decl_namespace_list
->last ();
3610 if (current_class_type
)
3611 result
= decl_namespace_context (current_class_type
);
3612 else if (current_function_decl
)
3613 result
= decl_namespace_context (current_function_decl
);
3615 result
= current_namespace
;
3619 /* Process any ATTRIBUTES on a namespace definition. Returns true if
3620 attribute visibility is seen. */
3623 handle_namespace_attrs (tree ns
, tree attributes
)
3626 bool saw_vis
= false;
3628 for (d
= attributes
; d
; d
= TREE_CHAIN (d
))
3630 tree name
= get_attribute_name (d
);
3631 tree args
= TREE_VALUE (d
);
3633 if (is_attribute_p ("visibility", name
))
3635 /* attribute visibility is a property of the syntactic block
3636 rather than the namespace as a whole, so we don't touch the
3637 NAMESPACE_DECL at all. */
3638 tree x
= args
? TREE_VALUE (args
) : NULL_TREE
;
3639 if (x
== NULL_TREE
|| TREE_CODE (x
) != STRING_CST
|| TREE_CHAIN (args
))
3641 warning (OPT_Wattributes
,
3642 "%qD attribute requires a single NTBS argument",
3647 if (!TREE_PUBLIC (ns
))
3648 warning (OPT_Wattributes
,
3649 "%qD attribute is meaningless since members of the "
3650 "anonymous namespace get local symbols", name
);
3652 push_visibility (TREE_STRING_POINTER (x
), 1);
3655 else if (is_attribute_p ("abi_tag", name
))
3657 if (!DECL_NAMESPACE_ASSOCIATIONS (ns
))
3659 warning (OPT_Wattributes
, "ignoring %qD attribute on non-inline "
3663 if (!DECL_NAME (ns
))
3665 warning (OPT_Wattributes
, "ignoring %qD attribute on anonymous "
3671 tree dn
= DECL_NAME (ns
);
3672 args
= build_string (IDENTIFIER_LENGTH (dn
) + 1,
3673 IDENTIFIER_POINTER (dn
));
3674 TREE_TYPE (args
) = char_array_type_node
;
3675 args
= fix_string_type (args
);
3676 args
= build_tree_list (NULL_TREE
, args
);
3678 if (check_abi_tag_args (args
, name
))
3679 DECL_ATTRIBUTES (ns
) = tree_cons (name
, args
,
3680 DECL_ATTRIBUTES (ns
));
3684 warning (OPT_Wattributes
, "%qD attribute directive ignored",
3693 /* Push into the scope of the NAME namespace. If NAME is NULL_TREE, then we
3694 select a name that is unique to this compilation unit. */
3697 push_namespace (tree name
)
3700 bool need_new
= true;
3701 bool implicit_use
= false;
3704 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
3706 /* We should not get here if the global_namespace is not yet constructed
3707 nor if NAME designates the global namespace: The global scope is
3708 constructed elsewhere. */
3709 gcc_assert (global_namespace
!= NULL
&& name
!= global_scope_name
);
3713 name
= get_anonymous_namespace_name();
3714 d
= IDENTIFIER_NAMESPACE_VALUE (name
);
3716 /* Reopening anonymous namespace. */
3718 implicit_use
= true;
3722 /* Check whether this is an extended namespace definition. */
3723 d
= IDENTIFIER_NAMESPACE_VALUE (name
);
3724 if (d
!= NULL_TREE
&& TREE_CODE (d
) == NAMESPACE_DECL
)
3726 tree dna
= DECL_NAMESPACE_ALIAS (d
);
3729 /* We do some error recovery for, eg, the redeclaration
3736 However, in nasty cases like:
3744 we just error out below, in duplicate_decls. */
3745 if (NAMESPACE_LEVEL (dna
)->level_chain
3746 == current_binding_level
)
3748 error ("namespace alias %qD not allowed here, "
3749 "assuming %qD", d
, dna
);
3761 /* Make a new namespace, binding the name to it. */
3762 d
= build_lang_decl (NAMESPACE_DECL
, name
, void_type_node
);
3763 DECL_CONTEXT (d
) = FROB_CONTEXT (current_namespace
);
3764 /* The name of this namespace is not visible to other translation
3765 units if it is an anonymous namespace or member thereof. */
3766 if (anon
|| decl_anon_ns_mem_p (current_namespace
))
3767 TREE_PUBLIC (d
) = 0;
3769 TREE_PUBLIC (d
) = 1;
3773 /* Clear DECL_NAME for the benefit of debugging back ends. */
3774 SET_DECL_ASSEMBLER_NAME (d
, name
);
3775 DECL_NAME (d
) = NULL_TREE
;
3777 begin_scope (sk_namespace
, d
);
3780 resume_scope (NAMESPACE_LEVEL (d
));
3783 do_using_directive (d
);
3784 /* Enter the name space. */
3785 current_namespace
= d
;
3787 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
3790 /* Pop from the scope of the current namespace. */
3793 pop_namespace (void)
3795 gcc_assert (current_namespace
!= global_namespace
);
3796 current_namespace
= CP_DECL_CONTEXT (current_namespace
);
3797 /* The binding level is not popped, as it might be re-opened later. */
3801 /* Push into the scope of the namespace NS, even if it is deeply
3802 nested within another namespace. */
3805 push_nested_namespace (tree ns
)
3807 if (ns
== global_namespace
)
3808 push_to_top_level ();
3811 push_nested_namespace (CP_DECL_CONTEXT (ns
));
3812 push_namespace (DECL_NAME (ns
));
3816 /* Pop back from the scope of the namespace NS, which was previously
3817 entered with push_nested_namespace. */
3820 pop_nested_namespace (tree ns
)
3822 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
3823 gcc_assert (current_namespace
== ns
);
3824 while (ns
!= global_namespace
)
3827 ns
= CP_DECL_CONTEXT (ns
);
3830 pop_from_top_level ();
3831 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
3834 /* Temporarily set the namespace for the current declaration. */
3837 push_decl_namespace (tree decl
)
3839 if (TREE_CODE (decl
) != NAMESPACE_DECL
)
3840 decl
= decl_namespace_context (decl
);
3841 vec_safe_push (decl_namespace_list
, ORIGINAL_NAMESPACE (decl
));
3844 /* [namespace.memdef]/2 */
3847 pop_decl_namespace (void)
3849 decl_namespace_list
->pop ();
3852 /* Return the namespace that is the common ancestor
3853 of two given namespaces. */
3856 namespace_ancestor_1 (tree ns1
, tree ns2
)
3859 if (is_ancestor (ns1
, ns2
))
3862 nsr
= namespace_ancestor_1 (CP_DECL_CONTEXT (ns1
), ns2
);
3866 /* Wrapper for namespace_ancestor_1. */
3869 namespace_ancestor (tree ns1
, tree ns2
)
3872 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
3873 nsr
= namespace_ancestor_1 (ns1
, ns2
);
3874 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
3878 /* Process a namespace-alias declaration. */
3881 do_namespace_alias (tree alias
, tree name_space
)
3883 if (name_space
== error_mark_node
)
3886 gcc_assert (TREE_CODE (name_space
) == NAMESPACE_DECL
);
3888 name_space
= ORIGINAL_NAMESPACE (name_space
);
3890 /* Build the alias. */
3891 alias
= build_lang_decl (NAMESPACE_DECL
, alias
, void_type_node
);
3892 DECL_NAMESPACE_ALIAS (alias
) = name_space
;
3893 DECL_EXTERNAL (alias
) = 1;
3894 DECL_CONTEXT (alias
) = FROB_CONTEXT (current_scope ());
3897 /* Emit debug info for namespace alias. */
3898 if (!building_stmt_list_p ())
3899 (*debug_hooks
->early_global_decl
) (alias
);
3902 /* Like pushdecl, only it places X in the current namespace,
3906 pushdecl_namespace_level (tree x
, bool is_friend
)
3908 cp_binding_level
*b
= current_binding_level
;
3911 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
3912 t
= pushdecl_with_scope (x
, NAMESPACE_LEVEL (current_namespace
), is_friend
);
3914 /* Now, the type_shadowed stack may screw us. Munge it so it does
3916 if (TREE_CODE (t
) == TYPE_DECL
)
3918 tree name
= DECL_NAME (t
);
3920 tree
*ptr
= (tree
*)0;
3921 for (; !global_scope_p (b
); b
= b
->level_chain
)
3923 tree shadowed
= b
->type_shadowed
;
3924 for (; shadowed
; shadowed
= TREE_CHAIN (shadowed
))
3925 if (TREE_PURPOSE (shadowed
) == name
)
3927 ptr
= &TREE_VALUE (shadowed
);
3928 /* Can't break out of the loop here because sometimes
3929 a binding level will have duplicate bindings for
3930 PT names. It's gross, but I haven't time to fix it. */
3933 newval
= TREE_TYPE (t
);
3934 if (ptr
== (tree
*)0)
3936 /* @@ This shouldn't be needed. My test case "zstring.cc" trips
3937 up here if this is changed to an assertion. --KR */
3938 SET_IDENTIFIER_TYPE_VALUE (name
, t
);
3945 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
3949 /* Insert USED into the using list of USER. Set INDIRECT_flag if this
3950 directive is not directly from the source. Also find the common
3951 ancestor and let our users know about the new namespace */
3954 add_using_namespace_1 (tree user
, tree used
, bool indirect
)
3957 /* Using oneself is a no-op. */
3960 gcc_assert (TREE_CODE (user
) == NAMESPACE_DECL
);
3961 gcc_assert (TREE_CODE (used
) == NAMESPACE_DECL
);
3962 /* Check if we already have this. */
3963 t
= purpose_member (used
, DECL_NAMESPACE_USING (user
));
3967 /* Promote to direct usage. */
3968 TREE_INDIRECT_USING (t
) = 0;
3972 /* Add used to the user's using list. */
3973 DECL_NAMESPACE_USING (user
)
3974 = tree_cons (used
, namespace_ancestor (user
, used
),
3975 DECL_NAMESPACE_USING (user
));
3977 TREE_INDIRECT_USING (DECL_NAMESPACE_USING (user
)) = indirect
;
3979 /* Add user to the used's users list. */
3980 DECL_NAMESPACE_USERS (used
)
3981 = tree_cons (user
, 0, DECL_NAMESPACE_USERS (used
));
3983 /* Recursively add all namespaces used. */
3984 for (t
= DECL_NAMESPACE_USING (used
); t
; t
= TREE_CHAIN (t
))
3985 /* indirect usage */
3986 add_using_namespace_1 (user
, TREE_PURPOSE (t
), 1);
3988 /* Tell everyone using us about the new used namespaces. */
3989 for (t
= DECL_NAMESPACE_USERS (user
); t
; t
= TREE_CHAIN (t
))
3990 add_using_namespace_1 (TREE_PURPOSE (t
), used
, 1);
3993 /* Wrapper for add_using_namespace_1. */
3996 add_using_namespace (tree user
, tree used
, bool indirect
)
3998 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
3999 add_using_namespace_1 (user
, used
, indirect
);
4000 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
4003 /* Process a using-declaration not appearing in class or local scope. */
4006 do_toplevel_using_decl (tree decl
, tree scope
, tree name
)
4008 tree oldval
, oldtype
, newval
, newtype
;
4009 tree orig_decl
= decl
;
4010 cxx_binding
*binding
;
4012 decl
= validate_nonmember_using_decl (decl
, scope
, name
);
4013 if (decl
== NULL_TREE
)
4016 binding
= binding_for_name (NAMESPACE_LEVEL (current_namespace
), name
);
4018 oldval
= binding
->value
;
4019 oldtype
= binding
->type
;
4021 do_nonmember_using_decl (scope
, name
, oldval
, oldtype
, &newval
, &newtype
);
4023 /* Emit debug info. */
4024 if (!processing_template_decl
)
4025 cp_emit_debug_info_for_using (orig_decl
, current_namespace
);
4027 /* Copy declarations found. */
4029 binding
->value
= newval
;
4031 binding
->type
= newtype
;
4034 /* Process a using-directive. */
4037 do_using_directive (tree name_space
)
4039 tree context
= NULL_TREE
;
4041 if (name_space
== error_mark_node
)
4044 gcc_assert (TREE_CODE (name_space
) == NAMESPACE_DECL
);
4046 if (building_stmt_list_p ())
4047 add_stmt (build_stmt (input_location
, USING_STMT
, name_space
));
4048 name_space
= ORIGINAL_NAMESPACE (name_space
);
4050 if (!toplevel_bindings_p ())
4052 push_using_directive (name_space
);
4057 add_using_namespace (current_namespace
, name_space
, 0);
4058 if (current_namespace
!= global_namespace
)
4059 context
= current_namespace
;
4061 /* Emit debugging info. */
4062 if (!processing_template_decl
)
4063 (*debug_hooks
->imported_module_or_decl
) (name_space
, NULL_TREE
,
4068 /* Deal with a using-directive seen by the parser. Currently we only
4069 handle attributes here, since they cannot appear inside a template. */
4072 parse_using_directive (tree name_space
, tree attribs
)
4074 do_using_directive (name_space
);
4076 if (attribs
== error_mark_node
)
4079 for (tree a
= attribs
; a
; a
= TREE_CHAIN (a
))
4081 tree name
= get_attribute_name (a
);
4082 if (is_attribute_p ("strong", name
))
4084 if (!toplevel_bindings_p ())
4085 error ("strong using only meaningful at namespace scope");
4086 else if (name_space
!= error_mark_node
)
4088 if (!is_ancestor (current_namespace
, name_space
))
4089 error ("current namespace %qD does not enclose strongly used namespace %qD",
4090 current_namespace
, name_space
);
4091 DECL_NAMESPACE_ASSOCIATIONS (name_space
)
4092 = tree_cons (current_namespace
, 0,
4093 DECL_NAMESPACE_ASSOCIATIONS (name_space
));
4097 warning (OPT_Wattributes
, "%qD attribute directive ignored", name
);
4101 /* Like pushdecl, only it places X in the global scope if appropriate.
4102 Calls cp_finish_decl to register the variable, initializing it with
4103 *INIT, if INIT is non-NULL. */
4106 pushdecl_top_level_1 (tree x
, tree
*init
, bool is_friend
)
4108 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
4109 push_to_top_level ();
4110 x
= pushdecl_namespace_level (x
, is_friend
);
4112 cp_finish_decl (x
, *init
, false, NULL_TREE
, 0);
4113 pop_from_top_level ();
4114 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
4118 /* Like pushdecl, only it places X in the global scope if appropriate. */
4121 pushdecl_top_level (tree x
)
4123 return pushdecl_top_level_1 (x
, NULL
, false);
4126 /* Like pushdecl_top_level, but adding the IS_FRIEND parameter. */
4129 pushdecl_top_level_maybe_friend (tree x
, bool is_friend
)
4131 return pushdecl_top_level_1 (x
, NULL
, is_friend
);
4134 /* Like pushdecl, only it places X in the global scope if
4135 appropriate. Calls cp_finish_decl to register the variable,
4136 initializing it with INIT. */
4139 pushdecl_top_level_and_finish (tree x
, tree init
)
4141 return pushdecl_top_level_1 (x
, &init
, false);
4144 /* Combines two sets of overloaded functions into an OVERLOAD chain, removing
4145 duplicates. The first list becomes the tail of the result.
4147 The algorithm is O(n^2). We could get this down to O(n log n) by
4148 doing a sort on the addresses of the functions, if that becomes
4152 merge_functions (tree s1
, tree s2
)
4154 for (; s2
; s2
= OVL_NEXT (s2
))
4156 tree fn2
= OVL_CURRENT (s2
);
4159 for (fns1
= s1
; fns1
; fns1
= OVL_NEXT (fns1
))
4161 tree fn1
= OVL_CURRENT (fns1
);
4163 /* If the function from S2 is already in S1, there is no
4164 need to add it again. For `extern "C"' functions, we
4165 might have two FUNCTION_DECLs for the same function, in
4166 different namespaces, but let's leave them in case
4167 they have different default arguments. */
4172 /* If we exhausted all of the functions in S1, FN2 is new. */
4174 s1
= build_overload (fn2
, s1
);
4179 /* Returns TRUE iff OLD and NEW are the same entity.
4181 3 [basic]/3: An entity is a value, object, reference, function,
4182 enumerator, type, class member, template, template specialization,
4183 namespace, parameter pack, or this.
4185 7.3.4 [namespace.udir]/4: If name lookup finds a declaration for a name
4186 in two different namespaces, and the declarations do not declare the
4187 same entity and do not declare functions, the use of the name is
4191 same_entity_p (tree one
, tree two
)
4197 if (TREE_CODE (one
) == TYPE_DECL
4198 && TREE_CODE (two
) == TYPE_DECL
4199 && same_type_p (TREE_TYPE (one
), TREE_TYPE (two
)))
4204 /* This should return an error not all definitions define functions.
4205 It is not an error if we find two functions with exactly the
4206 same signature, only if these are selected in overload resolution.
4207 old is the current set of bindings, new_binding the freshly-found binding.
4208 XXX Do we want to give *all* candidates in case of ambiguity?
4209 XXX In what way should I treat extern declarations?
4210 XXX I don't want to repeat the entire duplicate_decls here */
4213 ambiguous_decl (struct scope_binding
*old
, cxx_binding
*new_binding
, int flags
)
4216 gcc_assert (old
!= NULL
);
4218 /* Copy the type. */
4219 type
= new_binding
->type
;
4220 if (LOOKUP_NAMESPACES_ONLY (flags
)
4221 || (type
&& hidden_name_p (type
) && !(flags
& LOOKUP_HIDDEN
)))
4224 /* Copy the value. */
4225 val
= new_binding
->value
;
4228 if (hidden_name_p (val
) && !(flags
& LOOKUP_HIDDEN
))
4231 switch (TREE_CODE (val
))
4234 /* If we expect types or namespaces, and not templates,
4235 or this is not a template class. */
4236 if ((LOOKUP_QUALIFIERS_ONLY (flags
)
4237 && !DECL_TYPE_TEMPLATE_P (val
)))
4241 if (LOOKUP_NAMESPACES_ONLY (flags
)
4242 || (type
&& (flags
& LOOKUP_PREFER_TYPES
)))
4245 case NAMESPACE_DECL
:
4246 if (LOOKUP_TYPES_ONLY (flags
))
4250 /* Ignore built-in functions that are still anticipated. */
4251 if (LOOKUP_QUALIFIERS_ONLY (flags
))
4255 if (LOOKUP_QUALIFIERS_ONLY (flags
))
4260 /* If val is hidden, shift down any class or enumeration name. */
4269 else if (val
&& !same_entity_p (val
, old
->value
))
4271 if (is_overloaded_fn (old
->value
) && is_overloaded_fn (val
))
4272 old
->value
= merge_functions (old
->value
, val
);
4275 old
->value
= tree_cons (NULL_TREE
, old
->value
,
4276 build_tree_list (NULL_TREE
, val
));
4277 TREE_TYPE (old
->value
) = error_mark_node
;
4283 else if (type
&& old
->type
!= type
)
4285 old
->type
= tree_cons (NULL_TREE
, old
->type
,
4286 build_tree_list (NULL_TREE
, type
));
4287 TREE_TYPE (old
->type
) = error_mark_node
;
4291 /* Return the declarations that are members of the namespace NS. */
4294 cp_namespace_decls (tree ns
)
4296 return NAMESPACE_LEVEL (ns
)->names
;
4299 /* Combine prefer_type and namespaces_only into flags. */
4302 lookup_flags (int prefer_type
, int namespaces_only
)
4304 if (namespaces_only
)
4305 return LOOKUP_PREFER_NAMESPACES
;
4306 if (prefer_type
> 1)
4307 return LOOKUP_PREFER_TYPES
;
4308 if (prefer_type
> 0)
4309 return LOOKUP_PREFER_BOTH
;
4313 /* Given a lookup that returned VAL, use FLAGS to decide if we want to
4314 ignore it or not. Subroutine of lookup_name_real and
4315 lookup_type_scope. */
4318 qualify_lookup (tree val
, int flags
)
4320 if (val
== NULL_TREE
)
4322 if ((flags
& LOOKUP_PREFER_NAMESPACES
) && TREE_CODE (val
) == NAMESPACE_DECL
)
4324 if (flags
& LOOKUP_PREFER_TYPES
)
4326 tree target_val
= strip_using_decl (val
);
4327 if (TREE_CODE (target_val
) == TYPE_DECL
4328 || TREE_CODE (target_val
) == TEMPLATE_DECL
)
4331 if (flags
& (LOOKUP_PREFER_NAMESPACES
| LOOKUP_PREFER_TYPES
))
4333 /* Look through lambda things that we shouldn't be able to see. */
4334 if (is_lambda_ignored_entity (val
))
4339 /* Given a lookup that returned VAL, decide if we want to ignore it or
4340 not based on DECL_ANTICIPATED. */
4343 hidden_name_p (tree val
)
4346 && DECL_LANG_SPECIFIC (val
)
4347 && TYPE_FUNCTION_OR_TEMPLATE_DECL_P (val
)
4348 && DECL_ANTICIPATED (val
))
4350 if (TREE_CODE (val
) == OVERLOAD
)
4352 for (tree o
= val
; o
; o
= OVL_CHAIN (o
))
4353 if (!hidden_name_p (OVL_FUNCTION (o
)))
4360 /* Remove any hidden friend functions from a possibly overloaded set
4364 remove_hidden_names (tree fns
)
4369 if (TREE_CODE (fns
) == FUNCTION_DECL
&& hidden_name_p (fns
))
4371 else if (TREE_CODE (fns
) == OVERLOAD
)
4375 for (o
= fns
; o
; o
= OVL_NEXT (o
))
4376 if (hidden_name_p (OVL_CURRENT (o
)))
4382 for (o
= fns
; o
; o
= OVL_NEXT (o
))
4383 if (!hidden_name_p (OVL_CURRENT (o
)))
4384 n
= build_overload (OVL_CURRENT (o
), n
);
4392 /* Suggest alternatives for NAME, an IDENTIFIER_NODE for which name
4393 lookup failed. Search through all available namespaces and print out
4394 possible candidates. */
4397 suggest_alternatives_for (location_t location
, tree name
)
4399 vec
<tree
> candidates
= vNULL
;
4400 vec
<tree
> namespaces_to_search
= vNULL
;
4401 int max_to_search
= PARAM_VALUE (CXX_MAX_NAMESPACES_FOR_DIAGNOSTIC_HELP
);
4406 namespaces_to_search
.safe_push (global_namespace
);
4408 while (!namespaces_to_search
.is_empty ()
4409 && n_searched
< max_to_search
)
4411 tree scope
= namespaces_to_search
.pop ();
4412 struct scope_binding binding
= EMPTY_SCOPE_BINDING
;
4413 cp_binding_level
*level
= NAMESPACE_LEVEL (scope
);
4415 /* Look in this namespace. */
4416 qualified_lookup_using_namespace (name
, scope
, &binding
, 0);
4421 candidates
.safe_push (binding
.value
);
4423 /* Add child namespaces. */
4424 for (t
= level
->namespaces
; t
; t
= DECL_CHAIN (t
))
4425 namespaces_to_search
.safe_push (t
);
4428 /* If we stopped before we could examine all namespaces, inform the
4429 user. Do this even if we don't have any candidates, since there
4430 might be more candidates further down that we weren't able to
4432 if (n_searched
>= max_to_search
4433 && !namespaces_to_search
.is_empty ())
4435 "maximum limit of %d namespaces searched for %qE",
4436 max_to_search
, name
);
4438 namespaces_to_search
.release ();
4440 /* Nothing useful to report. */
4441 if (candidates
.is_empty ())
4444 inform_n (location
, candidates
.length (),
4445 "suggested alternative:",
4446 "suggested alternatives:");
4448 FOR_EACH_VEC_ELT (candidates
, ix
, t
)
4449 inform (location_of (t
), " %qE", t
);
4451 candidates
.release ();
4454 /* Unscoped lookup of a global: iterate over current namespaces,
4455 considering using-directives. */
4458 unqualified_namespace_lookup_1 (tree name
, int flags
)
4460 tree initial
= current_decl_namespace ();
4461 tree scope
= initial
;
4463 cp_binding_level
*level
;
4464 tree val
= NULL_TREE
;
4466 for (; !val
; scope
= CP_DECL_CONTEXT (scope
))
4468 struct scope_binding binding
= EMPTY_SCOPE_BINDING
;
4470 cp_binding_level_find_binding_for_name (NAMESPACE_LEVEL (scope
), name
);
4473 ambiguous_decl (&binding
, b
, flags
);
4475 /* Add all _DECLs seen through local using-directives. */
4476 for (level
= current_binding_level
;
4477 level
->kind
!= sk_namespace
;
4478 level
= level
->level_chain
)
4479 if (!lookup_using_namespace (name
, &binding
, level
->using_directives
,
4481 /* Give up because of error. */
4482 return error_mark_node
;
4484 /* Add all _DECLs seen through global using-directives. */
4485 /* XXX local and global using lists should work equally. */
4489 if (!lookup_using_namespace (name
, &binding
,
4490 DECL_NAMESPACE_USING (siter
),
4492 /* Give up because of error. */
4493 return error_mark_node
;
4494 if (siter
== scope
) break;
4495 siter
= CP_DECL_CONTEXT (siter
);
4498 val
= binding
.value
;
4499 if (scope
== global_namespace
)
4505 /* Wrapper for unqualified_namespace_lookup_1. */
4508 unqualified_namespace_lookup (tree name
, int flags
)
4511 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
4512 ret
= unqualified_namespace_lookup_1 (name
, flags
);
4513 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
4517 /* Look up NAME (an IDENTIFIER_NODE) in SCOPE (either a NAMESPACE_DECL
4518 or a class TYPE). If IS_TYPE_P is TRUE, then ignore non-type
4521 Returns a DECL (or OVERLOAD, or BASELINK) representing the
4522 declaration found. If no suitable declaration can be found,
4523 ERROR_MARK_NODE is returned. If COMPLAIN is true and SCOPE is
4524 neither a class-type nor a namespace a diagnostic is issued. */
4527 lookup_qualified_name (tree scope
, tree name
, bool is_type_p
, bool complain
)
4532 if (TREE_CODE (scope
) == NAMESPACE_DECL
)
4534 struct scope_binding binding
= EMPTY_SCOPE_BINDING
;
4537 flags
|= LOOKUP_PREFER_TYPES
;
4538 if (qualified_lookup_using_namespace (name
, scope
, &binding
, flags
))
4541 else if (cxx_dialect
!= cxx98
&& TREE_CODE (scope
) == ENUMERAL_TYPE
)
4542 t
= lookup_enumerator (scope
, name
);
4543 else if (is_class_type (scope
, complain
))
4544 t
= lookup_member (scope
, name
, 2, is_type_p
, tf_warning_or_error
);
4547 return error_mark_node
;
4551 /* Subroutine of unqualified_namespace_lookup:
4552 Add the bindings of NAME in used namespaces to VAL.
4553 We are currently looking for names in namespace SCOPE, so we
4554 look through USINGS for using-directives of namespaces
4555 which have SCOPE as a common ancestor with the current scope.
4556 Returns false on errors. */
4559 lookup_using_namespace (tree name
, struct scope_binding
*val
,
4560 tree usings
, tree scope
, int flags
)
4563 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
4564 /* Iterate over all used namespaces in current, searching for using
4565 directives of scope. */
4566 for (iter
= usings
; iter
; iter
= TREE_CHAIN (iter
))
4567 if (TREE_VALUE (iter
) == scope
)
4569 tree used
= ORIGINAL_NAMESPACE (TREE_PURPOSE (iter
));
4571 cp_binding_level_find_binding_for_name (NAMESPACE_LEVEL (used
), name
);
4572 /* Resolve ambiguities. */
4574 ambiguous_decl (val
, val1
, flags
);
4576 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
4577 return val
->value
!= error_mark_node
;
4580 /* Returns true iff VEC contains TARGET. */
4583 tree_vec_contains (vec
<tree
, va_gc
> *vec
, tree target
)
4587 FOR_EACH_VEC_SAFE_ELT (vec
,i
,elt
)
4594 Accepts the NAME to lookup and its qualifying SCOPE.
4595 Returns the name/type pair found into the cxx_binding *RESULT,
4596 or false on error. */
4599 qualified_lookup_using_namespace (tree name
, tree scope
,
4600 struct scope_binding
*result
, int flags
)
4602 /* Maintain a list of namespaces visited... */
4603 vec
<tree
, va_gc
> *seen
= NULL
;
4604 vec
<tree
, va_gc
> *seen_inline
= NULL
;
4605 /* ... and a list of namespace yet to see. */
4606 vec
<tree
, va_gc
> *todo
= NULL
;
4607 vec
<tree
, va_gc
> *todo_maybe
= NULL
;
4608 vec
<tree
, va_gc
> *todo_inline
= NULL
;
4610 timevar_start (TV_NAME_LOOKUP
);
4611 /* Look through namespace aliases. */
4612 scope
= ORIGINAL_NAMESPACE (scope
);
4614 /* Algorithm: Starting with SCOPE, walk through the set of used
4615 namespaces. For each used namespace, look through its inline
4616 namespace set for any bindings and usings. If no bindings are
4617 found, add any usings seen to the set of used namespaces. */
4618 vec_safe_push (todo
, scope
);
4620 while (todo
->length ())
4623 scope
= todo
->pop ();
4624 if (tree_vec_contains (seen
, scope
))
4626 vec_safe_push (seen
, scope
);
4627 vec_safe_push (todo_inline
, scope
);
4630 while (todo_inline
->length ())
4632 cxx_binding
*binding
;
4634 scope
= todo_inline
->pop ();
4635 if (tree_vec_contains (seen_inline
, scope
))
4637 vec_safe_push (seen_inline
, scope
);
4640 cp_binding_level_find_binding_for_name (NAMESPACE_LEVEL (scope
), name
);
4644 ambiguous_decl (result
, binding
, flags
);
4647 for (usings
= DECL_NAMESPACE_USING (scope
); usings
;
4648 usings
= TREE_CHAIN (usings
))
4649 if (!TREE_INDIRECT_USING (usings
))
4651 if (is_associated_namespace (scope
, TREE_PURPOSE (usings
)))
4652 vec_safe_push (todo_inline
, TREE_PURPOSE (usings
));
4654 vec_safe_push (todo_maybe
, TREE_PURPOSE (usings
));
4659 vec_safe_truncate (todo_maybe
, 0);
4661 while (vec_safe_length (todo_maybe
))
4662 vec_safe_push (todo
, todo_maybe
->pop ());
4665 vec_free (todo_maybe
);
4666 vec_free (todo_inline
);
4668 vec_free (seen_inline
);
4669 timevar_stop (TV_NAME_LOOKUP
);
4670 return result
->value
!= error_mark_node
;
4673 /* Subroutine of outer_binding.
4675 Returns TRUE if BINDING is a binding to a template parameter of
4676 SCOPE. In that case SCOPE is the scope of a primary template
4677 parameter -- in the sense of G++, i.e, a template that has its own
4680 Returns FALSE otherwise. */
4683 binding_to_template_parms_of_scope_p (cxx_binding
*binding
,
4684 cp_binding_level
*scope
)
4686 tree binding_value
, tmpl
, tinfo
;
4689 if (!binding
|| !scope
|| !scope
->this_entity
)
4692 binding_value
= binding
->value
? binding
->value
: binding
->type
;
4693 tinfo
= get_template_info (scope
->this_entity
);
4695 /* BINDING_VALUE must be a template parm. */
4696 if (binding_value
== NULL_TREE
4697 || (!DECL_P (binding_value
)
4698 || !DECL_TEMPLATE_PARM_P (binding_value
)))
4701 /* The level of BINDING_VALUE. */
4703 template_type_parameter_p (binding_value
)
4704 ? TEMPLATE_PARM_LEVEL (TEMPLATE_TYPE_PARM_INDEX
4705 (TREE_TYPE (binding_value
)))
4706 : TEMPLATE_PARM_LEVEL (DECL_INITIAL (binding_value
));
4708 /* The template of the current scope, iff said scope is a primary
4711 && PRIMARY_TEMPLATE_P (TI_TEMPLATE (tinfo
))
4712 ? TI_TEMPLATE (tinfo
)
4715 /* If the level of the parm BINDING_VALUE equals the depth of TMPL,
4716 then BINDING_VALUE is a parameter of TMPL. */
4717 return (tmpl
&& level
== TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (tmpl
)));
4720 /* Return the innermost non-namespace binding for NAME from a scope
4721 containing BINDING, or, if BINDING is NULL, the current scope.
4722 Please note that for a given template, the template parameters are
4723 considered to be in the scope containing the current scope.
4724 If CLASS_P is false, then class bindings are ignored. */
4727 outer_binding (tree name
,
4728 cxx_binding
*binding
,
4732 cp_binding_level
*scope
;
4733 cp_binding_level
*outer_scope
;
4737 scope
= binding
->scope
->level_chain
;
4738 outer
= binding
->previous
;
4742 scope
= current_binding_level
;
4743 outer
= IDENTIFIER_BINDING (name
);
4745 outer_scope
= outer
? outer
->scope
: NULL
;
4747 /* Because we create class bindings lazily, we might be missing a
4748 class binding for NAME. If there are any class binding levels
4749 between the LAST_BINDING_LEVEL and the scope in which OUTER was
4750 declared, we must lookup NAME in those class scopes. */
4752 while (scope
&& scope
!= outer_scope
&& scope
->kind
!= sk_namespace
)
4754 if (scope
->kind
== sk_class
)
4756 cxx_binding
*class_binding
;
4758 class_binding
= get_class_binding (name
, scope
);
4761 /* Thread this new class-scope binding onto the
4762 IDENTIFIER_BINDING list so that future lookups
4764 class_binding
->previous
= outer
;
4766 binding
->previous
= class_binding
;
4768 IDENTIFIER_BINDING (name
) = class_binding
;
4769 return class_binding
;
4772 /* If we are in a member template, the template parms of the member
4773 template are considered to be inside the scope of the containing
4774 class, but within G++ the class bindings are all pushed between the
4775 template parms and the function body. So if the outer binding is
4776 a template parm for the current scope, return it now rather than
4777 look for a class binding. */
4778 if (outer_scope
&& outer_scope
->kind
== sk_template_parms
4779 && binding_to_template_parms_of_scope_p (outer
, scope
))
4782 scope
= scope
->level_chain
;
4788 /* Return the innermost block-scope or class-scope value binding for
4789 NAME, or NULL_TREE if there is no such binding. */
4792 innermost_non_namespace_value (tree name
)
4794 cxx_binding
*binding
;
4795 binding
= outer_binding (name
, /*binding=*/NULL
, /*class_p=*/true);
4796 return binding
? binding
->value
: NULL_TREE
;
4799 /* Look up NAME in the current binding level and its superiors in the
4800 namespace of variables, functions and typedefs. Return a ..._DECL
4801 node of some kind representing its definition if there is only one
4802 such declaration, or return a TREE_LIST with all the overloaded
4803 definitions if there are many, or return 0 if it is undefined.
4804 Hidden name, either friend declaration or built-in function, are
4807 If PREFER_TYPE is > 0, we prefer TYPE_DECLs or namespaces.
4808 If PREFER_TYPE is > 1, we reject non-type decls (e.g. namespaces).
4809 Otherwise we prefer non-TYPE_DECLs.
4811 If NONCLASS is nonzero, bindings in class scopes are ignored. If
4812 BLOCK_P is false, bindings in block scopes are ignored. */
4815 lookup_name_real_1 (tree name
, int prefer_type
, int nonclass
, bool block_p
,
4816 int namespaces_only
, int flags
)
4819 tree val
= NULL_TREE
;
4821 /* Conversion operators are handled specially because ordinary
4822 unqualified name lookup will not find template conversion
4824 if (IDENTIFIER_TYPENAME_P (name
))
4826 cp_binding_level
*level
;
4828 for (level
= current_binding_level
;
4829 level
&& level
->kind
!= sk_namespace
;
4830 level
= level
->level_chain
)
4835 /* A conversion operator can only be declared in a class
4837 if (level
->kind
!= sk_class
)
4840 /* Lookup the conversion operator in the class. */
4841 class_type
= level
->this_entity
;
4842 operators
= lookup_fnfields (class_type
, name
, /*protect=*/0);
4850 flags
|= lookup_flags (prefer_type
, namespaces_only
);
4852 /* First, look in non-namespace scopes. */
4854 if (current_class_type
== NULL_TREE
)
4857 if (block_p
|| !nonclass
)
4858 for (iter
= outer_binding (name
, NULL
, !nonclass
);
4860 iter
= outer_binding (name
, iter
, !nonclass
))
4864 /* Skip entities we don't want. */
4865 if (LOCAL_BINDING_P (iter
) ? !block_p
: nonclass
)
4868 /* If this is the kind of thing we're looking for, we're done. */
4869 if (qualify_lookup (iter
->value
, flags
))
4870 binding
= iter
->value
;
4871 else if ((flags
& LOOKUP_PREFER_TYPES
)
4872 && qualify_lookup (iter
->type
, flags
))
4873 binding
= iter
->type
;
4875 binding
= NULL_TREE
;
4879 if (hidden_name_p (binding
))
4881 /* A non namespace-scope binding can only be hidden in the
4882 presence of a local class, due to friend declarations.
4884 In particular, consider:
4892 B* b; // error: B is hidden
4893 C* c; // OK, finds ::C
4896 B *b; // error: B is hidden
4897 C *c; // OK, finds ::C
4902 The standard says that "B" is a local class in "f"
4903 (but not nested within "A") -- but that name lookup
4904 for "B" does not find this declaration until it is
4905 declared directly with "f".
4911 If a friend declaration appears in a local class and
4912 the name specified is an unqualified name, a prior
4913 declaration is looked up without considering scopes
4914 that are outside the innermost enclosing non-class
4915 scope. For a friend function declaration, if there is
4916 no prior declaration, the program is ill-formed. For a
4917 friend class declaration, if there is no prior
4918 declaration, the class that is specified belongs to the
4919 innermost enclosing non-class scope, but if it is
4920 subsequently referenced, its name is not found by name
4921 lookup until a matching declaration is provided in the
4922 innermost enclosing nonclass scope.
4924 So just keep looking for a non-hidden binding.
4926 gcc_assert (TREE_CODE (binding
) == TYPE_DECL
);
4934 /* Now lookup in namespace scopes. */
4936 val
= unqualified_namespace_lookup (name
, flags
);
4938 /* If we have a single function from a using decl, pull it out. */
4939 if (val
&& TREE_CODE (val
) == OVERLOAD
&& !really_overloaded_fn (val
))
4940 val
= OVL_FUNCTION (val
);
4945 /* Wrapper for lookup_name_real_1. */
4948 lookup_name_real (tree name
, int prefer_type
, int nonclass
, bool block_p
,
4949 int namespaces_only
, int flags
)
4952 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
4953 ret
= lookup_name_real_1 (name
, prefer_type
, nonclass
, block_p
,
4954 namespaces_only
, flags
);
4955 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
4960 lookup_name_nonclass (tree name
)
4962 return lookup_name_real (name
, 0, 1, /*block_p=*/true, 0, 0);
4966 lookup_function_nonclass (tree name
, vec
<tree
, va_gc
> *args
, bool block_p
)
4969 lookup_arg_dependent (name
,
4970 lookup_name_real (name
, 0, 1, block_p
, 0, 0),
4975 lookup_name (tree name
)
4977 return lookup_name_real (name
, 0, 0, /*block_p=*/true, 0, 0);
4981 lookup_name_prefer_type (tree name
, int prefer_type
)
4983 return lookup_name_real (name
, prefer_type
, 0, /*block_p=*/true, 0, 0);
4986 /* Look up NAME for type used in elaborated name specifier in
4987 the scopes given by SCOPE. SCOPE can be either TS_CURRENT or
4988 TS_WITHIN_ENCLOSING_NON_CLASS. Although not implied by the
4989 name, more scopes are checked if cleanup or template parameter
4990 scope is encountered.
4992 Unlike lookup_name_real, we make sure that NAME is actually
4993 declared in the desired scope, not from inheritance, nor using
4994 directive. For using declaration, there is DR138 still waiting
4995 to be resolved. Hidden name coming from an earlier friend
4996 declaration is also returned.
4998 A TYPE_DECL best matching the NAME is returned. Catching error
4999 and issuing diagnostics are caller's responsibility. */
5002 lookup_type_scope_1 (tree name
, tag_scope scope
)
5004 cxx_binding
*iter
= NULL
;
5005 tree val
= NULL_TREE
;
5007 /* Look in non-namespace scope first. */
5008 if (current_binding_level
->kind
!= sk_namespace
)
5009 iter
= outer_binding (name
, NULL
, /*class_p=*/ true);
5010 for (; iter
; iter
= outer_binding (name
, iter
, /*class_p=*/ true))
5012 /* Check if this is the kind of thing we're looking for.
5013 If SCOPE is TS_CURRENT, also make sure it doesn't come from
5014 base class. For ITER->VALUE, we can simply use
5015 INHERITED_VALUE_BINDING_P. For ITER->TYPE, we have to use
5018 We check ITER->TYPE before ITER->VALUE in order to handle
5019 typedef struct C {} C;
5022 if (qualify_lookup (iter
->type
, LOOKUP_PREFER_TYPES
)
5023 && (scope
!= ts_current
5024 || LOCAL_BINDING_P (iter
)
5025 || DECL_CONTEXT (iter
->type
) == iter
->scope
->this_entity
))
5027 else if ((scope
!= ts_current
5028 || !INHERITED_VALUE_BINDING_P (iter
))
5029 && qualify_lookup (iter
->value
, LOOKUP_PREFER_TYPES
))
5036 /* Look in namespace scope. */
5039 iter
= cp_binding_level_find_binding_for_name
5040 (NAMESPACE_LEVEL (current_decl_namespace ()), name
);
5044 /* If this is the kind of thing we're looking for, we're done. */
5045 if (qualify_lookup (iter
->type
, LOOKUP_PREFER_TYPES
))
5047 else if (qualify_lookup (iter
->value
, LOOKUP_PREFER_TYPES
))
5053 /* Type found, check if it is in the allowed scopes, ignoring cleanup
5054 and template parameter scopes. */
5057 cp_binding_level
*b
= current_binding_level
;
5060 if (iter
->scope
== b
)
5063 if (b
->kind
== sk_cleanup
|| b
->kind
== sk_template_parms
5064 || b
->kind
== sk_function_parms
)
5066 else if (b
->kind
== sk_class
5067 && scope
== ts_within_enclosing_non_class
)
5077 /* Wrapper for lookup_type_scope_1. */
5080 lookup_type_scope (tree name
, tag_scope scope
)
5083 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
5084 ret
= lookup_type_scope_1 (name
, scope
);
5085 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
5090 /* Similar to `lookup_name' but look only in the innermost non-class
5094 lookup_name_innermost_nonclass_level_1 (tree name
)
5096 cp_binding_level
*b
;
5099 b
= innermost_nonclass_level ();
5101 if (b
->kind
== sk_namespace
)
5103 t
= IDENTIFIER_NAMESPACE_VALUE (name
);
5105 /* extern "C" function() */
5106 if (t
!= NULL_TREE
&& TREE_CODE (t
) == TREE_LIST
)
5109 else if (IDENTIFIER_BINDING (name
)
5110 && LOCAL_BINDING_P (IDENTIFIER_BINDING (name
)))
5112 cxx_binding
*binding
;
5113 binding
= IDENTIFIER_BINDING (name
);
5116 if (binding
->scope
== b
5117 && !(VAR_P (binding
->value
)
5118 && DECL_DEAD_FOR_LOCAL (binding
->value
)))
5119 return binding
->value
;
5121 if (b
->kind
== sk_cleanup
)
5131 /* Wrapper for lookup_name_innermost_nonclass_level_1. */
5134 lookup_name_innermost_nonclass_level (tree name
)
5137 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
5138 ret
= lookup_name_innermost_nonclass_level_1 (name
);
5139 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
5144 /* Returns true iff DECL is a block-scope extern declaration of a function
5148 is_local_extern (tree decl
)
5150 cxx_binding
*binding
;
5152 /* For functions, this is easy. */
5153 if (TREE_CODE (decl
) == FUNCTION_DECL
)
5154 return DECL_LOCAL_FUNCTION_P (decl
);
5158 if (!current_function_decl
)
5161 /* For variables, this is not easy. We need to look at the binding stack
5162 for the identifier to see whether the decl we have is a local. */
5163 for (binding
= IDENTIFIER_BINDING (DECL_NAME (decl
));
5164 binding
&& binding
->scope
->kind
!= sk_namespace
;
5165 binding
= binding
->previous
)
5166 if (binding
->value
== decl
)
5167 return LOCAL_BINDING_P (binding
);
5172 /* Like lookup_name_innermost_nonclass_level, but for types. */
5175 lookup_type_current_level (tree name
)
5179 timevar_start (TV_NAME_LOOKUP
);
5180 gcc_assert (current_binding_level
->kind
!= sk_namespace
);
5182 if (REAL_IDENTIFIER_TYPE_VALUE (name
) != NULL_TREE
5183 && REAL_IDENTIFIER_TYPE_VALUE (name
) != global_type_node
)
5185 cp_binding_level
*b
= current_binding_level
;
5188 if (purpose_member (name
, b
->type_shadowed
))
5190 t
= REAL_IDENTIFIER_TYPE_VALUE (name
);
5193 if (b
->kind
== sk_cleanup
)
5200 timevar_stop (TV_NAME_LOOKUP
);
5204 /* [basic.lookup.koenig] */
5205 /* A nonzero return value in the functions below indicates an error. */
5210 vec
<tree
, va_gc
> *args
;
5211 vec
<tree
, va_gc
> *namespaces
;
5212 vec
<tree
, va_gc
> *classes
;
5214 hash_set
<tree
> *fn_set
;
5217 static bool arg_assoc (struct arg_lookup
*, tree
);
5218 static bool arg_assoc_args (struct arg_lookup
*, tree
);
5219 static bool arg_assoc_args_vec (struct arg_lookup
*, vec
<tree
, va_gc
> *);
5220 static bool arg_assoc_type (struct arg_lookup
*, tree
);
5221 static bool add_function (struct arg_lookup
*, tree
);
5222 static bool arg_assoc_namespace (struct arg_lookup
*, tree
);
5223 static bool arg_assoc_class_only (struct arg_lookup
*, tree
);
5224 static bool arg_assoc_bases (struct arg_lookup
*, tree
);
5225 static bool arg_assoc_class (struct arg_lookup
*, tree
);
5226 static bool arg_assoc_template_arg (struct arg_lookup
*, tree
);
5228 /* Add a function to the lookup structure.
5229 Returns true on error. */
5232 add_function (struct arg_lookup
*k
, tree fn
)
5234 if (!is_overloaded_fn (fn
))
5235 /* All names except those of (possibly overloaded) functions and
5236 function templates are ignored. */;
5237 else if (k
->fn_set
&& k
->fn_set
->add (fn
))
5238 /* It's already in the list. */;
5239 else if (!k
->functions
)
5241 else if (fn
== k
->functions
)
5245 k
->functions
= build_overload (fn
, k
->functions
);
5246 if (TREE_CODE (k
->functions
) == OVERLOAD
)
5247 OVL_ARG_DEPENDENT (k
->functions
) = true;
5253 /* Returns true iff CURRENT has declared itself to be an associated
5254 namespace of SCOPE via a strong using-directive (or transitive chain
5255 thereof). Both are namespaces. */
5258 is_associated_namespace (tree current
, tree scope
)
5260 vec
<tree
, va_gc
> *seen
= make_tree_vector ();
5261 vec
<tree
, va_gc
> *todo
= make_tree_vector ();
5267 if (scope
== current
)
5272 vec_safe_push (seen
, scope
);
5273 for (t
= DECL_NAMESPACE_ASSOCIATIONS (scope
); t
; t
= TREE_CHAIN (t
))
5274 if (!vec_member (TREE_PURPOSE (t
), seen
))
5275 vec_safe_push (todo
, TREE_PURPOSE (t
));
5276 if (!todo
->is_empty ())
5278 scope
= todo
->last ();
5288 release_tree_vector (seen
);
5289 release_tree_vector (todo
);
5294 /* Add functions of a namespace to the lookup structure.
5295 Returns true on error. */
5298 arg_assoc_namespace (struct arg_lookup
*k
, tree scope
)
5302 if (vec_member (scope
, k
->namespaces
))
5304 vec_safe_push (k
->namespaces
, scope
);
5306 /* Check out our super-users. */
5307 for (value
= DECL_NAMESPACE_ASSOCIATIONS (scope
); value
;
5308 value
= TREE_CHAIN (value
))
5309 if (arg_assoc_namespace (k
, TREE_PURPOSE (value
)))
5312 /* Also look down into inline namespaces. */
5313 for (value
= DECL_NAMESPACE_USING (scope
); value
;
5314 value
= TREE_CHAIN (value
))
5315 if (is_associated_namespace (scope
, TREE_PURPOSE (value
)))
5316 if (arg_assoc_namespace (k
, TREE_PURPOSE (value
)))
5319 value
= namespace_binding (k
->name
, scope
);
5323 for (; value
; value
= OVL_NEXT (value
))
5325 /* We don't want to find arbitrary hidden functions via argument
5326 dependent lookup. We only want to find friends of associated
5327 classes, which we'll do via arg_assoc_class. */
5328 if (hidden_name_p (OVL_CURRENT (value
)))
5331 if (add_function (k
, OVL_CURRENT (value
)))
5338 /* Adds everything associated with a template argument to the lookup
5339 structure. Returns true on error. */
5342 arg_assoc_template_arg (struct arg_lookup
*k
, tree arg
)
5344 /* [basic.lookup.koenig]
5346 If T is a template-id, its associated namespaces and classes are
5347 ... the namespaces and classes associated with the types of the
5348 template arguments provided for template type parameters
5349 (excluding template template parameters); the namespaces in which
5350 any template template arguments are defined; and the classes in
5351 which any member templates used as template template arguments
5352 are defined. [Note: non-type template arguments do not
5353 contribute to the set of associated namespaces. ] */
5355 /* Consider first template template arguments. */
5356 if (TREE_CODE (arg
) == TEMPLATE_TEMPLATE_PARM
5357 || TREE_CODE (arg
) == UNBOUND_CLASS_TEMPLATE
)
5359 else if (TREE_CODE (arg
) == TEMPLATE_DECL
)
5361 tree ctx
= CP_DECL_CONTEXT (arg
);
5363 /* It's not a member template. */
5364 if (TREE_CODE (ctx
) == NAMESPACE_DECL
)
5365 return arg_assoc_namespace (k
, ctx
);
5366 /* Otherwise, it must be member template. */
5368 return arg_assoc_class_only (k
, ctx
);
5370 /* It's an argument pack; handle it recursively. */
5371 else if (ARGUMENT_PACK_P (arg
))
5373 tree args
= ARGUMENT_PACK_ARGS (arg
);
5374 int i
, len
= TREE_VEC_LENGTH (args
);
5375 for (i
= 0; i
< len
; ++i
)
5376 if (arg_assoc_template_arg (k
, TREE_VEC_ELT (args
, i
)))
5381 /* It's not a template template argument, but it is a type template
5383 else if (TYPE_P (arg
))
5384 return arg_assoc_type (k
, arg
);
5385 /* It's a non-type template argument. */
5390 /* Adds the class and its friends to the lookup structure.
5391 Returns true on error. */
5394 arg_assoc_class_only (struct arg_lookup
*k
, tree type
)
5396 tree list
, friends
, context
;
5398 /* Backend-built structures, such as __builtin_va_list, aren't
5399 affected by all this. */
5400 if (!CLASS_TYPE_P (type
))
5403 context
= decl_namespace_context (type
);
5404 if (arg_assoc_namespace (k
, context
))
5407 complete_type (type
);
5409 /* Process friends. */
5410 for (list
= DECL_FRIENDLIST (TYPE_MAIN_DECL (type
)); list
;
5411 list
= TREE_CHAIN (list
))
5412 if (k
->name
== FRIEND_NAME (list
))
5413 for (friends
= FRIEND_DECLS (list
); friends
;
5414 friends
= TREE_CHAIN (friends
))
5416 tree fn
= TREE_VALUE (friends
);
5418 /* Only interested in global functions with potentially hidden
5419 (i.e. unqualified) declarations. */
5420 if (CP_DECL_CONTEXT (fn
) != context
)
5422 /* Template specializations are never found by name lookup.
5423 (Templates themselves can be found, but not template
5424 specializations.) */
5425 if (TREE_CODE (fn
) == FUNCTION_DECL
&& DECL_USE_TEMPLATE (fn
))
5427 if (add_function (k
, fn
))
5434 /* Adds the class and its bases to the lookup structure.
5435 Returns true on error. */
5438 arg_assoc_bases (struct arg_lookup
*k
, tree type
)
5440 if (arg_assoc_class_only (k
, type
))
5443 if (TYPE_BINFO (type
))
5445 /* Process baseclasses. */
5446 tree binfo
, base_binfo
;
5449 for (binfo
= TYPE_BINFO (type
), i
= 0;
5450 BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); i
++)
5451 if (arg_assoc_bases (k
, BINFO_TYPE (base_binfo
)))
5458 /* Adds everything associated with a class argument type to the lookup
5459 structure. Returns true on error.
5461 If T is a class type (including unions), its associated classes are: the
5462 class itself; the class of which it is a member, if any; and its direct
5463 and indirect base classes. Its associated namespaces are the namespaces
5464 of which its associated classes are members. Furthermore, if T is a
5465 class template specialization, its associated namespaces and classes
5466 also include: the namespaces and classes associated with the types of
5467 the template arguments provided for template type parameters (excluding
5468 template template parameters); the namespaces of which any template
5469 template arguments are members; and the classes of which any member
5470 templates used as template template arguments are members. [ Note:
5471 non-type template arguments do not contribute to the set of associated
5472 namespaces. --end note] */
5475 arg_assoc_class (struct arg_lookup
*k
, tree type
)
5480 /* Backend build structures, such as __builtin_va_list, aren't
5481 affected by all this. */
5482 if (!CLASS_TYPE_P (type
))
5485 if (vec_member (type
, k
->classes
))
5487 vec_safe_push (k
->classes
, type
);
5489 if (TYPE_CLASS_SCOPE_P (type
)
5490 && arg_assoc_class_only (k
, TYPE_CONTEXT (type
)))
5493 if (arg_assoc_bases (k
, type
))
5496 /* Process template arguments. */
5497 if (CLASSTYPE_TEMPLATE_INFO (type
)
5498 && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (type
)))
5500 list
= INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (type
));
5501 for (i
= 0; i
< TREE_VEC_LENGTH (list
); ++i
)
5502 if (arg_assoc_template_arg (k
, TREE_VEC_ELT (list
, i
)))
5509 /* Adds everything associated with a given type.
5510 Returns 1 on error. */
5513 arg_assoc_type (struct arg_lookup
*k
, tree type
)
5515 /* As we do not get the type of non-type dependent expressions
5516 right, we can end up with such things without a type. */
5520 if (TYPE_PTRDATAMEM_P (type
))
5522 /* Pointer to member: associate class type and value type. */
5523 if (arg_assoc_type (k
, TYPE_PTRMEM_CLASS_TYPE (type
)))
5525 return arg_assoc_type (k
, TYPE_PTRMEM_POINTED_TO_TYPE (type
));
5527 else switch (TREE_CODE (type
))
5537 case FIXED_POINT_TYPE
:
5542 if (TYPE_PTRMEMFUNC_P (type
))
5543 return arg_assoc_type (k
, TYPE_PTRMEMFUNC_FN_TYPE (type
));
5545 return arg_assoc_class (k
, type
);
5547 case REFERENCE_TYPE
:
5549 return arg_assoc_type (k
, TREE_TYPE (type
));
5551 if (TYPE_CLASS_SCOPE_P (type
)
5552 && arg_assoc_class_only (k
, TYPE_CONTEXT (type
)))
5554 return arg_assoc_namespace (k
, decl_namespace_context (type
));
5556 /* The basetype is referenced in the first arg type, so just
5559 /* Associate the parameter types. */
5560 if (arg_assoc_args (k
, TYPE_ARG_TYPES (type
)))
5562 /* Associate the return type. */
5563 return arg_assoc_type (k
, TREE_TYPE (type
));
5564 case TEMPLATE_TYPE_PARM
:
5565 case BOUND_TEMPLATE_TEMPLATE_PARM
:
5570 gcc_assert (type
== unknown_type_node
5571 || type
== init_list_type_node
);
5573 case TYPE_PACK_EXPANSION
:
5574 return arg_assoc_type (k
, PACK_EXPANSION_PATTERN (type
));
5582 /* Adds everything associated with arguments. Returns true on error. */
5585 arg_assoc_args (struct arg_lookup
*k
, tree args
)
5587 for (; args
; args
= TREE_CHAIN (args
))
5588 if (arg_assoc (k
, TREE_VALUE (args
)))
5593 /* Adds everything associated with an argument vector. Returns true
5597 arg_assoc_args_vec (struct arg_lookup
*k
, vec
<tree
, va_gc
> *args
)
5602 FOR_EACH_VEC_SAFE_ELT (args
, ix
, arg
)
5603 if (arg_assoc (k
, arg
))
5608 /* Adds everything associated with a given tree_node. Returns 1 on error. */
5611 arg_assoc (struct arg_lookup
*k
, tree n
)
5613 if (n
== error_mark_node
)
5617 return arg_assoc_type (k
, n
);
5619 if (! type_unknown_p (n
))
5620 return arg_assoc_type (k
, TREE_TYPE (n
));
5622 if (TREE_CODE (n
) == ADDR_EXPR
)
5623 n
= TREE_OPERAND (n
, 0);
5624 if (TREE_CODE (n
) == COMPONENT_REF
)
5625 n
= TREE_OPERAND (n
, 1);
5626 if (TREE_CODE (n
) == OFFSET_REF
)
5627 n
= TREE_OPERAND (n
, 1);
5628 while (TREE_CODE (n
) == TREE_LIST
)
5631 n
= BASELINK_FUNCTIONS (n
);
5633 if (TREE_CODE (n
) == FUNCTION_DECL
)
5634 return arg_assoc_type (k
, TREE_TYPE (n
));
5635 if (TREE_CODE (n
) == TEMPLATE_ID_EXPR
)
5637 /* The working paper doesn't currently say how to handle template-id
5638 arguments. The sensible thing would seem to be to handle the list
5639 of template candidates like a normal overload set, and handle the
5640 template arguments like we do for class template
5642 tree templ
= TREE_OPERAND (n
, 0);
5643 tree args
= TREE_OPERAND (n
, 1);
5646 /* First the templates. */
5647 if (arg_assoc (k
, templ
))
5650 /* Now the arguments. */
5652 for (ix
= TREE_VEC_LENGTH (args
); ix
--;)
5653 if (arg_assoc_template_arg (k
, TREE_VEC_ELT (args
, ix
)) == 1)
5656 else if (TREE_CODE (n
) == OVERLOAD
)
5658 for (; n
; n
= OVL_NEXT (n
))
5659 if (arg_assoc_type (k
, TREE_TYPE (OVL_CURRENT (n
))))
5666 /* Performs Koenig lookup depending on arguments, where fns
5667 are the functions found in normal lookup. */
5670 lookup_arg_dependent_1 (tree name
, tree fns
, vec
<tree
, va_gc
> *args
)
5672 struct arg_lookup k
;
5674 /* Remove any hidden friend functions from the list of functions
5675 found so far. They will be added back by arg_assoc_class as
5677 fns
= remove_hidden_names (fns
);
5682 k
.classes
= make_tree_vector ();
5684 /* We previously performed an optimization here by setting
5685 NAMESPACES to the current namespace when it was safe. However, DR
5686 164 says that namespaces that were already searched in the first
5687 stage of template processing are searched again (potentially
5688 picking up later definitions) in the second stage. */
5689 k
.namespaces
= make_tree_vector ();
5691 /* We used to allow duplicates and let joust discard them, but
5692 since the above change for DR 164 we end up with duplicates of
5693 all the functions found by unqualified lookup. So keep track
5694 of which ones we've seen. */
5698 /* We shouldn't be here if lookup found something other than
5699 namespace-scope functions. */
5700 gcc_assert (DECL_NAMESPACE_SCOPE_P (OVL_CURRENT (fns
)));
5701 k
.fn_set
= new hash_set
<tree
>;
5702 for (ovl
= fns
; ovl
; ovl
= OVL_NEXT (ovl
))
5703 k
.fn_set
->add (OVL_CURRENT (ovl
));
5708 arg_assoc_args_vec (&k
, args
);
5714 && !is_overloaded_fn (fns
))
5716 error ("argument dependent lookup finds %q+D", fns
);
5717 error (" in call to %qD", name
);
5718 fns
= error_mark_node
;
5721 release_tree_vector (k
.classes
);
5722 release_tree_vector (k
.namespaces
);
5728 /* Wrapper for lookup_arg_dependent_1. */
5731 lookup_arg_dependent (tree name
, tree fns
, vec
<tree
, va_gc
> *args
)
5735 subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
5736 ret
= lookup_arg_dependent_1 (name
, fns
, args
);
5737 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
5742 /* Add namespace to using_directives. Return NULL_TREE if nothing was
5743 changed (i.e. there was already a directive), or the fresh
5744 TREE_LIST otherwise. */
5747 push_using_directive_1 (tree used
)
5749 tree ud
= current_binding_level
->using_directives
;
5750 tree iter
, ancestor
;
5752 /* Check if we already have this. */
5753 if (purpose_member (used
, ud
) != NULL_TREE
)
5756 ancestor
= namespace_ancestor (current_decl_namespace (), used
);
5757 ud
= current_binding_level
->using_directives
;
5758 ud
= tree_cons (used
, ancestor
, ud
);
5759 current_binding_level
->using_directives
= ud
;
5761 /* Recursively add all namespaces used. */
5762 for (iter
= DECL_NAMESPACE_USING (used
); iter
; iter
= TREE_CHAIN (iter
))
5763 push_using_directive (TREE_PURPOSE (iter
));
5768 /* Wrapper for push_using_directive_1. */
5771 push_using_directive (tree used
)
5774 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
5775 ret
= push_using_directive_1 (used
);
5776 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
5780 /* The type TYPE is being declared. If it is a class template, or a
5781 specialization of a class template, do any processing required and
5782 perform error-checking. If IS_FRIEND is nonzero, this TYPE is
5783 being declared a friend. B is the binding level at which this TYPE
5786 Returns the TYPE_DECL for TYPE, which may have been altered by this
5790 maybe_process_template_type_declaration (tree type
, int is_friend
,
5791 cp_binding_level
*b
)
5793 tree decl
= TYPE_NAME (type
);
5795 if (processing_template_parmlist
)
5796 /* You can't declare a new template type in a template parameter
5797 list. But, you can declare a non-template type:
5799 template <class A*> struct S;
5801 is a forward-declaration of `A'. */
5803 else if (b
->kind
== sk_namespace
5804 && current_binding_level
->kind
!= sk_namespace
)
5805 /* If this new type is being injected into a containing scope,
5806 then it's not a template type. */
5810 gcc_assert (MAYBE_CLASS_TYPE_P (type
)
5811 || TREE_CODE (type
) == ENUMERAL_TYPE
);
5813 if (processing_template_decl
)
5815 /* This may change after the call to
5816 push_template_decl_real, but we want the original value. */
5817 tree name
= DECL_NAME (decl
);
5819 decl
= push_template_decl_real (decl
, is_friend
);
5820 if (decl
== error_mark_node
)
5821 return error_mark_node
;
5823 /* If the current binding level is the binding level for the
5824 template parameters (see the comment in
5825 begin_template_parm_list) and the enclosing level is a class
5826 scope, and we're not looking at a friend, push the
5827 declaration of the member class into the class scope. In the
5828 friend case, push_template_decl will already have put the
5829 friend into global scope, if appropriate. */
5830 if (TREE_CODE (type
) != ENUMERAL_TYPE
5831 && !is_friend
&& b
->kind
== sk_template_parms
5832 && b
->level_chain
->kind
== sk_class
)
5834 finish_member_declaration (CLASSTYPE_TI_TEMPLATE (type
));
5836 if (!COMPLETE_TYPE_P (current_class_type
))
5838 maybe_add_class_template_decl_list (current_class_type
,
5839 type
, /*friend_p=*/0);
5840 /* Put this UTD in the table of UTDs for the class. */
5841 if (CLASSTYPE_NESTED_UTDS (current_class_type
) == NULL
)
5842 CLASSTYPE_NESTED_UTDS (current_class_type
) =
5843 binding_table_new (SCOPE_DEFAULT_HT_SIZE
);
5845 binding_table_insert
5846 (CLASSTYPE_NESTED_UTDS (current_class_type
), name
, type
);
5855 /* Push a tag name NAME for struct/class/union/enum type TYPE. In case
5856 that the NAME is a class template, the tag is processed but not pushed.
5858 The pushed scope depend on the SCOPE parameter:
5859 - When SCOPE is TS_CURRENT, put it into the inner-most non-sk_cleanup
5861 - When SCOPE is TS_GLOBAL, put it in the inner-most non-class and
5862 non-template-parameter scope. This case is needed for forward
5864 - When SCOPE is TS_WITHIN_ENCLOSING_NON_CLASS, this is similar to
5865 TS_GLOBAL case except that names within template-parameter scopes
5866 are not pushed at all.
5868 Returns TYPE upon success and ERROR_MARK_NODE otherwise. */
5871 pushtag_1 (tree name
, tree type
, tag_scope scope
)
5873 cp_binding_level
*b
;
5876 b
= current_binding_level
;
5877 while (/* Cleanup scopes are not scopes from the point of view of
5879 b
->kind
== sk_cleanup
5880 /* Neither are function parameter scopes. */
5881 || b
->kind
== sk_function_parms
5882 /* Neither are the scopes used to hold template parameters
5883 for an explicit specialization. For an ordinary template
5884 declaration, these scopes are not scopes from the point of
5885 view of the language. */
5886 || (b
->kind
== sk_template_parms
5887 && (b
->explicit_spec_p
|| scope
== ts_global
))
5888 || (b
->kind
== sk_class
5889 && (scope
!= ts_current
5890 /* We may be defining a new type in the initializer
5891 of a static member variable. We allow this when
5892 not pedantic, and it is particularly useful for
5893 type punning via an anonymous union. */
5894 || COMPLETE_TYPE_P (b
->this_entity
))))
5897 gcc_assert (identifier_p (name
));
5899 /* Do C++ gratuitous typedefing. */
5900 if (identifier_type_value_1 (name
) != type
)
5904 tree context
= TYPE_CONTEXT (type
);
5908 tree cs
= current_scope ();
5910 if (scope
== ts_current
5911 || (cs
&& TREE_CODE (cs
) == FUNCTION_DECL
))
5913 else if (cs
!= NULL_TREE
&& TYPE_P (cs
))
5914 /* When declaring a friend class of a local class, we want
5915 to inject the newly named class into the scope
5916 containing the local class, not the namespace
5918 context
= decl_function_context (get_type_decl (cs
));
5921 context
= current_namespace
;
5923 if (b
->kind
== sk_class
5924 || (b
->kind
== sk_template_parms
5925 && b
->level_chain
->kind
== sk_class
))
5928 if (current_lang_name
== lang_name_java
)
5929 TYPE_FOR_JAVA (type
) = 1;
5931 tdef
= create_implicit_typedef (name
, type
);
5932 DECL_CONTEXT (tdef
) = FROB_CONTEXT (context
);
5933 if (scope
== ts_within_enclosing_non_class
)
5935 /* This is a friend. Make this TYPE_DECL node hidden from
5936 ordinary name lookup. Its corresponding TEMPLATE_DECL
5937 will be marked in push_template_decl_real. */
5938 retrofit_lang_decl (tdef
);
5939 DECL_ANTICIPATED (tdef
) = 1;
5940 DECL_FRIEND_P (tdef
) = 1;
5943 decl
= maybe_process_template_type_declaration
5944 (type
, scope
== ts_within_enclosing_non_class
, b
);
5945 if (decl
== error_mark_node
)
5948 if (b
->kind
== sk_class
)
5950 if (!TYPE_BEING_DEFINED (current_class_type
))
5951 return error_mark_node
;
5953 if (!PROCESSING_REAL_TEMPLATE_DECL_P ())
5954 /* Put this TYPE_DECL on the TYPE_FIELDS list for the
5955 class. But if it's a member template class, we want
5956 the TEMPLATE_DECL, not the TYPE_DECL, so this is done
5958 finish_member_declaration (decl
);
5960 pushdecl_class_level (decl
);
5962 else if (b
->kind
!= sk_template_parms
)
5964 decl
= pushdecl_with_scope_1 (decl
, b
, /*is_friend=*/false);
5965 if (decl
== error_mark_node
)
5970 set_identifier_type_value_with_scope (name
, tdef
, b
);
5972 TYPE_CONTEXT (type
) = DECL_CONTEXT (decl
);
5974 /* If this is a local class, keep track of it. We need this
5975 information for name-mangling, and so that it is possible to
5976 find all function definitions in a translation unit in a
5977 convenient way. (It's otherwise tricky to find a member
5978 function definition it's only pointed to from within a local
5980 if (TYPE_FUNCTION_SCOPE_P (type
))
5982 if (processing_template_decl
)
5984 /* Push a DECL_EXPR so we call pushtag at the right time in
5985 template instantiation rather than in some nested context. */
5986 add_decl_expr (decl
);
5989 vec_safe_push (local_classes
, type
);
5992 if (b
->kind
== sk_class
5993 && !COMPLETE_TYPE_P (current_class_type
))
5995 maybe_add_class_template_decl_list (current_class_type
,
5996 type
, /*friend_p=*/0);
5998 if (CLASSTYPE_NESTED_UTDS (current_class_type
) == NULL
)
5999 CLASSTYPE_NESTED_UTDS (current_class_type
)
6000 = binding_table_new (SCOPE_DEFAULT_HT_SIZE
);
6002 binding_table_insert
6003 (CLASSTYPE_NESTED_UTDS (current_class_type
), name
, type
);
6006 decl
= TYPE_NAME (type
);
6007 gcc_assert (TREE_CODE (decl
) == TYPE_DECL
);
6009 /* Set type visibility now if this is a forward declaration. */
6010 TREE_PUBLIC (decl
) = 1;
6011 determine_visibility (decl
);
6016 /* Wrapper for pushtag_1. */
6019 pushtag (tree name
, tree type
, tag_scope scope
)
6022 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
6023 ret
= pushtag_1 (name
, type
, scope
);
6024 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
6028 /* Subroutines for reverting temporarily to top-level for instantiation
6029 of templates and such. We actually need to clear out the class- and
6030 local-value slots of all identifiers, so that only the global values
6031 are at all visible. Simply setting current_binding_level to the global
6032 scope isn't enough, because more binding levels may be pushed. */
6033 struct saved_scope
*scope_chain
;
6035 /* Return true if ID has not already been marked. */
6038 store_binding_p (tree id
)
6040 if (!id
|| !IDENTIFIER_BINDING (id
))
6043 if (IDENTIFIER_MARKED (id
))
6049 /* Add an appropriate binding to *OLD_BINDINGS which needs to already
6050 have enough space reserved. */
6053 store_binding (tree id
, vec
<cxx_saved_binding
, va_gc
> **old_bindings
)
6055 cxx_saved_binding saved
;
6057 gcc_checking_assert (store_binding_p (id
));
6059 IDENTIFIER_MARKED (id
) = 1;
6061 saved
.identifier
= id
;
6062 saved
.binding
= IDENTIFIER_BINDING (id
);
6063 saved
.real_type_value
= REAL_IDENTIFIER_TYPE_VALUE (id
);
6064 (*old_bindings
)->quick_push (saved
);
6065 IDENTIFIER_BINDING (id
) = NULL
;
6069 store_bindings (tree names
, vec
<cxx_saved_binding
, va_gc
> **old_bindings
)
6071 static vec
<tree
> bindings_need_stored
= vNULL
;
6075 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
6076 for (t
= names
; t
; t
= TREE_CHAIN (t
))
6078 if (TREE_CODE (t
) == TREE_LIST
)
6079 id
= TREE_PURPOSE (t
);
6083 if (store_binding_p (id
))
6084 bindings_need_stored
.safe_push (id
);
6086 if (!bindings_need_stored
.is_empty ())
6088 vec_safe_reserve_exact (*old_bindings
, bindings_need_stored
.length ());
6089 for (i
= 0; bindings_need_stored
.iterate (i
, &id
); ++i
)
6091 /* We can appearantly have duplicates in NAMES. */
6092 if (store_binding_p (id
))
6093 store_binding (id
, old_bindings
);
6095 bindings_need_stored
.truncate (0);
6097 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
6100 /* Like store_bindings, but NAMES is a vector of cp_class_binding
6101 objects, rather than a TREE_LIST. */
6104 store_class_bindings (vec
<cp_class_binding
, va_gc
> *names
,
6105 vec
<cxx_saved_binding
, va_gc
> **old_bindings
)
6107 static vec
<tree
> bindings_need_stored
= vNULL
;
6109 cp_class_binding
*cb
;
6111 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
6112 for (i
= 0; vec_safe_iterate (names
, i
, &cb
); ++i
)
6113 if (store_binding_p (cb
->identifier
))
6114 bindings_need_stored
.safe_push (cb
->identifier
);
6115 if (!bindings_need_stored
.is_empty ())
6118 vec_safe_reserve_exact (*old_bindings
, bindings_need_stored
.length ());
6119 for (i
= 0; bindings_need_stored
.iterate (i
, &id
); ++i
)
6120 store_binding (id
, old_bindings
);
6121 bindings_need_stored
.truncate (0);
6123 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
6127 push_to_top_level (void)
6129 struct saved_scope
*s
;
6130 cp_binding_level
*b
;
6131 cxx_saved_binding
*sb
;
6135 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
6136 s
= ggc_cleared_alloc
<saved_scope
> ();
6138 b
= scope_chain
? current_binding_level
: 0;
6140 /* If we're in the middle of some function, save our state. */
6144 push_function_context ();
6149 if (scope_chain
&& previous_class_level
)
6150 store_class_bindings (previous_class_level
->class_shadowed
,
6153 /* Have to include the global scope, because class-scope decls
6154 aren't listed anywhere useful. */
6155 for (; b
; b
= b
->level_chain
)
6159 /* Template IDs are inserted into the global level. If they were
6160 inserted into namespace level, finish_file wouldn't find them
6161 when doing pending instantiations. Therefore, don't stop at
6162 namespace level, but continue until :: . */
6163 if (global_scope_p (b
))
6166 store_bindings (b
->names
, &s
->old_bindings
);
6167 /* We also need to check class_shadowed to save class-level type
6168 bindings, since pushclass doesn't fill in b->names. */
6169 if (b
->kind
== sk_class
)
6170 store_class_bindings (b
->class_shadowed
, &s
->old_bindings
);
6172 /* Unwind type-value slots back to top level. */
6173 for (t
= b
->type_shadowed
; t
; t
= TREE_CHAIN (t
))
6174 SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (t
), TREE_VALUE (t
));
6177 FOR_EACH_VEC_SAFE_ELT (s
->old_bindings
, i
, sb
)
6178 IDENTIFIER_MARKED (sb
->identifier
) = 0;
6180 s
->prev
= scope_chain
;
6182 s
->need_pop_function_context
= need_pop
;
6183 s
->function_decl
= current_function_decl
;
6184 s
->unevaluated_operand
= cp_unevaluated_operand
;
6185 s
->inhibit_evaluation_warnings
= c_inhibit_evaluation_warnings
;
6186 s
->x_stmt_tree
.stmts_are_full_exprs_p
= true;
6189 current_function_decl
= NULL_TREE
;
6190 vec_alloc (current_lang_base
, 10);
6191 current_lang_name
= lang_name_cplusplus
;
6192 current_namespace
= global_namespace
;
6193 push_class_stack ();
6194 cp_unevaluated_operand
= 0;
6195 c_inhibit_evaluation_warnings
= 0;
6196 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
6200 pop_from_top_level_1 (void)
6202 struct saved_scope
*s
= scope_chain
;
6203 cxx_saved_binding
*saved
;
6206 /* Clear out class-level bindings cache. */
6207 if (previous_class_level
)
6208 invalidate_class_lookup_cache ();
6211 current_lang_base
= 0;
6213 scope_chain
= s
->prev
;
6214 FOR_EACH_VEC_SAFE_ELT (s
->old_bindings
, i
, saved
)
6216 tree id
= saved
->identifier
;
6218 IDENTIFIER_BINDING (id
) = saved
->binding
;
6219 SET_IDENTIFIER_TYPE_VALUE (id
, saved
->real_type_value
);
6222 /* If we were in the middle of compiling a function, restore our
6224 if (s
->need_pop_function_context
)
6225 pop_function_context ();
6226 current_function_decl
= s
->function_decl
;
6227 cp_unevaluated_operand
= s
->unevaluated_operand
;
6228 c_inhibit_evaluation_warnings
= s
->inhibit_evaluation_warnings
;
6231 /* Wrapper for pop_from_top_level_1. */
6234 pop_from_top_level (void)
6236 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
6237 pop_from_top_level_1 ();
6238 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
6242 /* Pop off extraneous binding levels left over due to syntax errors.
6244 We don't pop past namespaces, as they might be valid. */
6247 pop_everything (void)
6249 if (ENABLE_SCOPE_CHECKING
)
6250 verbatim ("XXX entering pop_everything ()\n");
6251 while (!toplevel_bindings_p ())
6253 if (current_binding_level
->kind
== sk_class
)
6254 pop_nested_class ();
6258 if (ENABLE_SCOPE_CHECKING
)
6259 verbatim ("XXX leaving pop_everything ()\n");
6262 /* Emit debugging information for using declarations and directives.
6263 If input tree is overloaded fn then emit debug info for all
6267 cp_emit_debug_info_for_using (tree t
, tree context
)
6269 /* Don't try to emit any debug information if we have errors. */
6273 /* Ignore this FUNCTION_DECL if it refers to a builtin declaration
6274 of a builtin function. */
6275 if (TREE_CODE (t
) == FUNCTION_DECL
6276 && DECL_EXTERNAL (t
)
6277 && DECL_BUILT_IN (t
))
6280 /* Do not supply context to imported_module_or_decl, if
6281 it is a global namespace. */
6282 if (context
== global_namespace
)
6283 context
= NULL_TREE
;
6286 t
= BASELINK_FUNCTIONS (t
);
6288 /* FIXME: Handle TEMPLATE_DECLs. */
6289 for (t
= OVL_CURRENT (t
); t
; t
= OVL_NEXT (t
))
6290 if (TREE_CODE (t
) != TEMPLATE_DECL
)
6292 if (building_stmt_list_p ())
6293 add_stmt (build_stmt (input_location
, USING_STMT
, t
));
6295 (*debug_hooks
->imported_module_or_decl
) (t
, NULL_TREE
, context
, false);
6299 #include "gt-cp-name-lookup.h"