OSDN Git Service

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