OSDN Git Service

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