OSDN Git Service

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