Update gcc-50 to SVN version 221572
[dragonfly.git] / contrib / gcc-5.0 / gcc / cp / name-lookup.c
CommitLineData
dda118e3
JM
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>
4
5This file is part of GCC.
6
7GCC is free software; you can redistribute it and/or modify
8it under the terms of the GNU General Public License as published by
9the Free Software Foundation; either version 3, or (at your option)
10any later version.
11
12GCC is distributed in the hope that it will be useful,
13but WITHOUT ANY WARRANTY; without even the implied warranty of
14MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15GNU General Public License for more details.
16
17You should have received a copy of the GNU General Public License
18along with GCC; see the file COPYING3. If not see
19<http://www.gnu.org/licenses/>. */
20
21#include "config.h"
22#include "system.h"
23#include "coretypes.h"
24#include "tm.h"
25#include "flags.h"
26#include "hash-set.h"
27#include "machmode.h"
28#include "vec.h"
29#include "double-int.h"
30#include "input.h"
31#include "alias.h"
32#include "symtab.h"
33#include "wide-int.h"
34#include "inchash.h"
35#include "tree.h"
36#include "stringpool.h"
37#include "print-tree.h"
38#include "attribs.h"
39#include "cp-tree.h"
40#include "name-lookup.h"
41#include "timevar.h"
42#include "diagnostic-core.h"
43#include "intl.h"
44#include "debug.h"
45#include "c-family/c-pragma.h"
46#include "params.h"
47
48/* The bindings for a particular name in a particular scope. */
49
50struct scope_binding {
51 tree value;
52 tree type;
53};
54#define EMPTY_SCOPE_BINDING { NULL_TREE, NULL_TREE }
55
56static cp_binding_level *innermost_nonclass_level (void);
57static cxx_binding *binding_for_name (cp_binding_level *, tree);
58static tree push_overloaded_decl (tree, int, bool);
59static bool lookup_using_namespace (tree, struct scope_binding *, tree,
60 tree, int);
61static bool qualified_lookup_using_namespace (tree, tree,
62 struct scope_binding *, int);
63static tree lookup_type_current_level (tree);
64static tree push_using_directive (tree);
65static tree lookup_extern_c_fun_in_all_ns (tree);
66static void diagnose_name_conflict (tree, tree);
67
68/* The :: namespace. */
69
70tree global_namespace;
71
72/* The name of the anonymous namespace, throughout this translation
73 unit. */
74static GTY(()) tree anonymous_namespace_name;
75
76/* Initialize anonymous_namespace_name if necessary, and return it. */
77
78static tree
79get_anonymous_namespace_name (void)
80{
81 if (!anonymous_namespace_name)
82 {
83 /* We used to use get_file_function_name here, but that isn't
84 necessary now that anonymous namespace typeinfos
85 are !TREE_PUBLIC, and thus compared by address. */
86 /* The demangler expects anonymous namespaces to be called
87 something starting with '_GLOBAL__N_'. */
88 anonymous_namespace_name = get_identifier ("_GLOBAL__N_1");
89 }
90 return anonymous_namespace_name;
91}
92
93/* Compute the chain index of a binding_entry given the HASH value of its
94 name and the total COUNT of chains. COUNT is assumed to be a power
95 of 2. */
96
97#define ENTRY_INDEX(HASH, COUNT) (((HASH) >> 3) & ((COUNT) - 1))
98
99/* A free list of "binding_entry"s awaiting for re-use. */
100
101static GTY((deletable)) binding_entry free_binding_entry = NULL;
102
103/* Create a binding_entry object for (NAME, TYPE). */
104
105static inline binding_entry
106binding_entry_make (tree name, tree type)
107{
108 binding_entry entry;
109
110 if (free_binding_entry)
111 {
112 entry = free_binding_entry;
113 free_binding_entry = entry->chain;
114 }
115 else
116 entry = ggc_alloc<binding_entry_s> ();
117
118 entry->name = name;
119 entry->type = type;
120 entry->chain = NULL;
121
122 return entry;
123}
124
125/* Put ENTRY back on the free list. */
126#if 0
127static inline void
128binding_entry_free (binding_entry entry)
129{
130 entry->name = NULL;
131 entry->type = NULL;
132 entry->chain = free_binding_entry;
133 free_binding_entry = entry;
134}
135#endif
136
137/* The datatype used to implement the mapping from names to types at
138 a given scope. */
139struct GTY(()) binding_table_s {
140 /* Array of chains of "binding_entry"s */
141 binding_entry * GTY((length ("%h.chain_count"))) chain;
142
143 /* The number of chains in this table. This is the length of the
144 member "chain" considered as an array. */
145 size_t chain_count;
146
147 /* Number of "binding_entry"s in this table. */
148 size_t entry_count;
149};
150
151/* Construct TABLE with an initial CHAIN_COUNT. */
152
153static inline void
154binding_table_construct (binding_table table, size_t chain_count)
155{
156 table->chain_count = chain_count;
157 table->entry_count = 0;
158 table->chain = ggc_cleared_vec_alloc<binding_entry> (table->chain_count);
159}
160
161/* Make TABLE's entries ready for reuse. */
162#if 0
163static void
164binding_table_free (binding_table table)
165{
166 size_t i;
167 size_t count;
168
169 if (table == NULL)
170 return;
171
172 for (i = 0, count = table->chain_count; i < count; ++i)
173 {
174 binding_entry temp = table->chain[i];
175 while (temp != NULL)
176 {
177 binding_entry entry = temp;
178 temp = entry->chain;
179 binding_entry_free (entry);
180 }
181 table->chain[i] = NULL;
182 }
183 table->entry_count = 0;
184}
185#endif
186
187/* Allocate a table with CHAIN_COUNT, assumed to be a power of two. */
188
189static inline binding_table
190binding_table_new (size_t chain_count)
191{
192 binding_table table = ggc_alloc<binding_table_s> ();
193 table->chain = NULL;
194 binding_table_construct (table, chain_count);
195 return table;
196}
197
198/* Expand TABLE to twice its current chain_count. */
199
200static void
201binding_table_expand (binding_table table)
202{
203 const size_t old_chain_count = table->chain_count;
204 const size_t old_entry_count = table->entry_count;
205 const size_t new_chain_count = 2 * old_chain_count;
206 binding_entry *old_chains = table->chain;
207 size_t i;
208
209 binding_table_construct (table, new_chain_count);
210 for (i = 0; i < old_chain_count; ++i)
211 {
212 binding_entry entry = old_chains[i];
213 for (; entry != NULL; entry = old_chains[i])
214 {
215 const unsigned int hash = IDENTIFIER_HASH_VALUE (entry->name);
216 const size_t j = ENTRY_INDEX (hash, new_chain_count);
217
218 old_chains[i] = entry->chain;
219 entry->chain = table->chain[j];
220 table->chain[j] = entry;
221 }
222 }
223 table->entry_count = old_entry_count;
224}
225
226/* Insert a binding for NAME to TYPE into TABLE. */
227
228static void
229binding_table_insert (binding_table table, tree name, tree type)
230{
231 const unsigned int hash = IDENTIFIER_HASH_VALUE (name);
232 const size_t i = ENTRY_INDEX (hash, table->chain_count);
233 binding_entry entry = binding_entry_make (name, type);
234
235 entry->chain = table->chain[i];
236 table->chain[i] = entry;
237 ++table->entry_count;
238
239 if (3 * table->chain_count < 5 * table->entry_count)
240 binding_table_expand (table);
241}
242
243/* Return the binding_entry, if any, that maps NAME. */
244
245binding_entry
246binding_table_find (binding_table table, tree name)
247{
248 const unsigned int hash = IDENTIFIER_HASH_VALUE (name);
249 binding_entry entry = table->chain[ENTRY_INDEX (hash, table->chain_count)];
250
251 while (entry != NULL && entry->name != name)
252 entry = entry->chain;
253
254 return entry;
255}
256
257/* Apply PROC -- with DATA -- to all entries in TABLE. */
258
259void
260binding_table_foreach (binding_table table, bt_foreach_proc proc, void *data)
261{
262 size_t chain_count;
263 size_t i;
264
265 if (!table)
266 return;
267
268 chain_count = table->chain_count;
269 for (i = 0; i < chain_count; ++i)
270 {
271 binding_entry entry = table->chain[i];
272 for (; entry != NULL; entry = entry->chain)
273 proc (entry, data);
274 }
275}
276\f
277#ifndef ENABLE_SCOPE_CHECKING
278# define ENABLE_SCOPE_CHECKING 0
279#else
280# define ENABLE_SCOPE_CHECKING 1
281#endif
282
283/* A free list of "cxx_binding"s, connected by their PREVIOUS. */
284
285static GTY((deletable)) cxx_binding *free_bindings;
286
287/* Initialize VALUE and TYPE field for BINDING, and set the PREVIOUS
288 field to NULL. */
289
290static inline void
291cxx_binding_init (cxx_binding *binding, tree value, tree type)
292{
293 binding->value = value;
294 binding->type = type;
295 binding->previous = NULL;
296}
297
298/* (GC)-allocate a binding object with VALUE and TYPE member initialized. */
299
300static cxx_binding *
301cxx_binding_make (tree value, tree type)
302{
303 cxx_binding *binding;
304 if (free_bindings)
305 {
306 binding = free_bindings;
307 free_bindings = binding->previous;
308 }
309 else
310 binding = ggc_alloc<cxx_binding> ();
311
312 cxx_binding_init (binding, value, type);
313
314 return binding;
315}
316
317/* Put BINDING back on the free list. */
318
319static inline void
320cxx_binding_free (cxx_binding *binding)
321{
322 binding->scope = NULL;
323 binding->previous = free_bindings;
324 free_bindings = binding;
325}
326
327/* Create a new binding for NAME (with the indicated VALUE and TYPE
328 bindings) in the class scope indicated by SCOPE. */
329
330static cxx_binding *
331new_class_binding (tree name, tree value, tree type, cp_binding_level *scope)
332{
333 cp_class_binding cb = {cxx_binding_make (value, type), name};
334 cxx_binding *binding = cb.base;
335 vec_safe_push (scope->class_shadowed, cb);
336 binding->scope = scope;
337 return binding;
338}
339
340/* Make DECL the innermost binding for ID. The LEVEL is the binding
341 level at which this declaration is being bound. */
342
343static void
344push_binding (tree id, tree decl, cp_binding_level* level)
345{
346 cxx_binding *binding;
347
348 if (level != class_binding_level)
349 {
350 binding = cxx_binding_make (decl, NULL_TREE);
351 binding->scope = level;
352 }
353 else
354 binding = new_class_binding (id, decl, /*type=*/NULL_TREE, level);
355
356 /* Now, fill in the binding information. */
357 binding->previous = IDENTIFIER_BINDING (id);
358 INHERITED_VALUE_BINDING_P (binding) = 0;
359 LOCAL_BINDING_P (binding) = (level != class_binding_level);
360
361 /* And put it on the front of the list of bindings for ID. */
362 IDENTIFIER_BINDING (id) = binding;
363}
364
365/* Remove the binding for DECL which should be the innermost binding
366 for ID. */
367
368void
369pop_binding (tree id, tree decl)
370{
371 cxx_binding *binding;
372
373 if (id == NULL_TREE)
374 /* It's easiest to write the loops that call this function without
375 checking whether or not the entities involved have names. We
376 get here for such an entity. */
377 return;
378
379 /* Get the innermost binding for ID. */
380 binding = IDENTIFIER_BINDING (id);
381
382 /* The name should be bound. */
383 gcc_assert (binding != NULL);
384
385 /* The DECL will be either the ordinary binding or the type
386 binding for this identifier. Remove that binding. */
387 if (binding->value == decl)
388 binding->value = NULL_TREE;
389 else
390 {
391 gcc_assert (binding->type == decl);
392 binding->type = NULL_TREE;
393 }
394
395 if (!binding->value && !binding->type)
396 {
397 /* We're completely done with the innermost binding for this
398 identifier. Unhook it from the list of bindings. */
399 IDENTIFIER_BINDING (id) = binding->previous;
400
401 /* Add it to the free list. */
402 cxx_binding_free (binding);
403 }
404}
405
406/* Remove the bindings for the decls of the current level and leave
407 the current scope. */
408
409void
410pop_bindings_and_leave_scope (void)
411{
412 for (tree t = getdecls (); t; t = DECL_CHAIN (t))
413 pop_binding (DECL_NAME (t), t);
414 leave_scope ();
415}
416
417/* Strip non dependent using declarations. If DECL is dependent,
418 surreptitiously create a typename_type and return it. */
419
420tree
421strip_using_decl (tree decl)
422{
423 if (decl == NULL_TREE)
424 return NULL_TREE;
425
426 while (TREE_CODE (decl) == USING_DECL && !DECL_DEPENDENT_P (decl))
427 decl = USING_DECL_DECLS (decl);
428
429 if (TREE_CODE (decl) == USING_DECL && DECL_DEPENDENT_P (decl)
430 && USING_DECL_TYPENAME_P (decl))
431 {
432 /* We have found a type introduced by a using
433 declaration at class scope that refers to a dependent
434 type.
435
436 using typename :: [opt] nested-name-specifier unqualified-id ;
437 */
438 decl = make_typename_type (TREE_TYPE (decl),
439 DECL_NAME (decl),
440 typename_type, tf_error);
441 if (decl != error_mark_node)
442 decl = TYPE_NAME (decl);
443 }
444
445 return decl;
446}
447
448/* BINDING records an existing declaration for a name in the current scope.
449 But, DECL is another declaration for that same identifier in the
450 same scope. This is the `struct stat' hack whereby a non-typedef
451 class name or enum-name can be bound at the same level as some other
452 kind of entity.
453 3.3.7/1
454
455 A class name (9.1) or enumeration name (7.2) can be hidden by the
456 name of an object, function, or enumerator declared in the same scope.
457 If a class or enumeration name and an object, function, or enumerator
458 are declared in the same scope (in any order) with the same name, the
459 class or enumeration name is hidden wherever the object, function, or
460 enumerator name is visible.
461
462 It's the responsibility of the caller to check that
463 inserting this name is valid here. Returns nonzero if the new binding
464 was successful. */
465
466static bool
467supplement_binding_1 (cxx_binding *binding, tree decl)
468{
469 tree bval = binding->value;
470 bool ok = true;
471 tree target_bval = strip_using_decl (bval);
472 tree target_decl = strip_using_decl (decl);
473
474 if (TREE_CODE (target_decl) == TYPE_DECL && DECL_ARTIFICIAL (target_decl)
475 && target_decl != target_bval
476 && (TREE_CODE (target_bval) != TYPE_DECL
477 /* We allow pushing an enum multiple times in a class
478 template in order to handle late matching of underlying
479 type on an opaque-enum-declaration followed by an
480 enum-specifier. */
481 || (processing_template_decl
482 && TREE_CODE (TREE_TYPE (target_decl)) == ENUMERAL_TYPE
483 && TREE_CODE (TREE_TYPE (target_bval)) == ENUMERAL_TYPE
484 && (dependent_type_p (ENUM_UNDERLYING_TYPE
485 (TREE_TYPE (target_decl)))
486 || dependent_type_p (ENUM_UNDERLYING_TYPE
487 (TREE_TYPE (target_bval)))))))
488 /* The new name is the type name. */
489 binding->type = decl;
490 else if (/* TARGET_BVAL is null when push_class_level_binding moves
491 an inherited type-binding out of the way to make room
492 for a new value binding. */
493 !target_bval
494 /* TARGET_BVAL is error_mark_node when TARGET_DECL's name
495 has been used in a non-class scope prior declaration.
496 In that case, we should have already issued a
497 diagnostic; for graceful error recovery purpose, pretend
498 this was the intended declaration for that name. */
499 || target_bval == error_mark_node
500 /* If TARGET_BVAL is anticipated but has not yet been
501 declared, pretend it is not there at all. */
502 || (TREE_CODE (target_bval) == FUNCTION_DECL
503 && DECL_ANTICIPATED (target_bval)
504 && !DECL_HIDDEN_FRIEND_P (target_bval)))
505 binding->value = decl;
506 else if (TREE_CODE (target_bval) == TYPE_DECL
507 && DECL_ARTIFICIAL (target_bval)
508 && target_decl != target_bval
509 && (TREE_CODE (target_decl) != TYPE_DECL
510 || same_type_p (TREE_TYPE (target_decl),
511 TREE_TYPE (target_bval))))
512 {
513 /* The old binding was a type name. It was placed in
514 VALUE field because it was thought, at the point it was
515 declared, to be the only entity with such a name. Move the
516 type name into the type slot; it is now hidden by the new
517 binding. */
518 binding->type = bval;
519 binding->value = decl;
520 binding->value_is_inherited = false;
521 }
522 else if (TREE_CODE (target_bval) == TYPE_DECL
523 && TREE_CODE (target_decl) == TYPE_DECL
524 && DECL_NAME (target_decl) == DECL_NAME (target_bval)
525 && binding->scope->kind != sk_class
526 && (same_type_p (TREE_TYPE (target_decl), TREE_TYPE (target_bval))
527 /* If either type involves template parameters, we must
528 wait until instantiation. */
529 || uses_template_parms (TREE_TYPE (target_decl))
530 || uses_template_parms (TREE_TYPE (target_bval))))
531 /* We have two typedef-names, both naming the same type to have
532 the same name. In general, this is OK because of:
533
534 [dcl.typedef]
535
536 In a given scope, a typedef specifier can be used to redefine
537 the name of any type declared in that scope to refer to the
538 type to which it already refers.
539
540 However, in class scopes, this rule does not apply due to the
541 stricter language in [class.mem] prohibiting redeclarations of
542 members. */
543 ok = false;
544 /* There can be two block-scope declarations of the same variable,
545 so long as they are `extern' declarations. However, there cannot
546 be two declarations of the same static data member:
547
548 [class.mem]
549
550 A member shall not be declared twice in the
551 member-specification. */
552 else if (VAR_P (target_decl)
553 && VAR_P (target_bval)
554 && DECL_EXTERNAL (target_decl) && DECL_EXTERNAL (target_bval)
555 && !DECL_CLASS_SCOPE_P (target_decl))
556 {
557 duplicate_decls (decl, binding->value, /*newdecl_is_friend=*/false);
558 ok = false;
559 }
560 else if (TREE_CODE (decl) == NAMESPACE_DECL
561 && TREE_CODE (bval) == NAMESPACE_DECL
562 && DECL_NAMESPACE_ALIAS (decl)
563 && DECL_NAMESPACE_ALIAS (bval)
564 && ORIGINAL_NAMESPACE (bval) == ORIGINAL_NAMESPACE (decl))
565 /* [namespace.alias]
566
567 In a declarative region, a namespace-alias-definition can be
568 used to redefine a namespace-alias declared in that declarative
569 region to refer only to the namespace to which it already
570 refers. */
571 ok = false;
572 else if (maybe_remove_implicit_alias (bval))
573 {
574 /* There was a mangling compatibility alias using this mangled name,
575 but now we have a real decl that wants to use it instead. */
576 binding->value = decl;
577 }
578 else
579 {
580 diagnose_name_conflict (decl, bval);
581 ok = false;
582 }
583
584 return ok;
585}
586
587/* Diagnose a name conflict between DECL and BVAL. */
588
589static void
590diagnose_name_conflict (tree decl, tree bval)
591{
592 if (TREE_CODE (decl) == TREE_CODE (bval)
593 && (TREE_CODE (decl) != TYPE_DECL
594 || (DECL_ARTIFICIAL (decl) && DECL_ARTIFICIAL (bval))
595 || (!DECL_ARTIFICIAL (decl) && !DECL_ARTIFICIAL (bval)))
596 && !is_overloaded_fn (decl))
597 error ("redeclaration of %q#D", decl);
598 else
599 error ("%q#D conflicts with a previous declaration", decl);
600
601 inform (input_location, "previous declaration %q+#D", bval);
602}
603
604/* Wrapper for supplement_binding_1. */
605
606static bool
607supplement_binding (cxx_binding *binding, tree decl)
608{
609 bool ret;
610 bool subtime = timevar_cond_start (TV_NAME_LOOKUP);
611 ret = supplement_binding_1 (binding, decl);
612 timevar_cond_stop (TV_NAME_LOOKUP, subtime);
613 return ret;
614}
615
616/* Add DECL to the list of things declared in B. */
617
618static void
619add_decl_to_level (tree decl, cp_binding_level *b)
620{
621 /* We used to record virtual tables as if they were ordinary
622 variables, but no longer do so. */
623 gcc_assert (!(VAR_P (decl) && DECL_VIRTUAL_P (decl)));
624
625 if (TREE_CODE (decl) == NAMESPACE_DECL
626 && !DECL_NAMESPACE_ALIAS (decl))
627 {
628 DECL_CHAIN (decl) = b->namespaces;
629 b->namespaces = decl;
630 }
631 else
632 {
633 /* We build up the list in reverse order, and reverse it later if
634 necessary. */
635 TREE_CHAIN (decl) = b->names;
636 b->names = decl;
637
638 /* If appropriate, add decl to separate list of statics. We
639 include extern variables because they might turn out to be
640 static later. It's OK for this list to contain a few false
641 positives. */
642 if (b->kind == sk_namespace)
643 if ((VAR_P (decl)
644 && (TREE_STATIC (decl) || DECL_EXTERNAL (decl)))
645 || (TREE_CODE (decl) == FUNCTION_DECL
646 && (!TREE_PUBLIC (decl)
647 || decl_anon_ns_mem_p (decl)
648 || DECL_DECLARED_INLINE_P (decl))))
649 vec_safe_push (b->static_decls, decl);
650 }
651}
652
653/* Record a decl-node X as belonging to the current lexical scope.
654 Check for errors (such as an incompatible declaration for the same
655 name already seen in the same scope). IS_FRIEND is true if X is
656 declared as a friend.
657
658 Returns either X or an old decl for the same name.
659 If an old decl is returned, it may have been smashed
660 to agree with what X says. */
661
662static tree
663pushdecl_maybe_friend_1 (tree x, bool is_friend)
664{
665 tree t;
666 tree name;
667 int need_new_binding;
668
669 if (x == error_mark_node)
670 return error_mark_node;
671
672 need_new_binding = 1;
673
674 if (DECL_TEMPLATE_PARM_P (x))
675 /* Template parameters have no context; they are not X::T even
676 when declared within a class or namespace. */
677 ;
678 else
679 {
680 if (current_function_decl && x != current_function_decl
681 /* A local declaration for a function doesn't constitute
682 nesting. */
683 && TREE_CODE (x) != FUNCTION_DECL
684 /* A local declaration for an `extern' variable is in the
685 scope of the current namespace, not the current
686 function. */
687 && !(VAR_P (x) && DECL_EXTERNAL (x))
688 /* When parsing the parameter list of a function declarator,
689 don't set DECL_CONTEXT to an enclosing function. When we
690 push the PARM_DECLs in order to process the function body,
691 current_binding_level->this_entity will be set. */
692 && !(TREE_CODE (x) == PARM_DECL
693 && current_binding_level->kind == sk_function_parms
694 && current_binding_level->this_entity == NULL)
695 && !DECL_CONTEXT (x))
696 DECL_CONTEXT (x) = current_function_decl;
697
698 /* If this is the declaration for a namespace-scope function,
699 but the declaration itself is in a local scope, mark the
700 declaration. */
701 if (TREE_CODE (x) == FUNCTION_DECL
702 && DECL_NAMESPACE_SCOPE_P (x)
703 && current_function_decl
704 && x != current_function_decl)
705 DECL_LOCAL_FUNCTION_P (x) = 1;
706 }
707
708 name = DECL_NAME (x);
709 if (name)
710 {
711 int different_binding_level = 0;
712
713 if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
714 name = TREE_OPERAND (name, 0);
715
716 /* In case this decl was explicitly namespace-qualified, look it
717 up in its namespace context. */
718 if (DECL_NAMESPACE_SCOPE_P (x) && namespace_bindings_p ())
719 t = namespace_binding (name, DECL_CONTEXT (x));
720 else
721 t = lookup_name_innermost_nonclass_level (name);
722
723 /* [basic.link] If there is a visible declaration of an entity
724 with linkage having the same name and type, ignoring entities
725 declared outside the innermost enclosing namespace scope, the
726 block scope declaration declares that same entity and
727 receives the linkage of the previous declaration. */
728 if (! t && current_function_decl && x != current_function_decl
729 && VAR_OR_FUNCTION_DECL_P (x)
730 && DECL_EXTERNAL (x))
731 {
732 /* Look in block scope. */
733 t = innermost_non_namespace_value (name);
734 /* Or in the innermost namespace. */
735 if (! t)
736 t = namespace_binding (name, DECL_CONTEXT (x));
737 /* Does it have linkage? Note that if this isn't a DECL, it's an
738 OVERLOAD, which is OK. */
739 if (t && DECL_P (t) && ! (TREE_STATIC (t) || DECL_EXTERNAL (t)))
740 t = NULL_TREE;
741 if (t)
742 different_binding_level = 1;
743 }
744
745 /* If we are declaring a function, and the result of name-lookup
746 was an OVERLOAD, look for an overloaded instance that is
747 actually the same as the function we are declaring. (If
748 there is one, we have to merge our declaration with the
749 previous declaration.) */
750 if (t && TREE_CODE (t) == OVERLOAD)
751 {
752 tree match;
753
754 if (TREE_CODE (x) == FUNCTION_DECL)
755 for (match = t; match; match = OVL_NEXT (match))
756 {
757 if (decls_match (OVL_CURRENT (match), x))
758 break;
759 }
760 else
761 /* Just choose one. */
762 match = t;
763
764 if (match)
765 t = OVL_CURRENT (match);
766 else
767 t = NULL_TREE;
768 }
769
770 if (t && t != error_mark_node)
771 {
772 if (different_binding_level)
773 {
774 if (decls_match (x, t))
775 /* The standard only says that the local extern
776 inherits linkage from the previous decl; in
777 particular, default args are not shared. Add
778 the decl into a hash table to make sure only
779 the previous decl in this case is seen by the
780 middle end. */
781 {
782 struct cxx_int_tree_map *h;
783
784 TREE_PUBLIC (x) = TREE_PUBLIC (t);
785
786 if (cp_function_chain->extern_decl_map == NULL)
787 cp_function_chain->extern_decl_map
788 = hash_table<cxx_int_tree_map_hasher>::create_ggc (20);
789
790 h = ggc_alloc<cxx_int_tree_map> ();
791 h->uid = DECL_UID (x);
792 h->to = t;
793 cxx_int_tree_map **loc = cp_function_chain->extern_decl_map
794 ->find_slot (h, INSERT);
795 *loc = h;
796 }
797 }
798 else if (TREE_CODE (t) == PARM_DECL)
799 {
800 /* Check for duplicate params. */
801 tree d = duplicate_decls (x, t, is_friend);
802 if (d)
803 return d;
804 }
805 else if ((DECL_EXTERN_C_FUNCTION_P (x)
806 || DECL_FUNCTION_TEMPLATE_P (x))
807 && is_overloaded_fn (t))
808 /* Don't do anything just yet. */;
809 else if (t == wchar_decl_node)
810 {
811 if (! DECL_IN_SYSTEM_HEADER (x))
812 pedwarn (input_location, OPT_Wpedantic, "redeclaration of %<wchar_t%> as %qT",
813 TREE_TYPE (x));
814
815 /* Throw away the redeclaration. */
816 return t;
817 }
818 else
819 {
820 tree olddecl = duplicate_decls (x, t, is_friend);
821
822 /* If the redeclaration failed, we can stop at this
823 point. */
824 if (olddecl == error_mark_node)
825 return error_mark_node;
826
827 if (olddecl)
828 {
829 if (TREE_CODE (t) == TYPE_DECL)
830 SET_IDENTIFIER_TYPE_VALUE (name, TREE_TYPE (t));
831
832 return t;
833 }
834 else if (DECL_MAIN_P (x) && TREE_CODE (t) == FUNCTION_DECL)
835 {
836 /* A redeclaration of main, but not a duplicate of the
837 previous one.
838
839 [basic.start.main]
840
841 This function shall not be overloaded. */
842 error ("invalid redeclaration of %q+D", t);
843 error ("as %qD", x);
844 /* We don't try to push this declaration since that
845 causes a crash. */
846 return x;
847 }
848 }
849 }
850
851 /* If x has C linkage-specification, (extern "C"),
852 lookup its binding, in case it's already bound to an object.
853 The lookup is done in all namespaces.
854 If we find an existing binding, make sure it has the same
855 exception specification as x, otherwise, bail in error [7.5, 7.6]. */
856 if ((TREE_CODE (x) == FUNCTION_DECL)
857 && DECL_EXTERN_C_P (x)
858 /* We should ignore declarations happening in system headers. */
859 && !DECL_ARTIFICIAL (x)
860 && !DECL_IN_SYSTEM_HEADER (x))
861 {
862 tree previous = lookup_extern_c_fun_in_all_ns (x);
863 if (previous
864 && !DECL_ARTIFICIAL (previous)
865 && !DECL_IN_SYSTEM_HEADER (previous)
866 && DECL_CONTEXT (previous) != DECL_CONTEXT (x))
867 {
868 /* In case either x or previous is declared to throw an exception,
869 make sure both exception specifications are equal. */
870 if (decls_match (x, previous))
871 {
872 tree x_exception_spec = NULL_TREE;
873 tree previous_exception_spec = NULL_TREE;
874
875 x_exception_spec =
876 TYPE_RAISES_EXCEPTIONS (TREE_TYPE (x));
877 previous_exception_spec =
878 TYPE_RAISES_EXCEPTIONS (TREE_TYPE (previous));
879 if (!comp_except_specs (previous_exception_spec,
880 x_exception_spec,
881 ce_normal))
882 {
883 pedwarn (input_location, 0,
884 "declaration of %q#D with C language linkage",
885 x);
886 pedwarn (input_location, 0,
887 "conflicts with previous declaration %q+#D",
888 previous);
889 pedwarn (input_location, 0,
890 "due to different exception specifications");
891 return error_mark_node;
892 }
893 if (DECL_ASSEMBLER_NAME_SET_P (previous))
894 SET_DECL_ASSEMBLER_NAME (x,
895 DECL_ASSEMBLER_NAME (previous));
896 }
897 else
898 {
899 pedwarn (input_location, 0,
900 "declaration of %q#D with C language linkage", x);
901 pedwarn (input_location, 0,
902 "conflicts with previous declaration %q+#D",
903 previous);
904 }
905 }
906 }
907
908 check_template_shadow (x);
909
910 /* If this is a function conjured up by the back end, massage it
911 so it looks friendly. */
912 if (DECL_NON_THUNK_FUNCTION_P (x) && ! DECL_LANG_SPECIFIC (x))
913 {
914 retrofit_lang_decl (x);
915 SET_DECL_LANGUAGE (x, lang_c);
916 }
917
918 t = x;
919 if (DECL_NON_THUNK_FUNCTION_P (x) && ! DECL_FUNCTION_MEMBER_P (x))
920 {
921 t = push_overloaded_decl (x, PUSH_LOCAL, is_friend);
922 if (!namespace_bindings_p ())
923 /* We do not need to create a binding for this name;
924 push_overloaded_decl will have already done so if
925 necessary. */
926 need_new_binding = 0;
927 }
928 else if (DECL_FUNCTION_TEMPLATE_P (x) && DECL_NAMESPACE_SCOPE_P (x))
929 {
930 t = push_overloaded_decl (x, PUSH_GLOBAL, is_friend);
931 if (t == x)
932 add_decl_to_level (x, NAMESPACE_LEVEL (CP_DECL_CONTEXT (t)));
933 }
934
935 if (DECL_DECLARES_FUNCTION_P (t))
936 {
937 check_default_args (t);
938
939 if (is_friend && t == x && !flag_friend_injection)
940 {
941 /* This is a new friend declaration of a function or a
942 function template, so hide it from ordinary function
943 lookup. */
944 DECL_ANTICIPATED (t) = 1;
945 DECL_HIDDEN_FRIEND_P (t) = 1;
946 }
947 }
948
949 if (t != x || DECL_FUNCTION_TEMPLATE_P (t))
950 return t;
951
952 /* If declaring a type as a typedef, copy the type (unless we're
953 at line 0), and install this TYPE_DECL as the new type's typedef
954 name. See the extensive comment of set_underlying_type (). */
955 if (TREE_CODE (x) == TYPE_DECL)
956 {
957 tree type = TREE_TYPE (x);
958
959 if (DECL_IS_BUILTIN (x)
960 || (TREE_TYPE (x) != error_mark_node
961 && TYPE_NAME (type) != x
962 /* We don't want to copy the type when all we're
963 doing is making a TYPE_DECL for the purposes of
964 inlining. */
965 && (!TYPE_NAME (type)
966 || TYPE_NAME (type) != DECL_ABSTRACT_ORIGIN (x))))
967 set_underlying_type (x);
968
969 if (type != error_mark_node
970 && TYPE_IDENTIFIER (type))
971 set_identifier_type_value (DECL_NAME (x), x);
972
973 /* If this is a locally defined typedef in a function that
974 is not a template instantation, record it to implement
975 -Wunused-local-typedefs. */
976 if (current_instantiation () == NULL
977 || (current_instantiation ()->decl != current_function_decl))
978 record_locally_defined_typedef (x);
979 }
980
981 /* Multiple external decls of the same identifier ought to match.
982
983 We get warnings about inline functions where they are defined.
984 We get warnings about other functions from push_overloaded_decl.
985
986 Avoid duplicate warnings where they are used. */
987 if (TREE_PUBLIC (x) && TREE_CODE (x) != FUNCTION_DECL)
988 {
989 tree decl;
990
991 decl = IDENTIFIER_NAMESPACE_VALUE (name);
992 if (decl && TREE_CODE (decl) == OVERLOAD)
993 decl = OVL_FUNCTION (decl);
994
995 if (decl && decl != error_mark_node
996 && (DECL_EXTERNAL (decl) || TREE_PUBLIC (decl))
997 /* If different sort of thing, we already gave an error. */
998 && TREE_CODE (decl) == TREE_CODE (x)
999 && !comptypes (TREE_TYPE (x), TREE_TYPE (decl),
1000 COMPARE_REDECLARATION))
1001 {
1002 if (permerror (input_location, "type mismatch with previous "
1003 "external decl of %q#D", x))
1004 inform (input_location, "previous external decl of %q+#D",
1005 decl);
1006 }
1007 }
1008
1009 /* This name is new in its binding level.
1010 Install the new declaration and return it. */
1011 if (namespace_bindings_p ())
1012 {
1013 /* Install a global value. */
1014
1015 /* If the first global decl has external linkage,
1016 warn if we later see static one. */
1017 if (IDENTIFIER_GLOBAL_VALUE (name) == NULL_TREE && TREE_PUBLIC (x))
1018 TREE_PUBLIC (name) = 1;
1019
1020 /* Bind the name for the entity. */
1021 if (!(TREE_CODE (x) == TYPE_DECL && DECL_ARTIFICIAL (x)
1022 && t != NULL_TREE)
1023 && (TREE_CODE (x) == TYPE_DECL
1024 || VAR_P (x)
1025 || TREE_CODE (x) == NAMESPACE_DECL
1026 || TREE_CODE (x) == CONST_DECL
1027 || TREE_CODE (x) == TEMPLATE_DECL))
1028 SET_IDENTIFIER_NAMESPACE_VALUE (name, x);
1029
1030 /* If new decl is `static' and an `extern' was seen previously,
1031 warn about it. */
1032 if (x != NULL_TREE && t != NULL_TREE && decls_match (x, t))
1033 warn_extern_redeclared_static (x, t);
1034 }
1035 else
1036 {
1037 /* Here to install a non-global value. */
1038 tree oldglobal = IDENTIFIER_NAMESPACE_VALUE (name);
1039 tree oldlocal = NULL_TREE;
1040 cp_binding_level *oldscope = NULL;
1041 cxx_binding *oldbinding = outer_binding (name, NULL, true);
1042 if (oldbinding)
1043 {
1044 oldlocal = oldbinding->value;
1045 oldscope = oldbinding->scope;
1046 }
1047
1048 if (need_new_binding)
1049 {
1050 push_local_binding (name, x, 0);
1051 /* Because push_local_binding will hook X on to the
1052 current_binding_level's name list, we don't want to
1053 do that again below. */
1054 need_new_binding = 0;
1055 }
1056
1057 /* If this is a TYPE_DECL, push it into the type value slot. */
1058 if (TREE_CODE (x) == TYPE_DECL)
1059 set_identifier_type_value (name, x);
1060
1061 /* Clear out any TYPE_DECL shadowed by a namespace so that
1062 we won't think this is a type. The C struct hack doesn't
1063 go through namespaces. */
1064 if (TREE_CODE (x) == NAMESPACE_DECL)
1065 set_identifier_type_value (name, NULL_TREE);
1066
1067 if (oldlocal)
1068 {
1069 tree d = oldlocal;
1070
1071 while (oldlocal
1072 && VAR_P (oldlocal)
1073 && DECL_DEAD_FOR_LOCAL (oldlocal))
1074 oldlocal = DECL_SHADOWED_FOR_VAR (oldlocal);
1075
1076 if (oldlocal == NULL_TREE)
1077 oldlocal = IDENTIFIER_NAMESPACE_VALUE (DECL_NAME (d));
1078 }
1079
1080 /* If this is an extern function declaration, see if we
1081 have a global definition or declaration for the function. */
1082 if (oldlocal == NULL_TREE
1083 && DECL_EXTERNAL (x)
1084 && oldglobal != NULL_TREE
1085 && TREE_CODE (x) == FUNCTION_DECL
1086 && TREE_CODE (oldglobal) == FUNCTION_DECL)
1087 {
1088 /* We have one. Their types must agree. */
1089 if (decls_match (x, oldglobal))
1090 /* OK */;
1091 else
1092 {
1093 warning (0, "extern declaration of %q#D doesn%'t match", x);
1094 warning (0, "global declaration %q+#D", oldglobal);
1095 }
1096 }
1097 /* If we have a local external declaration,
1098 and no file-scope declaration has yet been seen,
1099 then if we later have a file-scope decl it must not be static. */
1100 if (oldlocal == NULL_TREE
1101 && oldglobal == NULL_TREE
1102 && DECL_EXTERNAL (x)
1103 && TREE_PUBLIC (x))
1104 TREE_PUBLIC (name) = 1;
1105
1106 /* Don't complain about the parms we push and then pop
1107 while tentatively parsing a function declarator. */
1108 if (TREE_CODE (x) == PARM_DECL && DECL_CONTEXT (x) == NULL_TREE)
1109 /* Ignore. */;
1110
1111 /* Warn if shadowing an argument at the top level of the body. */
1112 else if (oldlocal != NULL_TREE && !DECL_EXTERNAL (x)
1113 /* Inline decls shadow nothing. */
1114 && !DECL_FROM_INLINE (x)
1115 && (TREE_CODE (oldlocal) == PARM_DECL
1116 || VAR_P (oldlocal)
1117 /* If the old decl is a type decl, only warn if the
1118 old decl is an explicit typedef or if both the old
1119 and new decls are type decls. */
1120 || (TREE_CODE (oldlocal) == TYPE_DECL
1121 && (!DECL_ARTIFICIAL (oldlocal)
1122 || TREE_CODE (x) == TYPE_DECL)))
1123 /* Don't check for internally generated vars unless
1124 it's an implicit typedef (see create_implicit_typedef
1125 in decl.c). */
1126 && (!DECL_ARTIFICIAL (x) || DECL_IMPLICIT_TYPEDEF_P (x)))
1127 {
1128 bool nowarn = false;
1129
1130 /* Don't complain if it's from an enclosing function. */
1131 if (DECL_CONTEXT (oldlocal) == current_function_decl
1132 && TREE_CODE (x) != PARM_DECL
1133 && TREE_CODE (oldlocal) == PARM_DECL)
1134 {
1135 /* Go to where the parms should be and see if we find
1136 them there. */
1137 cp_binding_level *b = current_binding_level->level_chain;
1138
1139 if (FUNCTION_NEEDS_BODY_BLOCK (current_function_decl))
1140 /* Skip the ctor/dtor cleanup level. */
1141 b = b->level_chain;
1142
1143 /* ARM $8.3 */
1144 if (b->kind == sk_function_parms)
1145 {
1146 error ("declaration of %q#D shadows a parameter", x);
1147 nowarn = true;
1148 }
1149 }
1150
1151 /* The local structure or class can't use parameters of
1152 the containing function anyway. */
1153 if (DECL_CONTEXT (oldlocal) != current_function_decl)
1154 {
1155 cp_binding_level *scope = current_binding_level;
1156 tree context = DECL_CONTEXT (oldlocal);
1157 for (; scope; scope = scope->level_chain)
1158 {
1159 if (scope->kind == sk_function_parms
1160 && scope->this_entity == context)
1161 break;
1162 if (scope->kind == sk_class
1163 && !LAMBDA_TYPE_P (scope->this_entity))
1164 {
1165 nowarn = true;
1166 break;
1167 }
1168 }
1169 }
1170 /* Error if redeclaring a local declared in a
1171 for-init-statement or in the condition of an if or
1172 switch statement when the new declaration is in the
1173 outermost block of the controlled statement.
1174 Redeclaring a variable from a for or while condition is
1175 detected elsewhere. */
1176 else if (VAR_P (oldlocal)
1177 && oldscope == current_binding_level->level_chain
1178 && (oldscope->kind == sk_cond
1179 || oldscope->kind == sk_for))
1180 {
1181 error ("redeclaration of %q#D", x);
1182 inform (input_location, "%q+#D previously declared here",
1183 oldlocal);
1184 nowarn = true;
1185 }
1186 /* C++11:
1187 3.3.3/3: The name declared in an exception-declaration (...)
1188 shall not be redeclared in the outermost block of the handler.
1189 3.3.3/2: A parameter name shall not be redeclared (...) in
1190 the outermost block of any handler associated with a
1191 function-try-block.
1192 3.4.1/15: The function parameter names shall not be redeclared
1193 in the exception-declaration nor in the outermost block of a
1194 handler for the function-try-block. */
1195 else if ((VAR_P (oldlocal)
1196 && oldscope == current_binding_level->level_chain
1197 && oldscope->kind == sk_catch)
1198 || (TREE_CODE (oldlocal) == PARM_DECL
1199 && (current_binding_level->kind == sk_catch
1200 || (current_binding_level->level_chain->kind
1201 == sk_catch))
1202 && in_function_try_handler))
1203 {
1204 if (permerror (input_location, "redeclaration of %q#D", x))
1205 inform (input_location, "%q+#D previously declared here",
1206 oldlocal);
1207 nowarn = true;
1208 }
1209
1210 if (warn_shadow && !nowarn)
1211 {
1212 bool warned;
1213
1214 if (TREE_CODE (oldlocal) == PARM_DECL)
1215 warned = warning_at (input_location, OPT_Wshadow,
1216 "declaration of %q#D shadows a parameter", x);
1217 else if (is_capture_proxy (oldlocal))
1218 warned = warning_at (input_location, OPT_Wshadow,
1219 "declaration of %qD shadows a lambda capture",
1220 x);
1221 else
1222 warned = warning_at (input_location, OPT_Wshadow,
1223 "declaration of %qD shadows a previous local",
1224 x);
1225
1226 if (warned)
1227 inform (DECL_SOURCE_LOCATION (oldlocal),
1228 "shadowed declaration is here");
1229 }
1230 }
1231
1232 /* Maybe warn if shadowing something else. */
1233 else if (warn_shadow && !DECL_EXTERNAL (x)
1234 /* No shadow warnings for internally generated vars unless
1235 it's an implicit typedef (see create_implicit_typedef
1236 in decl.c). */
1237 && (! DECL_ARTIFICIAL (x) || DECL_IMPLICIT_TYPEDEF_P (x))
1238 /* No shadow warnings for vars made for inlining. */
1239 && ! DECL_FROM_INLINE (x))
1240 {
1241 tree member;
1242
1243 if (nonlambda_method_basetype ())
1244 member = lookup_member (current_nonlambda_class_type (),
1245 name,
1246 /*protect=*/0,
1247 /*want_type=*/false,
1248 tf_warning_or_error);
1249 else
1250 member = NULL_TREE;
1251
1252 if (member && !TREE_STATIC (member))
1253 {
1254 if (BASELINK_P (member))
1255 member = BASELINK_FUNCTIONS (member);
1256 member = OVL_CURRENT (member);
1257
1258 /* Do not warn if a variable shadows a function, unless
1259 the variable is a function or a pointer-to-function. */
1260 if (TREE_CODE (member) != FUNCTION_DECL
1261 || TREE_CODE (x) == FUNCTION_DECL
1262 || TYPE_PTRFN_P (TREE_TYPE (x))
1263 || TYPE_PTRMEMFUNC_P (TREE_TYPE (x)))
1264 {
1265 if (warning_at (input_location, OPT_Wshadow,
1266 "declaration of %qD shadows a member of %qT",
1267 x, current_nonlambda_class_type ())
1268 && DECL_P (member))
1269 inform (DECL_SOURCE_LOCATION (member),
1270 "shadowed declaration is here");
1271 }
1272 }
1273 else if (oldglobal != NULL_TREE
1274 && (VAR_P (oldglobal)
1275 /* If the old decl is a type decl, only warn if the
1276 old decl is an explicit typedef or if both the
1277 old and new decls are type decls. */
1278 || (TREE_CODE (oldglobal) == TYPE_DECL
1279 && (!DECL_ARTIFICIAL (oldglobal)
1280 || TREE_CODE (x) == TYPE_DECL))))
1281 /* XXX shadow warnings in outer-more namespaces */
1282 {
1283 if (warning_at (input_location, OPT_Wshadow,
1284 "declaration of %qD shadows a "
1285 "global declaration", x))
1286 inform (DECL_SOURCE_LOCATION (oldglobal),
1287 "shadowed declaration is here");
1288 }
1289 }
1290 }
1291
1292 if (VAR_P (x))
1293 maybe_register_incomplete_var (x);
1294 }
1295
1296 if (need_new_binding)
1297 add_decl_to_level (x,
1298 DECL_NAMESPACE_SCOPE_P (x)
1299 ? NAMESPACE_LEVEL (CP_DECL_CONTEXT (x))
1300 : current_binding_level);
1301
1302 return x;
1303}
1304
1305/* Wrapper for pushdecl_maybe_friend_1. */
1306
1307tree
1308pushdecl_maybe_friend (tree x, bool is_friend)
1309{
1310 tree ret;
1311 bool subtime = timevar_cond_start (TV_NAME_LOOKUP);
1312 ret = pushdecl_maybe_friend_1 (x, is_friend);
1313 timevar_cond_stop (TV_NAME_LOOKUP, subtime);
1314 return ret;
1315}
1316
1317/* Record a decl-node X as belonging to the current lexical scope. */
1318
1319tree
1320pushdecl (tree x)
1321{
1322 return pushdecl_maybe_friend (x, false);
1323}
1324
1325/* Enter DECL into the symbol table, if that's appropriate. Returns
1326 DECL, or a modified version thereof. */
1327
1328tree
1329maybe_push_decl (tree decl)
1330{
1331 tree type = TREE_TYPE (decl);
1332
1333 /* Add this decl to the current binding level, but not if it comes
1334 from another scope, e.g. a static member variable. TEM may equal
1335 DECL or it may be a previous decl of the same name. */
1336 if (decl == error_mark_node
1337 || (TREE_CODE (decl) != PARM_DECL
1338 && DECL_CONTEXT (decl) != NULL_TREE
1339 /* Definitions of namespace members outside their namespace are
1340 possible. */
1341 && !DECL_NAMESPACE_SCOPE_P (decl))
1342 || (TREE_CODE (decl) == TEMPLATE_DECL && !namespace_bindings_p ())
1343 || type == unknown_type_node
1344 /* The declaration of a template specialization does not affect
1345 the functions available for overload resolution, so we do not
1346 call pushdecl. */
1347 || (TREE_CODE (decl) == FUNCTION_DECL
1348 && DECL_TEMPLATE_SPECIALIZATION (decl)))
1349 return decl;
1350 else
1351 return pushdecl (decl);
1352}
1353
1354/* Bind DECL to ID in the current_binding_level, assumed to be a local
1355 binding level. If PUSH_USING is set in FLAGS, we know that DECL
1356 doesn't really belong to this binding level, that it got here
1357 through a using-declaration. */
1358
1359void
1360push_local_binding (tree id, tree decl, int flags)
1361{
1362 cp_binding_level *b;
1363
1364 /* Skip over any local classes. This makes sense if we call
1365 push_local_binding with a friend decl of a local class. */
1366 b = innermost_nonclass_level ();
1367
1368 if (lookup_name_innermost_nonclass_level (id))
1369 {
1370 /* Supplement the existing binding. */
1371 if (!supplement_binding (IDENTIFIER_BINDING (id), decl))
1372 /* It didn't work. Something else must be bound at this
1373 level. Do not add DECL to the list of things to pop
1374 later. */
1375 return;
1376 }
1377 else
1378 /* Create a new binding. */
1379 push_binding (id, decl, b);
1380
1381 if (TREE_CODE (decl) == OVERLOAD || (flags & PUSH_USING))
1382 /* We must put the OVERLOAD into a TREE_LIST since the
1383 TREE_CHAIN of an OVERLOAD is already used. Similarly for
1384 decls that got here through a using-declaration. */
1385 decl = build_tree_list (NULL_TREE, decl);
1386
1387 /* And put DECL on the list of things declared by the current
1388 binding level. */
1389 add_decl_to_level (decl, b);
1390}
1391
1392/* Check to see whether or not DECL is a variable that would have been
1393 in scope under the ARM, but is not in scope under the ANSI/ISO
1394 standard. If so, issue an error message. If name lookup would
1395 work in both cases, but return a different result, this function
1396 returns the result of ANSI/ISO lookup. Otherwise, it returns
1397 DECL. */
1398
1399tree
1400check_for_out_of_scope_variable (tree decl)
1401{
1402 tree shadowed;
1403
1404 /* We only care about out of scope variables. */
1405 if (!(VAR_P (decl) && DECL_DEAD_FOR_LOCAL (decl)))
1406 return decl;
1407
1408 shadowed = DECL_HAS_SHADOWED_FOR_VAR_P (decl)
1409 ? DECL_SHADOWED_FOR_VAR (decl) : NULL_TREE ;
1410 while (shadowed != NULL_TREE && VAR_P (shadowed)
1411 && DECL_DEAD_FOR_LOCAL (shadowed))
1412 shadowed = DECL_HAS_SHADOWED_FOR_VAR_P (shadowed)
1413 ? DECL_SHADOWED_FOR_VAR (shadowed) : NULL_TREE;
1414 if (!shadowed)
1415 shadowed = IDENTIFIER_NAMESPACE_VALUE (DECL_NAME (decl));
1416 if (shadowed)
1417 {
1418 if (!DECL_ERROR_REPORTED (decl))
1419 {
1420 warning (0, "name lookup of %qD changed", DECL_NAME (decl));
1421 warning (0, " matches this %q+D under ISO standard rules",
1422 shadowed);
1423 warning (0, " matches this %q+D under old rules", decl);
1424 DECL_ERROR_REPORTED (decl) = 1;
1425 }
1426 return shadowed;
1427 }
1428
1429 /* If we have already complained about this declaration, there's no
1430 need to do it again. */
1431 if (DECL_ERROR_REPORTED (decl))
1432 return decl;
1433
1434 DECL_ERROR_REPORTED (decl) = 1;
1435
1436 if (TREE_TYPE (decl) == error_mark_node)
1437 return decl;
1438
1439 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TREE_TYPE (decl)))
1440 {
1441 error ("name lookup of %qD changed for ISO %<for%> scoping",
1442 DECL_NAME (decl));
1443 error (" cannot use obsolete binding at %q+D because "
1444 "it has a destructor", decl);
1445 return error_mark_node;
1446 }
1447 else
1448 {
1449 permerror (input_location, "name lookup of %qD changed for ISO %<for%> scoping",
1450 DECL_NAME (decl));
1451 if (flag_permissive)
1452 permerror (input_location, " using obsolete binding at %q+D", decl);
1453 else
1454 {
1455 static bool hint;
1456 if (!hint)
1457 {
1458 inform (input_location, "(if you use %<-fpermissive%> G++ will accept your code)");
1459 hint = true;
1460 }
1461 }
1462 }
1463
1464 return decl;
1465}
1466\f
1467/* true means unconditionally make a BLOCK for the next level pushed. */
1468
1469static bool keep_next_level_flag;
1470
1471static int binding_depth = 0;
1472
1473static void
1474indent (int depth)
1475{
1476 int i;
1477
1478 for (i = 0; i < depth * 2; i++)
1479 putc (' ', stderr);
1480}
1481
1482/* Return a string describing the kind of SCOPE we have. */
1483static const char *
1484cp_binding_level_descriptor (cp_binding_level *scope)
1485{
1486 /* The order of this table must match the "scope_kind"
1487 enumerators. */
1488 static const char* scope_kind_names[] = {
1489 "block-scope",
1490 "cleanup-scope",
1491 "try-scope",
1492 "catch-scope",
1493 "for-scope",
1494 "function-parameter-scope",
1495 "class-scope",
1496 "namespace-scope",
1497 "template-parameter-scope",
1498 "template-explicit-spec-scope"
1499 };
1500 const scope_kind kind = scope->explicit_spec_p
1501 ? sk_template_spec : scope->kind;
1502
1503 return scope_kind_names[kind];
1504}
1505
1506/* Output a debugging information about SCOPE when performing
1507 ACTION at LINE. */
1508static void
1509cp_binding_level_debug (cp_binding_level *scope, int line, const char *action)
1510{
1511 const char *desc = cp_binding_level_descriptor (scope);
1512 if (scope->this_entity)
1513 verbatim ("%s %s(%E) %p %d\n", action, desc,
1514 scope->this_entity, (void *) scope, line);
1515 else
1516 verbatim ("%s %s %p %d\n", action, desc, (void *) scope, line);
1517}
1518
1519/* Return the estimated initial size of the hashtable of a NAMESPACE
1520 scope. */
1521
1522static inline size_t
1523namespace_scope_ht_size (tree ns)
1524{
1525 tree name = DECL_NAME (ns);
1526
1527 return name == std_identifier
1528 ? NAMESPACE_STD_HT_SIZE
1529 : (name == global_scope_name
1530 ? GLOBAL_SCOPE_HT_SIZE
1531 : NAMESPACE_ORDINARY_HT_SIZE);
1532}
1533
1534/* A chain of binding_level structures awaiting reuse. */
1535
1536static GTY((deletable)) cp_binding_level *free_binding_level;
1537
1538/* Insert SCOPE as the innermost binding level. */
1539
1540void
1541push_binding_level (cp_binding_level *scope)
1542{
1543 /* Add it to the front of currently active scopes stack. */
1544 scope->level_chain = current_binding_level;
1545 current_binding_level = scope;
1546 keep_next_level_flag = false;
1547
1548 if (ENABLE_SCOPE_CHECKING)
1549 {
1550 scope->binding_depth = binding_depth;
1551 indent (binding_depth);
1552 cp_binding_level_debug (scope, LOCATION_LINE (input_location),
1553 "push");
1554 binding_depth++;
1555 }
1556}
1557
1558/* Create a new KIND scope and make it the top of the active scopes stack.
1559 ENTITY is the scope of the associated C++ entity (namespace, class,
1560 function, C++0x enumeration); it is NULL otherwise. */
1561
1562cp_binding_level *
1563begin_scope (scope_kind kind, tree entity)
1564{
1565 cp_binding_level *scope;
1566
1567 /* Reuse or create a struct for this binding level. */
1568 if (!ENABLE_SCOPE_CHECKING && free_binding_level)
1569 {
1570 scope = free_binding_level;
1571 memset (scope, 0, sizeof (cp_binding_level));
1572 free_binding_level = scope->level_chain;
1573 }
1574 else
1575 scope = ggc_cleared_alloc<cp_binding_level> ();
1576
1577 scope->this_entity = entity;
1578 scope->more_cleanups_ok = true;
1579 switch (kind)
1580 {
1581 case sk_cleanup:
1582 scope->keep = true;
1583 break;
1584
1585 case sk_template_spec:
1586 scope->explicit_spec_p = true;
1587 kind = sk_template_parms;
1588 /* Fall through. */
1589 case sk_template_parms:
1590 case sk_block:
1591 case sk_try:
1592 case sk_catch:
1593 case sk_for:
1594 case sk_cond:
1595 case sk_class:
1596 case sk_scoped_enum:
1597 case sk_function_parms:
1598 case sk_omp:
1599 scope->keep = keep_next_level_flag;
1600 break;
1601
1602 case sk_namespace:
1603 NAMESPACE_LEVEL (entity) = scope;
1604 vec_alloc (scope->static_decls,
1605 (DECL_NAME (entity) == std_identifier
1606 || DECL_NAME (entity) == global_scope_name) ? 200 : 10);
1607 break;
1608
1609 default:
1610 /* Should not happen. */
1611 gcc_unreachable ();
1612 break;
1613 }
1614 scope->kind = kind;
1615
1616 push_binding_level (scope);
1617
1618 return scope;
1619}
1620
1621/* We're about to leave current scope. Pop the top of the stack of
1622 currently active scopes. Return the enclosing scope, now active. */
1623
1624cp_binding_level *
1625leave_scope (void)
1626{
1627 cp_binding_level *scope = current_binding_level;
1628
1629 if (scope->kind == sk_namespace && class_binding_level)
1630 current_binding_level = class_binding_level;
1631
1632 /* We cannot leave a scope, if there are none left. */
1633 if (NAMESPACE_LEVEL (global_namespace))
1634 gcc_assert (!global_scope_p (scope));
1635
1636 if (ENABLE_SCOPE_CHECKING)
1637 {
1638 indent (--binding_depth);
1639 cp_binding_level_debug (scope, LOCATION_LINE (input_location),
1640 "leave");
1641 }
1642
1643 /* Move one nesting level up. */
1644 current_binding_level = scope->level_chain;
1645
1646 /* Namespace-scopes are left most probably temporarily, not
1647 completely; they can be reopened later, e.g. in namespace-extension
1648 or any name binding activity that requires us to resume a
1649 namespace. For classes, we cache some binding levels. For other
1650 scopes, we just make the structure available for reuse. */
1651 if (scope->kind != sk_namespace
1652 && scope->kind != sk_class)
1653 {
1654 scope->level_chain = free_binding_level;
1655 gcc_assert (!ENABLE_SCOPE_CHECKING
1656 || scope->binding_depth == binding_depth);
1657 free_binding_level = scope;
1658 }
1659
1660 if (scope->kind == sk_class)
1661 {
1662 /* Reset DEFINING_CLASS_P to allow for reuse of a
1663 class-defining scope in a non-defining context. */
1664 scope->defining_class_p = 0;
1665
1666 /* Find the innermost enclosing class scope, and reset
1667 CLASS_BINDING_LEVEL appropriately. */
1668 class_binding_level = NULL;
1669 for (scope = current_binding_level; scope; scope = scope->level_chain)
1670 if (scope->kind == sk_class)
1671 {
1672 class_binding_level = scope;
1673 break;
1674 }
1675 }
1676
1677 return current_binding_level;
1678}
1679
1680static void
1681resume_scope (cp_binding_level* b)
1682{
1683 /* Resuming binding levels is meant only for namespaces,
1684 and those cannot nest into classes. */
1685 gcc_assert (!class_binding_level);
1686 /* Also, resuming a non-directly nested namespace is a no-no. */
1687 gcc_assert (b->level_chain == current_binding_level);
1688 current_binding_level = b;
1689 if (ENABLE_SCOPE_CHECKING)
1690 {
1691 b->binding_depth = binding_depth;
1692 indent (binding_depth);
1693 cp_binding_level_debug (b, LOCATION_LINE (input_location), "resume");
1694 binding_depth++;
1695 }
1696}
1697
1698/* Return the innermost binding level that is not for a class scope. */
1699
1700static cp_binding_level *
1701innermost_nonclass_level (void)
1702{
1703 cp_binding_level *b;
1704
1705 b = current_binding_level;
1706 while (b->kind == sk_class)
1707 b = b->level_chain;
1708
1709 return b;
1710}
1711
1712/* We're defining an object of type TYPE. If it needs a cleanup, but
1713 we're not allowed to add any more objects with cleanups to the current
1714 scope, create a new binding level. */
1715
1716void
1717maybe_push_cleanup_level (tree type)
1718{
1719 if (type != error_mark_node
1720 && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type)
1721 && current_binding_level->more_cleanups_ok == 0)
1722 {
1723 begin_scope (sk_cleanup, NULL);
1724 current_binding_level->statement_list = push_stmt_list ();
1725 }
1726}
1727
1728/* Return true if we are in the global binding level. */
1729
1730bool
1731global_bindings_p (void)
1732{
1733 return global_scope_p (current_binding_level);
1734}
1735
1736/* True if we are currently in a toplevel binding level. This
1737 means either the global binding level or a namespace in a toplevel
1738 binding level. Since there are no non-toplevel namespace levels,
1739 this really means any namespace or template parameter level. We
1740 also include a class whose context is toplevel. */
1741
1742bool
1743toplevel_bindings_p (void)
1744{
1745 cp_binding_level *b = innermost_nonclass_level ();
1746
1747 return b->kind == sk_namespace || b->kind == sk_template_parms;
1748}
1749
1750/* True if this is a namespace scope, or if we are defining a class
1751 which is itself at namespace scope, or whose enclosing class is
1752 such a class, etc. */
1753
1754bool
1755namespace_bindings_p (void)
1756{
1757 cp_binding_level *b = innermost_nonclass_level ();
1758
1759 return b->kind == sk_namespace;
1760}
1761
1762/* True if the innermost non-class scope is a block scope. */
1763
1764bool
1765local_bindings_p (void)
1766{
1767 cp_binding_level *b = innermost_nonclass_level ();
1768 return b->kind < sk_function_parms || b->kind == sk_omp;
1769}
1770
1771/* True if the current level needs to have a BLOCK made. */
1772
1773bool
1774kept_level_p (void)
1775{
1776 return (current_binding_level->blocks != NULL_TREE
1777 || current_binding_level->keep
1778 || current_binding_level->kind == sk_cleanup
1779 || current_binding_level->names != NULL_TREE
1780 || current_binding_level->using_directives);
1781}
1782
1783/* Returns the kind of the innermost scope. */
1784
1785scope_kind
1786innermost_scope_kind (void)
1787{
1788 return current_binding_level->kind;
1789}
1790
1791/* Returns true if this scope was created to store template parameters. */
1792
1793bool
1794template_parm_scope_p (void)
1795{
1796 return innermost_scope_kind () == sk_template_parms;
1797}
1798
1799/* If KEEP is true, make a BLOCK node for the next binding level,
1800 unconditionally. Otherwise, use the normal logic to decide whether
1801 or not to create a BLOCK. */
1802
1803void
1804keep_next_level (bool keep)
1805{
1806 keep_next_level_flag = keep;
1807}
1808
1809/* Return the list of declarations of the current level.
1810 Note that this list is in reverse order unless/until
1811 you nreverse it; and when you do nreverse it, you must
1812 store the result back using `storedecls' or you will lose. */
1813
1814tree
1815getdecls (void)
1816{
1817 return current_binding_level->names;
1818}
1819
1820/* Return how many function prototypes we are currently nested inside. */
1821
1822int
1823function_parm_depth (void)
1824{
1825 int level = 0;
1826 cp_binding_level *b;
1827
1828 for (b = current_binding_level;
1829 b->kind == sk_function_parms;
1830 b = b->level_chain)
1831 ++level;
1832
1833 return level;
1834}
1835
1836/* For debugging. */
1837static int no_print_functions = 0;
1838static int no_print_builtins = 0;
1839
1840static void
1841print_binding_level (cp_binding_level* lvl)
1842{
1843 tree t;
1844 int i = 0, len;
1845 fprintf (stderr, " blocks=%p", (void *) lvl->blocks);
1846 if (lvl->more_cleanups_ok)
1847 fprintf (stderr, " more-cleanups-ok");
1848 if (lvl->have_cleanups)
1849 fprintf (stderr, " have-cleanups");
1850 fprintf (stderr, "\n");
1851 if (lvl->names)
1852 {
1853 fprintf (stderr, " names:\t");
1854 /* We can probably fit 3 names to a line? */
1855 for (t = lvl->names; t; t = TREE_CHAIN (t))
1856 {
1857 if (no_print_functions && (TREE_CODE (t) == FUNCTION_DECL))
1858 continue;
1859 if (no_print_builtins
1860 && (TREE_CODE (t) == TYPE_DECL)
1861 && DECL_IS_BUILTIN (t))
1862 continue;
1863
1864 /* Function decls tend to have longer names. */
1865 if (TREE_CODE (t) == FUNCTION_DECL)
1866 len = 3;
1867 else
1868 len = 2;
1869 i += len;
1870 if (i > 6)
1871 {
1872 fprintf (stderr, "\n\t");
1873 i = len;
1874 }
1875 print_node_brief (stderr, "", t, 0);
1876 if (t == error_mark_node)
1877 break;
1878 }
1879 if (i)
1880 fprintf (stderr, "\n");
1881 }
1882 if (vec_safe_length (lvl->class_shadowed))
1883 {
1884 size_t i;
1885 cp_class_binding *b;
1886 fprintf (stderr, " class-shadowed:");
1887 FOR_EACH_VEC_ELT (*lvl->class_shadowed, i, b)
1888 fprintf (stderr, " %s ", IDENTIFIER_POINTER (b->identifier));
1889 fprintf (stderr, "\n");
1890 }
1891 if (lvl->type_shadowed)
1892 {
1893 fprintf (stderr, " type-shadowed:");
1894 for (t = lvl->type_shadowed; t; t = TREE_CHAIN (t))
1895 {
1896 fprintf (stderr, " %s ", IDENTIFIER_POINTER (TREE_PURPOSE (t)));
1897 }
1898 fprintf (stderr, "\n");
1899 }
1900}
1901
1902DEBUG_FUNCTION void
1903debug (cp_binding_level &ref)
1904{
1905 print_binding_level (&ref);
1906}
1907
1908DEBUG_FUNCTION void
1909debug (cp_binding_level *ptr)
1910{
1911 if (ptr)
1912 debug (*ptr);
1913 else
1914 fprintf (stderr, "<nil>\n");
1915}
1916
1917
1918void
1919print_other_binding_stack (cp_binding_level *stack)
1920{
1921 cp_binding_level *level;
1922 for (level = stack; !global_scope_p (level); level = level->level_chain)
1923 {
1924 fprintf (stderr, "binding level %p\n", (void *) level);
1925 print_binding_level (level);
1926 }
1927}
1928
1929void
1930print_binding_stack (void)
1931{
1932 cp_binding_level *b;
1933 fprintf (stderr, "current_binding_level=%p\n"
1934 "class_binding_level=%p\n"
1935 "NAMESPACE_LEVEL (global_namespace)=%p\n",
1936 (void *) current_binding_level, (void *) class_binding_level,
1937 (void *) NAMESPACE_LEVEL (global_namespace));
1938 if (class_binding_level)
1939 {
1940 for (b = class_binding_level; b; b = b->level_chain)
1941 if (b == current_binding_level)
1942 break;
1943 if (b)
1944 b = class_binding_level;
1945 else
1946 b = current_binding_level;
1947 }
1948 else
1949 b = current_binding_level;
1950 print_other_binding_stack (b);
1951 fprintf (stderr, "global:\n");
1952 print_binding_level (NAMESPACE_LEVEL (global_namespace));
1953}
1954\f
1955/* Return the type associated with ID. */
1956
1957static tree
1958identifier_type_value_1 (tree id)
1959{
1960 /* There is no type with that name, anywhere. */
1961 if (REAL_IDENTIFIER_TYPE_VALUE (id) == NULL_TREE)
1962 return NULL_TREE;
1963 /* This is not the type marker, but the real thing. */
1964 if (REAL_IDENTIFIER_TYPE_VALUE (id) != global_type_node)
1965 return REAL_IDENTIFIER_TYPE_VALUE (id);
1966 /* Have to search for it. It must be on the global level, now.
1967 Ask lookup_name not to return non-types. */
1968 id = lookup_name_real (id, 2, 1, /*block_p=*/true, 0, 0);
1969 if (id)
1970 return TREE_TYPE (id);
1971 return NULL_TREE;
1972}
1973
1974/* Wrapper for identifier_type_value_1. */
1975
1976tree
1977identifier_type_value (tree id)
1978{
1979 tree ret;
1980 timevar_start (TV_NAME_LOOKUP);
1981 ret = identifier_type_value_1 (id);
1982 timevar_stop (TV_NAME_LOOKUP);
1983 return ret;
1984}
1985
1986
1987/* Return the IDENTIFIER_GLOBAL_VALUE of T, for use in common code, since
1988 the definition of IDENTIFIER_GLOBAL_VALUE is different for C and C++. */
1989
1990tree
1991identifier_global_value (tree t)
1992{
1993 return IDENTIFIER_GLOBAL_VALUE (t);
1994}
1995
1996/* Push a definition of struct, union or enum tag named ID. into
1997 binding_level B. DECL is a TYPE_DECL for the type. We assume that
1998 the tag ID is not already defined. */
1999
2000static void
2001set_identifier_type_value_with_scope (tree id, tree decl, cp_binding_level *b)
2002{
2003 tree type;
2004
2005 if (b->kind != sk_namespace)
2006 {
2007 /* Shadow the marker, not the real thing, so that the marker
2008 gets restored later. */
2009 tree old_type_value = REAL_IDENTIFIER_TYPE_VALUE (id);
2010 b->type_shadowed
2011 = tree_cons (id, old_type_value, b->type_shadowed);
2012 type = decl ? TREE_TYPE (decl) : NULL_TREE;
2013 TREE_TYPE (b->type_shadowed) = type;
2014 }
2015 else
2016 {
2017 cxx_binding *binding =
2018 binding_for_name (NAMESPACE_LEVEL (current_namespace), id);
2019 gcc_assert (decl);
2020 if (binding->value)
2021 supplement_binding (binding, decl);
2022 else
2023 binding->value = decl;
2024
2025 /* Store marker instead of real type. */
2026 type = global_type_node;
2027 }
2028 SET_IDENTIFIER_TYPE_VALUE (id, type);
2029}
2030
2031/* As set_identifier_type_value_with_scope, but using
2032 current_binding_level. */
2033
2034void
2035set_identifier_type_value (tree id, tree decl)
2036{
2037 set_identifier_type_value_with_scope (id, decl, current_binding_level);
2038}
2039
2040/* Return the name for the constructor (or destructor) for the
2041 specified class TYPE. When given a template, this routine doesn't
2042 lose the specialization. */
2043
2044static inline tree
2045constructor_name_full (tree type)
2046{
2047 return TYPE_IDENTIFIER (TYPE_MAIN_VARIANT (type));
2048}
2049
2050/* Return the name for the constructor (or destructor) for the
2051 specified class. When given a template, return the plain
2052 unspecialized name. */
2053
2054tree
2055constructor_name (tree type)
2056{
2057 tree name;
2058 name = constructor_name_full (type);
2059 if (IDENTIFIER_TEMPLATE (name))
2060 name = IDENTIFIER_TEMPLATE (name);
2061 return name;
2062}
2063
2064/* Returns TRUE if NAME is the name for the constructor for TYPE,
2065 which must be a class type. */
2066
2067bool
2068constructor_name_p (tree name, tree type)
2069{
2070 tree ctor_name;
2071
2072 gcc_assert (MAYBE_CLASS_TYPE_P (type));
2073
2074 if (!name)
2075 return false;
2076
2077 if (!identifier_p (name))
2078 return false;
2079
2080 /* These don't have names. */
2081 if (TREE_CODE (type) == DECLTYPE_TYPE
2082 || TREE_CODE (type) == TYPEOF_TYPE)
2083 return false;
2084
2085 ctor_name = constructor_name_full (type);
2086 if (name == ctor_name)
2087 return true;
2088 if (IDENTIFIER_TEMPLATE (ctor_name)
2089 && name == IDENTIFIER_TEMPLATE (ctor_name))
2090 return true;
2091 return false;
2092}
2093
2094/* Counter used to create anonymous type names. */
2095
2096static GTY(()) int anon_cnt;
2097
2098/* Return an IDENTIFIER which can be used as a name for
2099 anonymous structs and unions. */
2100
2101tree
2102make_anon_name (void)
2103{
2104 char buf[32];
2105
2106 sprintf (buf, ANON_AGGRNAME_FORMAT, anon_cnt++);
2107 return get_identifier (buf);
2108}
2109
2110/* This code is practically identical to that for creating
2111 anonymous names, but is just used for lambdas instead. This isn't really
2112 necessary, but it's convenient to avoid treating lambdas like other
2113 anonymous types. */
2114
2115static GTY(()) int lambda_cnt = 0;
2116
2117tree
2118make_lambda_name (void)
2119{
2120 char buf[32];
2121
2122 sprintf (buf, LAMBDANAME_FORMAT, lambda_cnt++);
2123 return get_identifier (buf);
2124}
2125
2126/* Return (from the stack of) the BINDING, if any, established at SCOPE. */
2127
2128static inline cxx_binding *
2129find_binding (cp_binding_level *scope, cxx_binding *binding)
2130{
2131 for (; binding != NULL; binding = binding->previous)
2132 if (binding->scope == scope)
2133 return binding;
2134
2135 return (cxx_binding *)0;
2136}
2137
2138/* Return the binding for NAME in SCOPE, if any. Otherwise, return NULL. */
2139
2140static inline cxx_binding *
2141cp_binding_level_find_binding_for_name (cp_binding_level *scope, tree name)
2142{
2143 cxx_binding *b = IDENTIFIER_NAMESPACE_BINDINGS (name);
2144 if (b)
2145 {
2146 /* Fold-in case where NAME is used only once. */
2147 if (scope == b->scope && b->previous == NULL)
2148 return b;
2149 return find_binding (scope, b);
2150 }
2151 return NULL;
2152}
2153
2154/* Always returns a binding for name in scope. If no binding is
2155 found, make a new one. */
2156
2157static cxx_binding *
2158binding_for_name (cp_binding_level *scope, tree name)
2159{
2160 cxx_binding *result;
2161
2162 result = cp_binding_level_find_binding_for_name (scope, name);
2163 if (result)
2164 return result;
2165 /* Not found, make a new one. */
2166 result = cxx_binding_make (NULL, NULL);
2167 result->previous = IDENTIFIER_NAMESPACE_BINDINGS (name);
2168 result->scope = scope;
2169 result->is_local = false;
2170 result->value_is_inherited = false;
2171 IDENTIFIER_NAMESPACE_BINDINGS (name) = result;
2172 return result;
2173}
2174
2175/* Walk through the bindings associated to the name of FUNCTION,
2176 and return the first declaration of a function with a
2177 "C" linkage specification, a.k.a 'extern "C"'.
2178 This function looks for the binding, regardless of which scope it
2179 has been defined in. It basically looks in all the known scopes.
2180 Note that this function does not lookup for bindings of builtin functions
2181 or for functions declared in system headers. */
2182static tree
2183lookup_extern_c_fun_in_all_ns (tree function)
2184{
2185 tree name;
2186 cxx_binding *iter;
2187
2188 gcc_assert (function && TREE_CODE (function) == FUNCTION_DECL);
2189
2190 name = DECL_NAME (function);
2191 gcc_assert (name && identifier_p (name));
2192
2193 for (iter = IDENTIFIER_NAMESPACE_BINDINGS (name);
2194 iter;
2195 iter = iter->previous)
2196 {
2197 tree ovl;
2198 for (ovl = iter->value; ovl; ovl = OVL_NEXT (ovl))
2199 {
2200 tree decl = OVL_CURRENT (ovl);
2201 if (decl
2202 && TREE_CODE (decl) == FUNCTION_DECL
2203 && DECL_EXTERN_C_P (decl)
2204 && !DECL_ARTIFICIAL (decl))
2205 {
2206 return decl;
2207 }
2208 }
2209 }
2210 return NULL;
2211}
2212
2213/* Returns a list of C-linkage decls with the name NAME. */
2214
2215tree
2216c_linkage_bindings (tree name)
2217{
2218 tree decls = NULL_TREE;
2219 cxx_binding *iter;
2220
2221 for (iter = IDENTIFIER_NAMESPACE_BINDINGS (name);
2222 iter;
2223 iter = iter->previous)
2224 {
2225 tree ovl;
2226 for (ovl = iter->value; ovl; ovl = OVL_NEXT (ovl))
2227 {
2228 tree decl = OVL_CURRENT (ovl);
2229 if (decl
2230 && DECL_EXTERN_C_P (decl)
2231 && !DECL_ARTIFICIAL (decl))
2232 {
2233 if (decls == NULL_TREE)
2234 decls = decl;
2235 else
2236 decls = tree_cons (NULL_TREE, decl, decls);
2237 }
2238 }
2239 }
2240 return decls;
2241}
2242
2243/* Insert another USING_DECL into the current binding level, returning
2244 this declaration. If this is a redeclaration, do nothing, and
2245 return NULL_TREE if this not in namespace scope (in namespace
2246 scope, a using decl might extend any previous bindings). */
2247
2248static tree
2249push_using_decl_1 (tree scope, tree name)
2250{
2251 tree decl;
2252
2253 gcc_assert (TREE_CODE (scope) == NAMESPACE_DECL);
2254 gcc_assert (identifier_p (name));
2255 for (decl = current_binding_level->usings; decl; decl = DECL_CHAIN (decl))
2256 if (USING_DECL_SCOPE (decl) == scope && DECL_NAME (decl) == name)
2257 break;
2258 if (decl)
2259 return namespace_bindings_p () ? decl : NULL_TREE;
2260 decl = build_lang_decl (USING_DECL, name, NULL_TREE);
2261 USING_DECL_SCOPE (decl) = scope;
2262 DECL_CHAIN (decl) = current_binding_level->usings;
2263 current_binding_level->usings = decl;
2264 return decl;
2265}
2266
2267/* Wrapper for push_using_decl_1. */
2268
2269static tree
2270push_using_decl (tree scope, tree name)
2271{
2272 tree ret;
2273 timevar_start (TV_NAME_LOOKUP);
2274 ret = push_using_decl_1 (scope, name);
2275 timevar_stop (TV_NAME_LOOKUP);
2276 return ret;
2277}
2278
2279/* Same as pushdecl, but define X in binding-level LEVEL. We rely on the
2280 caller to set DECL_CONTEXT properly.
2281
2282 Note that this must only be used when X will be the new innermost
2283 binding for its name, as we tack it onto the front of IDENTIFIER_BINDING
2284 without checking to see if the current IDENTIFIER_BINDING comes from a
2285 closer binding level than LEVEL. */
2286
2287static tree
2288pushdecl_with_scope_1 (tree x, cp_binding_level *level, bool is_friend)
2289{
2290 cp_binding_level *b;
2291 tree function_decl = current_function_decl;
2292
2293 current_function_decl = NULL_TREE;
2294 if (level->kind == sk_class)
2295 {
2296 b = class_binding_level;
2297 class_binding_level = level;
2298 pushdecl_class_level (x);
2299 class_binding_level = b;
2300 }
2301 else
2302 {
2303 b = current_binding_level;
2304 current_binding_level = level;
2305 x = pushdecl_maybe_friend (x, is_friend);
2306 current_binding_level = b;
2307 }
2308 current_function_decl = function_decl;
2309 return x;
2310}
2311
2312/* Wrapper for pushdecl_with_scope_1. */
2313
2314tree
2315pushdecl_with_scope (tree x, cp_binding_level *level, bool is_friend)
2316{
2317 tree ret;
2318 bool subtime = timevar_cond_start (TV_NAME_LOOKUP);
2319 ret = pushdecl_with_scope_1 (x, level, is_friend);
2320 timevar_cond_stop (TV_NAME_LOOKUP, subtime);
2321 return ret;
2322}
2323
2324/* Helper function for push_overloaded_decl_1 and do_nonmember_using_decl.
2325 Compares the parameter-type-lists of DECL1 and DECL2 and returns false
2326 if they are different. If the DECLs are template functions, the return
2327 types and the template parameter lists are compared too (DR 565). */
2328
2329static bool
2330compparms_for_decl_and_using_decl (tree decl1, tree decl2)
2331{
2332 if (!compparms (TYPE_ARG_TYPES (TREE_TYPE (decl1)),
2333 TYPE_ARG_TYPES (TREE_TYPE (decl2))))
2334 return false;
2335
2336 if (! DECL_FUNCTION_TEMPLATE_P (decl1)
2337 || ! DECL_FUNCTION_TEMPLATE_P (decl2))
2338 return true;
2339
2340 return (comp_template_parms (DECL_TEMPLATE_PARMS (decl1),
2341 DECL_TEMPLATE_PARMS (decl2))
2342 && same_type_p (TREE_TYPE (TREE_TYPE (decl1)),
2343 TREE_TYPE (TREE_TYPE (decl2))));
2344}
2345
2346/* DECL is a FUNCTION_DECL for a non-member function, which may have
2347 other definitions already in place. We get around this by making
2348 the value of the identifier point to a list of all the things that
2349 want to be referenced by that name. It is then up to the users of
2350 that name to decide what to do with that list.
2351
2352 DECL may also be a TEMPLATE_DECL, with a FUNCTION_DECL in its
2353 DECL_TEMPLATE_RESULT. It is dealt with the same way.
2354
2355 FLAGS is a bitwise-or of the following values:
2356 PUSH_LOCAL: Bind DECL in the current scope, rather than at
2357 namespace scope.
2358 PUSH_USING: DECL is being pushed as the result of a using
2359 declaration.
2360
2361 IS_FRIEND is true if this is a friend declaration.
2362
2363 The value returned may be a previous declaration if we guessed wrong
2364 about what language DECL should belong to (C or C++). Otherwise,
2365 it's always DECL (and never something that's not a _DECL). */
2366
2367static tree
2368push_overloaded_decl_1 (tree decl, int flags, bool is_friend)
2369{
2370 tree name = DECL_NAME (decl);
2371 tree old;
2372 tree new_binding;
2373 int doing_global = (namespace_bindings_p () || !(flags & PUSH_LOCAL));
2374
2375 if (doing_global)
2376 old = namespace_binding (name, DECL_CONTEXT (decl));
2377 else
2378 old = lookup_name_innermost_nonclass_level (name);
2379
2380 if (old)
2381 {
2382 if (TREE_CODE (old) == TYPE_DECL && DECL_ARTIFICIAL (old))
2383 {
2384 tree t = TREE_TYPE (old);
2385 if (MAYBE_CLASS_TYPE_P (t) && warn_shadow
2386 && (! DECL_IN_SYSTEM_HEADER (decl)
2387 || ! DECL_IN_SYSTEM_HEADER (old)))
2388 warning (OPT_Wshadow, "%q#D hides constructor for %q#T", decl, t);
2389 old = NULL_TREE;
2390 }
2391 else if (is_overloaded_fn (old))
2392 {
2393 tree tmp;
2394
2395 for (tmp = old; tmp; tmp = OVL_NEXT (tmp))
2396 {
2397 tree fn = OVL_CURRENT (tmp);
2398 tree dup;
2399
2400 if (TREE_CODE (tmp) == OVERLOAD && OVL_USED (tmp)
2401 && !(flags & PUSH_USING)
2402 && compparms_for_decl_and_using_decl (fn, decl)
2403 && ! decls_match (fn, decl))
2404 diagnose_name_conflict (decl, fn);
2405
2406 dup = duplicate_decls (decl, fn, is_friend);
2407 /* If DECL was a redeclaration of FN -- even an invalid
2408 one -- pass that information along to our caller. */
2409 if (dup == fn || dup == error_mark_node)
2410 return dup;
2411 }
2412
2413 /* We don't overload implicit built-ins. duplicate_decls()
2414 may fail to merge the decls if the new decl is e.g. a
2415 template function. */
2416 if (TREE_CODE (old) == FUNCTION_DECL
2417 && DECL_ANTICIPATED (old)
2418 && !DECL_HIDDEN_FRIEND_P (old))
2419 old = NULL;
2420 }
2421 else if (old == error_mark_node)
2422 /* Ignore the undefined symbol marker. */
2423 old = NULL_TREE;
2424 else
2425 {
2426 error ("previous non-function declaration %q+#D", old);
2427 error ("conflicts with function declaration %q#D", decl);
2428 return decl;
2429 }
2430 }
2431
2432 if (old || TREE_CODE (decl) == TEMPLATE_DECL
2433 /* If it's a using declaration, we always need to build an OVERLOAD,
2434 because it's the only way to remember that the declaration comes
2435 from 'using', and have the lookup behave correctly. */
2436 || (flags & PUSH_USING))
2437 {
2438 if (old && TREE_CODE (old) != OVERLOAD)
2439 new_binding = ovl_cons (decl, ovl_cons (old, NULL_TREE));
2440 else
2441 new_binding = ovl_cons (decl, old);
2442 if (flags & PUSH_USING)
2443 OVL_USED (new_binding) = 1;
2444 }
2445 else
2446 /* NAME is not ambiguous. */
2447 new_binding = decl;
2448
2449 if (doing_global)
2450 set_namespace_binding (name, current_namespace, new_binding);
2451 else
2452 {
2453 /* We only create an OVERLOAD if there was a previous binding at
2454 this level, or if decl is a template. In the former case, we
2455 need to remove the old binding and replace it with the new
2456 binding. We must also run through the NAMES on the binding
2457 level where the name was bound to update the chain. */
2458
2459 if (TREE_CODE (new_binding) == OVERLOAD && old)
2460 {
2461 tree *d;
2462
2463 for (d = &IDENTIFIER_BINDING (name)->scope->names;
2464 *d;
2465 d = &TREE_CHAIN (*d))
2466 if (*d == old
2467 || (TREE_CODE (*d) == TREE_LIST
2468 && TREE_VALUE (*d) == old))
2469 {
2470 if (TREE_CODE (*d) == TREE_LIST)
2471 /* Just replace the old binding with the new. */
2472 TREE_VALUE (*d) = new_binding;
2473 else
2474 /* Build a TREE_LIST to wrap the OVERLOAD. */
2475 *d = tree_cons (NULL_TREE, new_binding,
2476 TREE_CHAIN (*d));
2477
2478 /* And update the cxx_binding node. */
2479 IDENTIFIER_BINDING (name)->value = new_binding;
2480 return decl;
2481 }
2482
2483 /* We should always find a previous binding in this case. */
2484 gcc_unreachable ();
2485 }
2486
2487 /* Install the new binding. */
2488 push_local_binding (name, new_binding, flags);
2489 }
2490
2491 return decl;
2492}
2493
2494/* Wrapper for push_overloaded_decl_1. */
2495
2496static tree
2497push_overloaded_decl (tree decl, int flags, bool is_friend)
2498{
2499 tree ret;
2500 bool subtime = timevar_cond_start (TV_NAME_LOOKUP);
2501 ret = push_overloaded_decl_1 (decl, flags, is_friend);
2502 timevar_cond_stop (TV_NAME_LOOKUP, subtime);
2503 return ret;
2504}
2505
2506/* Check a non-member using-declaration. Return the name and scope
2507 being used, and the USING_DECL, or NULL_TREE on failure. */
2508
2509static tree
2510validate_nonmember_using_decl (tree decl, tree scope, tree name)
2511{
2512 /* [namespace.udecl]
2513 A using-declaration for a class member shall be a
2514 member-declaration. */
2515 if (TYPE_P (scope))
2516 {
2517 error ("%qT is not a namespace or unscoped enum", scope);
2518 return NULL_TREE;
2519 }
2520 else if (scope == error_mark_node)
2521 return NULL_TREE;
2522
2523 if (TREE_CODE (decl) == TEMPLATE_ID_EXPR)
2524 {
2525 /* 7.3.3/5
2526 A using-declaration shall not name a template-id. */
2527 error ("a using-declaration cannot specify a template-id. "
2528 "Try %<using %D%>", name);
2529 return NULL_TREE;
2530 }
2531
2532 if (TREE_CODE (decl) == NAMESPACE_DECL)
2533 {
2534 error ("namespace %qD not allowed in using-declaration", decl);
2535 return NULL_TREE;
2536 }
2537
2538 if (TREE_CODE (decl) == SCOPE_REF)
2539 {
2540 /* It's a nested name with template parameter dependent scope.
2541 This can only be using-declaration for class member. */
2542 error ("%qT is not a namespace", TREE_OPERAND (decl, 0));
2543 return NULL_TREE;
2544 }
2545
2546 if (is_overloaded_fn (decl))
2547 decl = get_first_fn (decl);
2548
2549 gcc_assert (DECL_P (decl));
2550
2551 /* Make a USING_DECL. */
2552 tree using_decl = push_using_decl (scope, name);
2553
2554 if (using_decl == NULL_TREE
2555 && at_function_scope_p ()
2556 && VAR_P (decl))
2557 /* C++11 7.3.3/10. */
2558 error ("%qD is already declared in this scope", name);
2559
2560 return using_decl;
2561}
2562
2563/* Process local and global using-declarations. */
2564
2565static void
2566do_nonmember_using_decl (tree scope, tree name, tree oldval, tree oldtype,
2567 tree *newval, tree *newtype)
2568{
2569 struct scope_binding decls = EMPTY_SCOPE_BINDING;
2570
2571 *newval = *newtype = NULL_TREE;
2572 if (!qualified_lookup_using_namespace (name, scope, &decls, 0))
2573 /* Lookup error */
2574 return;
2575
2576 if (!decls.value && !decls.type)
2577 {
2578 error ("%qD not declared", name);
2579 return;
2580 }
2581
2582 /* Shift the old and new bindings around so we're comparing class and
2583 enumeration names to each other. */
2584 if (oldval && DECL_IMPLICIT_TYPEDEF_P (oldval))
2585 {
2586 oldtype = oldval;
2587 oldval = NULL_TREE;
2588 }
2589
2590 if (decls.value && DECL_IMPLICIT_TYPEDEF_P (decls.value))
2591 {
2592 decls.type = decls.value;
2593 decls.value = NULL_TREE;
2594 }
2595
2596 /* It is impossible to overload a built-in function; any explicit
2597 declaration eliminates the built-in declaration. So, if OLDVAL
2598 is a built-in, then we can just pretend it isn't there. */
2599 if (oldval
2600 && TREE_CODE (oldval) == FUNCTION_DECL
2601 && DECL_ANTICIPATED (oldval)
2602 && !DECL_HIDDEN_FRIEND_P (oldval))
2603 oldval = NULL_TREE;
2604
2605 if (decls.value)
2606 {
2607 /* Check for using functions. */
2608 if (is_overloaded_fn (decls.value))
2609 {
2610 tree tmp, tmp1;
2611
2612 if (oldval && !is_overloaded_fn (oldval))
2613 {
2614 error ("%qD is already declared in this scope", name);
2615 oldval = NULL_TREE;
2616 }
2617
2618 *newval = oldval;
2619 for (tmp = decls.value; tmp; tmp = OVL_NEXT (tmp))
2620 {
2621 tree new_fn = OVL_CURRENT (tmp);
2622
2623 /* [namespace.udecl]
2624
2625 If a function declaration in namespace scope or block
2626 scope has the same name and the same parameter types as a
2627 function introduced by a using declaration the program is
2628 ill-formed. */
2629 for (tmp1 = oldval; tmp1; tmp1 = OVL_NEXT (tmp1))
2630 {
2631 tree old_fn = OVL_CURRENT (tmp1);
2632
2633 if (new_fn == old_fn)
2634 /* The function already exists in the current namespace. */
2635 break;
2636 else if (TREE_CODE (tmp1) == OVERLOAD && OVL_USED (tmp1))
2637 continue; /* this is a using decl */
2638 else if (compparms_for_decl_and_using_decl (new_fn, old_fn))
2639 {
2640 gcc_assert (!DECL_ANTICIPATED (old_fn)
2641 || DECL_HIDDEN_FRIEND_P (old_fn));
2642
2643 /* There was already a non-using declaration in
2644 this scope with the same parameter types. If both
2645 are the same extern "C" functions, that's ok. */
2646 if (decls_match (new_fn, old_fn))
2647 break;
2648 else
2649 {
2650 diagnose_name_conflict (new_fn, old_fn);
2651 break;
2652 }
2653 }
2654 }
2655
2656 /* If we broke out of the loop, there's no reason to add
2657 this function to the using declarations for this
2658 scope. */
2659 if (tmp1)
2660 continue;
2661
2662 /* If we are adding to an existing OVERLOAD, then we no
2663 longer know the type of the set of functions. */
2664 if (*newval && TREE_CODE (*newval) == OVERLOAD)
2665 TREE_TYPE (*newval) = unknown_type_node;
2666 /* Add this new function to the set. */
2667 *newval = build_overload (OVL_CURRENT (tmp), *newval);
2668 /* If there is only one function, then we use its type. (A
2669 using-declaration naming a single function can be used in
2670 contexts where overload resolution cannot be
2671 performed.) */
2672 if (TREE_CODE (*newval) != OVERLOAD)
2673 {
2674 *newval = ovl_cons (*newval, NULL_TREE);
2675 TREE_TYPE (*newval) = TREE_TYPE (OVL_CURRENT (tmp));
2676 }
2677 OVL_USED (*newval) = 1;
2678 }
2679 }
2680 else
2681 {
2682 *newval = decls.value;
2683 if (oldval && !decls_match (*newval, oldval))
2684 error ("%qD is already declared in this scope", name);
2685 }
2686 }
2687 else
2688 *newval = oldval;
2689
2690 if (decls.type && TREE_CODE (decls.type) == TREE_LIST)
2691 {
2692 error ("reference to %qD is ambiguous", name);
2693 print_candidates (decls.type);
2694 }
2695 else
2696 {
2697 *newtype = decls.type;
2698 if (oldtype && *newtype && !decls_match (oldtype, *newtype))
2699 error ("%qD is already declared in this scope", name);
2700 }
2701
2702 /* If *newval is empty, shift any class or enumeration name down. */
2703 if (!*newval)
2704 {
2705 *newval = *newtype;
2706 *newtype = NULL_TREE;
2707 }
2708}
2709
2710/* Process a using-declaration at function scope. */
2711
2712void
2713do_local_using_decl (tree decl, tree scope, tree name)
2714{
2715 tree oldval, oldtype, newval, newtype;
2716 tree orig_decl = decl;
2717
2718 decl = validate_nonmember_using_decl (decl, scope, name);
2719 if (decl == NULL_TREE)
2720 return;
2721
2722 if (building_stmt_list_p ()
2723 && at_function_scope_p ())
2724 add_decl_expr (decl);
2725
2726 oldval = lookup_name_innermost_nonclass_level (name);
2727 oldtype = lookup_type_current_level (name);
2728
2729 do_nonmember_using_decl (scope, name, oldval, oldtype, &newval, &newtype);
2730
2731 if (newval)
2732 {
2733 if (is_overloaded_fn (newval))
2734 {
2735 tree fn, term;
2736
2737 /* We only need to push declarations for those functions
2738 that were not already bound in the current level.
2739 The old value might be NULL_TREE, it might be a single
2740 function, or an OVERLOAD. */
2741 if (oldval && TREE_CODE (oldval) == OVERLOAD)
2742 term = OVL_FUNCTION (oldval);
2743 else
2744 term = oldval;
2745 for (fn = newval; fn && OVL_CURRENT (fn) != term;
2746 fn = OVL_NEXT (fn))
2747 push_overloaded_decl (OVL_CURRENT (fn),
2748 PUSH_LOCAL | PUSH_USING,
2749 false);
2750 }
2751 else
2752 push_local_binding (name, newval, PUSH_USING);
2753 }
2754 if (newtype)
2755 {
2756 push_local_binding (name, newtype, PUSH_USING);
2757 set_identifier_type_value (name, newtype);
2758 }
2759
2760 /* Emit debug info. */
2761 if (!processing_template_decl)
2762 cp_emit_debug_info_for_using (orig_decl, current_scope());
2763}
2764
2765/* Returns true if ROOT (a namespace, class, or function) encloses
2766 CHILD. CHILD may be either a class type or a namespace. */
2767
2768bool
2769is_ancestor (tree root, tree child)
2770{
2771 gcc_assert ((TREE_CODE (root) == NAMESPACE_DECL
2772 || TREE_CODE (root) == FUNCTION_DECL
2773 || CLASS_TYPE_P (root)));
2774 gcc_assert ((TREE_CODE (child) == NAMESPACE_DECL
2775 || CLASS_TYPE_P (child)));
2776
2777 /* The global namespace encloses everything. */
2778 if (root == global_namespace)
2779 return true;
2780
2781 while (true)
2782 {
2783 /* If we've run out of scopes, stop. */
2784 if (!child)
2785 return false;
2786 /* If we've reached the ROOT, it encloses CHILD. */
2787 if (root == child)
2788 return true;
2789 /* Go out one level. */
2790 if (TYPE_P (child))
2791 child = TYPE_NAME (child);
2792 child = DECL_CONTEXT (child);
2793 }
2794}
2795
2796/* Enter the class or namespace scope indicated by T suitable for name
2797 lookup. T can be arbitrary scope, not necessary nested inside the
2798 current scope. Returns a non-null scope to pop iff pop_scope
2799 should be called later to exit this scope. */
2800
2801tree
2802push_scope (tree t)
2803{
2804 if (TREE_CODE (t) == NAMESPACE_DECL)
2805 push_decl_namespace (t);
2806 else if (CLASS_TYPE_P (t))
2807 {
2808 if (!at_class_scope_p ()
2809 || !same_type_p (current_class_type, t))
2810 push_nested_class (t);
2811 else
2812 /* T is the same as the current scope. There is therefore no
2813 need to re-enter the scope. Since we are not actually
2814 pushing a new scope, our caller should not call
2815 pop_scope. */
2816 t = NULL_TREE;
2817 }
2818
2819 return t;
2820}
2821
2822/* Leave scope pushed by push_scope. */
2823
2824void
2825pop_scope (tree t)
2826{
2827 if (t == NULL_TREE)
2828 return;
2829 if (TREE_CODE (t) == NAMESPACE_DECL)
2830 pop_decl_namespace ();
2831 else if CLASS_TYPE_P (t)
2832 pop_nested_class ();
2833}
2834
2835/* Subroutine of push_inner_scope. */
2836
2837static void
2838push_inner_scope_r (tree outer, tree inner)
2839{
2840 tree prev;
2841
2842 if (outer == inner
2843 || (TREE_CODE (inner) != NAMESPACE_DECL && !CLASS_TYPE_P (inner)))
2844 return;
2845
2846 prev = CP_DECL_CONTEXT (TREE_CODE (inner) == NAMESPACE_DECL ? inner : TYPE_NAME (inner));
2847 if (outer != prev)
2848 push_inner_scope_r (outer, prev);
2849 if (TREE_CODE (inner) == NAMESPACE_DECL)
2850 {
2851 cp_binding_level *save_template_parm = 0;
2852 /* Temporary take out template parameter scopes. They are saved
2853 in reversed order in save_template_parm. */
2854 while (current_binding_level->kind == sk_template_parms)
2855 {
2856 cp_binding_level *b = current_binding_level;
2857 current_binding_level = b->level_chain;
2858 b->level_chain = save_template_parm;
2859 save_template_parm = b;
2860 }
2861
2862 resume_scope (NAMESPACE_LEVEL (inner));
2863 current_namespace = inner;
2864
2865 /* Restore template parameter scopes. */
2866 while (save_template_parm)
2867 {
2868 cp_binding_level *b = save_template_parm;
2869 save_template_parm = b->level_chain;
2870 b->level_chain = current_binding_level;
2871 current_binding_level = b;
2872 }
2873 }
2874 else
2875 pushclass (inner);
2876}
2877
2878/* Enter the scope INNER from current scope. INNER must be a scope
2879 nested inside current scope. This works with both name lookup and
2880 pushing name into scope. In case a template parameter scope is present,
2881 namespace is pushed under the template parameter scope according to
2882 name lookup rule in 14.6.1/6.
2883
2884 Return the former current scope suitable for pop_inner_scope. */
2885
2886tree
2887push_inner_scope (tree inner)
2888{
2889 tree outer = current_scope ();
2890 if (!outer)
2891 outer = current_namespace;
2892
2893 push_inner_scope_r (outer, inner);
2894 return outer;
2895}
2896
2897/* Exit the current scope INNER back to scope OUTER. */
2898
2899void
2900pop_inner_scope (tree outer, tree inner)
2901{
2902 if (outer == inner
2903 || (TREE_CODE (inner) != NAMESPACE_DECL && !CLASS_TYPE_P (inner)))
2904 return;
2905
2906 while (outer != inner)
2907 {
2908 if (TREE_CODE (inner) == NAMESPACE_DECL)
2909 {
2910 cp_binding_level *save_template_parm = 0;
2911 /* Temporary take out template parameter scopes. They are saved
2912 in reversed order in save_template_parm. */
2913 while (current_binding_level->kind == sk_template_parms)
2914 {
2915 cp_binding_level *b = current_binding_level;
2916 current_binding_level = b->level_chain;
2917 b->level_chain = save_template_parm;
2918 save_template_parm = b;
2919 }
2920
2921 pop_namespace ();
2922
2923 /* Restore template parameter scopes. */
2924 while (save_template_parm)
2925 {
2926 cp_binding_level *b = save_template_parm;
2927 save_template_parm = b->level_chain;
2928 b->level_chain = current_binding_level;
2929 current_binding_level = b;
2930 }
2931 }
2932 else
2933 popclass ();
2934
2935 inner = CP_DECL_CONTEXT (TREE_CODE (inner) == NAMESPACE_DECL ? inner : TYPE_NAME (inner));
2936 }
2937}
2938\f
2939/* Do a pushlevel for class declarations. */
2940
2941void
2942pushlevel_class (void)
2943{
2944 class_binding_level = begin_scope (sk_class, current_class_type);
2945}
2946
2947/* ...and a poplevel for class declarations. */
2948
2949void
2950poplevel_class (void)
2951{
2952 cp_binding_level *level = class_binding_level;
2953 cp_class_binding *cb;
2954 size_t i;
2955 tree shadowed;
2956
2957 bool subtime = timevar_cond_start (TV_NAME_LOOKUP);
2958 gcc_assert (level != 0);
2959
2960 /* If we're leaving a toplevel class, cache its binding level. */
2961 if (current_class_depth == 1)
2962 previous_class_level = level;
2963 for (shadowed = level->type_shadowed;
2964 shadowed;
2965 shadowed = TREE_CHAIN (shadowed))
2966 SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (shadowed), TREE_VALUE (shadowed));
2967
2968 /* Remove the bindings for all of the class-level declarations. */
2969 if (level->class_shadowed)
2970 {
2971 FOR_EACH_VEC_ELT (*level->class_shadowed, i, cb)
2972 {
2973 IDENTIFIER_BINDING (cb->identifier) = cb->base->previous;
2974 cxx_binding_free (cb->base);
2975 }
2976 ggc_free (level->class_shadowed);
2977 level->class_shadowed = NULL;
2978 }
2979
2980 /* Now, pop out of the binding level which we created up in the
2981 `pushlevel_class' routine. */
2982 gcc_assert (current_binding_level == level);
2983 leave_scope ();
2984 timevar_cond_stop (TV_NAME_LOOKUP, subtime);
2985}
2986
2987/* Set INHERITED_VALUE_BINDING_P on BINDING to true or false, as
2988 appropriate. DECL is the value to which a name has just been
2989 bound. CLASS_TYPE is the class in which the lookup occurred. */
2990
2991static void
2992set_inherited_value_binding_p (cxx_binding *binding, tree decl,
2993 tree class_type)
2994{
2995 if (binding->value == decl && TREE_CODE (decl) != TREE_LIST)
2996 {
2997 tree context;
2998
2999 if (TREE_CODE (decl) == OVERLOAD)
3000 context = ovl_scope (decl);
3001 else
3002 {
3003 gcc_assert (DECL_P (decl));
3004 context = context_for_name_lookup (decl);
3005 }
3006
3007 if (is_properly_derived_from (class_type, context))
3008 INHERITED_VALUE_BINDING_P (binding) = 1;
3009 else
3010 INHERITED_VALUE_BINDING_P (binding) = 0;
3011 }
3012 else if (binding->value == decl)
3013 /* We only encounter a TREE_LIST when there is an ambiguity in the
3014 base classes. Such an ambiguity can be overridden by a
3015 definition in this class. */
3016 INHERITED_VALUE_BINDING_P (binding) = 1;
3017 else
3018 INHERITED_VALUE_BINDING_P (binding) = 0;
3019}
3020
3021/* Make the declaration of X appear in CLASS scope. */
3022
3023bool
3024pushdecl_class_level (tree x)
3025{
3026 tree name;
3027 bool is_valid = true;
3028 bool subtime;
3029
3030 /* Do nothing if we're adding to an outer lambda closure type,
3031 outer_binding will add it later if it's needed. */
3032 if (current_class_type != class_binding_level->this_entity)
3033 return true;
3034
3035 subtime = timevar_cond_start (TV_NAME_LOOKUP);
3036 /* Get the name of X. */
3037 if (TREE_CODE (x) == OVERLOAD)
3038 name = DECL_NAME (get_first_fn (x));
3039 else
3040 name = DECL_NAME (x);
3041
3042 if (name)
3043 {
3044 is_valid = push_class_level_binding (name, x);
3045 if (TREE_CODE (x) == TYPE_DECL)
3046 set_identifier_type_value (name, x);
3047 }
3048 else if (ANON_AGGR_TYPE_P (TREE_TYPE (x)))
3049 {
3050 /* If X is an anonymous aggregate, all of its members are
3051 treated as if they were members of the class containing the
3052 aggregate, for naming purposes. */
3053 tree f;
3054
3055 for (f = TYPE_FIELDS (TREE_TYPE (x)); f; f = DECL_CHAIN (f))
3056 {
3057 location_t save_location = input_location;
3058 input_location = DECL_SOURCE_LOCATION (f);
3059 if (!pushdecl_class_level (f))
3060 is_valid = false;
3061 input_location = save_location;
3062 }
3063 }
3064 timevar_cond_stop (TV_NAME_LOOKUP, subtime);
3065 return is_valid;
3066}
3067
3068/* Return the BINDING (if any) for NAME in SCOPE, which is a class
3069 scope. If the value returned is non-NULL, and the PREVIOUS field
3070 is not set, callers must set the PREVIOUS field explicitly. */
3071
3072static cxx_binding *
3073get_class_binding (tree name, cp_binding_level *scope)
3074{
3075 tree class_type;
3076 tree type_binding;
3077 tree value_binding;
3078 cxx_binding *binding;
3079
3080 class_type = scope->this_entity;
3081
3082 /* Get the type binding. */
3083 type_binding = lookup_member (class_type, name,
3084 /*protect=*/2, /*want_type=*/true,
3085 tf_warning_or_error);
3086 /* Get the value binding. */
3087 value_binding = lookup_member (class_type, name,
3088 /*protect=*/2, /*want_type=*/false,
3089 tf_warning_or_error);
3090
3091 if (value_binding
3092 && (TREE_CODE (value_binding) == TYPE_DECL
3093 || DECL_CLASS_TEMPLATE_P (value_binding)
3094 || (TREE_CODE (value_binding) == TREE_LIST
3095 && TREE_TYPE (value_binding) == error_mark_node
3096 && (TREE_CODE (TREE_VALUE (value_binding))
3097 == TYPE_DECL))))
3098 /* We found a type binding, even when looking for a non-type
3099 binding. This means that we already processed this binding
3100 above. */
3101 ;
3102 else if (value_binding)
3103 {
3104 if (TREE_CODE (value_binding) == TREE_LIST
3105 && TREE_TYPE (value_binding) == error_mark_node)
3106 /* NAME is ambiguous. */
3107 ;
3108 else if (BASELINK_P (value_binding))
3109 /* NAME is some overloaded functions. */
3110 value_binding = BASELINK_FUNCTIONS (value_binding);
3111 }
3112
3113 /* If we found either a type binding or a value binding, create a
3114 new binding object. */
3115 if (type_binding || value_binding)
3116 {
3117 binding = new_class_binding (name,
3118 value_binding,
3119 type_binding,
3120 scope);
3121 /* This is a class-scope binding, not a block-scope binding. */
3122 LOCAL_BINDING_P (binding) = 0;
3123 set_inherited_value_binding_p (binding, value_binding, class_type);
3124 }
3125 else
3126 binding = NULL;
3127
3128 return binding;
3129}
3130
3131/* Make the declaration(s) of X appear in CLASS scope under the name
3132 NAME. Returns true if the binding is valid. */
3133
3134static bool
3135push_class_level_binding_1 (tree name, tree x)
3136{
3137 cxx_binding *binding;
3138 tree decl = x;
3139 bool ok;
3140
3141 /* The class_binding_level will be NULL if x is a template
3142 parameter name in a member template. */
3143 if (!class_binding_level)
3144 return true;
3145
3146 if (name == error_mark_node)
3147 return false;
3148
3149 /* Can happen for an erroneous declaration (c++/60384). */
3150 if (!identifier_p (name))
3151 {
3152 gcc_assert (errorcount || sorrycount);
3153 return false;
3154 }
3155
3156 /* Check for invalid member names. But don't worry about a default
3157 argument-scope lambda being pushed after the class is complete. */
3158 gcc_assert (TYPE_BEING_DEFINED (current_class_type)
3159 || LAMBDA_TYPE_P (TREE_TYPE (decl)));
3160 /* Check that we're pushing into the right binding level. */
3161 gcc_assert (current_class_type == class_binding_level->this_entity);
3162
3163 /* We could have been passed a tree list if this is an ambiguous
3164 declaration. If so, pull the declaration out because
3165 check_template_shadow will not handle a TREE_LIST. */
3166 if (TREE_CODE (decl) == TREE_LIST
3167 && TREE_TYPE (decl) == error_mark_node)
3168 decl = TREE_VALUE (decl);
3169
3170 if (!check_template_shadow (decl))
3171 return false;
3172
3173 /* [class.mem]
3174
3175 If T is the name of a class, then each of the following shall
3176 have a name different from T:
3177
3178 -- every static data member of class T;
3179
3180 -- every member of class T that is itself a type;
3181
3182 -- every enumerator of every member of class T that is an
3183 enumerated type;
3184
3185 -- every member of every anonymous union that is a member of
3186 class T.
3187
3188 (Non-static data members were also forbidden to have the same
3189 name as T until TC1.) */
3190 if ((VAR_P (x)
3191 || TREE_CODE (x) == CONST_DECL
3192 || (TREE_CODE (x) == TYPE_DECL
3193 && !DECL_SELF_REFERENCE_P (x))
3194 /* A data member of an anonymous union. */
3195 || (TREE_CODE (x) == FIELD_DECL
3196 && DECL_CONTEXT (x) != current_class_type))
3197 && DECL_NAME (x) == constructor_name (current_class_type))
3198 {
3199 tree scope = context_for_name_lookup (x);
3200 if (TYPE_P (scope) && same_type_p (scope, current_class_type))
3201 {
3202 error ("%qD has the same name as the class in which it is "
3203 "declared",
3204 x);
3205 return false;
3206 }
3207 }
3208
3209 /* Get the current binding for NAME in this class, if any. */
3210 binding = IDENTIFIER_BINDING (name);
3211 if (!binding || binding->scope != class_binding_level)
3212 {
3213 binding = get_class_binding (name, class_binding_level);
3214 /* If a new binding was created, put it at the front of the
3215 IDENTIFIER_BINDING list. */
3216 if (binding)
3217 {
3218 binding->previous = IDENTIFIER_BINDING (name);
3219 IDENTIFIER_BINDING (name) = binding;
3220 }
3221 }
3222
3223 /* If there is already a binding, then we may need to update the
3224 current value. */
3225 if (binding && binding->value)
3226 {
3227 tree bval = binding->value;
3228 tree old_decl = NULL_TREE;
3229 tree target_decl = strip_using_decl (decl);
3230 tree target_bval = strip_using_decl (bval);
3231
3232 if (INHERITED_VALUE_BINDING_P (binding))
3233 {
3234 /* If the old binding was from a base class, and was for a
3235 tag name, slide it over to make room for the new binding.
3236 The old binding is still visible if explicitly qualified
3237 with a class-key. */
3238 if (TREE_CODE (target_bval) == TYPE_DECL
3239 && DECL_ARTIFICIAL (target_bval)
3240 && !(TREE_CODE (target_decl) == TYPE_DECL
3241 && DECL_ARTIFICIAL (target_decl)))
3242 {
3243 old_decl = binding->type;
3244 binding->type = bval;
3245 binding->value = NULL_TREE;
3246 INHERITED_VALUE_BINDING_P (binding) = 0;
3247 }
3248 else
3249 {
3250 old_decl = bval;
3251 /* Any inherited type declaration is hidden by the type
3252 declaration in the derived class. */
3253 if (TREE_CODE (target_decl) == TYPE_DECL
3254 && DECL_ARTIFICIAL (target_decl))
3255 binding->type = NULL_TREE;
3256 }
3257 }
3258 else if (TREE_CODE (target_decl) == OVERLOAD
3259 && is_overloaded_fn (target_bval))
3260 old_decl = bval;
3261 else if (TREE_CODE (decl) == USING_DECL
3262 && TREE_CODE (bval) == USING_DECL
3263 && same_type_p (USING_DECL_SCOPE (decl),
3264 USING_DECL_SCOPE (bval)))
3265 /* This is a using redeclaration that will be diagnosed later
3266 in supplement_binding */
3267 ;
3268 else if (TREE_CODE (decl) == USING_DECL
3269 && TREE_CODE (bval) == USING_DECL
3270 && DECL_DEPENDENT_P (decl)
3271 && DECL_DEPENDENT_P (bval))
3272 return true;
3273 else if (TREE_CODE (decl) == USING_DECL
3274 && is_overloaded_fn (target_bval))
3275 old_decl = bval;
3276 else if (TREE_CODE (bval) == USING_DECL
3277 && is_overloaded_fn (target_decl))
3278 return true;
3279
3280 if (old_decl && binding->scope == class_binding_level)
3281 {
3282 binding->value = x;
3283 /* It is always safe to clear INHERITED_VALUE_BINDING_P
3284 here. This function is only used to register bindings
3285 from with the class definition itself. */
3286 INHERITED_VALUE_BINDING_P (binding) = 0;
3287 return true;
3288 }
3289 }
3290
3291 /* Note that we declared this value so that we can issue an error if
3292 this is an invalid redeclaration of a name already used for some
3293 other purpose. */
3294 note_name_declared_in_class (name, decl);
3295
3296 /* If we didn't replace an existing binding, put the binding on the
3297 stack of bindings for the identifier, and update the shadowed
3298 list. */
3299 if (binding && binding->scope == class_binding_level)
3300 /* Supplement the existing binding. */
3301 ok = supplement_binding (binding, decl);
3302 else
3303 {
3304 /* Create a new binding. */
3305 push_binding (name, decl, class_binding_level);
3306 ok = true;
3307 }
3308
3309 return ok;
3310}
3311
3312/* Wrapper for push_class_level_binding_1. */
3313
3314bool
3315push_class_level_binding (tree name, tree x)
3316{
3317 bool ret;
3318 bool subtime = timevar_cond_start (TV_NAME_LOOKUP);
3319 ret = push_class_level_binding_1 (name, x);
3320 timevar_cond_stop (TV_NAME_LOOKUP, subtime);
3321 return ret;
3322}
3323
3324/* Process "using SCOPE::NAME" in a class scope. Return the
3325 USING_DECL created. */
3326
3327tree
3328do_class_using_decl (tree scope, tree name)
3329{
3330 /* The USING_DECL returned by this function. */
3331 tree value;
3332 /* The declaration (or declarations) name by this using
3333 declaration. NULL if we are in a template and cannot figure out
3334 what has been named. */
3335 tree decl;
3336 /* True if SCOPE is a dependent type. */
3337 bool scope_dependent_p;
3338 /* True if SCOPE::NAME is dependent. */
3339 bool name_dependent_p;
3340 /* True if any of the bases of CURRENT_CLASS_TYPE are dependent. */
3341 bool bases_dependent_p;
3342 tree binfo;
3343 tree base_binfo;
3344 int i;
3345
3346 if (name == error_mark_node)
3347 return NULL_TREE;
3348
3349 if (!scope || !TYPE_P (scope))
3350 {
3351 error ("using-declaration for non-member at class scope");
3352 return NULL_TREE;
3353 }
3354
3355 /* Make sure the name is not invalid */
3356 if (TREE_CODE (name) == BIT_NOT_EXPR)
3357 {
3358 error ("%<%T::%D%> names destructor", scope, name);
3359 return NULL_TREE;
3360 }
3361 /* Using T::T declares inheriting ctors, even if T is a typedef. */
3362 if (MAYBE_CLASS_TYPE_P (scope)
3363 && (name == TYPE_IDENTIFIER (scope)
3364 || constructor_name_p (name, scope)))
3365 {
3366 maybe_warn_cpp0x (CPP0X_INHERITING_CTORS);
3367 name = ctor_identifier;
3368 }
3369 if (constructor_name_p (name, current_class_type))
3370 {
3371 error ("%<%T::%D%> names constructor in %qT",
3372 scope, name, current_class_type);
3373 return NULL_TREE;
3374 }
3375
3376 scope_dependent_p = dependent_scope_p (scope);
3377 name_dependent_p = (scope_dependent_p
3378 || (IDENTIFIER_TYPENAME_P (name)
3379 && dependent_type_p (TREE_TYPE (name))));
3380
3381 bases_dependent_p = false;
3382 if (processing_template_decl)
3383 for (binfo = TYPE_BINFO (current_class_type), i = 0;
3384 BINFO_BASE_ITERATE (binfo, i, base_binfo);
3385 i++)
3386 if (dependent_type_p (TREE_TYPE (base_binfo)))
3387 {
3388 bases_dependent_p = true;
3389 break;
3390 }
3391
3392 decl = NULL_TREE;
3393
3394 /* From [namespace.udecl]:
3395
3396 A using-declaration used as a member-declaration shall refer to a
3397 member of a base class of the class being defined.
3398
3399 In general, we cannot check this constraint in a template because
3400 we do not know the entire set of base classes of the current
3401 class type. Morover, if SCOPE is dependent, it might match a
3402 non-dependent base. */
3403
3404 if (!scope_dependent_p)
3405 {
3406 base_kind b_kind;
3407 binfo = lookup_base (current_class_type, scope, ba_any, &b_kind,
3408 tf_warning_or_error);
3409 if (b_kind < bk_proper_base)
3410 {
3411 if (!bases_dependent_p)
3412 {
3413 error_not_base_type (scope, current_class_type);
3414 return NULL_TREE;
3415 }
3416 }
3417 else if (!name_dependent_p)
3418 {
3419 decl = lookup_member (binfo, name, 0, false, tf_warning_or_error);
3420 if (!decl)
3421 {
3422 error ("no members matching %<%T::%D%> in %q#T", scope, name,
3423 scope);
3424 return NULL_TREE;
3425 }
3426 /* The binfo from which the functions came does not matter. */
3427 if (BASELINK_P (decl))
3428 decl = BASELINK_FUNCTIONS (decl);
3429 }
3430 }
3431
3432 value = build_lang_decl (USING_DECL, name, NULL_TREE);
3433 USING_DECL_DECLS (value) = decl;
3434 USING_DECL_SCOPE (value) = scope;
3435 DECL_DEPENDENT_P (value) = !decl;
3436
3437 return value;
3438}
3439
3440\f
3441/* Return the binding value for name in scope. */
3442
3443
3444static tree
3445namespace_binding_1 (tree name, tree scope)
3446{
3447 cxx_binding *binding;
3448
3449 if (SCOPE_FILE_SCOPE_P (scope))
3450 scope = global_namespace;
3451 else
3452 /* Unnecessary for the global namespace because it can't be an alias. */
3453 scope = ORIGINAL_NAMESPACE (scope);
3454
3455 binding = cp_binding_level_find_binding_for_name (NAMESPACE_LEVEL (scope), name);
3456
3457 return binding ? binding->value : NULL_TREE;
3458}
3459
3460tree
3461namespace_binding (tree name, tree scope)
3462{
3463 tree ret;
3464 bool subtime = timevar_cond_start (TV_NAME_LOOKUP);
3465 ret = namespace_binding_1 (name, scope);
3466 timevar_cond_stop (TV_NAME_LOOKUP, subtime);
3467 return ret;
3468}
3469
3470/* Set the binding value for name in scope. */
3471
3472static void
3473set_namespace_binding_1 (tree name, tree scope, tree val)
3474{
3475 cxx_binding *b;
3476
3477 if (scope == NULL_TREE)
3478 scope = global_namespace;
3479 b = binding_for_name (NAMESPACE_LEVEL (scope), name);
3480 if (!b->value || TREE_CODE (val) == OVERLOAD || val == error_mark_node)
3481 b->value = val;
3482 else
3483 supplement_binding (b, val);
3484}
3485
3486/* Wrapper for set_namespace_binding_1. */
3487
3488void
3489set_namespace_binding (tree name, tree scope, tree val)
3490{
3491 bool subtime = timevar_cond_start (TV_NAME_LOOKUP);
3492 set_namespace_binding_1 (name, scope, val);
3493 timevar_cond_stop (TV_NAME_LOOKUP, subtime);
3494}
3495
3496/* Set the context of a declaration to scope. Complain if we are not
3497 outside scope. */
3498
3499void
3500set_decl_namespace (tree decl, tree scope, bool friendp)
3501{
3502 tree old;
3503
3504 /* Get rid of namespace aliases. */
3505 scope = ORIGINAL_NAMESPACE (scope);
3506
3507 /* It is ok for friends to be qualified in parallel space. */
3508 if (!friendp && !is_ancestor (current_namespace, scope))
3509 error ("declaration of %qD not in a namespace surrounding %qD",
3510 decl, scope);
3511 DECL_CONTEXT (decl) = FROB_CONTEXT (scope);
3512
3513 /* Writing "int N::i" to declare a variable within "N" is invalid. */
3514 if (scope == current_namespace)
3515 {
3516 if (at_namespace_scope_p ())
3517 error ("explicit qualification in declaration of %qD",
3518 decl);
3519 return;
3520 }
3521
3522 /* See whether this has been declared in the namespace. */
3523 old = lookup_qualified_name (scope, DECL_NAME (decl), false, true);
3524 if (old == error_mark_node)
3525 /* No old declaration at all. */
3526 goto complain;
3527 /* If it's a TREE_LIST, the result of the lookup was ambiguous. */
3528 if (TREE_CODE (old) == TREE_LIST)
3529 {
3530 error ("reference to %qD is ambiguous", decl);
3531 print_candidates (old);
3532 return;
3533 }
3534 if (!is_overloaded_fn (decl))
3535 {
3536 /* We might have found OLD in an inline namespace inside SCOPE. */
3537 if (TREE_CODE (decl) == TREE_CODE (old))
3538 DECL_CONTEXT (decl) = DECL_CONTEXT (old);
3539 /* Don't compare non-function decls with decls_match here, since
3540 it can't check for the correct constness at this
3541 point. pushdecl will find those errors later. */
3542 return;
3543 }
3544 /* Since decl is a function, old should contain a function decl. */
3545 if (!is_overloaded_fn (old))
3546 goto complain;
3547 /* A template can be explicitly specialized in any namespace. */
3548 if (processing_explicit_instantiation)
3549 return;
3550 if (processing_template_decl || processing_specialization)
3551 /* We have not yet called push_template_decl to turn a
3552 FUNCTION_DECL into a TEMPLATE_DECL, so the declarations won't
3553 match. But, we'll check later, when we construct the
3554 template. */
3555 return;
3556 /* Instantiations or specializations of templates may be declared as
3557 friends in any namespace. */
3558 if (friendp && DECL_USE_TEMPLATE (decl))
3559 return;
3560 if (is_overloaded_fn (old))
3561 {
3562 tree found = NULL_TREE;
3563 tree elt = old;
3564 for (; elt; elt = OVL_NEXT (elt))
3565 {
3566 tree ofn = OVL_CURRENT (elt);
3567 /* Adjust DECL_CONTEXT first so decls_match will return true
3568 if DECL will match a declaration in an inline namespace. */
3569 DECL_CONTEXT (decl) = DECL_CONTEXT (ofn);
3570 if (decls_match (decl, ofn))
3571 {
3572 if (found && !decls_match (found, ofn))
3573 {
3574 DECL_CONTEXT (decl) = FROB_CONTEXT (scope);
3575 error ("reference to %qD is ambiguous", decl);
3576 print_candidates (old);
3577 return;
3578 }
3579 found = ofn;
3580 }
3581 }
3582 if (found)
3583 {
3584 if (!is_associated_namespace (scope, CP_DECL_CONTEXT (found)))
3585 goto complain;
3586 DECL_CONTEXT (decl) = DECL_CONTEXT (found);
3587 return;
3588 }
3589 }
3590 else
3591 {
3592 DECL_CONTEXT (decl) = DECL_CONTEXT (old);
3593 if (decls_match (decl, old))
3594 return;
3595 }
3596
3597 /* It didn't work, go back to the explicit scope. */
3598 DECL_CONTEXT (decl) = FROB_CONTEXT (scope);
3599 complain:
3600 error ("%qD should have been declared inside %qD", decl, scope);
3601}
3602
3603/* Return the namespace where the current declaration is declared. */
3604
3605tree
3606current_decl_namespace (void)
3607{
3608 tree result;
3609 /* If we have been pushed into a different namespace, use it. */
3610 if (!vec_safe_is_empty (decl_namespace_list))
3611 return decl_namespace_list->last ();
3612
3613 if (current_class_type)
3614 result = decl_namespace_context (current_class_type);
3615 else if (current_function_decl)
3616 result = decl_namespace_context (current_function_decl);
3617 else
3618 result = current_namespace;
3619 return result;
3620}
3621
3622/* Process any ATTRIBUTES on a namespace definition. Returns true if
3623 attribute visibility is seen. */
3624
3625bool
3626handle_namespace_attrs (tree ns, tree attributes)
3627{
3628 tree d;
3629 bool saw_vis = false;
3630
3631 for (d = attributes; d; d = TREE_CHAIN (d))
3632 {
3633 tree name = get_attribute_name (d);
3634 tree args = TREE_VALUE (d);
3635
3636 if (is_attribute_p ("visibility", name))
3637 {
3638 /* attribute visibility is a property of the syntactic block
3639 rather than the namespace as a whole, so we don't touch the
3640 NAMESPACE_DECL at all. */
3641 tree x = args ? TREE_VALUE (args) : NULL_TREE;
3642 if (x == NULL_TREE || TREE_CODE (x) != STRING_CST || TREE_CHAIN (args))
3643 {
3644 warning (OPT_Wattributes,
3645 "%qD attribute requires a single NTBS argument",
3646 name);
3647 continue;
3648 }
3649
3650 if (!TREE_PUBLIC (ns))
3651 warning (OPT_Wattributes,
3652 "%qD attribute is meaningless since members of the "
3653 "anonymous namespace get local symbols", name);
3654
3655 push_visibility (TREE_STRING_POINTER (x), 1);
3656 saw_vis = true;
3657 }
3658 else if (is_attribute_p ("abi_tag", name))
3659 {
38c0c85b
JM
3660 if (!NAMESPACE_IS_INLINE (ns))
3661 {
3662 warning (OPT_Wattributes, "ignoring %qD attribute on non-inline "
3663 "namespace", name);
3664 continue;
3665 }
3666 if (!args)
3667 {
3668 tree dn = DECL_NAME (ns);
3669 args = build_string (IDENTIFIER_LENGTH (dn) + 1,
3670 IDENTIFIER_POINTER (dn));
3671 TREE_TYPE (args) = char_array_type_node;
3672 args = fix_string_type (args);
3673 args = build_tree_list (NULL_TREE, args);
3674 }
3675 if (check_abi_tag_args (args, name))
3676 DECL_ATTRIBUTES (ns) = tree_cons (name, args,
3677 DECL_ATTRIBUTES (ns));
dda118e3
JM
3678 }
3679 else
3680 {
3681 warning (OPT_Wattributes, "%qD attribute directive ignored",
3682 name);
3683 continue;
3684 }
3685 }
3686
3687 return saw_vis;
3688}
3689
3690/* Push into the scope of the NAME namespace. If NAME is NULL_TREE, then we
3691 select a name that is unique to this compilation unit. */
3692
3693void
3694push_namespace (tree name)
3695{
3696 tree d = NULL_TREE;
3697 bool need_new = true;
3698 bool implicit_use = false;
3699 bool anon = !name;
3700
3701 bool subtime = timevar_cond_start (TV_NAME_LOOKUP);
3702
3703 /* We should not get here if the global_namespace is not yet constructed
3704 nor if NAME designates the global namespace: The global scope is
3705 constructed elsewhere. */
3706 gcc_assert (global_namespace != NULL && name != global_scope_name);
3707
3708 if (anon)
3709 {
3710 name = get_anonymous_namespace_name();
3711 d = IDENTIFIER_NAMESPACE_VALUE (name);
3712 if (d)
3713 /* Reopening anonymous namespace. */
3714 need_new = false;
3715 implicit_use = true;
3716 }
3717 else
3718 {
3719 /* Check whether this is an extended namespace definition. */
3720 d = IDENTIFIER_NAMESPACE_VALUE (name);
3721 if (d != NULL_TREE && TREE_CODE (d) == NAMESPACE_DECL)
3722 {
3723 tree dna = DECL_NAMESPACE_ALIAS (d);
3724 if (dna)
3725 {
3726 /* We do some error recovery for, eg, the redeclaration
3727 of M here:
3728
3729 namespace N {}
3730 namespace M = N;
3731 namespace M {}
3732
3733 However, in nasty cases like:
3734
3735 namespace N
3736 {
3737 namespace M = N;
3738 namespace M {}
3739 }
3740
3741 we just error out below, in duplicate_decls. */
3742 if (NAMESPACE_LEVEL (dna)->level_chain
3743 == current_binding_level)
3744 {
3745 error ("namespace alias %qD not allowed here, "
3746 "assuming %qD", d, dna);
3747 d = dna;
3748 need_new = false;
3749 }
3750 }
3751