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