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