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