OSDN Git Service

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