OSDN Git Service

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