OSDN Git Service

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