1 /* Definitions for C++ name lookup routines.
2 Copyright (C) 2003-2018 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 #define INCLUDE_UNIQUE_PTR
23 #include "system.h"
24 #include "coretypes.h"
25 #include "cp-tree.h"
26 #include "timevar.h"
27 #include "stringpool.h"
28 #include "print-tree.h"
29 #include "attribs.h"
30 #include "debug.h"
31 #include "c-family/c-pragma.h"
32 #include "params.h"
33 #include "gcc-rich-location.h"
34 #include "spellcheck-tree.h"
35 #include "parser.h"
36 #include "c-family/name-hint.h"
37 #include "c-family/known-headers.h"
38 #include "c-family/c-spellcheck.h"
39
40 static cxx_binding *cxx_binding_make (tree value, tree type);
41 static cp_binding_level *innermost_nonclass_level (void);
42 static void set_identifier_type_value_with_scope (tree id, tree decl,
43 cp_binding_level *b);
44 static bool maybe_suggest_missing_std_header (location_t location, tree name);
45
46 /* Create an overload suitable for recording an artificial TYPE_DECL
47 and another decl. We use this machanism to implement the struct
48 stat hack within a namespace. It'd be nice to use it everywhere. */
49
50 #define STAT_HACK_P(N) ((N) && TREE_CODE (N) == OVERLOAD && OVL_LOOKUP_P (N))
51 #define STAT_TYPE(N) TREE_TYPE (N)
52 #define STAT_DECL(N) OVL_FUNCTION (N)
53 #define MAYBE_STAT_DECL(N) (STAT_HACK_P (N) ? STAT_DECL (N) : N)
54 #define MAYBE_STAT_TYPE(N) (STAT_HACK_P (N) ? STAT_TYPE (N) : NULL_TREE)
55
56 /* Create a STAT_HACK node with DECL as the value binding and TYPE as
57 the type binding. */
58
59 static tree
60 stat_hack (tree decl = NULL_TREE, tree type = NULL_TREE)
61 {
62 tree result = make_node (OVERLOAD);
63
64 /* Mark this as a lookup, so we can tell this is a stat hack. */
65 OVL_LOOKUP_P (result) = true;
66 STAT_DECL (result) = decl;
67 STAT_TYPE (result) = type;
68 return result;
69 }
70
71 /* Create a local binding level for NAME. */
72
73 static cxx_binding *
create_local_binding(cp_binding_level * level,tree name)74 create_local_binding (cp_binding_level *level, tree name)
75 {
76 cxx_binding *binding = cxx_binding_make (NULL, NULL);
77
78 INHERITED_VALUE_BINDING_P (binding) = false;
79 LOCAL_BINDING_P (binding) = true;
80 binding->scope = level;
81 binding->previous = IDENTIFIER_BINDING (name);
82
83 IDENTIFIER_BINDING (name) = binding;
84
85 return binding;
86 }
87
88 /* Find the binding for NAME in namespace NS. If CREATE_P is true,
89 make an empty binding if there wasn't one. */
90
91 static tree *
92 find_namespace_slot (tree ns, tree name, bool create_p = false)
93 {
94 tree *slot = DECL_NAMESPACE_BINDINGS (ns)
95 ->find_slot_with_hash (name, name ? IDENTIFIER_HASH_VALUE (name) : 0,
96 create_p ? INSERT : NO_INSERT);
97 return slot;
98 }
99
100 static tree
find_namespace_value(tree ns,tree name)101 find_namespace_value (tree ns, tree name)
102 {
103 tree *b = find_namespace_slot (ns, name);
104
105 return b ? MAYBE_STAT_DECL (*b) : NULL_TREE;
106 }
107
108 /* Add DECL to the list of things declared in B. */
109
110 static void
add_decl_to_level(cp_binding_level * b,tree decl)111 add_decl_to_level (cp_binding_level *b, tree decl)
112 {
113 gcc_assert (b->kind != sk_class);
114
115 /* Make sure we don't create a circular list. xref_tag can end
116 up pushing the same artificial decl more than once. We
117 should have already detected that in update_binding. */
118 gcc_assert (b->names != decl);
119
120 /* We build up the list in reverse order, and reverse it later if
121 necessary. */
122 TREE_CHAIN (decl) = b->names;
123 b->names = decl;
124
125 /* If appropriate, add decl to separate list of statics. We
126 include extern variables because they might turn out to be
127 static later. It's OK for this list to contain a few false
128 positives. */
129 if (b->kind == sk_namespace
130 && ((VAR_P (decl)
131 && (TREE_STATIC (decl) || DECL_EXTERNAL (decl)))
132 || (TREE_CODE (decl) == FUNCTION_DECL
133 && (!TREE_PUBLIC (decl)
134 || decl_anon_ns_mem_p (decl)
135 || DECL_DECLARED_INLINE_P (decl)))))
136 vec_safe_push (static_decls, decl);
137 }
138
139 /* Find the binding for NAME in the local binding level B. */
140
141 static cxx_binding *
find_local_binding(cp_binding_level * b,tree name)142 find_local_binding (cp_binding_level *b, tree name)
143 {
144 if (cxx_binding *binding = IDENTIFIER_BINDING (name))
145 for (;; b = b->level_chain)
146 {
147 if (binding->scope == b
148 && !(VAR_P (binding->value)
149 && DECL_DEAD_FOR_LOCAL (binding->value)))
150 return binding;
151
152 /* Cleanup contours are transparent to the language. */
153 if (b->kind != sk_cleanup)
154 break;
155 }
156 return NULL;
157 }
158
159 struct name_lookup
160 {
161 public:
162 typedef std::pair<tree, tree> using_pair;
163 typedef vec<using_pair, va_heap, vl_embed> using_queue;
164
165 public:
166 tree name; /* The identifier being looked for. */
167 tree value; /* A (possibly ambiguous) set of things found. */
168 tree type; /* A type that has been found. */
169 int flags; /* Lookup flags. */
170 bool deduping; /* Full deduping is needed because using declarations
171 are in play. */
172 vec<tree, va_heap, vl_embed> *scopes;
173 name_lookup *previous; /* Previously active lookup. */
174
175 protected:
176 /* Marked scope stack for outermost name lookup. */
177 static vec<tree, va_heap, vl_embed> *shared_scopes;
178 /* Currently active lookup. */
179 static name_lookup *active;
180
181 public:
182 name_lookup (tree n, int f = 0)
namename_lookup183 : name (n), value (NULL_TREE), type (NULL_TREE), flags (f),
184 deduping (false), scopes (NULL), previous (NULL)
185 {
186 preserve_state ();
187 }
~name_lookupname_lookup188 ~name_lookup ()
189 {
190 restore_state ();
191 }
192
193 private: /* Uncopyable, unmovable, unassignable. I am a rock. */
194 name_lookup (const name_lookup &);
195 name_lookup &operator= (const name_lookup &);
196
197 protected:
seen_pname_lookup198 static bool seen_p (tree scope)
199 {
200 return LOOKUP_SEEN_P (scope);
201 }
found_pname_lookup202 static bool found_p (tree scope)
203 {
204 return LOOKUP_FOUND_P (scope);
205 }
206
207 void mark_seen (tree scope); /* Mark and add to scope vector. */
mark_foundname_lookup208 static void mark_found (tree scope)
209 {
210 gcc_checking_assert (seen_p (scope));
211 LOOKUP_FOUND_P (scope) = true;
212 }
see_and_markname_lookup213 bool see_and_mark (tree scope)
214 {
215 bool ret = seen_p (scope);
216 if (!ret)
217 mark_seen (scope);
218 return ret;
219 }
220 bool find_and_mark (tree scope);
221
222 private:
223 void preserve_state ();
224 void restore_state ();
225
226 private:
227 static tree ambiguous (tree thing, tree current);
228 void add_overload (tree fns);
229 void add_value (tree new_val);
230 void add_type (tree new_type);
231 bool process_binding (tree val_bind, tree type_bind);
232
233 /* Look in only namespace. */
234 bool search_namespace_only (tree scope);
235 /* Look in namespace and its (recursive) inlines. Ignore using
236 directives. Return true if something found (inc dups). */
237 bool search_namespace (tree scope);
238 /* Look in the using directives of namespace + inlines using
239 qualified lookup rules. */
240 bool search_usings (tree scope);
241
242 private:
243 using_queue *queue_namespace (using_queue *queue, int depth, tree scope);
244 using_queue *do_queue_usings (using_queue *queue, int depth,
245 vec<tree, va_gc> *usings);
queue_usingsname_lookup246 using_queue *queue_usings (using_queue *queue, int depth,
247 vec<tree, va_gc> *usings)
248 {
249 if (usings)
250 queue = do_queue_usings (queue, depth, usings);
251 return queue;
252 }
253
254 private:
255 void add_fns (tree);
256
257 void adl_expr (tree);
258 void adl_type (tree);
259 void adl_template_arg (tree);
260 void adl_class (tree);
261 void adl_bases (tree);
262 void adl_class_only (tree);
263 void adl_namespace (tree);
264 void adl_namespace_only (tree);
265
266 public:
267 /* Search namespace + inlines + maybe usings as qualified lookup. */
268 bool search_qualified (tree scope, bool usings = true);
269
270 /* Search namespace + inlines + usings as unqualified lookup. */
271 bool search_unqualified (tree scope, cp_binding_level *);
272
273 /* ADL lookup of ARGS. */
274 tree search_adl (tree fns, vec<tree, va_gc> *args);
275 };
276
277 /* Scope stack shared by all outermost lookups. This avoids us
278 allocating and freeing on every single lookup. */
279 vec<tree, va_heap, vl_embed> *name_lookup::shared_scopes;
280
281 /* Currently active lookup. */
282 name_lookup *name_lookup::active;
283
284 /* Name lookup is recursive, becase ADL can cause template
285 instatiation. This is of course a rare event, so we optimize for
286 it not happening. When we discover an active name-lookup, which
287 must be an ADL lookup, we need to unmark the marked scopes and also
288 unmark the lookup we might have been accumulating. */
289
290 void
preserve_state()291 name_lookup::preserve_state ()
292 {
293 previous = active;
294 if (previous)
295 {
296 unsigned length = vec_safe_length (previous->scopes);
297 vec_safe_reserve (previous->scopes, length * 2);
298 for (unsigned ix = length; ix--;)
299 {
300 tree decl = (*previous->scopes)[ix];
301
302 gcc_checking_assert (LOOKUP_SEEN_P (decl));
303 LOOKUP_SEEN_P (decl) = false;
304
305 /* Preserve the FOUND_P state on the interrupted lookup's
306 stack. */
307 if (LOOKUP_FOUND_P (decl))
308 {
309 LOOKUP_FOUND_P (decl) = false;
310 previous->scopes->quick_push (decl);
311 }
312 }
313
314 /* Unmark the outer partial lookup. */
315 if (previous->deduping)
316 lookup_mark (previous->value, false);
317 }
318 else
319 scopes = shared_scopes;
320 active = this;
321 }
322
323 /* Restore the marking state of a lookup we interrupted. */
324
325 void
restore_state()326 name_lookup::restore_state ()
327 {
328 if (deduping)
329 lookup_mark (value, false);
330
331 /* Unmark and empty this lookup's scope stack. */
332 for (unsigned ix = vec_safe_length (scopes); ix--;)
333 {
334 tree decl = scopes->pop ();
335 gcc_checking_assert (LOOKUP_SEEN_P (decl));
336 LOOKUP_SEEN_P (decl) = false;
337 LOOKUP_FOUND_P (decl) = false;
338 }
339
340 active = previous;
341 if (previous)
342 {
343 free (scopes);
344
345 unsigned length = vec_safe_length (previous->scopes);
346 for (unsigned ix = 0; ix != length; ix++)
347 {
348 tree decl = (*previous->scopes)[ix];
349 if (LOOKUP_SEEN_P (decl))
350 {
351 /* The remainder of the scope stack must be recording
352 FOUND_P decls, which we want to pop off. */
353 do
354 {
355 tree decl = previous->scopes->pop ();
356 gcc_checking_assert (LOOKUP_SEEN_P (decl)
357 && !LOOKUP_FOUND_P (decl));
358 LOOKUP_FOUND_P (decl) = true;
359 }
360 while (++ix != length);
361 break;
362 }
363
364 gcc_checking_assert (!LOOKUP_FOUND_P (decl));
365 LOOKUP_SEEN_P (decl) = true;
366 }
367
368 /* Remark the outer partial lookup. */
369 if (previous->deduping)
370 lookup_mark (previous->value, true);
371 }
372 else
373 shared_scopes = scopes;
374 }
375
376 void
mark_seen(tree scope)377 name_lookup::mark_seen (tree scope)
378 {
379 gcc_checking_assert (!seen_p (scope));
380 LOOKUP_SEEN_P (scope) = true;
381 vec_safe_push (scopes, scope);
382 }
383
384 bool
find_and_mark(tree scope)385 name_lookup::find_and_mark (tree scope)
386 {
387 bool result = LOOKUP_FOUND_P (scope);
388 if (!result)
389 {
390 LOOKUP_FOUND_P (scope) = true;
391 if (!LOOKUP_SEEN_P (scope))
392 vec_safe_push (scopes, scope);
393 }
394
395 return result;
396 }
397
398 /* THING and CURRENT are ambiguous, concatenate them. */
399
400 tree
ambiguous(tree thing,tree current)401 name_lookup::ambiguous (tree thing, tree current)
402 {
403 if (TREE_CODE (current) != TREE_LIST)
404 {
405 current = build_tree_list (NULL_TREE, current);
406 TREE_TYPE (current) = error_mark_node;
407 }
408 current = tree_cons (NULL_TREE, thing, current);
409 TREE_TYPE (current) = error_mark_node;
410
411 return current;
412 }
413
414 /* FNS is a new overload set to add to the exising set. */
415
416 void
add_overload(tree fns)417 name_lookup::add_overload (tree fns)
418 {
419 if (!deduping && TREE_CODE (fns) == OVERLOAD)
420 {
421 tree probe = fns;
422 if (flags & LOOKUP_HIDDEN)
423 probe = ovl_skip_hidden (probe);
424 if (probe && TREE_CODE (probe) == OVERLOAD && OVL_USING_P (probe))
425 {
426 /* We're about to add something found by a using
427 declaration, so need to engage deduping mode. */
428 lookup_mark (value, true);
429 deduping = true;
430 }
431 }
432
433 value = lookup_maybe_add (fns, value, deduping);
434 }
435
436 /* Add a NEW_VAL, a found value binding into the current value binding. */
437
438 void
add_value(tree new_val)439 name_lookup::add_value (tree new_val)
440 {
441 if (OVL_P (new_val) && (!value || OVL_P (value)))
442 add_overload (new_val);
443 else if (!value)
444 value = new_val;
445 else if (value == new_val)
446 ;
447 else if ((TREE_CODE (value) == TYPE_DECL
448 && TREE_CODE (new_val) == TYPE_DECL
449 && same_type_p (TREE_TYPE (value), TREE_TYPE (new_val))))
450 /* Typedefs to the same type. */;
451 else if (TREE_CODE (value) == NAMESPACE_DECL
452 && TREE_CODE (new_val) == NAMESPACE_DECL
453 && ORIGINAL_NAMESPACE (value) == ORIGINAL_NAMESPACE (new_val))
454 /* Namespace (possibly aliased) to the same namespace. Locate
455 the namespace*/
456 value = ORIGINAL_NAMESPACE (value);
457 else
458 {
459 if (deduping)
460 {
461 /* Disengage deduping mode. */
462 lookup_mark (value, false);
463 deduping = false;
464 }
465 value = ambiguous (new_val, value);
466 }
467 }
468
469 /* Add a NEW_TYPE, a found type binding into the current type binding. */
470
471 void
add_type(tree new_type)472 name_lookup::add_type (tree new_type)
473 {
474 if (!type)
475 type = new_type;
476 else if (TREE_CODE (type) == TREE_LIST
477 || !same_type_p (TREE_TYPE (type), TREE_TYPE (new_type)))
478 type = ambiguous (new_type, type);
479 }
480
481 /* Process a found binding containing NEW_VAL and NEW_TYPE. Returns
482 true if we actually found something noteworthy. */
483
484 bool
process_binding(tree new_val,tree new_type)485 name_lookup::process_binding (tree new_val, tree new_type)
486 {
487 /* Did we really see a type? */
488 if (new_type
489 && (LOOKUP_NAMESPACES_ONLY (flags)
490 || (!(flags & LOOKUP_HIDDEN)
491 && DECL_LANG_SPECIFIC (new_type)
492 && DECL_ANTICIPATED (new_type))))
493 new_type = NULL_TREE;
494
495 if (new_val && !(flags & LOOKUP_HIDDEN))
496 new_val = ovl_skip_hidden (new_val);
497
498 /* Do we really see a value? */
499 if (new_val)
500 switch (TREE_CODE (new_val))
501 {
502 case TEMPLATE_DECL:
503 /* If we expect types or namespaces, and not templates,
504 or this is not a template class. */
505 if ((LOOKUP_QUALIFIERS_ONLY (flags)
506 && !DECL_TYPE_TEMPLATE_P (new_val)))
507 new_val = NULL_TREE;
508 break;
509 case TYPE_DECL:
510 if (LOOKUP_NAMESPACES_ONLY (flags)
511 || (new_type && (flags & LOOKUP_PREFER_TYPES)))
512 new_val = NULL_TREE;
513 break;
514 case NAMESPACE_DECL:
515 if (LOOKUP_TYPES_ONLY (flags))
516 new_val = NULL_TREE;
517 break;
518 default:
519 if (LOOKUP_QUALIFIERS_ONLY (flags))
520 new_val = NULL_TREE;
521 }
522
523 if (!new_val)
524 {
525 new_val = new_type;
526 new_type = NULL_TREE;
527 }
528
529 /* Merge into the lookup */
530 if (new_val)
531 add_value (new_val);
532 if (new_type)
533 add_type (new_type);
534
535 return new_val != NULL_TREE;
536 }
537
538 /* Look in exactly namespace SCOPE. */
539
540 bool
search_namespace_only(tree scope)541 name_lookup::search_namespace_only (tree scope)
542 {
543 bool found = false;
544
545 if (tree *binding = find_namespace_slot (scope, name))
546 found |= process_binding (MAYBE_STAT_DECL (*binding),
547 MAYBE_STAT_TYPE (*binding));
548
549 return found;
550 }
551
552 /* Conditionally look in namespace SCOPE and inline children. */
553
554 bool
search_namespace(tree scope)555 name_lookup::search_namespace (tree scope)
556 {
557 if (see_and_mark (scope))
558 /* We've visited this scope before. Return what we found then. */
559 return found_p (scope);
560
561 /* Look in exactly namespace. */
562 bool found = search_namespace_only (scope);
563
564 /* Don't look into inline children, if we're looking for an
565 anonymous name -- it must be in the current scope, if anywhere. */
566 if (name)
567 /* Recursively look in its inline children. */
568 if (vec<tree, va_gc> *inlinees = DECL_NAMESPACE_INLINEES (scope))
569 for (unsigned ix = inlinees->length (); ix--;)
570 found |= search_namespace ((*inlinees)[ix]);
571
572 if (found)
573 mark_found (scope);
574
575 return found;
576 }
577
578 /* Recursively follow using directives of SCOPE & its inline children.
579 Such following is essentially a flood-fill algorithm. */
580
581 bool
search_usings(tree scope)582 name_lookup::search_usings (tree scope)
583 {
584 /* We do not check seen_p here, as that was already set during the
585 namespace_only walk. */
586 if (found_p (scope))
587 return true;
588
589 bool found = false;
590 if (vec<tree, va_gc> *usings = DECL_NAMESPACE_USING (scope))
591 for (unsigned ix = usings->length (); ix--;)
592 found |= search_qualified ((*usings)[ix], true);
593
594 /* Look in its inline children. */
595 if (vec<tree, va_gc> *inlinees = DECL_NAMESPACE_INLINEES (scope))
596 for (unsigned ix = inlinees->length (); ix--;)
597 found |= search_usings ((*inlinees)[ix]);
598
599 if (found)
600 mark_found (scope);
601
602 return found;
603 }
604
605 /* Qualified namespace lookup in SCOPE.
606 1) Look in SCOPE (+inlines). If found, we're done.
607 2) Otherwise, if USINGS is true,
608 recurse for every using directive of SCOPE (+inlines).
609
610 Trickiness is (a) loops and (b) multiple paths to same namespace.
611 In both cases we want to not repeat any lookups, and know whether
612 to stop the caller's step #2. Do this via the FOUND_P marker. */
613
614 bool
search_qualified(tree scope,bool usings)615 name_lookup::search_qualified (tree scope, bool usings)
616 {
617 bool found = false;
618
619 if (seen_p (scope))
620 found = found_p (scope);
621 else
622 {
623 found = search_namespace (scope);
624 if (!found && usings)
625 found = search_usings (scope);
626 }
627
628 return found;
629 }
630
631 /* Add SCOPE to the unqualified search queue, recursively add its
632 inlines and those via using directives. */
633
634 name_lookup::using_queue *
queue_namespace(using_queue * queue,int depth,tree scope)635 name_lookup::queue_namespace (using_queue *queue, int depth, tree scope)
636 {
637 if (see_and_mark (scope))
638 return queue;
639
640 /* Record it. */
641 tree common = scope;
642 while (SCOPE_DEPTH (common) > depth)
643 common = CP_DECL_CONTEXT (common);
644 vec_safe_push (queue, using_pair (common, scope));
645
646 /* Queue its inline children. */
647 if (vec<tree, va_gc> *inlinees = DECL_NAMESPACE_INLINEES (scope))
648 for (unsigned ix = inlinees->length (); ix--;)
649 queue = queue_namespace (queue, depth, (*inlinees)[ix]);
650
651 /* Queue its using targets. */
652 queue = queue_usings (queue, depth, DECL_NAMESPACE_USING (scope));
653
654 return queue;
655 }
656
657 /* Add the namespaces in USINGS to the unqualified search queue. */
658
659 name_lookup::using_queue *
do_queue_usings(using_queue * queue,int depth,vec<tree,va_gc> * usings)660 name_lookup::do_queue_usings (using_queue *queue, int depth,
661 vec<tree, va_gc> *usings)
662 {
663 for (unsigned ix = usings->length (); ix--;)
664 queue = queue_namespace (queue, depth, (*usings)[ix]);
665
666 return queue;
667 }
668
669 /* Unqualified namespace lookup in SCOPE.
670 1) add scope+inlins to worklist.
671 2) recursively add target of every using directive
672 3) for each worklist item where SCOPE is common ancestor, search it
673 4) if nothing find, scope=parent, goto 1. */
674
675 bool
search_unqualified(tree scope,cp_binding_level * level)676 name_lookup::search_unqualified (tree scope, cp_binding_level *level)
677 {
678 /* Make static to avoid continual reallocation. We're not
679 recursive. */
680 static using_queue *queue = NULL;
681 bool found = false;
682 int length = vec_safe_length (queue);
683
684 /* Queue local using-directives. */
685 for (; level->kind != sk_namespace; level = level->level_chain)
686 queue = queue_usings (queue, SCOPE_DEPTH (scope), level->using_directives);
687
688 for (; !found; scope = CP_DECL_CONTEXT (scope))
689 {
690 gcc_assert (!DECL_NAMESPACE_ALIAS (scope));
691 int depth = SCOPE_DEPTH (scope);
692
693 /* Queue namespaces reachable from SCOPE. */
694 queue = queue_namespace (queue, depth, scope);
695
696 /* Search every queued namespace where SCOPE is the common
697 ancestor. Adjust the others. */
698 unsigned ix = length;
699 do
700 {
701 using_pair &pair = (*queue)[ix];
702 while (pair.first == scope)
703 {
704 found |= search_namespace_only (pair.second);
705 pair = queue->pop ();
706 if (ix == queue->length ())
707 goto done;
708 }
709 /* The depth is the same as SCOPE, find the parent scope. */
710 if (SCOPE_DEPTH (pair.first) == depth)
711 pair.first = CP_DECL_CONTEXT (pair.first);
712 ix++;
713 }
714 while (ix < queue->length ());
715 done:;
716 if (scope == global_namespace)
717 break;
718
719 /* If looking for hidden names, we only look in the innermost
720 namespace scope. [namespace.memdef]/3 If a friend
721 declaration in a non-local class first declares a class,
722 function, class template or function template the friend is a
723 member of the innermost enclosing namespace. See also
724 [basic.lookup.unqual]/7 */
725 if (flags & LOOKUP_HIDDEN)
726 break;
727 }
728
729 vec_safe_truncate (queue, length);
730
731 return found;
732 }
733
734 /* FNS is a value binding. If it is a (set of overloaded) functions,
735 add them into the current value. */
736
737 void
add_fns(tree fns)738 name_lookup::add_fns (tree fns)
739 {
740 if (!fns)
741 return;
742 else if (TREE_CODE (fns) == OVERLOAD)
743 {
744 if (TREE_TYPE (fns) != unknown_type_node)
745 fns = OVL_FUNCTION (fns);
746 }
747 else if (!DECL_DECLARES_FUNCTION_P (fns))
748 return;
749
750 add_overload (fns);
751 }
752
753 /* Add functions of a namespace to the lookup structure. */
754
755 void
adl_namespace_only(tree scope)756 name_lookup::adl_namespace_only (tree scope)
757 {
758 mark_seen (scope);
759
760 /* Look down into inline namespaces. */
761 if (vec<tree, va_gc> *inlinees = DECL_NAMESPACE_INLINEES (scope))
762 for (unsigned ix = inlinees->length (); ix--;)
763 adl_namespace_only ((*inlinees)[ix]);
764
765 if (tree fns = find_namespace_value (scope, name))
766 add_fns (ovl_skip_hidden (fns));
767 }
768
769 /* Find the containing non-inlined namespace, add it and all its
770 inlinees. */
771
772 void
adl_namespace(tree scope)773 name_lookup::adl_namespace (tree scope)
774 {
775 if (seen_p (scope))
776 return;
777
778 /* Find the containing non-inline namespace. */
779 while (DECL_NAMESPACE_INLINE_P (scope))
780 scope = CP_DECL_CONTEXT (scope);
781
782 adl_namespace_only (scope);
783 }
784
785 /* Adds the class and its friends to the lookup structure. */
786
787 void
adl_class_only(tree type)788 name_lookup::adl_class_only (tree type)
789 {
790 /* Backend-built structures, such as __builtin_va_list, aren't
791 affected by all this. */
792 if (!CLASS_TYPE_P (type))
793 return;
794
795 type = TYPE_MAIN_VARIANT (type);
796
797 if (see_and_mark (type))
798 return;
799
800 tree context = decl_namespace_context (type);
801 adl_namespace (context);
802
803 complete_type (type);
804
805 /* Add friends. */
806 for (tree list = DECL_FRIENDLIST (TYPE_MAIN_DECL (type)); list;
807 list = TREE_CHAIN (list))
808 if (name == FRIEND_NAME (list))
809 for (tree friends = FRIEND_DECLS (list); friends;
810 friends = TREE_CHAIN (friends))
811 {
812 tree fn = TREE_VALUE (friends);
813
814 /* Only interested in global functions with potentially hidden
815 (i.e. unqualified) declarations. */
816 if (CP_DECL_CONTEXT (fn) != context)
817 continue;
818
819 /* Only interested in anticipated friends. (Non-anticipated
820 ones will have been inserted during the namespace
821 adl.) */
822 if (!DECL_ANTICIPATED (fn))
823 continue;
824
825 /* Template specializations are never found by name lookup.
826 (Templates themselves can be found, but not template
827 specializations.) */
828 if (TREE_CODE (fn) == FUNCTION_DECL && DECL_USE_TEMPLATE (fn))
829 continue;
830
831 add_fns (fn);
832 }
833 }
834
835 /* Adds the class and its bases to the lookup structure.
836 Returns true on error. */
837
838 void
adl_bases(tree type)839 name_lookup::adl_bases (tree type)
840 {
841 adl_class_only (type);
842
843 /* Process baseclasses. */
844 if (tree binfo = TYPE_BINFO (type))
845 {
846 tree base_binfo;
847 int i;
848
849 for (i = 0; BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
850 adl_bases (BINFO_TYPE (base_binfo));
851 }
852 }
853
854 /* Adds everything associated with a class argument type to the lookup
855 structure. Returns true on error.
856
857 If T is a class type (including unions), its associated classes are: the
858 class itself; the class of which it is a member, if any; and its direct
859 and indirect base classes. Its associated namespaces are the namespaces
860 of which its associated classes are members. Furthermore, if T is a
861 class template specialization, its associated namespaces and classes
862 also include: the namespaces and classes associated with the types of
863 the template arguments provided for template type parameters (excluding
864 template template parameters); the namespaces of which any template
865 template arguments are members; and the classes of which any member
866 templates used as template template arguments are members. [ Note:
867 non-type template arguments do not contribute to the set of associated
868 namespaces. --end note] */
869
870 void
adl_class(tree type)871 name_lookup::adl_class (tree type)
872 {
873 /* Backend build structures, such as __builtin_va_list, aren't
874 affected by all this. */
875 if (!CLASS_TYPE_P (type))
876 return;
877
878 type = TYPE_MAIN_VARIANT (type);
879 /* We don't set found here because we have to have set seen first,
880 which is done in the adl_bases walk. */
881 if (found_p (type))
882 return;
883
884 adl_bases (type);
885 mark_found (type);
886
887 if (TYPE_CLASS_SCOPE_P (type))
888 adl_class_only (TYPE_CONTEXT (type));
889
890 /* Process template arguments. */
891 if (CLASSTYPE_TEMPLATE_INFO (type)
892 && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (type)))
893 {
894 tree list = INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (type));
895 for (int i = 0; i < TREE_VEC_LENGTH (list); ++i)
896 adl_template_arg (TREE_VEC_ELT (list, i));
897 }
898 }
899
900 void
adl_expr(tree expr)901 name_lookup::adl_expr (tree expr)
902 {
903 if (!expr)
904 return;
905
906 gcc_assert (!TYPE_P (expr));
907
908 if (TREE_TYPE (expr) != unknown_type_node)
909 {
910 adl_type (TREE_TYPE (expr));
911 return;
912 }
913
914 if (TREE_CODE (expr) == ADDR_EXPR)
915 expr = TREE_OPERAND (expr, 0);
916 if (TREE_CODE (expr) == COMPONENT_REF
917 || TREE_CODE (expr) == OFFSET_REF)
918 expr = TREE_OPERAND (expr, 1);
919 expr = MAYBE_BASELINK_FUNCTIONS (expr);
920
921 if (OVL_P (expr))
922 for (lkp_iterator iter (expr); iter; ++iter)
923 adl_type (TREE_TYPE (*iter));
924 else if (TREE_CODE (expr) == TEMPLATE_ID_EXPR)
925 {
926 /* The working paper doesn't currently say how to handle
927 template-id arguments. The sensible thing would seem to be
928 to handle the list of template candidates like a normal
929 overload set, and handle the template arguments like we do
930 for class template specializations. */
931
932 /* First the templates. */
933 adl_expr (TREE_OPERAND (expr, 0));
934
935 /* Now the arguments. */
936 if (tree args = TREE_OPERAND (expr, 1))
937 for (int ix = TREE_VEC_LENGTH (args); ix--;)
938 adl_template_arg (TREE_VEC_ELT (args, ix));
939 }
940 }
941
942 void
adl_type(tree type)943 name_lookup::adl_type (tree type)
944 {
945 if (!type)
946 return;
947
948 if (TYPE_PTRDATAMEM_P (type))
949 {
950 /* Pointer to member: associate class type and value type. */
951 adl_type (TYPE_PTRMEM_CLASS_TYPE (type));
952 adl_type (TYPE_PTRMEM_POINTED_TO_TYPE (type));
953 return;
954 }
955
956 switch (TREE_CODE (type))
957 {
958 case RECORD_TYPE:
959 if (TYPE_PTRMEMFUNC_P (type))
960 {
961 adl_type (TYPE_PTRMEMFUNC_FN_TYPE (type));
962 return;
963 }
964 /* FALLTHRU */
965 case UNION_TYPE:
966 adl_class (type);
967 return;
968
969 case METHOD_TYPE:
970 /* The basetype is referenced in the first arg type, so just
971 fall through. */
972 case FUNCTION_TYPE:
973 /* Associate the parameter types. */
974 for (tree args = TYPE_ARG_TYPES (type); args; args = TREE_CHAIN (args))
975 adl_type (TREE_VALUE (args));
976 /* FALLTHROUGH */
977
978 case POINTER_TYPE:
979 case REFERENCE_TYPE:
980 case ARRAY_TYPE:
981 adl_type (TREE_TYPE (type));
982 return;
983
984 case ENUMERAL_TYPE:
985 if (TYPE_CLASS_SCOPE_P (type))
986 adl_class_only (TYPE_CONTEXT (type));
987 adl_namespace (decl_namespace_context (type));
988 return;
989
990 case LANG_TYPE:
991 gcc_assert (type == unknown_type_node
992 || type == init_list_type_node);
993 return;
994
995 case TYPE_PACK_EXPANSION:
996 adl_type (PACK_EXPANSION_PATTERN (type));
997 return;
998
999 default:
1000 break;
1001 }
1002 }
1003
1004 /* Adds everything associated with a template argument to the lookup
1005 structure. */
1006
1007 void
adl_template_arg(tree arg)1008 name_lookup::adl_template_arg (tree arg)
1009 {
1010 /* [basic.lookup.koenig]
1011
1012 If T is a template-id, its associated namespaces and classes are
1013 ... the namespaces and classes associated with the types of the
1014 template arguments provided for template type parameters
1015 (excluding template template parameters); the namespaces in which
1016 any template template arguments are defined; and the classes in
1017 which any member templates used as template template arguments
1018 are defined. [Note: non-type template arguments do not
1019 contribute to the set of associated namespaces. ] */
1020
1021 /* Consider first template template arguments. */
1022 if (TREE_CODE (arg) == TEMPLATE_TEMPLATE_PARM
1023 || TREE_CODE (arg) == UNBOUND_CLASS_TEMPLATE)
1024 ;
1025 else if (TREE_CODE (arg) == TEMPLATE_DECL)
1026 {
1027 tree ctx = CP_DECL_CONTEXT (arg);
1028
1029 /* It's not a member template. */
1030 if (TREE_CODE (ctx) == NAMESPACE_DECL)
1031 adl_namespace (ctx);
1032 /* Otherwise, it must be member template. */
1033 else
1034 adl_class_only (ctx);
1035 }
1036 /* It's an argument pack; handle it recursively. */
1037 else if (ARGUMENT_PACK_P (arg))
1038 {
1039 tree args = ARGUMENT_PACK_ARGS (arg);
1040 int i, len = TREE_VEC_LENGTH (args);
1041 for (i = 0; i < len; ++i)
1042 adl_template_arg (TREE_VEC_ELT (args, i));
1043 }
1044 /* It's not a template template argument, but it is a type template
1045 argument. */
1046 else if (TYPE_P (arg))
1047 adl_type (arg);
1048 }
1049
1050 /* Perform ADL lookup. FNS is the existing lookup result and ARGS are
1051 the call arguments. */
1052
1053 tree
search_adl(tree fns,vec<tree,va_gc> * args)1054 name_lookup::search_adl (tree fns, vec<tree, va_gc> *args)
1055 {
1056 if (fns)
1057 {
1058 deduping = true;
1059 lookup_mark (fns, true);
1060 }
1061 value = fns;
1062
1063 unsigned ix;
1064 tree arg;
1065
1066 FOR_EACH_VEC_ELT_REVERSE (*args, ix, arg)
1067 /* OMP reduction operators put an ADL-significant type as the
1068 first arg. */
1069 if (TYPE_P (arg))
1070 adl_type (arg);
1071 else
1072 adl_expr (arg);
1073
1074 fns = value;
1075
1076 return fns;
1077 }
1078
1079 static bool qualified_namespace_lookup (tree, name_lookup *);
1080 static void consider_binding_level (tree name,
1081 best_match <tree, const char *> &bm,
1082 cp_binding_level *lvl,
1083 bool look_within_fields,
1084 enum lookup_name_fuzzy_kind kind);
1085 static void diagnose_name_conflict (tree, tree);
1086
1087 /* ADL lookup of NAME. FNS is the result of regular lookup, and we
1088 don't add duplicates to it. ARGS is the vector of call
1089 arguments (which will not be empty). */
1090
1091 tree
lookup_arg_dependent(tree name,tree fns,vec<tree,va_gc> * args)1092 lookup_arg_dependent (tree name, tree fns, vec<tree, va_gc> *args)
1093 {
1094 bool subtime = timevar_cond_start (TV_NAME_LOOKUP);
1095 name_lookup lookup (name);
1096 fns = lookup.search_adl (fns, args);
1097 timevar_cond_stop (TV_NAME_LOOKUP, subtime);
1098 return fns;
1099 }
1100
1101 /* FNS is an overload set of conversion functions. Return the
1102 overloads converting to TYPE. */
1103
1104 static tree
extract_conversion_operator(tree fns,tree type)1105 extract_conversion_operator (tree fns, tree type)
1106 {
1107 tree convs = NULL_TREE;
1108 tree tpls = NULL_TREE;
1109
1110 for (ovl_iterator iter (fns); iter; ++iter)
1111 {
1112 if (same_type_p (DECL_CONV_FN_TYPE (*iter), type))
1113 convs = lookup_add (*iter, convs);
1114
1115 if (TREE_CODE (*iter) == TEMPLATE_DECL)
1116 tpls = lookup_add (*iter, tpls);
1117 }
1118
1119 if (!convs)
1120 convs = tpls;
1121
1122 return convs;
1123 }
1124
1125 /* Binary search of (ordered) MEMBER_VEC for NAME. */
1126
1127 static tree
member_vec_binary_search(vec<tree,va_gc> * member_vec,tree name)1128 member_vec_binary_search (vec<tree, va_gc> *member_vec, tree name)
1129 {
1130 for (unsigned lo = 0, hi = member_vec->length (); lo < hi;)
1131 {
1132 unsigned mid = (lo + hi) / 2;
1133 tree binding = (*member_vec)[mid];
1134 tree binding_name = OVL_NAME (binding);
1135
1136 if (binding_name > name)
1137 hi = mid;
1138 else if (binding_name < name)
1139 lo = mid + 1;
1140 else
1141 return binding;
1142 }
1143
1144 return NULL_TREE;
1145 }
1146
1147 /* Linear search of (unordered) MEMBER_VEC for NAME. */
1148
1149 static tree
member_vec_linear_search(vec<tree,va_gc> * member_vec,tree name)1150 member_vec_linear_search (vec<tree, va_gc> *member_vec, tree name)
1151 {
1152 for (int ix = member_vec->length (); ix--;)
1153 if (tree binding = (*member_vec)[ix])
1154 if (OVL_NAME (binding) == name)
1155 return binding;
1156
1157 return NULL_TREE;
1158 }
1159
1160 /* Linear search of (partially ordered) fields of KLASS for NAME. */
1161
1162 static tree
fields_linear_search(tree klass,tree name,bool want_type)1163 fields_linear_search (tree klass, tree name, bool want_type)
1164 {
1165 for (tree fields = TYPE_FIELDS (klass); fields; fields = DECL_CHAIN (fields))
1166 {
1167 tree decl = fields;
1168
1169 if (TREE_CODE (decl) == FIELD_DECL
1170 && ANON_AGGR_TYPE_P (TREE_TYPE (decl)))
1171 {
1172 if (tree temp = search_anon_aggr (TREE_TYPE (decl), name, want_type))
1173 return temp;
1174 }
1175
1176 if (DECL_NAME (decl) != name)
1177 continue;
1178
1179 if (TREE_CODE (decl) == USING_DECL)
1180 {
1181 decl = strip_using_decl (decl);
1182 if (is_overloaded_fn (decl))
1183 continue;
1184 }
1185
1186 if (DECL_DECLARES_FUNCTION_P (decl))
1187 /* Functions are found separately. */
1188 continue;
1189
1190 if (!want_type || DECL_DECLARES_TYPE_P (decl))
1191 return decl;
1192 }
1193
1194 return NULL_TREE;
1195 }
1196
1197 /* Look for NAME member inside of anonymous aggregate ANON. Although
1198 such things should only contain FIELD_DECLs, we check that too
1199 late, and would give very confusing errors if we weren't
1200 permissive here. */
1201
1202 tree
search_anon_aggr(tree anon,tree name,bool want_type)1203 search_anon_aggr (tree anon, tree name, bool want_type)
1204 {
1205 gcc_assert (COMPLETE_TYPE_P (anon));
1206 tree ret = get_class_binding_direct (anon, name, want_type);
1207 return ret;
1208 }
1209
1210 /* Look for NAME as an immediate member of KLASS (including
1211 anon-members or unscoped enum member). TYPE_OR_FNS is zero for
1212 regular search. >0 to get a type binding (if there is one) and <0
1213 if you want (just) the member function binding.
1214
1215 Use this if you do not want lazy member creation. */
1216
1217 tree
get_class_binding_direct(tree klass,tree name,int type_or_fns)1218 get_class_binding_direct (tree klass, tree name, int type_or_fns)
1219 {
1220 gcc_checking_assert (RECORD_OR_UNION_TYPE_P (klass));
1221
1222 /* Conversion operators can only be found by the marker conversion
1223 operator name. */
1224 bool conv_op = IDENTIFIER_CONV_OP_P (name);
1225 tree lookup = conv_op ? conv_op_identifier : name;
1226 tree val = NULL_TREE;
1227 vec<tree, va_gc> *member_vec = CLASSTYPE_MEMBER_VEC (klass);
1228
1229 if (COMPLETE_TYPE_P (klass) && member_vec)
1230 {
1231 val = member_vec_binary_search (member_vec, lookup);
1232 if (!val)
1233 ;
1234 else if (type_or_fns > 0)
1235 {
1236 if (STAT_HACK_P (val))
1237 val = STAT_TYPE (val);
1238 else if (!DECL_DECLARES_TYPE_P (val))
1239 val = NULL_TREE;
1240 }
1241 else if (STAT_HACK_P (val))
1242 val = STAT_DECL (val);
1243 }
1244 else
1245 {
1246 if (member_vec && type_or_fns <= 0)
1247 val = member_vec_linear_search (member_vec, lookup);
1248
1249 if (type_or_fns < 0)
1250 /* Don't bother looking for field. We don't want it. */;
1251 else if (!val || (TREE_CODE (val) == OVERLOAD && OVL_USING_P (val)))
1252 /* Dependent using declarations are a 'field', make sure we
1253 return that even if we saw an overload already. */
1254 if (tree field_val = fields_linear_search (klass, lookup,
1255 type_or_fns > 0))
1256 if (!val || TREE_CODE (field_val) == USING_DECL)
1257 val = field_val;
1258 }
1259
1260 /* Extract the conversion operators asked for, unless the general
1261 conversion operator was requested. */
1262 if (val && conv_op)
1263 {
1264 gcc_checking_assert (OVL_FUNCTION (val) == conv_op_marker);
1265 val = OVL_CHAIN (val);
1266 if (tree type = TREE_TYPE (name))
1267 val = extract_conversion_operator (val, type);
1268 }
1269
1270 return val;
1271 }
1272
1273 /* Look for NAME's binding in exactly KLASS. See
1274 get_class_binding_direct for argument description. Does lazy
1275 special function creation as necessary. */
1276
1277 tree
get_class_binding(tree klass,tree name,int type_or_fns)1278 get_class_binding (tree klass, tree name, int type_or_fns)
1279 {
1280 klass = complete_type (klass);
1281
1282 if (COMPLETE_TYPE_P (klass))
1283 {
1284 /* Lazily declare functions, if we're going to search these. */
1285 if (IDENTIFIER_CTOR_P (name))
1286 {
1287 if (CLASSTYPE_LAZY_DEFAULT_CTOR (klass))
1288 lazily_declare_fn (sfk_constructor, klass);
1289 if (CLASSTYPE_LAZY_COPY_CTOR (klass))
1290 lazily_declare_fn (sfk_copy_constructor, klass);
1291 if (CLASSTYPE_LAZY_MOVE_CTOR (klass))
1292 lazily_declare_fn (sfk_move_constructor, klass);
1293 }
1294 else if (IDENTIFIER_DTOR_P (name))
1295 {
1296 if (CLASSTYPE_LAZY_DESTRUCTOR (klass))
1297 lazily_declare_fn (sfk_destructor, klass);
1298 }
1299 else if (name == assign_op_identifier)
1300 {
1301 if (CLASSTYPE_LAZY_COPY_ASSIGN (klass))
1302 lazily_declare_fn (sfk_copy_assignment, klass);
1303 if (CLASSTYPE_LAZY_MOVE_ASSIGN (klass))
1304 lazily_declare_fn (sfk_move_assignment, klass);
1305 }
1306 }
1307
1308 return get_class_binding_direct (klass, name, type_or_fns);
1309 }
1310
1311 /* Find the slot containing overloads called 'NAME'. If there is no
1312 such slot and the class is complete, create an empty one, at the
1313 correct point in the sorted member vector. Otherwise return NULL.
1314 Deals with conv_op marker handling. */
1315
1316 tree *
find_member_slot(tree klass,tree name)1317 find_member_slot (tree klass, tree name)
1318 {
1319 bool complete_p = COMPLETE_TYPE_P (klass);
1320
1321 vec<tree, va_gc> *member_vec = CLASSTYPE_MEMBER_VEC (klass);
1322 if (!member_vec)
1323 {
1324 vec_alloc (member_vec, 8);
1325 CLASSTYPE_MEMBER_VEC (klass) = member_vec;
1326 if (complete_p)
1327 {
1328 /* If the class is complete but had no member_vec, we need
1329 to add the TYPE_FIELDS into it. We're also most likely
1330 to be adding ctors & dtors, so ask for 6 spare slots (the
1331 abstract cdtors and their clones). */
1332 set_class_bindings (klass, 6);
1333 member_vec = CLASSTYPE_MEMBER_VEC (klass);
1334 }
1335 }
1336
1337 if (IDENTIFIER_CONV_OP_P (name))
1338 name = conv_op_identifier;
1339
1340 unsigned ix, length = member_vec->length ();
1341 for (ix = 0; ix < length; ix++)
1342 {
1343 tree *slot = &(*member_vec)[ix];
1344 tree fn_name = OVL_NAME (*slot);
1345
1346 if (fn_name == name)
1347 {
1348 /* If we found an existing slot, it must be a function set.
1349 Even with insertion after completion, because those only
1350 happen with artificial fns that have unspellable names.
1351 This means we do not have to deal with the stat hack
1352 either. */
1353 gcc_checking_assert (OVL_P (*slot));
1354 if (name == conv_op_identifier)
1355 {
1356 gcc_checking_assert (OVL_FUNCTION (*slot) == conv_op_marker);
1357 /* Skip the conv-op marker. */
1358 slot = &OVL_CHAIN (*slot);
1359 }
1360 return slot;
1361 }
1362
1363 if (complete_p && fn_name > name)
1364 break;
1365 }
1366
1367 /* No slot found, add one if the class is complete. */
1368 if (complete_p)
1369 {
1370 /* Do exact allocation, as we don't expect to add many. */
1371 gcc_assert (name != conv_op_identifier);
1372 vec_safe_reserve_exact (member_vec, 1);
1373 CLASSTYPE_MEMBER_VEC (klass) = member_vec;
1374 member_vec->quick_insert (ix, NULL_TREE);
1375 return &(*member_vec)[ix];
1376 }
1377
1378 return NULL;
1379 }
1380
1381 /* KLASS is an incomplete class to which we're adding a method NAME.
1382 Add a slot and deal with conv_op marker handling. */
1383
1384 tree *
add_member_slot(tree klass,tree name)1385 add_member_slot (tree klass, tree name)
1386 {
1387 gcc_assert (!COMPLETE_TYPE_P (klass));
1388
1389 vec<tree, va_gc> *member_vec = CLASSTYPE_MEMBER_VEC (klass);
1390 vec_safe_push (member_vec, NULL_TREE);
1391 CLASSTYPE_MEMBER_VEC (klass) = member_vec;
1392
1393 tree *slot = &member_vec->last ();
1394 if (IDENTIFIER_CONV_OP_P (name))
1395 {
1396 /* Install the marker prefix. */
1397 *slot = ovl_make (conv_op_marker, NULL_TREE);
1398 slot = &OVL_CHAIN (*slot);
1399 }
1400
1401 return slot;
1402 }
1403
1404 /* Comparison function to compare two MEMBER_VEC entries by name.
1405 Because we can have duplicates during insertion of TYPE_FIELDS, we
1406 do extra checking so deduping doesn't have to deal with so many
1407 cases. */
1408
1409 static int
member_name_cmp(const void * a_p,const void * b_p)1410 member_name_cmp (const void *a_p, const void *b_p)
1411 {
1412 tree a = *(const tree *)a_p;
1413 tree b = *(const tree *)b_p;
1414 tree name_a = DECL_NAME (TREE_CODE (a) == OVERLOAD ? OVL_FUNCTION (a) : a);
1415 tree name_b = DECL_NAME (TREE_CODE (b) == OVERLOAD ? OVL_FUNCTION (b) : b);
1416
1417 gcc_checking_assert (name_a && name_b);
1418 if (name_a != name_b)
1419 return name_a < name_b ? -1 : +1;
1420
1421 if (name_a == conv_op_identifier)
1422 {
1423 /* Strip the conv-op markers. */
1424 gcc_checking_assert (OVL_FUNCTION (a) == conv_op_marker
1425 && OVL_FUNCTION (b) == conv_op_marker);
1426 a = OVL_CHAIN (a);
1427 b = OVL_CHAIN (b);
1428 }
1429
1430 if (TREE_CODE (a) == OVERLOAD)
1431 a = OVL_FUNCTION (a);
1432 if (TREE_CODE (b) == OVERLOAD)
1433 b = OVL_FUNCTION (b);
1434
1435 /* We're in STAT_HACK or USING_DECL territory (or possibly error-land). */
1436 if (TREE_CODE (a) != TREE_CODE (b))
1437 {
1438 /* If one of them is a TYPE_DECL, it loses. */
1439 if (TREE_CODE (a) == TYPE_DECL)
1440 return +1;
1441 else if (TREE_CODE (b) == TYPE_DECL)
1442 return -1;
1443
1444 /* If one of them is a USING_DECL, it loses. */
1445 if (TREE_CODE (a) == USING_DECL)
1446 return +1;
1447 else if (TREE_CODE (b) == USING_DECL)
1448 return -1;
1449
1450 /* There are no other cases with different kinds of decls, as
1451 duplicate detection should have kicked in earlier. However,
1452 some erroneous cases get though. */
1453 gcc_assert (errorcount);
1454 }
1455
1456 /* Using source location would be the best thing here, but we can
1457 get identically-located decls in the following circumstances:
1458
1459 1) duplicate artificial type-decls for the same type.
1460
1461 2) pack expansions of using-decls.
1462
1463 We should not be doing #1, but in either case it doesn't matter
1464 how we order these. Use UID as a proxy for source ordering, so
1465 that identically-located decls still have a well-defined stable
1466 ordering. */
1467 if (DECL_UID (a) != DECL_UID (b))
1468 return DECL_UID (a) < DECL_UID (b) ? -1 : +1;
1469 gcc_assert (a == b);
1470 return 0;
1471 }
1472
1473 static struct {
1474 gt_pointer_operator new_value;
1475 void *cookie;
1476 } resort_data;
1477
1478 /* This routine compares two fields like member_name_cmp but using the
1479 pointer operator in resort_field_decl_data. We don't have to deal
1480 with duplicates here. */
1481
1482 static int
resort_member_name_cmp(const void * a_p,const void * b_p)1483 resort_member_name_cmp (const void *a_p, const void *b_p)
1484 {
1485 tree a = *(const tree *)a_p;
1486 tree b = *(const tree *)b_p;
1487 tree name_a = OVL_NAME (a);
1488 tree name_b = OVL_NAME (b);
1489
1490 resort_data.new_value (&name_a, resort_data.cookie);
1491 resort_data.new_value (&name_b, resort_data.cookie);
1492
1493 gcc_checking_assert (name_a != name_b);
1494
1495 return name_a < name_b ? -1 : +1;
1496 }
1497
1498 /* Resort CLASSTYPE_MEMBER_VEC because pointers have been reordered. */
1499
1500 void
resort_type_member_vec(void * obj,void *,gt_pointer_operator new_value,void * cookie)1501 resort_type_member_vec (void *obj, void */*orig_obj*/,
1502 gt_pointer_operator new_value, void* cookie)
1503 {
1504 if (vec<tree, va_gc> *member_vec = (vec<tree, va_gc> *) obj)
1505 {
1506 resort_data.new_value = new_value;
1507 resort_data.cookie = cookie;
1508 member_vec->qsort (resort_member_name_cmp);
1509 }
1510 }
1511
1512 /* Recursively count the number of fields in KLASS, including anonymous
1513 union members. */
1514
1515 static unsigned
count_class_fields(tree klass)1516 count_class_fields (tree klass)
1517 {
1518 unsigned n_fields = 0;
1519
1520 for (tree fields = TYPE_FIELDS (klass); fields; fields = DECL_CHAIN (fields))
1521 if (DECL_DECLARES_FUNCTION_P (fields))
1522 /* Functions are dealt with separately. */;
1523 else if (TREE_CODE (fields) == FIELD_DECL
1524 && ANON_AGGR_TYPE_P (TREE_TYPE (fields)))
1525 n_fields += count_class_fields (TREE_TYPE (fields));
1526 else if (DECL_NAME (fields))
1527 n_fields += 1;
1528
1529 return n_fields;
1530 }
1531
1532 /* Append all the nonfunction members fields of KLASS to MEMBER_VEC.
1533 Recurse for anonymous members. MEMBER_VEC must have space. */
1534
1535 static void
member_vec_append_class_fields(vec<tree,va_gc> * member_vec,tree klass)1536 member_vec_append_class_fields (vec<tree, va_gc> *member_vec, tree klass)
1537 {
1538 for (tree fields = TYPE_FIELDS (klass); fields; fields = DECL_CHAIN (fields))
1539 if (DECL_DECLARES_FUNCTION_P (fields))
1540 /* Functions are handled separately. */;
1541 else if (TREE_CODE (fields) == FIELD_DECL
1542 && ANON_AGGR_TYPE_P (TREE_TYPE (fields)))
1543 member_vec_append_class_fields (member_vec, TREE_TYPE (fields));
1544 else if (DECL_NAME (fields))
1545 {
1546 tree field = fields;
1547 /* Mark a conv-op USING_DECL with the conv-op-marker. */
1548 if (TREE_CODE (field) == USING_DECL
1549 && IDENTIFIER_CONV_OP_P (DECL_NAME (field)))
1550 field = ovl_make (conv_op_marker, field);
1551 member_vec->quick_push (field);
1552 }
1553 }
1554
1555 /* Append all of the enum values of ENUMTYPE to MEMBER_VEC.
1556 MEMBER_VEC must have space. */
1557
1558 static void
member_vec_append_enum_values(vec<tree,va_gc> * member_vec,tree enumtype)1559 member_vec_append_enum_values (vec<tree, va_gc> *member_vec, tree enumtype)
1560 {
1561 for (tree values = TYPE_VALUES (enumtype);
1562 values; values = TREE_CHAIN (values))
1563 member_vec->quick_push (TREE_VALUE (values));
1564 }
1565
1566 /* MEMBER_VEC has just had new DECLs added to it, but is sorted.
1567 DeDup adjacent DECLS of the same name. We already dealt with
1568 conflict resolution when adding the fields or methods themselves.
1569 There are three cases (which could all be combined):
1570 1) a TYPE_DECL and non TYPE_DECL. Deploy STAT_HACK as appropriate.
1571 2) a USING_DECL and an overload. If the USING_DECL is dependent,
1572 it wins. Otherwise the OVERLOAD does.
1573 3) two USING_DECLS. ...
1574
1575 member_name_cmp will have ordered duplicates as
1576 <fns><using><type> */
1577
1578 static void
member_vec_dedup(vec<tree,va_gc> * member_vec)1579 member_vec_dedup (vec<tree, va_gc> *member_vec)
1580 {
1581 unsigned len = member_vec->length ();
1582 unsigned store = 0;
1583
1584 if (!len)
1585 return;
1586
1587 tree name = OVL_NAME ((*member_vec)[0]);
1588 for (unsigned jx, ix = 0; ix < len; ix = jx)
1589 {
1590 tree current = NULL_TREE;
1591 tree to_type = NULL_TREE;
1592 tree to_using = NULL_TREE;
1593 tree marker = NULL_TREE;
1594
1595 for (jx = ix; jx < len; jx++)
1596 {
1597 tree next = (*member_vec)[jx];
1598 if (jx != ix)
1599 {
1600 tree next_name = OVL_NAME (next);
1601 if (next_name != name)
1602 {
1603 name = next_name;
1604 break;
1605 }
1606 }
1607
1608 if (IDENTIFIER_CONV_OP_P (name))
1609 {
1610 marker = next;
1611 next = OVL_CHAIN (next);
1612 }
1613
1614 if (TREE_CODE (next) == USING_DECL)
1615 {
1616 if (IDENTIFIER_CTOR_P (name))
1617 /* Dependent inherited ctor. */
1618 continue;
1619
1620 next = strip_using_decl (next);
1621 if (TREE_CODE (next) == USING_DECL)
1622 {
1623 to_using = next;
1624 continue;
1625 }
1626
1627 if (is_overloaded_fn (next))
1628 continue;
1629 }
1630
1631 if (DECL_DECLARES_TYPE_P (next))
1632 {
1633 to_type = next;
1634 continue;
1635 }
1636
1637 if (!current)
1638 current = next;
1639 }
1640
1641 if (to_using)
1642 {
1643 if (!current)
1644 current = to_using;
1645 else
1646 current = ovl_make (to_using, current);
1647 }
1648
1649 if (to_type)
1650 {
1651 if (!current)
1652 current = to_type;
1653 else
1654 current = stat_hack (current, to_type);
1655 }
1656
1657 if (current)
1658 {
1659 if (marker)
1660 {
1661 OVL_CHAIN (marker) = current;
1662 current = marker;
1663 }
1664 (*member_vec)[store++] = current;
1665 }
1666 }
1667
1668 while (store++ < len)
1669 member_vec->pop ();
1670 }
1671
1672 /* Add the non-function members to CLASSTYPE_MEMBER_VEC. If there is
1673 no existing MEMBER_VEC and fewer than 8 fields, do nothing. We
1674 know there must be at least 1 field -- the self-reference
1675 TYPE_DECL, except for anon aggregates, which will have at least
1676 one field. */
1677
1678 void
set_class_bindings(tree klass,unsigned extra)1679 set_class_bindings (tree klass, unsigned extra)
1680 {
1681 unsigned n_fields = count_class_fields (klass);
1682 vec<tree, va_gc> *member_vec = CLASSTYPE_MEMBER_VEC (klass);
1683
1684 if (member_vec || n_fields >= 8)
1685 {
1686 /* Append the new fields. */
1687 vec_safe_reserve_exact (member_vec, extra + n_fields);
1688 member_vec_append_class_fields (member_vec, klass);
1689 }
1690
1691 if (member_vec)
1692 {
1693 CLASSTYPE_MEMBER_VEC (klass) = member_vec;
1694 member_vec->qsort (member_name_cmp);
1695 member_vec_dedup (member_vec);
1696 }
1697 }
1698
1699 /* Insert lately defined enum ENUMTYPE into KLASS for the sorted case. */
1700
1701 void
insert_late_enum_def_bindings(tree klass,tree enumtype)1702 insert_late_enum_def_bindings (tree klass, tree enumtype)
1703 {
1704 int n_fields;
1705 vec<tree, va_gc> *member_vec = CLASSTYPE_MEMBER_VEC (klass);
1706
1707 /* The enum bindings will already be on the TYPE_FIELDS, so don't
1708 count them twice. */
1709 if (!member_vec)
1710 n_fields = count_class_fields (klass);
1711 else
1712 n_fields = list_length (TYPE_VALUES (enumtype));
1713
1714 if (member_vec || n_fields >= 8)
1715 {
1716 vec_safe_reserve_exact (member_vec, n_fields);
1717 if (CLASSTYPE_MEMBER_VEC (klass))
1718 member_vec_append_enum_values (member_vec, enumtype);
1719 else
1720 member_vec_append_class_fields (member_vec, klass);
1721 CLASSTYPE_MEMBER_VEC (klass) = member_vec;
1722 member_vec->qsort (member_name_cmp);
1723 member_vec_dedup (member_vec);
1724 }
1725 }
1726
1727 /* Compute the chain index of a binding_entry given the HASH value of its
1728 name and the total COUNT of chains. COUNT is assumed to be a power
1729 of 2. */
1730
1731 #define ENTRY_INDEX(HASH, COUNT) (((HASH) >> 3) & ((COUNT) - 1))
1732
1733 /* A free list of "binding_entry"s awaiting for re-use. */
1734
1735 static GTY((deletable)) binding_entry free_binding_entry = NULL;
1736
1737 /* The binding oracle; see cp-tree.h. */
1738
1739 cp_binding_oracle_function *cp_binding_oracle;
1740
1741 /* If we have a binding oracle, ask it for all namespace-scoped
1742 definitions of NAME. */
1743
1744 static inline void
query_oracle(tree name)1745 query_oracle (tree name)
1746 {
1747 if (!cp_binding_oracle)
1748 return;
1749
1750 /* LOOKED_UP holds the set of identifiers that we have already
1751 looked up with the oracle. */
1752 static hash_set<tree> looked_up;
1753 if (looked_up.add (name))
1754 return;
1755
1756 cp_binding_oracle (CP_ORACLE_IDENTIFIER, name);
1757 }
1758
1759 /* Create a binding_entry object for (NAME, TYPE). */
1760
1761 static inline binding_entry
binding_entry_make(tree name,tree type)1762 binding_entry_make (tree name, tree type)
1763 {
1764 binding_entry entry;
1765
1766 if (free_binding_entry)
1767 {
1768 entry = free_binding_entry;
1769 free_binding_entry = entry->chain;
1770 }
1771 else
1772 entry = ggc_alloc<binding_entry_s> ();
1773
1774 entry->name = name;
1775 entry->type = type;
1776 entry->chain = NULL;
1777
1778 return entry;
1779 }
1780
1781 /* Put ENTRY back on the free list. */
1782 #if 0
1783 static inline void
1784 binding_entry_free (binding_entry entry)
1785 {
1786 entry->name = NULL;
1787 entry->type = NULL;
1788 entry->chain = free_binding_entry;
1789 free_binding_entry = entry;
1790 }
1791 #endif
1792
1793 /* The datatype used to implement the mapping from names to types at
1794 a given scope. */
1795 struct GTY(()) binding_table_s {
1796 /* Array of chains of "binding_entry"s */
1797 binding_entry * GTY((length ("%h.chain_count"))) chain;
1798
1799 /* The number of chains in this table. This is the length of the
1800 member "chain" considered as an array. */
1801 size_t chain_count;
1802
1803 /* Number of "binding_entry"s in this table. */
1804 size_t entry_count;
1805 };
1806
1807 /* Construct TABLE with an initial CHAIN_COUNT. */
1808
1809 static inline void
binding_table_construct(binding_table table,size_t chain_count)1810 binding_table_construct (binding_table table, size_t chain_count)
1811 {
1812 table->chain_count = chain_count;
1813 table->entry_count = 0;
1814 table->chain = ggc_cleared_vec_alloc<binding_entry> (table->chain_count);
1815 }
1816
1817 /* Make TABLE's entries ready for reuse. */
1818 #if 0
1819 static void
1820 binding_table_free (binding_table table)
1821 {
1822 size_t i;
1823 size_t count;
1824
1825 if (table == NULL)
1826 return;
1827
1828 for (i = 0, count = table->chain_count; i < count; ++i)
1829 {
1830 binding_entry temp = table->chain[i];
1831 while (temp != NULL)
1832 {
1833 binding_entry entry = temp;
1834 temp = entry->chain;
1835 binding_entry_free (entry);
1836 }
1837 table->chain[i] = NULL;
1838 }
1839 table->entry_count = 0;
1840 }
1841 #endif
1842
1843 /* Allocate a table with CHAIN_COUNT, assumed to be a power of two. */
1844
1845 static inline binding_table
binding_table_new(size_t chain_count)1846 binding_table_new (size_t chain_count)
1847 {
1848 binding_table table = ggc_alloc<binding_table_s> ();
1849 table->chain = NULL;
1850 binding_table_construct (table, chain_count);
1851 return table;
1852 }
1853
1854 /* Expand TABLE to twice its current chain_count. */
1855
1856 static void
binding_table_expand(binding_table table)1857 binding_table_expand (binding_table table)
1858 {
1859 const size_t old_chain_count = table->chain_count;
1860 const size_t old_entry_count = table->entry_count;
1861 const size_t new_chain_count = 2 * old_chain_count;
1862 binding_entry *old_chains = table->chain;
1863 size_t i;
1864
1865 binding_table_construct (table, new_chain_count);
1866 for (i = 0; i < old_chain_count; ++i)
1867 {
1868 binding_entry entry = old_chains[i];
1869 for (; entry != NULL; entry = old_chains[i])
1870 {
1871 const unsigned int hash = IDENTIFIER_HASH_VALUE (entry->name);
1872 const size_t j = ENTRY_INDEX (hash, new_chain_count);
1873
1874 old_chains[i] = entry->chain;
1875 entry->chain = table->chain[j];
1876 table->chain[j] = entry;
1877 }
1878 }
1879 table->entry_count = old_entry_count;
1880 }
1881
1882 /* Insert a binding for NAME to TYPE into TABLE. */
1883
1884 static void
binding_table_insert(binding_table table,tree name,tree type)1885 binding_table_insert (binding_table table, tree name, tree type)
1886 {
1887 const unsigned int hash = IDENTIFIER_HASH_VALUE (name);
1888 const size_t i = ENTRY_INDEX (hash, table->chain_count);
1889 binding_entry entry = binding_entry_make (name, type);
1890
1891 entry->chain = table->chain[i];
1892 table->chain[i] = entry;
1893 ++table->entry_count;
1894
1895 if (3 * table->chain_count < 5 * table->entry_count)
1896 binding_table_expand (table);
1897 }
1898
1899 /* Return the binding_entry, if any, that maps NAME. */
1900
1901 binding_entry
binding_table_find(binding_table table,tree name)1902 binding_table_find (binding_table table, tree name)
1903 {
1904 const unsigned int hash = IDENTIFIER_HASH_VALUE (name);
1905 binding_entry entry = table->chain[ENTRY_INDEX (hash, table->chain_count)];
1906
1907 while (entry != NULL && entry->name != name)
1908 entry = entry->chain;
1909
1910 return entry;
1911 }
1912
1913 /* Apply PROC -- with DATA -- to all entries in TABLE. */
1914
1915 void
binding_table_foreach(binding_table table,bt_foreach_proc proc,void * data)1916 binding_table_foreach (binding_table table, bt_foreach_proc proc, void *data)
1917 {
1918 size_t chain_count;
1919 size_t i;
1920
1921 if (!table)
1922 return;
1923
1924 chain_count = table->chain_count;
1925 for (i = 0; i < chain_count; ++i)
1926 {
1927 binding_entry entry = table->chain[i];
1928 for (; entry != NULL; entry = entry->chain)
1929 proc (entry, data);
1930 }
1931 }
1932
1933 #ifndef ENABLE_SCOPE_CHECKING
1934 # define ENABLE_SCOPE_CHECKING 0
1935 #else
1936 # define ENABLE_SCOPE_CHECKING 1
1937 #endif
1938
1939 /* A free list of "cxx_binding"s, connected by their PREVIOUS. */
1940
1941 static GTY((deletable)) cxx_binding *free_bindings;
1942
1943 /* Initialize VALUE and TYPE field for BINDING, and set the PREVIOUS
1944 field to NULL. */
1945
1946 static inline void
cxx_binding_init(cxx_binding * binding,tree value,tree type)1947 cxx_binding_init (cxx_binding *binding, tree value, tree type)
1948 {
1949 binding->value = value;
1950 binding->type = type;
1951 binding->previous = NULL;
1952 }
1953
1954 /* (GC)-allocate a binding object with VALUE and TYPE member initialized. */
1955
1956 static cxx_binding *
cxx_binding_make(tree value,tree type)1957 cxx_binding_make (tree value, tree type)
1958 {
1959 cxx_binding *binding;
1960 if (free_bindings)
1961 {
1962 binding = free_bindings;
1963 free_bindings = binding->previous;
1964 }
1965 else
1966 binding = ggc_alloc<cxx_binding> ();
1967
1968 cxx_binding_init (binding, value, type);
1969
1970 return binding;
1971 }
1972
1973 /* Put BINDING back on the free list. */
1974
1975 static inline void
cxx_binding_free(cxx_binding * binding)1976 cxx_binding_free (cxx_binding *binding)
1977 {
1978 binding->scope = NULL;
1979 binding->previous = free_bindings;
1980 free_bindings = binding;
1981 }
1982
1983 /* Create a new binding for NAME (with the indicated VALUE and TYPE
1984 bindings) in the class scope indicated by SCOPE. */
1985
1986 static cxx_binding *
new_class_binding(tree name,tree value,tree type,cp_binding_level * scope)1987 new_class_binding (tree name, tree value, tree type, cp_binding_level *scope)
1988 {
1989 cp_class_binding cb = {cxx_binding_make (value, type), name};
1990 cxx_binding *binding = cb.base;
1991 vec_safe_push (scope->class_shadowed, cb);
1992 binding->scope = scope;
1993 return binding;
1994 }
1995
1996 /* Make DECL the innermost binding for ID. The LEVEL is the binding
1997 level at which this declaration is being bound. */
1998
1999 void
push_binding(tree id,tree decl,cp_binding_level * level)2000 push_binding (tree id, tree decl, cp_binding_level* level)
2001 {
2002 cxx_binding *binding;
2003
2004 if (level != class_binding_level)
2005 {
2006 binding = cxx_binding_make (decl, NULL_TREE);
2007 binding->scope = level;
2008 }
2009 else
2010 binding = new_class_binding (id, decl, /*type=*/NULL_TREE, level);
2011
2012 /* Now, fill in the binding information. */
2013 binding->previous = IDENTIFIER_BINDING (id);
2014 INHERITED_VALUE_BINDING_P (binding) = 0;
2015 LOCAL_BINDING_P (binding) = (level != class_binding_level);
2016
2017 /* And put it on the front of the list of bindings for ID. */
2018 IDENTIFIER_BINDING (id) = binding;
2019 }
2020
2021 /* Remove the binding for DECL which should be the innermost binding
2022 for ID. */
2023
2024 void
pop_local_binding(tree id,tree decl)2025 pop_local_binding (tree id, tree decl)
2026 {
2027 cxx_binding *binding;
2028
2029 if (id == NULL_TREE)
2030 /* It's easiest to write the loops that call this function without
2031 checking whether or not the entities involved have names. We
2032 get here for such an entity. */
2033 return;
2034
2035 /* Get the innermost binding for ID. */
2036 binding = IDENTIFIER_BINDING (id);
2037
2038 /* The name should be bound. */
2039 gcc_assert (binding != NULL);
2040
2041 /* The DECL will be either the ordinary binding or the type
2042 binding for this identifier. Remove that binding. */
2043 if (binding->value == decl)
2044 binding->value = NULL_TREE;
2045 else
2046 {
2047 gcc_assert (binding->type == decl);
2048 binding->type = NULL_TREE;
2049 }
2050
2051 if (!binding->value && !binding->type)
2052 {
2053 /* We're completely done with the innermost binding for this
2054 identifier. Unhook it from the list of bindings. */
2055 IDENTIFIER_BINDING (id) = binding->previous;
2056
2057 /* Add it to the free list. */
2058 cxx_binding_free (binding);
2059 }
2060 }
2061
2062 /* Remove the bindings for the decls of the current level and leave
2063 the current scope. */
2064
2065 void
pop_bindings_and_leave_scope(void)2066 pop_bindings_and_leave_scope (void)
2067 {
2068 for (tree t = get_local_decls (); t; t = DECL_CHAIN (t))
2069 {
2070 tree decl = TREE_CODE (t) == TREE_LIST ? TREE_VALUE (t) : t;
2071 tree name = OVL_NAME (decl);
2072
2073 pop_local_binding (name, decl);
2074 }
2075
2076 leave_scope ();
2077 }
2078
2079 /* Strip non dependent using declarations. If DECL is dependent,
2080 surreptitiously create a typename_type and return it. */
2081
2082 tree
strip_using_decl(tree decl)2083 strip_using_decl (tree decl)
2084 {
2085 if (decl == NULL_TREE)
2086 return NULL_TREE;
2087
2088 while (TREE_CODE (decl) == USING_DECL && !DECL_DEPENDENT_P (decl))
2089 decl = USING_DECL_DECLS (decl);
2090
2091 if (TREE_CODE (decl) == USING_DECL && DECL_DEPENDENT_P (decl)
2092 && USING_DECL_TYPENAME_P (decl))
2093 {
2094 /* We have found a type introduced by a using
2095 declaration at class scope that refers to a dependent
2096 type.
2097
2098 using typename :: [opt] nested-name-specifier unqualified-id ;
2099 */
2100 decl = make_typename_type (TREE_TYPE (decl),
2101 DECL_NAME (decl),
2102 typename_type, tf_error);
2103 if (decl != error_mark_node)
2104 decl = TYPE_NAME (decl);
2105 }
2106
2107 return decl;
2108 }
2109
2110 /* Return true if OVL is an overload for an anticipated builtin. */
2111
2112 static bool
anticipated_builtin_p(tree ovl)2113 anticipated_builtin_p (tree ovl)
2114 {
2115 if (TREE_CODE (ovl) != OVERLOAD)
2116 return false;
2117
2118 if (!OVL_HIDDEN_P (ovl))
2119 return false;
2120
2121 tree fn = OVL_FUNCTION (ovl);
2122 gcc_checking_assert (DECL_ANTICIPATED (fn));
2123
2124 if (DECL_HIDDEN_FRIEND_P (fn))
2125 return false;
2126
2127 return true;
2128 }
2129
2130 /* BINDING records an existing declaration for a name in the current scope.
2131 But, DECL is another declaration for that same identifier in the
2132 same scope. This is the `struct stat' hack whereby a non-typedef
2133 class name or enum-name can be bound at the same level as some other
2134 kind of entity.
2135 3.3.7/1
2136
2137 A class name (9.1) or enumeration name (7.2) can be hidden by the
2138 name of an object, function, or enumerator declared in the same scope.
2139 If a class or enumeration name and an object, function, or enumerator
2140 are declared in the same scope (in any order) with the same name, the
2141 class or enumeration name is hidden wherever the object, function, or
2142 enumerator name is visible.
2143
2144 It's the responsibility of the caller to check that
2145 inserting this name is valid here. Returns nonzero if the new binding
2146 was successful. */
2147
2148 static bool
supplement_binding_1(cxx_binding * binding,tree decl)2149 supplement_binding_1 (cxx_binding *binding, tree decl)
2150 {
2151 tree bval = binding->value;
2152 bool ok = true;
2153 tree target_bval = strip_using_decl (bval);
2154 tree target_decl = strip_using_decl (decl);
2155
2156 if (TREE_CODE (target_decl) == TYPE_DECL && DECL_ARTIFICIAL (target_decl)
2157 && target_decl != target_bval
2158 && (TREE_CODE (target_bval) != TYPE_DECL
2159 /* We allow pushing an enum multiple times in a class
2160 template in order to handle late matching of underlying
2161 type on an opaque-enum-declaration followed by an
2162 enum-specifier. */
2163 || (processing_template_decl
2164 && TREE_CODE (TREE_TYPE (target_decl)) == ENUMERAL_TYPE
2165 && TREE_CODE (TREE_TYPE (target_bval)) == ENUMERAL_TYPE
2166 && (dependent_type_p (ENUM_UNDERLYING_TYPE
2167 (TREE_TYPE (target_decl)))
2168 || dependent_type_p (ENUM_UNDERLYING_TYPE
2169 (TREE_TYPE (target_bval)))))))
2170 /* The new name is the type name. */
2171 binding->type = decl;
2172 else if (/* TARGET_BVAL is null when push_class_level_binding moves
2173 an inherited type-binding out of the way to make room
2174 for a new value binding. */
2175 !target_bval
2176 /* TARGET_BVAL is error_mark_node when TARGET_DECL's name
2177 has been used in a non-class scope prior declaration.
2178 In that case, we should have already issued a
2179 diagnostic; for graceful error recovery purpose, pretend
2180 this was the intended declaration for that name. */
2181 || target_bval == error_mark_node
2182 /* If TARGET_BVAL is anticipated but has not yet been
2183 declared, pretend it is not there at all. */
2184 || anticipated_builtin_p (target_bval))
2185 binding->value = decl;
2186 else if (TREE_CODE (target_bval) == TYPE_DECL
2187 && DECL_ARTIFICIAL (target_bval)
2188 && target_decl != target_bval
2189 && (TREE_CODE (target_decl) != TYPE_DECL
2190 || same_type_p (TREE_TYPE (target_decl),
2191 TREE_TYPE (target_bval))))
2192 {
2193 /* The old binding was a type name. It was placed in
2194 VALUE field because it was thought, at the point it was
2195 declared, to be the only entity with such a name. Move the
2196 type name into the type slot; it is now hidden by the new
2197 binding. */
2198 binding->type = bval;
2199 binding->value = decl;
2200 binding->value_is_inherited = false;
2201 }
2202 else if (TREE_CODE (target_bval) == TYPE_DECL
2203 && TREE_CODE (target_decl) == TYPE_DECL
2204 && DECL_NAME (target_decl) == DECL_NAME (target_bval)
2205 && binding->scope->kind != sk_class
2206 && (same_type_p (TREE_TYPE (target_decl), TREE_TYPE (target_bval))
2207 /* If either type involves template parameters, we must
2208 wait until instantiation. */
2209 || uses_template_parms (TREE_TYPE (target_decl))
2210 || uses_template_parms (TREE_TYPE (target_bval))))
2211 /* We have two typedef-names, both naming the same type to have
2212 the same name. In general, this is OK because of:
2213
2214 [dcl.typedef]
2215
2216 In a given scope, a typedef specifier can be used to redefine
2217 the name of any type declared in that scope to refer to the
2218 type to which it already refers.
2219
2220 However, in class scopes, this rule does not apply due to the
2221 stricter language in [class.mem] prohibiting redeclarations of
2222 members. */
2223 ok = false;
2224 /* There can be two block-scope declarations of the same variable,
2225 so long as they are `extern' declarations. However, there cannot
2226 be two declarations of the same static data member:
2227
2228 [class.mem]
2229
2230 A member shall not be declared twice in the
2231 member-specification. */
2232 else if (VAR_P (target_decl)
2233 && VAR_P (target_bval)
2234 && DECL_EXTERNAL (target_decl) && DECL_EXTERNAL (target_bval)
2235 && !DECL_CLASS_SCOPE_P (target_decl))
2236 {
2237 duplicate_decls (decl, binding->value, /*newdecl_is_friend=*/false);
2238 ok = false;
2239 }
2240 else if (TREE_CODE (decl) == NAMESPACE_DECL
2241 && TREE_CODE (bval) == NAMESPACE_DECL
2242 && DECL_NAMESPACE_ALIAS (decl)
2243 && DECL_NAMESPACE_ALIAS (bval)
2244 && ORIGINAL_NAMESPACE (bval) == ORIGINAL_NAMESPACE (decl))
2245 /* [namespace.alias]
2246
2247 In a declarative region, a namespace-alias-definition can be
2248 used to redefine a namespace-alias declared in that declarative
2249 region to refer only to the namespace to which it already
2250 refers. */
2251 ok = false;
2252 else
2253 {
2254 if (!error_operand_p (bval))
2255 diagnose_name_conflict (decl, bval);
2256 ok = false;
2257 }
2258
2259 return ok;
2260 }
2261
2262 /* Diagnose a name conflict between DECL and BVAL. */
2263
2264 static void
diagnose_name_conflict(tree decl,tree bval)2265 diagnose_name_conflict (tree decl, tree bval)
2266 {
2267 if (TREE_CODE (decl) == TREE_CODE (bval)
2268 && TREE_CODE (decl) != NAMESPACE_DECL
2269 && !DECL_DECLARES_FUNCTION_P (decl)
2270 && (TREE_CODE (decl) != TYPE_DECL
2271 || DECL_ARTIFICIAL (decl) == DECL_ARTIFICIAL (bval))
2272 && CP_DECL_CONTEXT (decl) == CP_DECL_CONTEXT (bval))
2273 error ("redeclaration of %q#D", decl);
2274 else
2275 error ("%q#D conflicts with a previous declaration", decl);
2276
2277 inform (location_of (bval), "previous declaration %q#D", bval);
2278 }
2279
2280 /* Wrapper for supplement_binding_1. */
2281
2282 static bool
supplement_binding(cxx_binding * binding,tree decl)2283 supplement_binding (cxx_binding *binding, tree decl)
2284 {
2285 bool ret;
2286 bool subtime = timevar_cond_start (TV_NAME_LOOKUP);
2287 ret = supplement_binding_1 (binding, decl);
2288 timevar_cond_stop (TV_NAME_LOOKUP, subtime);
2289 return ret;
2290 }
2291
2292 /* Replace BINDING's current value on its scope's name list with
2293 NEWVAL. */
2294
2295 static void
update_local_overload(cxx_binding * binding,tree newval)2296 update_local_overload (cxx_binding *binding, tree newval)
2297 {
2298 tree *d;
2299
2300 for (d = &binding->scope->names; ; d = &TREE_CHAIN (*d))
2301 if (*d == binding->value)
2302 {
2303 /* Stitch new list node in. */
2304 *d = tree_cons (NULL_TREE, NULL_TREE, TREE_CHAIN (*d));
2305 break;
2306 }
2307 else if (TREE_CODE (*d) == TREE_LIST && TREE_VALUE (*d) == binding->value)
2308 break;
2309
2310 TREE_VALUE (*d) = newval;
2311 }
2312
2313 /* Compares the parameter-type-lists of ONE and TWO and
2314 returns false if they are different. If the DECLs are template
2315 functions, the return types and the template parameter lists are
2316 compared too (DR 565). */
2317
2318 static bool
matching_fn_p(tree one,tree two)2319 matching_fn_p (tree one, tree two)
2320 {
2321 if (!compparms (TYPE_ARG_TYPES (TREE_TYPE (one)),
2322 TYPE_ARG_TYPES (TREE_TYPE (two))))
2323 return false;
2324
2325 if (TREE_CODE (one) == TEMPLATE_DECL
2326 && TREE_CODE (two) == TEMPLATE_DECL)
2327 {
2328 /* Compare template parms. */
2329 if (!comp_template_parms (DECL_TEMPLATE_PARMS (one),
2330 DECL_TEMPLATE_PARMS (two)))
2331 return false;
2332
2333 /* And return type. */
2334 if (!same_type_p (TREE_TYPE (TREE_TYPE (one)),
2335 TREE_TYPE (TREE_TYPE (two))))
2336 return false;
2337 }
2338
2339 return true;
2340 }
2341
2342 /* Push DECL into nonclass LEVEL BINDING or SLOT. OLD is the current
2343 binding value (possibly with anticipated builtins stripped).
2344 Diagnose conflicts and return updated decl. */
2345
2346 static tree
update_binding(cp_binding_level * level,cxx_binding * binding,tree * slot,tree old,tree decl,bool is_friend)2347 update_binding (cp_binding_level *level, cxx_binding *binding, tree *slot,
2348 tree old, tree decl, bool is_friend)
2349 {
2350 tree to_val = decl;
2351 tree old_type = slot ? MAYBE_STAT_TYPE (*slot) : binding->type;
2352 tree to_type = old_type;
2353
2354 gcc_assert (level->kind == sk_namespace ? !binding
2355 : level->kind != sk_class && !slot);
2356 if (old == error_mark_node)
2357 old = NULL_TREE;
2358
2359 if (TREE_CODE (decl) == TYPE_DECL && DECL_ARTIFICIAL (decl))
2360 {
2361 tree other = to_type;
2362
2363 if (old && TREE_CODE (old) == TYPE_DECL && DECL_ARTIFICIAL (old))
2364 other = old;
2365
2366 /* Pushing an artificial typedef. See if this matches either
2367 the type slot or the old value slot. */
2368 if (!other)
2369 ;
2370 else if (same_type_p (TREE_TYPE (other), TREE_TYPE (decl)))
2371 /* Two artificial decls to same type. Do nothing. */
2372 return other;
2373 else
2374 goto conflict;
2375
2376 if (old)
2377 {
2378 /* Slide decl into the type slot, keep old unaltered */
2379 to_type = decl;
2380 to_val = old;
2381 goto done;
2382 }
2383 }
2384
2385 if (old && TREE_CODE (old) == TYPE_DECL && DECL_ARTIFICIAL (old))
2386 {
2387 /* Slide old into the type slot. */
2388 to_type = old;
2389 old = NULL_TREE;
2390 }
2391
2392 if (DECL_DECLARES_FUNCTION_P (decl))
2393 {
2394 if (!old)
2395 ;
2396 else if (OVL_P (old))
2397 {
2398 for (ovl_iterator iter (old); iter; ++iter)
2399 {
2400 tree fn = *iter;
2401
2402 if (iter.using_p () && matching_fn_p (fn, decl))
2403 {
2404 /* If a function declaration in namespace scope or
2405 block scope has the same name and the same
2406 parameter-type- list (8.3.5) as a function
2407 introduced by a using-declaration, and the
2408 declarations do not declare the same function,
2409 the program is ill-formed. [namespace.udecl]/14 */
2410 if (tree match = duplicate_decls (decl, fn, is_friend))
2411 return match;
2412 else
2413 /* FIXME: To preserve existing error behavior, we
2414 still push the decl. This might change. */
2415 diagnose_name_conflict (decl, fn);
2416 }
2417 }
2418 }
2419 else
2420 goto conflict;
2421
2422 if (to_type != old_type
2423 && warn_shadow
2424 && MAYBE_CLASS_TYPE_P (TREE_TYPE (to_type))
2425 && !(DECL_IN_SYSTEM_HEADER (decl)
2426 && DECL_IN_SYSTEM_HEADER (to_type)))
2427 warning (OPT_Wshadow, "%q#D hides constructor for %q#D",
2428 decl, to_type);
2429
2430 to_val = ovl_insert (decl, old);
2431 }
2432 else if (!old)
2433 ;
2434 else if (TREE_CODE (old) != TREE_CODE (decl))
2435 /* Different kinds of decls conflict. */
2436 goto conflict;
2437 else if (TREE_CODE (old) == TYPE_DECL)
2438 {
2439 if (same_type_p (TREE_TYPE (old), TREE_TYPE (decl)))
2440 /* Two type decls to the same type. Do nothing. */
2441 return old;
2442 else
2443 goto conflict;
2444 }
2445 else if (TREE_CODE (old) == NAMESPACE_DECL)
2446 {
2447 /* Two maybe-aliased namespaces. If they're to the same target
2448 namespace, that's ok. */
2449 if (ORIGINAL_NAMESPACE (old) != ORIGINAL_NAMESPACE (decl))
2450 goto conflict;
2451
2452 /* The new one must be an alias at this point. */
2453 gcc_assert (DECL_NAMESPACE_ALIAS (decl));
2454 return old;
2455 }
2456 else if (TREE_CODE (old) == VAR_DECL)
2457 {
2458 /* There can be two block-scope declarations of the same
2459 variable, so long as they are `extern' declarations. */
2460 if (!DECL_EXTERNAL (old) || !DECL_EXTERNAL (decl))
2461 goto conflict;
2462 else if (tree match = duplicate_decls (decl, old, false))
2463 return match;
2464 else
2465 goto conflict;
2466 }
2467 else
2468 {
2469 conflict:
2470 diagnose_name_conflict (decl, old);
2471 to_val = NULL_TREE;
2472 }
2473
2474 done:
2475 if (to_val)
2476 {
2477 if (level->kind == sk_namespace || to_type == decl || to_val == decl)
2478 add_decl_to_level (level, decl);
2479 else
2480 {
2481 gcc_checking_assert (binding->value && OVL_P (binding->value));
2482 update_local_overload (binding, to_val);
2483 }
2484
2485 if (slot)
2486 {
2487 if (STAT_HACK_P (*slot))
2488 {
2489 STAT_TYPE (*slot) = to_type;
2490 STAT_DECL (*slot) = to_val;
2491 }
2492 else if (to_type)
2493 *slot = stat_hack (to_val, to_type);
2494 else
2495 *slot = to_val;
2496 }
2497 else
2498 {
2499 binding->type = to_type;
2500 binding->value = to_val;
2501 }
2502 }
2503
2504 return decl;
2505 }
2506
2507 /* Table of identifiers to extern C declarations (or LISTS thereof). */
2508
2509 static GTY(()) hash_table<named_decl_hash> *extern_c_decls;
2510
2511 /* DECL has C linkage. If we have an existing instance, make sure the
2512 new one is compatible. Make sure it has the same exception
2513 specification [7.5, 7.6]. Add DECL to the map. */
2514
2515 static void
check_extern_c_conflict(tree decl)2516 check_extern_c_conflict (tree decl)
2517 {
2518 /* Ignore artificial or system header decls. */
2519 if (DECL_ARTIFICIAL (decl) || DECL_IN_SYSTEM_HEADER (decl))
2520 return;
2521
2522 /* This only applies to decls at namespace scope. */
2523 if (!DECL_NAMESPACE_SCOPE_P (decl))
2524 return;
2525
2526 if (!extern_c_decls)
2527 extern_c_decls = hash_table<named_decl_hash>::create_ggc (127);
2528
2529 tree *slot = extern_c_decls
2530 ->find_slot_with_hash (DECL_NAME (decl),
2531 IDENTIFIER_HASH_VALUE (DECL_NAME (decl)), INSERT);
2532 if (tree old = *slot)
2533 {
2534 if (TREE_CODE (old) == OVERLOAD)
2535 old = OVL_FUNCTION (old);
2536
2537 int mismatch = 0;
2538 if (DECL_CONTEXT (old) == DECL_CONTEXT (decl))
2539 ; /* If they're in the same context, we'll have already complained
2540 about a (possible) mismatch, when inserting the decl. */
2541 else if (!decls_match (decl, old))
2542 mismatch = 1;
2543 else if (TREE_CODE (decl) == FUNCTION_DECL
2544 && !comp_except_specs (TYPE_RAISES_EXCEPTIONS (TREE_TYPE (old)),
2545 TYPE_RAISES_EXCEPTIONS (TREE_TYPE (decl)),
2546 ce_normal))
2547 mismatch = -1;
2548 else if (DECL_ASSEMBLER_NAME_SET_P (old))
2549 SET_DECL_ASSEMBLER_NAME (decl, DECL_ASSEMBLER_NAME (old));
2550
2551 if (mismatch)
2552 {
2553 pedwarn (input_location, 0,
2554 "conflicting C language linkage declaration %q#D", decl);
2555 inform (DECL_SOURCE_LOCATION (old),
2556 "previous declaration %q#D", old);
2557 if (mismatch < 0)
2558 inform (input_location,
2559 "due to different exception specifications");
2560 }
2561 else
2562 {
2563 if (old == *slot)
2564 /* The hash table expects OVERLOADS, so construct one with
2565 OLD as both the function and the chain. This allocate
2566 an excess OVERLOAD node, but it's rare to have multiple
2567 extern "C" decls of the same name. And we save
2568 complicating the hash table logic (which is used
2569 elsewhere). */
2570 *slot = ovl_make (old, old);
2571
2572 slot = &OVL_CHAIN (*slot);
2573
2574 /* Chain it on for c_linkage_binding's use. */
2575 *slot = tree_cons (NULL_TREE, decl, *slot);
2576 }
2577 }
2578 else
2579 *slot = decl;
2580 }
2581
2582 /* Returns a list of C-linkage decls with the name NAME. Used in
2583 c-family/c-pragma.c to implement redefine_extname pragma. */
2584
2585 tree
c_linkage_bindings(tree name)2586 c_linkage_bindings (tree name)
2587 {
2588 if (extern_c_decls)
2589 if (tree *slot = extern_c_decls
2590 ->find_slot_with_hash (name, IDENTIFIER_HASH_VALUE (name), NO_INSERT))
2591 {
2592 tree result = *slot;
2593 if (TREE_CODE (result) == OVERLOAD)
2594 result = OVL_CHAIN (result);
2595 return result;
2596 }
2597
2598 return NULL_TREE;
2599 }
2600
2601 /* DECL is being declared at a local scope. Emit suitable shadow
2602 warnings. */
2603
2604 static void
check_local_shadow(tree decl)2605 check_local_shadow (tree decl)
2606 {
2607 /* Don't complain about the parms we push and then pop
2608 while tentatively parsing a function declarator. */
2609 if (TREE_CODE (decl) == PARM_DECL && !DECL_CONTEXT (decl))
2610 return;
2611
2612 /* Inline decls shadow nothing. */
2613 if (DECL_FROM_INLINE (decl))
2614 return;
2615
2616 /* External decls are something else. */
2617 if (DECL_EXTERNAL (decl))
2618 return;
2619
2620 tree old = NULL_TREE;
2621 cp_binding_level *old_scope = NULL;
2622 if (cxx_binding *binding = outer_binding (DECL_NAME (decl), NULL, true))
2623 {
2624 old = binding->value;
2625 old_scope = binding->scope;
2626 }
2627 while (old && VAR_P (old) && DECL_DEAD_FOR_LOCAL (old))
2628 old = DECL_SHADOWED_FOR_VAR (old);
2629
2630 tree shadowed = NULL_TREE;
2631 if (old
2632 && (TREE_CODE (old) == PARM_DECL
2633 || VAR_P (old)
2634 || (TREE_CODE (old) == TYPE_DECL
2635 && (!DECL_ARTIFICIAL (old)
2636 || TREE_CODE (decl) == TYPE_DECL)))
2637 && (!DECL_ARTIFICIAL (decl)
2638 || DECL_IMPLICIT_TYPEDEF_P (decl)
2639 || (VAR_P (decl) && DECL_ANON_UNION_VAR_P (decl))))
2640 {
2641 /* DECL shadows a local thing possibly of interest. */
2642
2643 /* Don't complain if it's from an enclosing function. */
2644 if (DECL_CONTEXT (old) == current_function_decl
2645 && TREE_CODE (decl) != PARM_DECL
2646 && TREE_CODE (old) == PARM_DECL)
2647 {
2648 /* Go to where the parms should be and see if we find
2649 them there. */
2650 cp_binding_level *b = current_binding_level->level_chain;
2651
2652 if (FUNCTION_NEEDS_BODY_BLOCK (current_function_decl))
2653 /* Skip the ctor/dtor cleanup level. */
2654 b = b->level_chain;
2655
2656 /* ARM $8.3 */
2657 if (b->kind == sk_function_parms)
2658 {
2659 error ("declaration of %q#D shadows a parameter", decl);
2660 return;
2661 }
2662 }
2663
2664 /* The local structure or class can't use parameters of
2665 the containing function anyway. */
2666 if (DECL_CONTEXT (old) != current_function_decl)
2667 {
2668 for (cp_binding_level *scope = current_binding_level;
2669 scope != old_scope; scope = scope->level_chain)
2670 if (scope->kind == sk_class
2671 && !LAMBDA_TYPE_P (scope->this_entity))
2672 return;
2673 }
2674 /* Error if redeclaring a local declared in a
2675 init-statement or in the condition of an if or
2676 switch statement when the new declaration is in the
2677 outermost block of the controlled statement.
2678 Redeclaring a variable from a for or while condition is
2679 detected elsewhere. */
2680 else if (VAR_P (old)
2681 && old_scope == current_binding_level->level_chain
2682 && (old_scope->kind == sk_cond || old_scope->kind == sk_for))
2683 {
2684 error ("redeclaration of %q#D", decl);
2685 inform (DECL_SOURCE_LOCATION (old),
2686 "%q#D previously declared here", old);
2687 return;
2688 }
2689 /* C++11:
2690 3.3.3/3: The name declared in an exception-declaration (...)
2691 shall not be redeclared in the outermost block of the handler.
2692 3.3.3/2: A parameter name shall not be redeclared (...) in
2693 the outermost block of any handler associated with a
2694 function-try-block.
2695 3.4.1/15: The function parameter names shall not be redeclared
2696 in the exception-declaration nor in the outermost block of a
2697 handler for the function-try-block. */
2698 else if ((TREE_CODE (old) == VAR_DECL
2699 && old_scope == current_binding_level->level_chain
2700 && old_scope->kind == sk_catch)
2701 || (TREE_CODE (old) == PARM_DECL
2702 && (current_binding_level->kind == sk_catch
2703 || current_binding_level->level_chain->kind == sk_catch)
2704 && in_function_try_handler))
2705 {
2706 if (permerror (input_location, "redeclaration of %q#D", decl))
2707 inform (DECL_SOURCE_LOCATION (old),
2708 "%q#D previously declared here", old);
2709 return;
2710 }
2711
2712 /* If '-Wshadow=compatible-local' is specified without other
2713 -Wshadow= flags, we will warn only when the type of the
2714 shadowing variable (DECL) can be converted to that of the
2715 shadowed parameter (OLD_LOCAL). The reason why we only check
2716 if DECL's type can be converted to OLD_LOCAL's type (but not the
2717 other way around) is because when users accidentally shadow a
2718 parameter, more than often they would use the variable
2719 thinking (mistakenly) it's still the parameter. It would be
2720 rare that users would use the variable in the place that
2721 expects the parameter but thinking it's a new decl. */
2722
2723 enum opt_code warning_code;
2724 if (warn_shadow)
2725 warning_code = OPT_Wshadow;
2726 else if (warn_shadow_local)
2727 warning_code = OPT_Wshadow_local;
2728 else if (warn_shadow_compatible_local
2729 && (same_type_p (TREE_TYPE (old), TREE_TYPE (decl))
2730 || (!dependent_type_p (TREE_TYPE (decl))
2731 && !dependent_type_p (TREE_TYPE (old))
2732 /* If the new decl uses auto, we don't yet know
2733 its type (the old type cannot be using auto
2734 at this point, without also being
2735 dependent). This is an indication we're
2736 (now) doing the shadow checking too
2737 early. */
2738 && !type_uses_auto (TREE_TYPE (decl))
2739 && can_convert (TREE_TYPE (old), TREE_TYPE (decl),
2740 tf_none))))
2741 warning_code = OPT_Wshadow_compatible_local;
2742 else
2743 return;
2744
2745 const char *msg;
2746 if (TREE_CODE (old) == PARM_DECL)
2747 msg = "declaration of %q#D shadows a parameter";
2748 else if (is_capture_proxy (old))
2749 msg = "declaration of %qD shadows a lambda capture";
2750 else
2751 msg = "declaration of %qD shadows a previous local";
2752
2753 if (warning_at (input_location, warning_code, msg, decl))
2754 {
2755 shadowed = old;
2756 goto inform_shadowed;
2757 }
2758 return;
2759 }
2760
2761 if (!warn_shadow)
2762 return;
2763
2764 /* Don't warn for artificial things that are not implicit typedefs. */
2765 if (DECL_ARTIFICIAL (decl) && !DECL_IMPLICIT_TYPEDEF_P (decl))
2766 return;
2767
2768 if (nonlambda_method_basetype ())
2769 if (tree member = lookup_member (current_nonlambda_class_type (),
2770 DECL_NAME (decl), /*protect=*/0,
2771 /*want_type=*/false, tf_warning_or_error))
2772 {
2773 member = MAYBE_BASELINK_FUNCTIONS (member);
2774
2775 /* Warn if a variable shadows a non-function, or the variable
2776 is a function or a pointer-to-function. */
2777 if (!OVL_P (member)
2778 || TREE_CODE (decl) == FUNCTION_DECL
2779 || TYPE_PTRFN_P (TREE_TYPE (decl))
2780 || TYPE_PTRMEMFUNC_P (TREE_TYPE (decl)))
2781 {
2782 if (warning_at (input_location, OPT_Wshadow,
2783 "declaration of %qD shadows a member of %qT",
2784 decl, current_nonlambda_class_type ())
2785 && DECL_P (member))
2786 {
2787 shadowed = member;
2788 goto inform_shadowed;
2789 }
2790 }
2791 return;
2792 }
2793
2794 /* Now look for a namespace shadow. */
2795 old = find_namespace_value (current_namespace, DECL_NAME (decl));
2796 if (old
2797 && (VAR_P (old)
2798 || (TREE_CODE (old) == TYPE_DECL
2799 && (!DECL_ARTIFICIAL (old)
2800 || TREE_CODE (decl) == TYPE_DECL)))
2801 && !instantiating_current_function_p ())
2802 /* XXX shadow warnings in outer-more namespaces */
2803 {
2804 if (warning_at (input_location, OPT_Wshadow,
2805 "declaration of %qD shadows a global declaration",
2806 decl))
2807 {
2808 shadowed = old;
2809 goto inform_shadowed;
2810 }
2811 return;
2812 }
2813
2814 return;
2815
2816 inform_shadowed:
2817 inform (DECL_SOURCE_LOCATION (shadowed), "shadowed declaration is here");
2818 }
2819
2820 /* DECL is being pushed inside function CTX. Set its context, if
2821 needed. */
2822
2823 static void
set_decl_context_in_fn(tree ctx,tree decl)2824 set_decl_context_in_fn (tree ctx, tree decl)
2825 {
2826 if (!DECL_CONTEXT (decl)
2827 /* A local declaration for a function doesn't constitute
2828 nesting. */
2829 && TREE_CODE (decl) != FUNCTION_DECL
2830 /* A local declaration for an `extern' variable is in the
2831 scope of the current namespace, not the current
2832 function. */
2833 && !(VAR_P (decl) && DECL_EXTERNAL (decl))
2834 /* When parsing the parameter list of a function declarator,
2835 don't set DECL_CONTEXT to an enclosing function. When we
2836 push the PARM_DECLs in order to process the function body,
2837 current_binding_level->this_entity will be set. */
2838 && !(TREE_CODE (decl) == PARM_DECL
2839 && current_binding_level->kind == sk_function_parms
2840 && current_binding_level->this_entity == NULL))
2841 DECL_CONTEXT (decl) = ctx;
2842
2843 /* If this is the declaration for a namespace-scope function,
2844 but the declaration itself is in a local scope, mark the
2845 declaration. */
2846 if (TREE_CODE (decl) == FUNCTION_DECL && DECL_NAMESPACE_SCOPE_P (decl))
2847 DECL_LOCAL_FUNCTION_P (decl) = 1;
2848 }
2849
2850 /* DECL is a local-scope decl with linkage. SHADOWED is true if the
2851 name is already bound at the current level.
2852
2853 [basic.link] If there is a visible declaration of an entity with
2854 linkage having the same name and type, ignoring entities declared
2855 outside the innermost enclosing namespace scope, the block scope
2856 declaration declares that same entity and receives the linkage of
2857 the previous declaration.
2858
2859 Also, make sure that this decl matches any existing external decl
2860 in the enclosing namespace. */
2861
2862 static void
set_local_extern_decl_linkage(tree decl,bool shadowed)2863 set_local_extern_decl_linkage (tree decl, bool shadowed)
2864 {
2865 tree ns_value = decl; /* Unique marker. */
2866
2867 if (!shadowed)
2868 {
2869 tree loc_value = innermost_non_namespace_value (DECL_NAME (decl));
2870 if (!loc_value)
2871 {
2872 ns_value
2873 = find_namespace_value (current_namespace, DECL_NAME (decl));
2874 loc_value = ns_value;
2875 }
2876 if (loc_value == error_mark_node
2877 /* An ambiguous lookup. */
2878 || (loc_value && TREE_CODE (loc_value) == TREE_LIST))
2879 loc_value = NULL_TREE;
2880
2881 for (ovl_iterator iter (loc_value); iter; ++iter)
2882 if (!iter.hidden_p ()
2883 && (TREE_STATIC (*iter) || DECL_EXTERNAL (*iter))
2884 && decls_match (*iter, decl))
2885 {
2886 /* The standard only says that the local extern inherits
2887 linkage from the previous decl; in particular, default
2888 args are not shared. Add the decl into a hash table to
2889 make sure only the previous decl in this case is seen
2890 by the middle end. */
2891 struct cxx_int_tree_map *h;
2892
2893 /* We inherit the outer decl's linkage. But we're a
2894 different decl. */
2895 TREE_PUBLIC (decl) = TREE_PUBLIC (*iter);
2896
2897 if (cp_function_chain->extern_decl_map == NULL)
2898 cp_function_chain->extern_decl_map
2899 = hash_table<cxx_int_tree_map_hasher>::create_ggc (20);
2900
2901 h = ggc_alloc<cxx_int_tree_map> ();
2902 h->uid = DECL_UID (decl);
2903 h->to = *iter;
2904 cxx_int_tree_map **loc = cp_function_chain->extern_decl_map
2905 ->find_slot (h, INSERT);
2906 *loc = h;
2907 break;
2908 }
2909 }
2910
2911 if (TREE_PUBLIC (decl))
2912 {
2913 /* DECL is externally visible. Make sure it matches a matching
2914 decl in the namespace scope. We only really need to check
2915 this when inserting the decl, not when we find an existing
2916 match in the current scope. However, in practice we're
2917 going to be inserting a new decl in the majority of cases --
2918 who writes multiple extern decls for the same thing in the
2919 same local scope? Doing it here often avoids a duplicate
2920 namespace lookup. */
2921
2922 /* Avoid repeating a lookup. */
2923 if (ns_value == decl)
2924 ns_value = find_namespace_value (current_namespace, DECL_NAME (decl));
2925
2926 if (ns_value == error_mark_node
2927 || (ns_value && TREE_CODE (ns_value) == TREE_LIST))
2928 ns_value = NULL_TREE;
2929
2930 for (ovl_iterator iter (ns_value); iter; ++iter)
2931 {
2932 tree other = *iter;
2933
2934 if (!(TREE_PUBLIC (other) || DECL_EXTERNAL (other)))
2935 ; /* Not externally visible. */
2936 else if (DECL_EXTERN_C_P (decl) && DECL_EXTERN_C_P (other))
2937 ; /* Both are extern "C", we'll check via that mechanism. */
2938 else if (TREE_CODE (other) != TREE_CODE (decl)
2939 || ((VAR_P (decl) || matching_fn_p (other, decl))
2940 && !comptypes (TREE_TYPE (decl), TREE_TYPE (other),
2941 COMPARE_REDECLARATION)))
2942 {
2943 if (permerror (DECL_SOURCE_LOCATION (decl),
2944 "local external declaration %q#D", decl))
2945 inform (DECL_SOURCE_LOCATION (other),
2946 "does not match previous declaration %q#D", other);
2947 break;
2948 }
2949 }
2950 }
2951 }
2952
2953 /* Record DECL as belonging to the current lexical scope. Check for
2954 errors (such as an incompatible declaration for the same name
2955 already seen in the same scope). IS_FRIEND is true if DECL is
2956 declared as a friend.
2957
2958 Returns either DECL or an old decl for the same name. If an old
2959 decl is returned, it may have been smashed to agree with what DECL
2960 says. */
2961
2962 static tree
do_pushdecl(tree decl,bool is_friend)2963 do_pushdecl (tree decl, bool is_friend)
2964 {
2965 if (decl == error_mark_node)
2966 return error_mark_node;
2967
2968 if (!DECL_TEMPLATE_PARM_P (decl) && current_function_decl)
2969 set_decl_context_in_fn (current_function_decl, decl);
2970
2971 /* The binding level we will be pushing into. During local class
2972 pushing, we want to push to the containing scope. */
2973 cp_binding_level *level = current_binding_level;
2974 while (level->kind == sk_class)
2975 level = level->level_chain;
2976
2977 /* An anonymous namespace has a NULL DECL_NAME, but we still want to
2978 insert it. Other NULL-named decls, not so much. */
2979 tree name = DECL_NAME (decl);
2980 if (name || TREE_CODE (decl) == NAMESPACE_DECL)
2981 {
2982 cxx_binding *binding = NULL; /* Local scope binding. */
2983 tree ns = NULL_TREE; /* Searched namespace. */
2984 tree *slot = NULL; /* Binding slot in namespace. */
2985 tree old = NULL_TREE;
2986
2987 if (level->kind == sk_namespace)
2988 {
2989 /* We look in the decl's namespace for an existing
2990 declaration, even though we push into the current
2991 namespace. */
2992 ns = (DECL_NAMESPACE_SCOPE_P (decl)
2993 ? CP_DECL_CONTEXT (decl) : current_namespace);
2994 /* Create the binding, if this is current namespace, because
2995 that's where we'll be pushing anyway. */
2996 slot = find_namespace_slot (ns, name, ns == current_namespace);
2997 if (slot)
2998 old = MAYBE_STAT_DECL (*slot);
2999 }
3000 else
3001 {
3002 binding = find_local_binding (level, name);
3003 if (binding)
3004 old = binding->value;
3005 }
3006
3007 if (current_function_decl && VAR_OR_FUNCTION_DECL_P (decl)
3008 && DECL_EXTERNAL (decl))
3009 set_local_extern_decl_linkage (decl, old != NULL_TREE);
3010
3011 if (old == error_mark_node)
3012 old = NULL_TREE;
3013
3014 for (ovl_iterator iter (old); iter; ++iter)
3015 if (iter.using_p ())
3016 ; /* Ignore using decls here. */
3017 else if (tree match = duplicate_decls (decl, *iter, is_friend))
3018 {
3019 if (match == error_mark_node)
3020 ;
3021 else if (TREE_CODE (match) == TYPE_DECL)
3022 /* The IDENTIFIER will have the type referring to the
3023 now-smashed TYPE_DECL, because ...? Reset it. */
3024 SET_IDENTIFIER_TYPE_VALUE (name, TREE_TYPE (match));
3025 else if (iter.hidden_p () && !DECL_HIDDEN_P (match))
3026 {
3027 /* Unhiding a previously hidden decl. */
3028 tree head = iter.reveal_node (old);
3029 if (head != old)
3030 {
3031 if (!ns)
3032 {
3033 update_local_overload (binding, head);
3034 binding->value = head;
3035 }
3036 else if (STAT_HACK_P (*slot))
3037 STAT_DECL (*slot) = head;
3038 else
3039 *slot = head;
3040 }
3041 if (DECL_EXTERN_C_P (match))
3042 /* We need to check and register the decl now. */
3043 check_extern_c_conflict (match);
3044 }
3045 return match;
3046 }
3047
3048 /* We are pushing a new decl. */
3049
3050 /* Skip a hidden builtin we failed to match already. There can
3051 only be one. */
3052 if (old && anticipated_builtin_p (old))
3053 old = OVL_CHAIN (old);
3054
3055 check_template_shadow (decl);
3056 bool visible_injection = false;
3057
3058 if (DECL_DECLARES_FUNCTION_P (decl))
3059 {
3060 check_default_args (decl);
3061
3062 if (is_friend)
3063 {
3064 if (level->kind != sk_namespace)
3065 {
3066 /* In a local class, a friend function declaration must
3067 find a matching decl in the innermost non-class scope.
3068 [class.friend/11] */
3069 error ("friend declaration %qD in local class without "
3070 "prior local declaration", decl);
3071 /* Don't attempt to push it. */
3072 return error_mark_node;
3073 }
3074 if (!flag_friend_injection)
3075 /* Hide it from ordinary lookup. */
3076 DECL_ANTICIPATED (decl) = DECL_HIDDEN_FRIEND_P (decl) = true;
3077 else
3078 visible_injection = true;
3079 }
3080 }
3081
3082 if (level->kind != sk_namespace)
3083 {
3084 check_local_shadow (decl);
3085
3086 if (TREE_CODE (decl) == NAMESPACE_DECL)
3087 /* A local namespace alias. */
3088 set_identifier_type_value (name, NULL_TREE);
3089
3090 if (!binding)
3091 binding = create_local_binding (level, name);
3092 }
3093 else if (!slot)
3094 {
3095 ns = current_namespace;
3096 slot = find_namespace_slot (ns, name, true);
3097 /* Update OLD to reflect the namespace we're going to be
3098 pushing into. */
3099 old = MAYBE_STAT_DECL (*slot);
3100 }
3101
3102 old = update_binding (level, binding, slot, old, decl, is_friend);
3103
3104 if (old != decl)
3105 /* An existing decl matched, use it. */
3106 decl = old;
3107 else if (TREE_CODE (decl) == TYPE_DECL)
3108 {
3109 tree type = TREE_TYPE (decl);
3110
3111 if (type != error_mark_node)
3112 {
3113 if (TYPE_NAME (type) != decl)
3114 set_underlying_type (decl);
3115
3116 if (!ns)
3117 set_identifier_type_value_with_scope (name, decl, level);
3118 else
3119 SET_IDENTIFIER_TYPE_VALUE (name, global_type_node);
3120 }
3121
3122 /* If this is a locally defined typedef in a function that
3123 is not a template instantation, record it to implement
3124 -Wunused-local-typedefs. */
3125 if (!instantiating_current_function_p ())
3126 record_locally_defined_typedef (decl);
3127 }
3128 else if (VAR_P (decl))
3129 maybe_register_incomplete_var (decl);
3130 else if (visible_injection)
3131 warning (0, "injected friend %qD is visible"
3132 " due to %<-ffriend-injection%>", decl);
3133
3134 if ((VAR_P (decl) || TREE_CODE (decl) == FUNCTION_DECL)
3135 && DECL_EXTERN_C_P (decl))
3136 check_extern_c_conflict (decl);
3137 }
3138 else
3139 add_decl_to_level (level, decl);
3140
3141 return decl;
3142 }
3143
3144 /* Record a decl-node X as belonging to the current lexical scope.
3145 It's a friend if IS_FRIEND is true -- which affects exactly where
3146 we push it. */
3147
3148 tree
pushdecl(tree x,bool is_friend)3149 pushdecl (tree x, bool is_friend)
3150 {
3151 bool subtime = timevar_cond_start (TV_NAME_LOOKUP);
3152 tree ret = do_pushdecl (x, is_friend);
3153 timevar_cond_stop (TV_NAME_LOOKUP, subtime);
3154 return ret;
3155 }
3156
3157 /* Enter DECL into the symbol table, if that's appropriate. Returns
3158 DECL, or a modified version thereof. */
3159
3160 tree
maybe_push_decl(tree decl)3161 maybe_push_decl (tree decl)
3162 {
3163 tree type = TREE_TYPE (decl);
3164
3165 /* Add this decl to the current binding level, but not if it comes
3166 from another scope, e.g. a static member variable. TEM may equal
3167 DECL or it may be a previous decl of the same name. */
3168 if (decl == error_mark_node
3169 || (TREE_CODE (decl) != PARM_DECL
3170 && DECL_CONTEXT (decl) != NULL_TREE
3171 /* Definitions of namespace members outside their namespace are
3172 possible. */
3173 && !DECL_NAMESPACE_SCOPE_P (decl))
3174 || (TREE_CODE (decl) == TEMPLATE_DECL && !namespace_bindings_p ())
3175 || type == unknown_type_node
3176 /* The declaration of a template specialization does not affect
3177 the functions available for overload resolution, so we do not
3178 call pushdecl. */
3179 || (TREE_CODE (decl) == FUNCTION_DECL
3180 && DECL_TEMPLATE_SPECIALIZATION (decl)))
3181 return decl;
3182 else
3183 return pushdecl (decl);
3184 }
3185
3186 /* Bind DECL to ID in the current_binding_level, assumed to be a local
3187 binding level. If IS_USING is true, DECL got here through a
3188 using-declaration. */
3189
3190 static void
push_local_binding(tree id,tree decl,bool is_using)3191 push_local_binding (tree id, tree decl, bool is_using)
3192 {
3193 /* Skip over any local classes. This makes sense if we call
3194 push_local_binding with a friend decl of a local class. */
3195 cp_binding_level *b = innermost_nonclass_level ();
3196
3197 gcc_assert (b->kind != sk_namespace);
3198 if (find_local_binding (b, id))
3199 {
3200 /* Supplement the existing binding. */
3201 if (!supplement_binding (IDENTIFIER_BINDING (id), decl))
3202 /* It didn't work. Something else must be bound at this
3203 level. Do not add DECL to the list of things to pop
3204 later. */
3205 return;
3206 }
3207 else
3208 /* Create a new binding. */
3209 push_binding (id, decl, b);
3210
3211 if (TREE_CODE (decl) == OVERLOAD || is_using)
3212 /* We must put the OVERLOAD or using into a TREE_LIST since we
3213 cannot use the decl's chain itself. */
3214 decl = build_tree_list (NULL_TREE, decl);
3215
3216 /* And put DECL on the list of things declared by the current
3217 binding level. */
3218 add_decl_to_level (b, decl);
3219 }
3220
3221 /* Check to see whether or not DECL is a variable that would have been
3222 in scope under the ARM, but is not in scope under the ANSI/ISO
3223 standard. If so, issue an error message. If name lookup would
3224 work in both cases, but return a different result, this function
3225 returns the result of ANSI/ISO lookup. Otherwise, it returns
3226 DECL.
3227
3228 FIXME: Scheduled for removal after GCC-8 is done. */
3229
3230 tree
check_for_out_of_scope_variable(tree decl)3231 check_for_out_of_scope_variable (tree decl)
3232 {
3233 tree shadowed;
3234
3235 /* We only care about out of scope variables. */
3236 if (!(VAR_P (decl) && DECL_DEAD_FOR_LOCAL (decl)))
3237 return decl;
3238
3239 shadowed = DECL_HAS_SHADOWED_FOR_VAR_P (decl)
3240 ? DECL_SHADOWED_FOR_VAR (decl) : NULL_TREE ;
3241 while (shadowed != NULL_TREE && VAR_P (shadowed)
3242 && DECL_DEAD_FOR_LOCAL (shadowed))
3243 shadowed = DECL_HAS_SHADOWED_FOR_VAR_P (shadowed)
3244 ? DECL_SHADOWED_FOR_VAR (shadowed) : NULL_TREE;
3245 if (!shadowed)
3246 shadowed = find_namespace_value (current_namespace, DECL_NAME (decl));
3247 if (shadowed)
3248 {
3249 if (!DECL_ERROR_REPORTED (decl)
3250 && flag_permissive
3251 && warning (0, "name lookup of %qD changed", DECL_NAME (decl)))
3252 {
3253 inform (DECL_SOURCE_LOCATION (shadowed),
3254 "matches this %qD under ISO standard rules", shadowed);
3255 inform (DECL_SOURCE_LOCATION (decl),
3256 " matches this %qD under old rules", decl);
3257 }
3258 DECL_ERROR_REPORTED (decl) = 1;
3259 return shadowed;
3260 }
3261
3262 /* If we have already complained about this declaration, there's no
3263 need to do it again. */
3264 if (DECL_ERROR_REPORTED (decl))
3265 return decl;
3266
3267 DECL_ERROR_REPORTED (decl) = 1;
3268
3269 if (TREE_TYPE (decl) == error_mark_node)
3270 return decl;
3271
3272 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TREE_TYPE (decl)))
3273 {
3274 error ("name lookup of %qD changed for ISO %<for%> scoping",
3275 DECL_NAME (decl));
3276 inform (DECL_SOURCE_LOCATION (decl),
3277 "cannot use obsolete binding %qD because it has a destructor",
3278 decl);
3279 return error_mark_node;
3280 }
3281 else
3282 {
3283 permerror (input_location,
3284 "name lookup of %qD changed for ISO %<for%> scoping",
3285 DECL_NAME (decl));
3286 if (flag_permissive)
3287 inform (DECL_SOURCE_LOCATION (decl),
3288 "using obsolete binding %qD", decl);
3289 static bool hint;
3290 if (!hint)
3291 inform (input_location, flag_permissive
3292 ? "this flexibility is deprecated and will be removed"
3293 : "if you use %<-fpermissive%> G++ will accept your code");
3294 hint = true;
3295 }
3296
3297 return decl;
3298 }
3299
3300 /* true means unconditionally make a BLOCK for the next level pushed. */
3301
3302 static bool keep_next_level_flag;
3303
3304 static int binding_depth = 0;
3305
3306 static void
indent(int depth)3307 indent (int depth)
3308 {
3309 int i;
3310
3311 for (i = 0; i < depth * 2; i++)
3312 putc (' ', stderr);
3313 }
3314
3315 /* Return a string describing the kind of SCOPE we have. */
3316 static const char *
cp_binding_level_descriptor(cp_binding_level * scope)3317 cp_binding_level_descriptor (cp_binding_level *scope)
3318 {
3319 /* The order of this table must match the "scope_kind"
3320 enumerators. */
3321 static const char* scope_kind_names[] = {
3322 "block-scope",
3323 "cleanup-scope",
3324 "try-scope",
3325 "catch-scope",
3326 "for-scope",
3327 "function-parameter-scope",
3328 "class-scope",
3329 "namespace-scope",
3330 "template-parameter-scope",
3331 "template-explicit-spec-scope"
3332 };
3333 const scope_kind kind = scope->explicit_spec_p
3334 ? sk_template_spec : scope->kind;
3335
3336 return scope_kind_names[kind];
3337 }
3338
3339 /* Output a debugging information about SCOPE when performing
3340 ACTION at LINE. */
3341 static void
cp_binding_level_debug(cp_binding_level * scope,int line,const char * action)3342 cp_binding_level_debug (cp_binding_level *scope, int line, const char *action)
3343 {
3344 const char *desc = cp_binding_level_descriptor (scope);
3345 if (scope->this_entity)
3346 verbatim ("%s %<%s(%E)%> %p %d\n", action, desc,
3347 scope->this_entity, (void *) scope, line);
3348 else
3349 verbatim ("%s %s %p %d\n", action, desc, (void *) scope, line);
3350 }
3351
3352 /* Return the estimated initial size of the hashtable of a NAMESPACE
3353 scope. */
3354
3355 static inline size_t
namespace_scope_ht_size(tree ns)3356 namespace_scope_ht_size (tree ns)
3357 {
3358 tree name = DECL_NAME (ns);
3359
3360 return name == std_identifier
3361 ? NAMESPACE_STD_HT_SIZE
3362 : (name == global_identifier
3363 ? GLOBAL_SCOPE_HT_SIZE
3364 : NAMESPACE_ORDINARY_HT_SIZE);
3365 }
3366
3367 /* A chain of binding_level structures awaiting reuse. */
3368
3369 static GTY((deletable)) cp_binding_level *free_binding_level;
3370
3371 /* Insert SCOPE as the innermost binding level. */
3372
3373 void
push_binding_level(cp_binding_level * scope)3374 push_binding_level (cp_binding_level *scope)
3375 {
3376 /* Add it to the front of currently active scopes stack. */
3377 scope->level_chain = current_binding_level;
3378 current_binding_level = scope;
3379 keep_next_level_flag = false;
3380
3381 if (ENABLE_SCOPE_CHECKING)
3382 {
3383 scope->binding_depth = binding_depth;
3384 indent (binding_depth);
3385 cp_binding_level_debug (scope, LOCATION_LINE (input_location),
3386 "push");
3387 binding_depth++;
3388 }
3389 }
3390
3391 /* Create a new KIND scope and make it the top of the active scopes stack.
3392 ENTITY is the scope of the associated C++ entity (namespace, class,
3393 function, C++0x enumeration); it is NULL otherwise. */
3394
3395 cp_binding_level *
begin_scope(scope_kind kind,tree entity)3396 begin_scope (scope_kind kind, tree entity)
3397 {
3398 cp_binding_level *scope;
3399
3400 /* Reuse or create a struct for this binding level. */
3401 if (!ENABLE_SCOPE_CHECKING && free_binding_level)
3402 {
3403 scope = free_binding_level;
3404 free_binding_level = scope->level_chain;
3405 memset (scope, 0, sizeof (cp_binding_level));
3406 }
3407 else
3408 scope = ggc_cleared_alloc<cp_binding_level> ();
3409
3410 scope->this_entity = entity;
3411 scope->more_cleanups_ok = true;
3412 switch (kind)
3413 {
3414 case sk_cleanup:
3415 scope->keep = true;
3416 break;
3417
3418 case sk_template_spec:
3419 scope->explicit_spec_p = true;
3420 kind = sk_template_parms;
3421 /* Fall through. */
3422 case sk_template_parms:
3423 case sk_block:
3424 case sk_try:
3425 case sk_catch:
3426 case sk_for:
3427 case sk_cond:
3428 case sk_class:
3429 case sk_scoped_enum:
3430 case sk_function_parms:
3431 case sk_transaction:
3432 case sk_omp:
3433 scope->keep = keep_next_level_flag;
3434 break;
3435
3436 case sk_namespace:
3437 NAMESPACE_LEVEL (entity) = scope;
3438 break;
3439
3440 default:
3441 /* Should not happen. */
3442 gcc_unreachable ();
3443 break;
3444 }
3445 scope->kind = kind;
3446
3447 push_binding_level (scope);
3448
3449 return scope;
3450 }
3451
3452 /* We're about to leave current scope. Pop the top of the stack of
3453 currently active scopes. Return the enclosing scope, now active. */
3454
3455 cp_binding_level *
leave_scope(void)3456 leave_scope (void)
3457 {
3458 cp_binding_level *scope = current_binding_level;
3459
3460 if (scope->kind == sk_namespace && class_binding_level)
3461 current_binding_level = class_binding_level;
3462
3463 /* We cannot leave a scope, if there are none left. */
3464 if (NAMESPACE_LEVEL (global_namespace))
3465 gcc_assert (!global_scope_p (scope));
3466
3467 if (ENABLE_SCOPE_CHECKING)
3468 {
3469 indent (--binding_depth);
3470 cp_binding_level_debug (scope, LOCATION_LINE (input_location),
3471 "leave");
3472 }
3473
3474 /* Move one nesting level up. */
3475 current_binding_level = scope->level_chain;
3476
3477 /* Namespace-scopes are left most probably temporarily, not
3478 completely; they can be reopened later, e.g. in namespace-extension
3479 or any name binding activity that requires us to resume a
3480 namespace. For classes, we cache some binding levels. For other
3481 scopes, we just make the structure available for reuse. */
3482 if (scope->kind != sk_namespace
3483 && scope->kind != sk_class)
3484 {
3485 scope->level_chain = free_binding_level;
3486 gcc_assert (!ENABLE_SCOPE_CHECKING
3487 || scope->binding_depth == binding_depth);
3488 free_binding_level = scope;
3489 }
3490
3491 if (scope->kind == sk_class)
3492 {
3493 /* Reset DEFINING_CLASS_P to allow for reuse of a
3494 class-defining scope in a non-defining context. */
3495 scope->defining_class_p = 0;
3496
3497 /* Find the innermost enclosing class scope, and reset
3498 CLASS_BINDING_LEVEL appropriately. */
3499 class_binding_level = NULL;
3500 for (scope = current_binding_level; scope; scope = scope->level_chain)
3501 if (scope->kind == sk_class)
3502 {
3503 class_binding_level = scope;
3504 break;
3505 }
3506 }
3507
3508 return current_binding_level;
3509 }
3510
3511 static void
resume_scope(cp_binding_level * b)3512 resume_scope (cp_binding_level* b)
3513 {
3514 /* Resuming binding levels is meant only for namespaces,
3515 and those cannot nest into classes. */
3516 gcc_assert (!class_binding_level);
3517 /* Also, resuming a non-directly nested namespace is a no-no. */
3518 gcc_assert (b->level_chain == current_binding_level);
3519 current_binding_level = b;
3520 if (ENABLE_SCOPE_CHECKING)
3521 {
3522 b->binding_depth = binding_depth;
3523 indent (binding_depth);
3524 cp_binding_level_debug (b, LOCATION_LINE (input_location), "resume");
3525 binding_depth++;
3526 }
3527 }
3528
3529 /* Return the innermost binding level that is not for a class scope. */
3530
3531 static cp_binding_level *
innermost_nonclass_level(void)3532 innermost_nonclass_level (void)
3533 {
3534 cp_binding_level *b;
3535
3536 b = current_binding_level;
3537 while (b->kind == sk_class)
3538 b = b->level_chain;
3539
3540 return b;
3541 }
3542
3543 /* We're defining an object of type TYPE. If it needs a cleanup, but
3544 we're not allowed to add any more objects with cleanups to the current
3545 scope, create a new binding level. */
3546
3547 void
maybe_push_cleanup_level(tree type)3548 maybe_push_cleanup_level (tree type)
3549 {
3550 if (type != error_mark_node
3551 && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type)
3552 && current_binding_level->more_cleanups_ok == 0)
3553 {
3554 begin_scope (sk_cleanup, NULL);
3555 current_binding_level->statement_list = push_stmt_list ();
3556 }
3557 }
3558
3559 /* Return true if we are in the global binding level. */
3560
3561 bool
global_bindings_p(void)3562 global_bindings_p (void)
3563 {
3564 return global_scope_p (current_binding_level);
3565 }
3566
3567 /* True if we are currently in a toplevel binding level. This
3568 means either the global binding level or a namespace in a toplevel
3569 binding level. Since there are no non-toplevel namespace levels,
3570 this really means any namespace or template parameter level. We
3571 also include a class whose context is toplevel. */
3572
3573 bool
toplevel_bindings_p(void)3574 toplevel_bindings_p (void)
3575 {
3576 cp_binding_level *b = innermost_nonclass_level ();
3577
3578 return b->kind == sk_namespace || b->kind == sk_template_parms;
3579 }
3580
3581 /* True if this is a namespace scope, or if we are defining a class
3582 which is itself at namespace scope, or whose enclosing class is
3583 such a class, etc. */
3584
3585 bool
namespace_bindings_p(void)3586 namespace_bindings_p (void)
3587 {
3588 cp_binding_level *b = innermost_nonclass_level ();
3589
3590 return b->kind == sk_namespace;
3591 }
3592
3593 /* True if the innermost non-class scope is a block scope. */
3594
3595 bool
local_bindings_p(void)3596 local_bindings_p (void)
3597 {
3598 cp_binding_level *b = innermost_nonclass_level ();
3599 return b->kind < sk_function_parms || b->kind == sk_omp;
3600 }
3601
3602 /* True if the current level needs to have a BLOCK made. */
3603
3604 bool
kept_level_p(void)3605 kept_level_p (void)
3606 {
3607 return (current_binding_level->blocks != NULL_TREE
3608 || current_binding_level->keep
3609 || current_binding_level->kind == sk_cleanup
3610 || current_binding_level->names != NULL_TREE
3611 || current_binding_level->using_directives);
3612 }
3613
3614 /* Returns the kind of the innermost scope. */
3615
3616 scope_kind
innermost_scope_kind(void)3617 innermost_scope_kind (void)
3618 {
3619 return current_binding_level->kind;
3620 }
3621
3622 /* Returns true if this scope was created to store template parameters. */
3623
3624 bool
template_parm_scope_p(void)3625 template_parm_scope_p (void)
3626 {
3627 return innermost_scope_kind () == sk_template_parms;
3628 }
3629
3630 /* If KEEP is true, make a BLOCK node for the next binding level,
3631 unconditionally. Otherwise, use the normal logic to decide whether
3632 or not to create a BLOCK. */
3633
3634 void
keep_next_level(bool keep)3635 keep_next_level (bool keep)
3636 {
3637 keep_next_level_flag = keep;
3638 }
3639
3640 /* Return the list of declarations of the current local scope. */
3641
3642 tree
get_local_decls(void)3643 get_local_decls (void)
3644 {
3645 gcc_assert (current_binding_level->kind != sk_namespace
3646 && current_binding_level->kind != sk_class);
3647 return current_binding_level->names;
3648 }
3649
3650 /* Return how many function prototypes we are currently nested inside. */
3651
3652 int
function_parm_depth(void)3653 function_parm_depth (void)
3654 {
3655 int level = 0;
3656 cp_binding_level *b;
3657
3658 for (b = current_binding_level;
3659 b->kind == sk_function_parms;
3660 b = b->level_chain)
3661 ++level;
3662
3663 return level;
3664 }
3665
3666 /* For debugging. */
3667 static int no_print_functions = 0;
3668 static int no_print_builtins = 0;
3669
3670 static void
print_binding_level(cp_binding_level * lvl)3671 print_binding_level (cp_binding_level* lvl)
3672 {
3673 tree t;
3674 int i = 0, len;
3675 fprintf (stderr, " blocks=%p", (void *) lvl->blocks);
3676 if (lvl->more_cleanups_ok)
3677 fprintf (stderr, " more-cleanups-ok");
3678 if (lvl->have_cleanups)
3679 fprintf (stderr, " have-cleanups");
3680 fprintf (stderr, "\n");
3681 if (lvl->names)
3682 {
3683 fprintf (stderr, " names:\t");
3684 /* We can probably fit 3 names to a line? */
3685 for (t = lvl->names; t; t = TREE_CHAIN (t))
3686 {
3687 if (no_print_functions && (TREE_CODE (t) == FUNCTION_DECL))
3688 continue;
3689 if (no_print_builtins
3690 && (TREE_CODE (t) == TYPE_DECL)
3691 && DECL_IS_BUILTIN (t))
3692 continue;
3693
3694 /* Function decls tend to have longer names. */
3695 if (TREE_CODE (t) == FUNCTION_DECL)
3696 len = 3;
3697 else
3698 len = 2;
3699 i += len;
3700 if (i > 6)
3701 {
3702 fprintf (stderr, "\n\t");
3703 i = len;
3704 }
3705 print_node_brief (stderr, "", t, 0);
3706 if (t == error_mark_node)
3707 break;
3708 }
3709 if (i)
3710 fprintf (stderr, "\n");
3711 }
3712 if (vec_safe_length (lvl->class_shadowed))
3713 {
3714 size_t i;
3715 cp_class_binding *b;
3716 fprintf (stderr, " class-shadowed:");
3717 FOR_EACH_VEC_ELT (*lvl->class_shadowed, i, b)
3718 fprintf (stderr, " %s ", IDENTIFIER_POINTER (b->identifier));
3719 fprintf (stderr, "\n");
3720 }
3721 if (lvl->type_shadowed)
3722 {
3723 fprintf (stderr, " type-shadowed:");
3724 for (t = lvl->type_shadowed; t; t = TREE_CHAIN (t))
3725 {
3726 fprintf (stderr, " %s ", IDENTIFIER_POINTER (TREE_PURPOSE (t)));
3727 }
3728 fprintf (stderr, "\n");
3729 }
3730 }
3731
3732 DEBUG_FUNCTION void
debug(cp_binding_level & ref)3733 debug (cp_binding_level &ref)
3734 {
3735 print_binding_level (&ref);
3736 }
3737
3738 DEBUG_FUNCTION void
debug(cp_binding_level * ptr)3739 debug (cp_binding_level *ptr)
3740 {
3741 if (ptr)
3742 debug (*ptr);
3743 else
3744 fprintf (stderr, "<nil>\n");
3745 }
3746
3747
3748 void
print_other_binding_stack(cp_binding_level * stack)3749 print_other_binding_stack (cp_binding_level *stack)
3750 {
3751 cp_binding_level *level;
3752 for (level = stack; !global_scope_p (level); level = level->level_chain)
3753 {
3754 fprintf (stderr, "binding level %p\n", (void *) level);
3755 print_binding_level (level);
3756 }
3757 }
3758
3759 void
print_binding_stack(void)3760 print_binding_stack (void)
3761 {
3762 cp_binding_level *b;
3763 fprintf (stderr, "current_binding_level=%p\n"
3764 "class_binding_level=%p\n"
3765 "NAMESPACE_LEVEL (global_namespace)=%p\n",
3766 (void *) current_binding_level, (void *) class_binding_level,
3767 (void *) NAMESPACE_LEVEL (global_namespace));
3768 if (class_binding_level)
3769 {
3770 for (b = class_binding_level; b; b = b->level_chain)
3771 if (b == current_binding_level)
3772 break;
3773 if (b)
3774 b = class_binding_level;
3775 else
3776 b = current_binding_level;
3777 }
3778 else
3779 b = current_binding_level;
3780 print_other_binding_stack (b);
3781 fprintf (stderr, "global:\n");
3782 print_binding_level (NAMESPACE_LEVEL (global_namespace));
3783 }
3784
3785 /* Return the type associated with ID. */
3786
3787 static tree
identifier_type_value_1(tree id)3788 identifier_type_value_1 (tree id)
3789 {
3790 /* There is no type with that name, anywhere. */
3791 if (REAL_IDENTIFIER_TYPE_VALUE (id) == NULL_TREE)
3792 return NULL_TREE;
3793 /* This is not the type marker, but the real thing. */
3794 if (REAL_IDENTIFIER_TYPE_VALUE (id) != global_type_node)
3795 return REAL_IDENTIFIER_TYPE_VALUE (id);
3796 /* Have to search for it. It must be on the global level, now.
3797 Ask lookup_name not to return non-types. */
3798 id = lookup_name_real (id, 2, 1, /*block_p=*/true, 0, 0);
3799 if (id)
3800 return TREE_TYPE (id);
3801 return NULL_TREE;
3802 }
3803
3804 /* Wrapper for identifier_type_value_1. */
3805
3806 tree
identifier_type_value(tree id)3807 identifier_type_value (tree id)
3808 {
3809 tree ret;
3810 timevar_start (TV_NAME_LOOKUP);
3811 ret = identifier_type_value_1 (id);
3812 timevar_stop (TV_NAME_LOOKUP);
3813 return ret;
3814 }
3815
3816 /* Push a definition of struct, union or enum tag named ID. into
3817 binding_level B. DECL is a TYPE_DECL for the type. We assume that
3818 the tag ID is not already defined. */
3819
3820 static void
set_identifier_type_value_with_scope(tree id,tree decl,cp_binding_level * b)3821 set_identifier_type_value_with_scope (tree id, tree decl, cp_binding_level *b)
3822 {
3823 tree type;
3824
3825 if (b->kind != sk_namespace)
3826 {
3827 /* Shadow the marker, not the real thing, so that the marker
3828 gets restored later. */
3829 tree old_type_value = REAL_IDENTIFIER_TYPE_VALUE (id);
3830 b->type_shadowed
3831 = tree_cons (id, old_type_value, b->type_shadowed);
3832 type = decl ? TREE_TYPE (decl) : NULL_TREE;
3833 TREE_TYPE (b->type_shadowed) = type;
3834 }
3835 else
3836 {
3837 tree *slot = find_namespace_slot (current_namespace, id, true);
3838 gcc_assert (decl);
3839 update_binding (b, NULL, slot, MAYBE_STAT_DECL (*slot), decl, false);
3840
3841 /* Store marker instead of real type. */
3842 type = global_type_node;
3843 }
3844 SET_IDENTIFIER_TYPE_VALUE (id, type);
3845 }
3846
3847 /* As set_identifier_type_value_with_scope, but using
3848 current_binding_level. */
3849
3850 void
set_identifier_type_value(tree id,tree decl)3851 set_identifier_type_value (tree id, tree decl)
3852 {
3853 set_identifier_type_value_with_scope (id, decl, current_binding_level);
3854 }
3855
3856 /* Return the name for the constructor (or destructor) for the
3857 specified class. */
3858
3859 tree
constructor_name(tree type)3860 constructor_name (tree type)
3861 {
3862 tree decl = TYPE_NAME (TYPE_MAIN_VARIANT (type));
3863
3864 return decl ? DECL_NAME (decl) : NULL_TREE;
3865 }
3866
3867 /* Returns TRUE if NAME is the name for the constructor for TYPE,
3868 which must be a class type. */
3869
3870 bool
constructor_name_p(tree name,tree type)3871 constructor_name_p (tree name, tree type)
3872 {
3873 gcc_assert (MAYBE_CLASS_TYPE_P (type));
3874
3875 /* These don't have names. */
3876 if (TREE_CODE (type) == DECLTYPE_TYPE
3877 || TREE_CODE (type) == TYPEOF_TYPE)
3878 return false;
3879
3880 if (name && name == constructor_name (type))
3881 return true;
3882
3883 return false;
3884 }
3885
3886 /* Counter used to create anonymous type names. */
3887
3888 static GTY(()) int anon_cnt;
3889
3890 /* Return an IDENTIFIER which can be used as a name for
3891 unnamed structs and unions. */
3892
3893 tree
make_anon_name(void)3894 make_anon_name (void)
3895 {
3896 char buf[32];
3897
3898 sprintf (buf, anon_aggrname_format (), anon_cnt++);
3899 return get_identifier (buf);
3900 }
3901
3902 /* This code is practically identical to that for creating
3903 anonymous names, but is just used for lambdas instead. This isn't really
3904 necessary, but it's convenient to avoid treating lambdas like other
3905 unnamed types. */
3906
3907 static GTY(()) int lambda_cnt = 0;
3908
3909 tree
make_lambda_name(void)3910 make_lambda_name (void)
3911 {
3912 char buf[32];
3913
3914 sprintf (buf, LAMBDANAME_FORMAT, lambda_cnt++);
3915 return get_identifier (buf);
3916 }
3917
3918 /* Insert another USING_DECL into the current binding level, returning
3919 this declaration. If this is a redeclaration, do nothing, and
3920 return NULL_TREE if this not in namespace scope (in namespace
3921 scope, a using decl might extend any previous bindings). */
3922
3923 static tree
push_using_decl_1(tree scope,tree name)3924 push_using_decl_1 (tree scope, tree name)
3925 {
3926 tree decl;
3927
3928 gcc_assert (TREE_CODE (scope) == NAMESPACE_DECL);
3929 gcc_assert (identifier_p (name));
3930 for (decl = current_binding_level->usings; decl; decl = DECL_CHAIN (decl))
3931 if (USING_DECL_SCOPE (decl) == scope && DECL_NAME (decl) == name)
3932 break;
3933 if (decl)
3934 return namespace_bindings_p () ? decl : NULL_TREE;
3935 decl = build_lang_decl (USING_DECL, name, NULL_TREE);
3936 USING_DECL_SCOPE (decl) = scope;
3937 DECL_CHAIN (decl) = current_binding_level->usings;
3938 current_binding_level->usings = decl;
3939 return decl;
3940 }
3941
3942 /* Wrapper for push_using_decl_1. */
3943
3944 static tree
push_using_decl(tree scope,tree name)3945 push_using_decl (tree scope, tree name)
3946 {
3947 tree ret;
3948 timevar_start (TV_NAME_LOOKUP);
3949 ret = push_using_decl_1 (scope, name);
3950 timevar_stop (TV_NAME_LOOKUP);
3951 return ret;
3952 }
3953
3954 /* Same as pushdecl, but define X in binding-level LEVEL. We rely on the
3955 caller to set DECL_CONTEXT properly.
3956
3957 Note that this must only be used when X will be the new innermost
3958 binding for its name, as we tack it onto the front of IDENTIFIER_BINDING
3959 without checking to see if the current IDENTIFIER_BINDING comes from a
3960 closer binding level than LEVEL. */
3961
3962 static tree
do_pushdecl_with_scope(tree x,cp_binding_level * level,bool is_friend)3963 do_pushdecl_with_scope (tree x, cp_binding_level *level, bool is_friend)
3964 {
3965 cp_binding_level *b;
3966
3967 if (level->kind == sk_class)
3968 {
3969 b = class_binding_level;
3970 class_binding_level = level;
3971 pushdecl_class_level (x);
3972 class_binding_level = b;
3973 }
3974 else
3975 {
3976 tree function_decl = current_function_decl;
3977 if (level->kind == sk_namespace)
3978 current_function_decl = NULL_TREE;
3979 b = current_binding_level;
3980 current_binding_level = level;
3981 x = pushdecl (x, is_friend);
3982 current_binding_level = b;
3983 current_function_decl = function_decl;
3984 }
3985 return x;
3986 }
3987
3988 /* Inject X into the local scope just before the function parms. */
3989
3990 tree
pushdecl_outermost_localscope(tree x)3991 pushdecl_outermost_localscope (tree x)
3992 {
3993 cp_binding_level *b = NULL;
3994 bool subtime = timevar_cond_start (TV_NAME_LOOKUP);
3995
3996 /* Find the scope just inside the function parms. */
3997 for (cp_binding_level *n = current_binding_level;
3998 n->kind != sk_function_parms; n = b->level_chain)
3999 b = n;
4000
4001 tree ret = b ? do_pushdecl_with_scope (x, b, false) : error_mark_node;
4002 timevar_cond_stop (TV_NAME_LOOKUP, subtime);
4003
4004 return ret;
4005 }
4006
4007 /* Check a non-member using-declaration. Return the name and scope
4008 being used, and the USING_DECL, or NULL_TREE on failure. */
4009
4010 static tree
validate_nonmember_using_decl(tree decl,tree scope,tree name)4011 validate_nonmember_using_decl (tree decl, tree scope, tree name)
4012 {
4013 /* [namespace.udecl]
4014 A using-declaration for a class member shall be a
4015 member-declaration. */
4016 if (TYPE_P (scope))
4017 {
4018 error ("%qT is not a namespace or unscoped enum", scope);
4019 return NULL_TREE;
4020 }
4021 else if (scope == error_mark_node)
4022 return NULL_TREE;
4023
4024 if (TREE_CODE (decl) == TEMPLATE_ID_EXPR)
4025 {
4026 /* 7.3.3/5
4027 A using-declaration shall not name a template-id. */
4028 error ("a using-declaration cannot specify a template-id. "
4029 "Try %<using %D%>", name);
4030 return NULL_TREE;
4031 }
4032
4033 if (TREE_CODE (decl) == NAMESPACE_DECL)
4034 {
4035 error ("namespace %qD not allowed in using-declaration", decl);
4036 return NULL_TREE;
4037 }
4038
4039 if (TREE_CODE (decl) == SCOPE_REF)
4040 {
4041 /* It's a nested name with template parameter dependent scope.
4042 This can only be using-declaration for class member. */
4043 error ("%qT is not a namespace", TREE_OPERAND (decl, 0));
4044 return NULL_TREE;
4045 }
4046
4047 decl = OVL_FIRST (decl);
4048
4049 /* Make a USING_DECL. */
4050 tree using_decl = push_using_decl (scope, name);
4051
4052 if (using_decl == NULL_TREE
4053 && at_function_scope_p ()
4054 && VAR_P (decl))
4055 /* C++11 7.3.3/10. */
4056 error ("%qD is already declared in this scope", name);
4057
4058 return using_decl;
4059 }
4060
4061 /* Process a local-scope or namespace-scope using declaration. SCOPE
4062 is the nominated scope to search for NAME. VALUE_P and TYPE_P
4063 point to the binding for NAME in the current scope and are
4064 updated. */
4065
4066 static void
do_nonmember_using_decl(tree scope,tree name,tree * value_p,tree * type_p)4067 do_nonmember_using_decl (tree scope, tree name, tree *value_p, tree *type_p)
4068 {
4069 name_lookup lookup (name, 0);
4070
4071 if (!qualified_namespace_lookup (scope, &lookup))
4072 {
4073 error ("%qD not declared", name);
4074 return;
4075 }
4076 else if (TREE_CODE (lookup.value) == TREE_LIST)
4077 {
4078 error ("reference to %qD is ambiguous", name);
4079 print_candidates (lookup.value);
4080 lookup.value = NULL_TREE;
4081 }
4082
4083 if (lookup.type && TREE_CODE (lookup.type) == TREE_LIST)
4084 {
4085 error ("reference to %qD is ambiguous", name);
4086 print_candidates (lookup.type);
4087 lookup.type = NULL_TREE;
4088 }
4089
4090 tree value = *value_p;
4091 tree type = *type_p;
4092
4093 /* Shift the old and new bindings around so we're comparing class and
4094 enumeration names to each other. */
4095 if (value && DECL_IMPLICIT_TYPEDEF_P (value))
4096 {
4097 type = value;
4098 value = NULL_TREE;
4099 }
4100
4101 if (lookup.value && DECL_IMPLICIT_TYPEDEF_P (lookup.value))
4102 {
4103 lookup.type = lookup.value;
4104 lookup.value = NULL_TREE;
4105 }
4106
4107 if (lookup.value && lookup.value != value)
4108 {
4109 /* Check for using functions. */
4110 if (OVL_P (lookup.value) && (!value || OVL_P (value)))
4111 {
4112 for (lkp_iterator usings (lookup.value); usings; ++usings)
4113 {
4114 tree new_fn = *usings;
4115
4116 /* [namespace.udecl]
4117
4118 If a function declaration in namespace scope or block
4119 scope has the same name and the same parameter types as a
4120 function introduced by a using declaration the program is
4121 ill-formed. */
4122 bool found = false;
4123 for (ovl_iterator old (value); !found && old; ++old)
4124 {
4125 tree old_fn = *old;
4126
4127 if (new_fn == old_fn)
4128 /* The function already exists in the current
4129 namespace. */
4130 found = true;
4131 else if (old.using_p ())
4132 continue; /* This is a using decl. */
4133 else if (old.hidden_p () && !DECL_HIDDEN_FRIEND_P (old_fn))
4134 continue; /* This is an anticipated builtin. */
4135 else if (!matching_fn_p (new_fn, old_fn))
4136 continue; /* Parameters do not match. */
4137 else if (decls_match (new_fn, old_fn))
4138 found = true;
4139 else
4140 {
4141 diagnose_name_conflict (new_fn, old_fn);
4142 found = true;
4143 }
4144 }
4145
4146 if (!found)
4147 /* Unlike the overload case we don't drop anticipated
4148 builtins here. They don't cause a problem, and
4149 we'd like to match them with a future
4150 declaration. */
4151 value = ovl_insert (new_fn, value, true);
4152 }
4153 }
4154 else if (value
4155 /* Ignore anticipated builtins. */
4156 && !anticipated_builtin_p (value)
4157 && !decls_match (lookup.value, value))
4158 diagnose_name_conflict (lookup.value, value);
4159 else
4160 value = lookup.value;
4161 }
4162
4163 if (lookup.type && lookup.type != type)
4164 {
4165 if (type && !decls_match (lookup.type, type))
4166 diagnose_name_conflict (lookup.type, type);
4167 else
4168 type = lookup.type;
4169 }
4170
4171 /* If bind->value is empty, shift any class or enumeration name back. */
4172 if (!value)
4173 {
4174 value = type;
4175 type = NULL_TREE;
4176 }
4177
4178 *value_p = value;
4179 *type_p = type;
4180 }
4181
4182 /* Returns true if ANCESTOR encloses DESCENDANT, including matching.
4183 Both are namespaces. */
4184
4185 bool
is_nested_namespace(tree ancestor,tree descendant,bool inline_only)4186 is_nested_namespace (tree ancestor, tree descendant, bool inline_only)
4187 {
4188 int depth = SCOPE_DEPTH (ancestor);
4189
4190 if (!depth && !inline_only)
4191 /* The global namespace encloses everything. */
4192 return true;
4193
4194 while (SCOPE_DEPTH (descendant) > depth
4195 && (!inline_only || DECL_NAMESPACE_INLINE_P (descendant)))
4196 descendant = CP_DECL_CONTEXT (descendant);
4197
4198 return ancestor == descendant;
4199 }
4200
4201 /* Returns true if ROOT (a namespace, class, or function) encloses
4202 CHILD. CHILD may be either a class type or a namespace. */
4203
4204 bool
is_ancestor(tree root,tree child)4205 is_ancestor (tree root, tree child)
4206 {
4207 gcc_assert ((TREE_CODE (root) == NAMESPACE_DECL
4208 || TREE_CODE (root) == FUNCTION_DECL
4209 || CLASS_TYPE_P (root)));
4210 gcc_assert ((TREE_CODE (child) == NAMESPACE_DECL
4211 || CLASS_TYPE_P (child)));
4212
4213 /* The global namespace encloses everything. */
4214 if (root == global_namespace)
4215 return true;
4216
4217 /* Search until we reach namespace scope. */
4218 while (TREE_CODE (child) != NAMESPACE_DECL)
4219 {
4220 /* If we've reached the ROOT, it encloses CHILD. */
4221 if (root == child)
4222 return true;
4223 /* Go out one level. */
4224 if (TYPE_P (child))
4225 child = TYPE_NAME (child);
4226 child = CP_DECL_CONTEXT (child);
4227 }
4228
4229 if (TREE_CODE (root) == NAMESPACE_DECL)
4230 return is_nested_namespace (root, child);
4231
4232 return false;
4233 }
4234
4235 /* Enter the class or namespace scope indicated by T suitable for name
4236 lookup. T can be arbitrary scope, not necessary nested inside the
4237 current scope. Returns a non-null scope to pop iff pop_scope
4238 should be called later to exit this scope. */
4239
4240 tree
push_scope(tree t)4241 push_scope (tree t)
4242 {
4243 if (TREE_CODE (t) == NAMESPACE_DECL)
4244 push_decl_namespace (t);
4245 else if (CLASS_TYPE_P (t))
4246 {
4247 if (!at_class_scope_p ()
4248 || !same_type_p (current_class_type, t))
4249 push_nested_class (t);
4250 else
4251 /* T is the same as the current scope. There is therefore no
4252 need to re-enter the scope. Since we are not actually
4253 pushing a new scope, our caller should not call
4254 pop_scope. */
4255 t = NULL_TREE;
4256 }
4257
4258 return t;
4259 }
4260
4261 /* Leave scope pushed by push_scope. */
4262
4263 void
pop_scope(tree t)4264 pop_scope (tree t)
4265 {
4266 if (t == NULL_TREE)
4267 return;
4268 if (TREE_CODE (t) == NAMESPACE_DECL)
4269 pop_decl_namespace ();
4270 else if CLASS_TYPE_P (t)
4271 pop_nested_class ();
4272 }
4273
4274 /* Subroutine of push_inner_scope. */
4275
4276 static void
push_inner_scope_r(tree outer,tree inner)4277 push_inner_scope_r (tree outer, tree inner)
4278 {
4279 tree prev;
4280
4281 if (outer == inner
4282 || (TREE_CODE (inner) != NAMESPACE_DECL && !CLASS_TYPE_P (inner)))
4283 return;
4284
4285 prev = CP_DECL_CONTEXT (TREE_CODE (inner) == NAMESPACE_DECL ? inner : TYPE_NAME (inner));
4286 if (outer != prev)
4287 push_inner_scope_r (outer, prev);
4288 if (TREE_CODE (inner) == NAMESPACE_DECL)
4289 {
4290 cp_binding_level *save_template_parm = 0;
4291 /* Temporary take out template parameter scopes. They are saved
4292 in reversed order in save_template_parm. */
4293 while (current_binding_level->kind == sk_template_parms)
4294 {
4295 cp_binding_level *b = current_binding_level;
4296 current_binding_level = b->level_chain;
4297 b->level_chain = save_template_parm;
4298 save_template_parm = b;
4299 }
4300
4301 resume_scope (NAMESPACE_LEVEL (inner));
4302 current_namespace = inner;
4303
4304 /* Restore template parameter scopes. */
4305 while (save_template_parm)
4306 {
4307 cp_binding_level *b = save_template_parm;
4308 save_template_parm = b->level_chain;
4309 b->level_chain = current_binding_level;
4310 current_binding_level = b;
4311 }
4312 }
4313 else
4314 pushclass (inner);
4315 }
4316
4317 /* Enter the scope INNER from current scope. INNER must be a scope
4318 nested inside current scope. This works with both name lookup and
4319 pushing name into scope. In case a template parameter scope is present,
4320 namespace is pushed under the template parameter scope according to
4321 name lookup rule in 14.6.1/6.
4322
4323 Return the former current scope suitable for pop_inner_scope. */
4324
4325 tree
push_inner_scope(tree inner)4326 push_inner_scope (tree inner)
4327 {
4328 tree outer = current_scope ();
4329 if (!outer)
4330 outer = current_namespace;
4331
4332 push_inner_scope_r (outer, inner);
4333 return outer;
4334 }
4335
4336 /* Exit the current scope INNER back to scope OUTER. */
4337
4338 void
pop_inner_scope(tree outer,tree inner)4339 pop_inner_scope (tree outer, tree inner)
4340 {
4341 if (outer == inner
4342 || (TREE_CODE (inner) != NAMESPACE_DECL && !CLASS_TYPE_P (inner)))
4343 return;
4344
4345 while (outer != inner)
4346 {
4347 if (TREE_CODE (inner) == NAMESPACE_DECL)
4348 {
4349 cp_binding_level *save_template_parm = 0;
4350 /* Temporary take out template parameter scopes. They are saved
4351 in reversed order in save_template_parm. */
4352 while (current_binding_level->kind == sk_template_parms)
4353 {
4354 cp_binding_level *b = current_binding_level;
4355 current_binding_level = b->level_chain;
4356 b->level_chain = save_template_parm;
4357 save_template_parm = b;
4358 }
4359
4360 pop_namespace ();
4361
4362 /* Restore template parameter scopes. */
4363 while (save_template_parm)
4364 {
4365 cp_binding_level *b = save_template_parm;
4366 save_template_parm = b->level_chain;
4367 b->level_chain = current_binding_level;
4368 current_binding_level = b;
4369 }
4370 }
4371 else
4372 popclass ();
4373
4374 inner = CP_DECL_CONTEXT (TREE_CODE (inner) == NAMESPACE_DECL ? inner : TYPE_NAME (inner));
4375 }
4376 }
4377
4378 /* Do a pushlevel for class declarations. */
4379
4380 void
pushlevel_class(void)4381 pushlevel_class (void)
4382 {
4383 class_binding_level = begin_scope (sk_class, current_class_type);
4384 }
4385
4386 /* ...and a poplevel for class declarations. */
4387
4388 void
poplevel_class(void)4389 poplevel_class (void)
4390 {
4391 cp_binding_level *level = class_binding_level;
4392 cp_class_binding *cb;
4393 size_t i;
4394 tree shadowed;
4395
4396 bool subtime = timevar_cond_start (TV_NAME_LOOKUP);
4397 gcc_assert (level != 0);
4398
4399 /* If we're leaving a toplevel class, cache its binding level. */
4400 if (current_class_depth == 1)
4401 previous_class_level = level;
4402 for (shadowed = level->type_shadowed;
4403 shadowed;
4404 shadowed = TREE_CHAIN (shadowed))
4405 SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (shadowed), TREE_VALUE (shadowed));
4406
4407 /* Remove the bindings for all of the class-level declarations. */
4408 if (level->class_shadowed)
4409 {
4410 FOR_EACH_VEC_ELT (*level->class_shadowed, i, cb)
4411 {
4412 IDENTIFIER_BINDING (cb->identifier) = cb->base->previous;
4413 cxx_binding_free (cb->base);
4414 }
4415 ggc_free (level->class_shadowed);
4416 level->class_shadowed = NULL;
4417 }
4418
4419 /* Now, pop out of the binding level which we created up in the
4420 `pushlevel_class' routine. */
4421 gcc_assert (current_binding_level == level);
4422 leave_scope ();
4423 timevar_cond_stop (TV_NAME_LOOKUP, subtime);
4424 }
4425
4426 /* Set INHERITED_VALUE_BINDING_P on BINDING to true or false, as
4427 appropriate. DECL is the value to which a name has just been
4428 bound. CLASS_TYPE is the class in which the lookup occurred. */
4429
4430 static void
set_inherited_value_binding_p(cxx_binding * binding,tree decl,tree class_type)4431 set_inherited_value_binding_p (cxx_binding *binding, tree decl,
4432 tree class_type)
4433 {
4434 if (binding->value == decl && TREE_CODE (decl) != TREE_LIST)
4435 {
4436 tree context;
4437
4438 if (TREE_CODE (decl) == OVERLOAD)
4439 context = ovl_scope (decl);
4440 else
4441 {
4442 gcc_assert (DECL_P (decl));
4443 context = context_for_name_lookup (decl);
4444 }
4445
4446 if (is_properly_derived_from (class_type, context))
4447 INHERITED_VALUE_BINDING_P (binding) = 1;
4448 else
4449 INHERITED_VALUE_BINDING_P (binding) = 0;
4450 }
4451 else if (binding->value == decl)
4452 /* We only encounter a TREE_LIST when there is an ambiguity in the
4453 base classes. Such an ambiguity can be overridden by a
4454 definition in this class. */
4455 INHERITED_VALUE_BINDING_P (binding) = 1;
4456 else
4457 INHERITED_VALUE_BINDING_P (binding) = 0;
4458 }
4459
4460 /* Make the declaration of X appear in CLASS scope. */
4461
4462 bool
pushdecl_class_level(tree x)4463 pushdecl_class_level (tree x)
4464 {
4465 bool is_valid = true;
4466 bool subtime;
4467
4468 /* Do nothing if we're adding to an outer lambda closure type,
4469 outer_binding will add it later if it's needed. */
4470 if (current_class_type != class_binding_level->this_entity)
4471 return true;
4472
4473 subtime = timevar_cond_start (TV_NAME_LOOKUP);
4474 /* Get the name of X. */
4475 tree name = OVL_NAME (x);
4476
4477 if (name)
4478 {
4479 is_valid = push_class_level_binding (name, x);
4480 if (TREE_CODE (x) == TYPE_DECL)
4481 set_identifier_type_value (name, x);
4482 }
4483 else if (ANON_AGGR_TYPE_P (TREE_TYPE (x)))
4484 {
4485 /* If X is an anonymous aggregate, all of its members are
4486 treated as if they were members of the class containing the
4487 aggregate, for naming purposes. */
4488 location_t save_location = input_location;
4489 tree anon = TREE_TYPE (x);
4490 if (vec<tree, va_gc> *member_vec = CLASSTYPE_MEMBER_VEC (anon))
4491 for (unsigned ix = member_vec->length (); ix--;)
4492 {
4493 tree binding = (*member_vec)[ix];
4494 if (STAT_HACK_P (binding))
4495 {
4496 if (!pushdecl_class_level (STAT_TYPE (binding)))
4497 is_valid = false;
4498 binding = STAT_DECL (binding);
4499 }
4500 if (!pushdecl_class_level (binding))
4501 is_valid = false;
4502 }
4503 else
4504 for (tree f = TYPE_FIELDS (anon); f; f = DECL_CHAIN (f))
4505 if (TREE_CODE (f) == FIELD_DECL)
4506 {
4507 input_location = DECL_SOURCE_LOCATION (f);
4508 if (!pushdecl_class_level (f))
4509 is_valid = false;
4510 }
4511 input_location = save_location;
4512 }
4513 timevar_cond_stop (TV_NAME_LOOKUP, subtime);
4514 return is_valid;
4515 }
4516
4517 /* Return the BINDING (if any) for NAME in SCOPE, which is a class
4518 scope. If the value returned is non-NULL, and the PREVIOUS field
4519 is not set, callers must set the PREVIOUS field explicitly. */
4520
4521 static cxx_binding *
get_class_binding(tree name,cp_binding_level * scope)4522 get_class_binding (tree name, cp_binding_level *scope)
4523 {
4524 tree class_type;
4525 tree type_binding;
4526 tree value_binding;
4527 cxx_binding *binding;
4528
4529 class_type = scope->this_entity;
4530
4531 /* Get the type binding. */
4532 type_binding = lookup_member (class_type, name,
4533 /*protect=*/2, /*want_type=*/true,
4534 tf_warning_or_error);
4535 /* Get the value binding. */
4536 value_binding = lookup_member (class_type, name,
4537 /*protect=*/2, /*want_type=*/false,
4538 tf_warning_or_error);
4539
4540 if (value_binding
4541 && (TREE_CODE (value_binding) == TYPE_DECL
4542 || DECL_CLASS_TEMPLATE_P (value_binding)
4543 || (TREE_CODE (value_binding) == TREE_LIST
4544 && TREE_TYPE (value_binding) == error_mark_node
4545 && (TREE_CODE (TREE_VALUE (value_binding))
4546 == TYPE_DECL))))
4547 /* We found a type binding, even when looking for a non-type
4548 binding. This means that we already processed this binding
4549 above. */
4550 ;
4551 else if (value_binding)
4552 {
4553 if (TREE_CODE (value_binding) == TREE_LIST
4554 && TREE_TYPE (value_binding) == error_mark_node)
4555 /* NAME is ambiguous. */
4556 ;
4557 else if (BASELINK_P (value_binding))
4558 /* NAME is some overloaded functions. */
4559 value_binding = BASELINK_FUNCTIONS (value_binding);
4560 }
4561
4562 /* If we found either a type binding or a value binding, create a
4563 new binding object. */
4564 if (type_binding || value_binding)
4565 {
4566 binding = new_class_binding (name,
4567 value_binding,
4568 type_binding,
4569 scope);
4570 /* This is a class-scope binding, not a block-scope binding. */
4571 LOCAL_BINDING_P (binding) = 0;
4572 set_inherited_value_binding_p (binding, value_binding, class_type);
4573 }
4574 else
4575 binding = NULL;
4576
4577 return binding;
4578 }
4579
4580 /* Make the declaration(s) of X appear in CLASS scope under the name
4581 NAME. Returns true if the binding is valid. */
4582
4583 static bool
push_class_level_binding_1(tree name,tree x)4584 push_class_level_binding_1 (tree name, tree x)
4585 {
4586 cxx_binding *binding;
4587 tree decl = x;
4588 bool ok;
4589
4590 /* The class_binding_level will be NULL if x is a template
4591 parameter name in a member template. */
4592 if (!class_binding_level)
4593 return true;
4594
4595 if (name == error_mark_node)
4596 return false;
4597
4598 /* Can happen for an erroneous declaration (c++/60384). */
4599 if (!identifier_p (name))
4600 {
4601 gcc_assert (errorcount || sorrycount);
4602 return false;
4603 }
4604
4605 /* Check for invalid member names. But don't worry about a default
4606 argument-scope lambda being pushed after the class is complete. */
4607 gcc_assert (TYPE_BEING_DEFINED (current_class_type)
4608 || LAMBDA_TYPE_P (TREE_TYPE (decl)));
4609 /* Check that we're pushing into the right binding level. */
4610 gcc_assert (current_class_type == class_binding_level->this_entity);
4611
4612 /* We could have been passed a tree list if this is an ambiguous
4613 declaration. If so, pull the declaration out because
4614 check_template_shadow will not handle a TREE_LIST. */
4615 if (TREE_CODE (decl) == TREE_LIST
4616 && TREE_TYPE (decl) == error_mark_node)
4617 decl = TREE_VALUE (decl);
4618
4619 if (!check_template_shadow (decl))
4620 return false;
4621
4622 /* [class.mem]
4623
4624 If T is the name of a class, then each of the following shall
4625 have a name different from T:
4626
4627 -- every static data member of class T;
4628
4629 -- every member of class T that is itself a type;
4630
4631 -- every enumerator of every member of class T that is an
4632 enumerated type;
4633
4634 -- every member of every anonymous union that is a member of
4635 class T.
4636
4637 (Non-static data members were also forbidden to have the same
4638 name as T until TC1.) */
4639 if ((VAR_P (x)
4640 || TREE_CODE (x) == CONST_DECL
4641 || (TREE_CODE (x) == TYPE_DECL
4642 && !DECL_SELF_REFERENCE_P (x))
4643 /* A data member of an anonymous union. */
4644 || (TREE_CODE (x) == FIELD_DECL
4645 && DECL_CONTEXT (x) != current_class_type))
4646 && DECL_NAME (x) == DECL_NAME (TYPE_NAME (current_class_type)))
4647 {
4648 tree scope = context_for_name_lookup (x);
4649 if (TYPE_P (scope) && same_type_p (scope, current_class_type))
4650 {
4651 error ("%qD has the same name as the class in which it is "
4652 "declared",
4653 x);
4654 return false;
4655 }
4656 }
4657
4658 /* Get the current binding for NAME in this class, if any. */
4659 binding = IDENTIFIER_BINDING (name);
4660 if (!binding || binding->scope != class_binding_level)
4661 {
4662 binding = get_class_binding (name, class_binding_level);
4663 /* If a new binding was created, put it at the front of the
4664 IDENTIFIER_BINDING list. */
4665 if (binding)
4666 {
4667 binding->previous = IDENTIFIER_BINDING (name);
4668 IDENTIFIER_BINDING (name) = binding;
4669 }
4670 }
4671
4672 /* If there is already a binding, then we may need to update the
4673 current value. */
4674 if (binding && binding->value)
4675 {
4676 tree bval = binding->value;
4677 tree old_decl = NULL_TREE;
4678 tree target_decl = strip_using_decl (decl);
4679 tree target_bval = strip_using_decl (bval);
4680
4681 if (INHERITED_VALUE_BINDING_P (binding))
4682 {
4683 /* If the old binding was from a base class, and was for a
4684 tag name, slide it over to make room for the new binding.
4685 The old binding is still visible if explicitly qualified
4686 with a class-key. */
4687 if (TREE_CODE (target_bval) == TYPE_DECL
4688 && DECL_ARTIFICIAL (target_bval)
4689 && !(TREE_CODE (target_decl) == TYPE_DECL
4690 && DECL_ARTIFICIAL (target_decl)))
4691 {
4692 old_decl = binding->type;
4693 binding->type = bval;
4694 binding->value = NULL_TREE;
4695 INHERITED_VALUE_BINDING_P (binding) = 0;
4696 }
4697 else
4698 {
4699 old_decl = bval;
4700 /* Any inherited type declaration is hidden by the type
4701 declaration in the derived class. */
4702 if (TREE_CODE (target_decl) == TYPE_DECL
4703 && DECL_ARTIFICIAL (target_decl))
4704 binding->type = NULL_TREE;
4705 }
4706 }
4707 else if (TREE_CODE (target_decl) == OVERLOAD
4708 && OVL_P (target_bval))
4709 old_decl = bval;
4710 else if (TREE_CODE (decl) == USING_DECL
4711 && TREE_CODE (bval) == USING_DECL
4712 && same_type_p (USING_DECL_SCOPE (decl),
4713 USING_DECL_SCOPE (bval)))
4714 /* This is a using redeclaration that will be diagnosed later
4715 in supplement_binding */
4716 ;
4717 else if (TREE_CODE (decl) == USING_DECL
4718 && TREE_CODE (bval) == USING_DECL
4719 && DECL_DEPENDENT_P (decl)
4720 && DECL_DEPENDENT_P (bval))
4721 return true;
4722 else if (TREE_CODE (decl) == USING_DECL
4723 && OVL_P (target_bval))
4724 old_decl = bval;
4725 else if (TREE_CODE (bval) == USING_DECL
4726 && OVL_P (target_decl))
4727 return true;
4728
4729 if (old_decl && binding->scope == class_binding_level)
4730 {
4731 binding->value = x;
4732 /* It is always safe to clear INHERITED_VALUE_BINDING_P
4733 here. This function is only used to register bindings
4734 from with the class definition itself. */
4735 INHERITED_VALUE_BINDING_P (binding) = 0;
4736 return true;
4737 }
4738 }
4739
4740 /* Note that we declared this value so that we can issue an error if
4741 this is an invalid redeclaration of a name already used for some
4742 other purpose. */
4743 note_name_declared_in_class (name, decl);
4744
4745 /* If we didn't replace an existing binding, put the binding on the
4746 stack of bindings for the identifier, and update the shadowed
4747 list. */
4748 if (binding && binding->scope == class_binding_level)
4749 /* Supplement the existing binding. */
4750 ok = supplement_binding (binding, decl);
4751 else
4752 {
4753 /* Create a new binding. */
4754 push_binding (name, decl, class_binding_level);
4755 ok = true;
4756 }
4757
4758 return ok;
4759 }
4760
4761 /* Wrapper for push_class_level_binding_1. */
4762
4763 bool
push_class_level_binding(tree name,tree x)4764 push_class_level_binding (tree name, tree x)
4765 {
4766 bool ret;
4767 bool subtime = timevar_cond_start (TV_NAME_LOOKUP);
4768 ret = push_class_level_binding_1 (name, x);
4769 timevar_cond_stop (TV_NAME_LOOKUP, subtime);
4770 return ret;
4771 }
4772
4773 /* Process "using SCOPE::NAME" in a class scope. Return the
4774 USING_DECL created. */
4775
4776 tree
do_class_using_decl(tree scope,tree name)4777 do_class_using_decl (tree scope, tree name)
4778 {
4779 if (name == error_mark_node)
4780 return NULL_TREE;
4781
4782 if (!scope || !TYPE_P (scope))
4783 {
4784 error ("using-declaration for non-member at class scope");
4785 return NULL_TREE;
4786 }
4787
4788 /* Make sure the name is not invalid */
4789 if (TREE_CODE (name) == BIT_NOT_EXPR)
4790 {
4791 error ("%<%T::%D%> names destructor", scope, name);
4792 return NULL_TREE;
4793 }
4794
4795 /* Using T::T declares inheriting ctors, even if T is a typedef. */
4796 if (MAYBE_CLASS_TYPE_P (scope)
4797 && (name == TYPE_IDENTIFIER (scope)
4798 || constructor_name_p (name, scope)))
4799 {
4800 maybe_warn_cpp0x (CPP0X_INHERITING_CTORS);
4801 name = ctor_identifier;
4802 CLASSTYPE_NON_AGGREGATE (current_class_type) = true;
4803 }
4804
4805 /* Cannot introduce a constructor name. */
4806 if (constructor_name_p (name, current_class_type))
4807 {
4808 error ("%<%T::%D%> names constructor in %qT",
4809 scope, name, current_class_type);
4810 return NULL_TREE;
4811 }
4812
4813 /* From [namespace.udecl]:
4814
4815 A using-declaration used as a member-declaration shall refer to a
4816 member of a base class of the class being defined.
4817
4818 In general, we cannot check this constraint in a template because
4819 we do not know the entire set of base classes of the current
4820 class type. Morover, if SCOPE is dependent, it might match a
4821 non-dependent base. */
4822
4823 tree decl = NULL_TREE;
4824 if (!dependent_scope_p (scope))
4825 {
4826 base_kind b_kind;
4827 tree binfo = lookup_base (current_class_type, scope, ba_any, &b_kind,
4828 tf_warning_or_error);
4829 if (b_kind < bk_proper_base)
4830 {
4831 /* If there are dependent bases, scope might resolve at
4832 instantiation time, even if it isn't exactly one of the
4833 dependent bases. */
4834 if (b_kind == bk_same_type || !any_dependent_bases_p ())
4835 {
4836 error_not_base_type (scope, current_class_type);
4837 return NULL_TREE;
4838 }
4839 }
4840 else if (name == ctor_identifier && !binfo_direct_p (binfo))
4841 {
4842 error ("cannot inherit constructors from indirect base %qT", scope);
4843 return NULL_TREE;
4844 }
4845 else if (!IDENTIFIER_CONV_OP_P (name)
4846 || !dependent_type_p (TREE_TYPE (name)))
4847 {
4848 decl = lookup_member (binfo, name, 0, false, tf_warning_or_error);
4849 if (!decl)
4850 {
4851 error ("no members matching %<%T::%D%> in %q#T", scope, name,
4852 scope);
4853 return NULL_TREE;
4854 }
4855
4856 /* The binfo from which the functions came does not matter. */
4857 if (BASELINK_P (decl))
4858 decl = BASELINK_FUNCTIONS (decl);
4859 }
4860 }
4861
4862 tree value = build_lang_decl (USING_DECL, name, NULL_TREE);
4863 USING_DECL_DECLS (value) = decl;
4864 USING_DECL_SCOPE (value) = scope;
4865 DECL_DEPENDENT_P (value) = !decl;
4866
4867 return value;
4868 }
4869
4870
4871 /* Return the binding for NAME in NS. If NS is NULL, look in
4872 global_namespace. */
4873
4874 tree
get_namespace_binding(tree ns,tree name)4875 get_namespace_binding (tree ns, tree name)
4876 {
4877 bool subtime = timevar_cond_start (TV_NAME_LOOKUP);
4878 if (!ns)
4879 ns = global_namespace;
4880 gcc_checking_assert (!DECL_NAMESPACE_ALIAS (ns));
4881 tree ret = find_namespace_value (ns, name);
4882 timevar_cond_stop (TV_NAME_LOOKUP, subtime);
4883 return ret;
4884 }
4885
4886 /* Push internal DECL into the global namespace. Does not do the
4887 full overload fn handling and does not add it to the list of things
4888 in the namespace. */
4889
4890 void
set_global_binding(tree decl)4891 set_global_binding (tree decl)
4892 {
4893 bool subtime = timevar_cond_start (TV_NAME_LOOKUP);
4894
4895 tree *slot = find_namespace_slot (global_namespace, DECL_NAME (decl), true);
4896
4897 if (*slot)
4898 /* The user's placed something in the implementor's namespace. */
4899 diagnose_name_conflict (decl, MAYBE_STAT_DECL (*slot));
4900
4901 /* Force the binding, so compiler internals continue to work. */
4902 *slot = decl;
4903
4904 timevar_cond_stop (TV_NAME_LOOKUP, subtime);
4905 }
4906
4907 /* Set the context of a declaration to scope. Complain if we are not
4908 outside scope. */
4909
4910 void
set_decl_namespace(tree decl,tree scope,bool friendp)4911 set_decl_namespace (tree decl, tree scope, bool friendp)
4912 {
4913 /* Get rid of namespace aliases. */
4914 scope = ORIGINAL_NAMESPACE (scope);
4915
4916 /* It is ok for friends to be qualified in parallel space. */
4917 if (!friendp && !is_nested_namespace (current_namespace, scope))
4918 error ("declaration of %qD not in a namespace surrounding %qD",
4919 decl, scope);
4920 DECL_CONTEXT (decl) = FROB_CONTEXT (scope);
4921
4922 /* See whether this has been declared in the namespace or inline
4923 children. */
4924 tree old = NULL_TREE;
4925 {
4926 name_lookup lookup (DECL_NAME (decl), LOOKUP_HIDDEN);
4927 if (!lookup.search_qualified (scope, /*usings=*/false))
4928 /* No old declaration at all. */
4929 goto not_found;
4930 old = lookup.value;
4931 }
4932
4933 /* If it's a TREE_LIST, the result of the lookup was ambiguous. */
4934 if (TREE_CODE (old) == TREE_LIST)
4935 {
4936 ambiguous:
4937 DECL_CONTEXT (decl) = FROB_CONTEXT (scope);
4938 error ("reference to %qD is ambiguous", decl);
4939 print_candidates (old);
4940 return;
4941 }
4942
4943 if (!DECL_DECLARES_FUNCTION_P (decl))
4944 {
4945 /* Don't compare non-function decls with decls_match here, since
4946 it can't check for the correct constness at this
4947 point. pushdecl will find those errors later. */
4948
4949 /* We might have found it in an inline namespace child of SCOPE. */
4950 if (TREE_CODE (decl) == TREE_CODE (old))
4951 DECL_CONTEXT (decl) = DECL_CONTEXT (old);
4952
4953 found:
4954 /* Writing "N::i" to declare something directly in "N" is invalid. */
4955 if (CP_DECL_CONTEXT (decl) == current_namespace
4956 && at_namespace_scope_p ())
4957 error ("explicit qualification in declaration of %qD", decl);
4958 return;
4959 }
4960
4961 /* Since decl is a function, old should contain a function decl. */
4962 if (!OVL_P (old))
4963 goto not_found;
4964
4965 /* We handle these in check_explicit_instantiation_namespace. */
4966 if (processing_explicit_instantiation)
4967 return;
4968 if (processing_template_decl || processing_specialization)
4969 /* We have not yet called push_template_decl to turn a
4970 FUNCTION_DECL into a TEMPLATE_DECL, so the declarations won't
4971 match. But, we'll check later, when we construct the
4972 template. */
4973 return;
4974 /* Instantiations or specializations of templates may be declared as
4975 friends in any namespace. */
4976 if (friendp && DECL_USE_TEMPLATE (decl))
4977 return;
4978
4979 tree found;
4980 found = NULL_TREE;
4981
4982 for (lkp_iterator iter (old); iter; ++iter)
4983 {
4984 if (iter.using_p ())
4985 continue;
4986
4987 tree ofn = *iter;
4988
4989 /* Adjust DECL_CONTEXT first so decls_match will return true
4990 if DECL will match a declaration in an inline namespace. */
4991 DECL_CONTEXT (decl) = DECL_CONTEXT (ofn);
4992 if (decls_match (decl, ofn))
4993 {
4994 if (found)
4995 {
4996 /* We found more than one matching declaration. */
4997 DECL_CONTEXT (decl) = FROB_CONTEXT (scope);
4998 goto ambiguous;
4999 }
5000 found = ofn;
5001 }
5002 }
5003
5004 if (found)
5005 {
5006 if (DECL_HIDDEN_FRIEND_P (found))
5007 {
5008 pedwarn (DECL_SOURCE_LOCATION (decl), 0,
5009 "%qD has not been declared within %qD", decl, scope);
5010 inform (DECL_SOURCE_LOCATION (found),
5011 "only here as a %<friend%>");
5012 }
5013 DECL_CONTEXT (decl) = DECL_CONTEXT (found);
5014 goto found;
5015 }
5016
5017 not_found:
5018 /* It didn't work, go back to the explicit scope. */
5019 DECL_CONTEXT (decl) = FROB_CONTEXT (scope);
5020 error ("%qD should have been declared inside %qD", decl, scope);
5021 }
5022
5023 /* Return the namespace where the current declaration is declared. */
5024
5025 tree
current_decl_namespace(void)5026 current_decl_namespace (void)
5027 {
5028 tree result;
5029 /* If we have been pushed into a different namespace, use it. */
5030 if (!vec_safe_is_empty (decl_namespace_list))
5031 return decl_namespace_list->last ();
5032
5033 if (current_class_type)
5034 result = decl_namespace_context (current_class_type);
5035 else if (current_function_decl)
5036 result = decl_namespace_context (current_function_decl);
5037 else
5038 result = current_namespace;
5039 return result;
5040 }
5041
5042 /* Process any ATTRIBUTES on a namespace definition. Returns true if
5043 attribute visibility is seen. */
5044
5045 bool
handle_namespace_attrs(tree ns,tree attributes)5046 handle_namespace_attrs (tree ns, tree attributes)
5047 {
5048 tree d;
5049 bool saw_vis = false;
5050
5051 if (attributes == error_mark_node)
5052 return false;
5053
5054 for (d = attributes; d; d = TREE_CHAIN (d))
5055 {
5056 tree name = get_attribute_name (d);
5057 tree args = TREE_VALUE (d);
5058
5059 if (is_attribute_p ("visibility", name))
5060 {
5061 /* attribute visibility is a property of the syntactic block
5062 rather than the namespace as a whole, so we don't touch the
5063 NAMESPACE_DECL at all. */
5064 tree x = args ? TREE_VALUE (args) : NULL_TREE;
5065 if (x == NULL_TREE || TREE_CODE (x) != STRING_CST || TREE_CHAIN (args))
5066 {
5067 warning (OPT_Wattributes,
5068 "%qD attribute requires a single NTBS argument",
5069 name);
5070 continue;
5071 }
5072
5073 if (!TREE_PUBLIC (ns))
5074 warning (OPT_Wattributes,
5075 "%qD attribute is meaningless since members of the "
5076 "anonymous namespace get local symbols", name);
5077
5078 push_visibility (TREE_STRING_POINTER (x), 1);
5079 saw_vis = true;
5080 }
5081 else if (is_attribute_p ("abi_tag", name))
5082 {
5083 if (!DECL_NAME (ns))
5084 {
5085 warning (OPT_Wattributes, "ignoring %qD attribute on anonymous "
5086 "namespace", name);
5087 continue;
5088 }
5089 if (!DECL_NAMESPACE_INLINE_P (ns))
5090 {
5091 warning (OPT_Wattributes, "ignoring %qD attribute on non-inline "
5092 "namespace", name);
5093 continue;
5094 }
5095 if (!args)
5096 {
5097 tree dn = DECL_NAME (ns);
5098 args = build_string (IDENTIFIER_LENGTH (dn) + 1,
5099 IDENTIFIER_POINTER (dn));
5100 TREE_TYPE (args) = char_array_type_node;
5101 args = fix_string_type (args);
5102 args = build_tree_list (NULL_TREE, args);
5103 }
5104 if (check_abi_tag_args (args, name))
5105 DECL_ATTRIBUTES (ns) = tree_cons (name, args,
5106 DECL_ATTRIBUTES (ns));
5107 }
5108 else
5109 {
5110 warning (OPT_Wattributes, "%qD attribute directive ignored",
5111 name);
5112 continue;
5113 }
5114 }
5115
5116 return saw_vis;
5117 }
5118
5119 /* Temporarily set the namespace for the current declaration. */
5120
5121 void
push_decl_namespace(tree decl)5122 push_decl_namespace (tree decl)
5123 {
5124 if (TREE_CODE (decl) != NAMESPACE_DECL)
5125 decl = decl_namespace_context (decl);
5126 vec_safe_push (decl_namespace_list, ORIGINAL_NAMESPACE (decl));
5127 }
5128
5129 /* [namespace.memdef]/2 */
5130
5131 void
pop_decl_namespace(void)5132 pop_decl_namespace (void)
5133 {
5134 decl_namespace_list->pop ();
5135 }
5136
5137 /* Process a namespace-alias declaration. */
5138
5139 void
do_namespace_alias(tree alias,tree name_space)5140 do_namespace_alias (tree alias, tree name_space)
5141 {
5142 if (name_space == error_mark_node)
5143 return;
5144
5145 gcc_assert (TREE_CODE (name_space) == NAMESPACE_DECL);
5146
5147 name_space = ORIGINAL_NAMESPACE (name_space);
5148
5149 /* Build the alias. */
5150 alias = build_lang_decl (NAMESPACE_DECL, alias, void_type_node);
5151 DECL_NAMESPACE_ALIAS (alias) = name_space;
5152 DECL_EXTERNAL (alias) = 1;
5153 DECL_CONTEXT (alias) = FROB_CONTEXT (current_scope ());
5154 pushdecl (alias);
5155
5156 /* Emit debug info for namespace alias. */
5157 if (!building_stmt_list_p ())
5158 (*debug_hooks->early_global_decl) (alias);
5159 }
5160
5161 /* Like pushdecl, only it places X in the current namespace,
5162 if appropriate. */
5163
5164 tree
pushdecl_namespace_level(tree x,bool is_friend)5165 pushdecl_namespace_level (tree x, bool is_friend)
5166 {
5167 cp_binding_level *b = current_binding_level;
5168 tree t;
5169
5170 bool subtime = timevar_cond_start (TV_NAME_LOOKUP);
5171 t = do_pushdecl_with_scope
5172 (x, NAMESPACE_LEVEL (current_namespace), is_friend);
5173
5174 /* Now, the type_shadowed stack may screw us. Munge it so it does
5175 what we want. */
5176 if (TREE_CODE (t) == TYPE_DECL)
5177 {
5178 tree name = DECL_NAME (t);
5179 tree newval;
5180 tree *ptr = (tree *)0;
5181 for (; !global_scope_p (b); b = b->level_chain)
5182 {
5183 tree shadowed = b->type_shadowed;
5184 for (; shadowed; shadowed = TREE_CHAIN (shadowed))
5185 if (TREE_PURPOSE (shadowed) == name)
5186 {
5187 ptr = &TREE_VALUE (shadowed);
5188 /* Can't break out of the loop here because sometimes
5189 a binding level will have duplicate bindings for
5190 PT names. It's gross, but I haven't time to fix it. */
5191 }
5192 }
5193 newval = TREE_TYPE (t);
5194 if (ptr == (tree *)0)
5195 {
5196 /* @@ This shouldn't be needed. My test case "zstring.cc" trips
5197 up here if this is changed to an assertion. --KR */
5198 SET_IDENTIFIER_TYPE_VALUE (name, t);
5199 }
5200 else
5201 {
5202 *ptr = newval;
5203 }
5204 }
5205 timevar_cond_stop (TV_NAME_LOOKUP, subtime);
5206 return t;
5207 }
5208
5209 /* Process a using-declaration appearing in namespace scope. */
5210
5211 void
finish_namespace_using_decl(tree decl,tree scope,tree name)5212 finish_namespace_using_decl (tree decl, tree scope, tree name)
5213 {
5214 tree orig_decl = decl;
5215
5216 gcc_checking_assert (current_binding_level->kind == sk_namespace
5217 && !processing_template_decl);
5218 decl = validate_nonmember_using_decl (decl, scope, name);
5219 if (decl == NULL_TREE)
5220 return;
5221
5222 tree *slot = find_namespace_slot (current_namespace, name, true);
5223 tree val = slot ? MAYBE_STAT_DECL (*slot) : NULL_TREE;
5224 tree type = slot ? MAYBE_STAT_TYPE (*slot) : NULL_TREE;
5225 do_nonmember_using_decl (scope, name, &val, &type);
5226 if (STAT_HACK_P (*slot))
5227 {
5228 STAT_DECL (*slot) = val;
5229 STAT_TYPE (*slot) = type;
5230 }
5231 else if (type)
5232 *slot = stat_hack (val, type);
5233 else
5234 *slot = val;
5235
5236 /* Emit debug info. */
5237 cp_emit_debug_info_for_using (orig_decl, current_namespace);
5238 }
5239
5240 /* Process a using-declaration at function scope. */
5241
5242 void
finish_local_using_decl(tree decl,tree scope,tree name)5243 finish_local_using_decl (tree decl, tree scope, tree name)
5244 {
5245 tree orig_decl = decl;
5246
5247 gcc_checking_assert (current_binding_level->kind != sk_class
5248 && current_binding_level->kind != sk_namespace);
5249 decl = validate_nonmember_using_decl (decl, scope, name);
5250 if (decl == NULL_TREE)
5251 return;
5252
5253 add_decl_expr (decl);
5254
5255 cxx_binding *binding = find_local_binding (current_binding_level, name);
5256 tree value = binding ? binding->value : NULL_TREE;
5257 tree type = binding ? binding->type : NULL_TREE;
5258
5259 do_nonmember_using_decl (scope, name, &value, &type);
5260
5261 if (!value)
5262 ;
5263 else if (binding && value == binding->value)
5264 ;
5265 else if (binding && binding->value && TREE_CODE (value) == OVERLOAD)
5266 {
5267 update_local_overload (IDENTIFIER_BINDING (name), value);
5268 IDENTIFIER_BINDING (name)->value = value;
5269 }
5270 else
5271 /* Install the new binding. */
5272 push_local_binding (name, value, true);
5273
5274 if (!type)
5275 ;
5276 else if (binding && type == binding->type)
5277 ;
5278 else
5279 {
5280 push_local_binding (name, type, true);
5281 set_identifier_type_value (name, type);
5282 }
5283
5284 /* Emit debug info. */
5285 if (!processing_template_decl)
5286 cp_emit_debug_info_for_using (orig_decl, current_scope ());
5287 }
5288
5289 /* Return the declarations that are members of the namespace NS. */
5290
5291 tree
cp_namespace_decls(tree ns)5292 cp_namespace_decls (tree ns)
5293 {
5294 return NAMESPACE_LEVEL (ns)->names;
5295 }
5296
5297 /* Combine prefer_type and namespaces_only into flags. */
5298
5299 static int
lookup_flags(int prefer_type,int namespaces_only)5300 lookup_flags (int prefer_type, int namespaces_only)
5301 {
5302 if (namespaces_only)
5303 return LOOKUP_PREFER_NAMESPACES;
5304 if (prefer_type > 1)
5305 return LOOKUP_PREFER_TYPES;
5306 if (prefer_type > 0)
5307 return LOOKUP_PREFER_BOTH;
5308 return 0;
5309 }
5310
5311 /* Given a lookup that returned VAL, use FLAGS to decide if we want to
5312 ignore it or not. Subroutine of lookup_name_real and
5313 lookup_type_scope. */
5314
5315 static bool
qualify_lookup(tree val,int flags)5316 qualify_lookup (tree val, int flags)
5317 {
5318 if (val == NULL_TREE)
5319 return false;
5320 if ((flags & LOOKUP_PREFER_NAMESPACES) && TREE_CODE (val) == NAMESPACE_DECL)
5321 return true;
5322 if (flags & LOOKUP_PREFER_TYPES)
5323 {
5324 tree target_val = strip_using_decl (val);
5325 if (TREE_CODE (target_val) == TYPE_DECL
5326 || TREE_CODE (target_val) == TEMPLATE_DECL)
5327 return true;
5328 }
5329 if (flags & (LOOKUP_PREFER_NAMESPACES | LOOKUP_PREFER_TYPES))
5330 return false;
5331 /* Look through lambda things that we shouldn't be able to see. */
5332 if (!(flags & LOOKUP_HIDDEN) && is_lambda_ignored_entity (val))
5333 return false;
5334 return true;
5335 }
5336
5337 /* Is there a "using namespace std;" directive within USINGS? */
5338
5339 static bool
using_directives_contain_std_p(vec<tree,va_gc> * usings)5340 using_directives_contain_std_p (vec<tree, va_gc> *usings)
5341 {
5342 if (!usings)
5343 return false;
5344
5345 for (unsigned ix = usings->length (); ix--;)
5346 if ((*usings)[ix] == std_node)
5347 return true;
5348
5349 return false;
5350 }
5351
5352 /* Is there a "using namespace std;" directive within the current
5353 namespace (or its ancestors)?
5354 Compare with name_lookup::search_unqualified. */
5355
5356 static bool
has_using_namespace_std_directive_p()5357 has_using_namespace_std_directive_p ()
5358 {
5359 /* Look at local using-directives. */
5360 for (cp_binding_level *level = current_binding_level;
5361 level->kind != sk_namespace;
5362 level = level->level_chain)
5363 if (using_directives_contain_std_p (level->using_directives))
5364 return true;
5365
5366 /* Look at this namespace and its ancestors. */
5367 for (tree scope = current_namespace; scope; scope = CP_DECL_CONTEXT (scope))
5368 {
5369 if (using_directives_contain_std_p (DECL_NAMESPACE_USING (scope)))
5370 return true;
5371
5372 if (scope == global_namespace)
5373 break;
5374 }
5375
5376 return false;
5377 }
5378
5379 /* Suggest alternatives for NAME, an IDENTIFIER_NODE for which name
5380 lookup failed. Search through all available namespaces and print out
5381 possible candidates. If no exact matches are found, and
5382 SUGGEST_MISSPELLINGS is true, then also look for near-matches and
5383 suggest the best near-match, if there is one. */
5384
5385 void
suggest_alternatives_for(location_t location,tree name,bool suggest_misspellings)5386 suggest_alternatives_for (location_t location, tree name,
5387 bool suggest_misspellings)
5388 {
5389 vec<tree> candidates = vNULL;
5390 vec<tree> worklist = vNULL;
5391 unsigned limit = PARAM_VALUE (CXX_MAX_NAMESPACES_FOR_DIAGNOSTIC_HELP);
5392 bool limited = false;
5393
5394 /* Breadth-first search of namespaces. Up to limit namespaces
5395 searched (limit zero == unlimited). */
5396 worklist.safe_push (global_namespace);
5397 for (unsigned ix = 0; ix != worklist.length (); ix++)
5398 {
5399 tree ns = worklist[ix];
5400 name_lookup lookup (name);
5401
5402 if (lookup.search_qualified (ns, false))
5403 candidates.safe_push (lookup.value);
5404
5405 if (!limited)
5406 {
5407 /* Look for child namespaces. We have to do this
5408 indirectly because they are chained in reverse order,
5409 which is confusing to the user. */
5410 vec<tree> children = vNULL;
5411
5412 for (tree decl = NAMESPACE_LEVEL (ns)->names;
5413 decl; decl = TREE_CHAIN (decl))
5414 if (TREE_CODE (decl) == NAMESPACE_DECL
5415 && !DECL_NAMESPACE_ALIAS (decl)
5416 && !DECL_NAMESPACE_INLINE_P (decl))
5417 children.safe_push (decl);
5418
5419 while (!limited && !children.is_empty ())
5420 {
5421 if (worklist.length () == limit)
5422 {
5423 /* Unconditionally warn that the search was truncated. */
5424 inform (location,
5425 "maximum limit of %d namespaces searched for %qE",
5426 limit, name);
5427 limited = true;
5428 }
5429 else
5430 worklist.safe_push (children.pop ());
5431 }
5432 children.release ();
5433 }
5434 }
5435 worklist.release ();
5436
5437 if (candidates.length ())
5438 {
5439 inform_n (location, candidates.length (),
5440 "suggested alternative:",
5441 "suggested alternatives:");
5442 for (unsigned ix = 0; ix != candidates.length (); ix++)
5443 {
5444 tree val = candidates[ix];
5445
5446 inform (location_of (val), " %qE", val);
5447 }
5448 candidates.release ();
5449 return;
5450 }
5451
5452 /* No candidates were found in the available namespaces. */
5453
5454 /* If there's a "using namespace std;" active, and this
5455 is one of the most common "std::" names, then it's probably a
5456 missing #include. */
5457 if (has_using_namespace_std_directive_p ())
5458 if (maybe_suggest_missing_std_header (location, name))
5459 return;
5460
5461 /* Otherwise, consider misspellings. */
5462 if (!suggest_misspellings)
5463 return;
5464 if (name_hint hint = lookup_name_fuzzy (name, FUZZY_LOOKUP_NAME,
5465 location))
5466 {
5467 /* Show a spelling correction. */
5468 gcc_rich_location richloc (location);
5469
5470 richloc.add_fixit_replace (hint.suggestion ());
5471 inform (&richloc, "suggested alternative: %qs", hint.suggestion ());
5472 }
5473 }
5474
5475 /* A well-known name within the C++ standard library, returned by
5476 get_std_name_hint. */
5477
5478 struct std_name_hint
5479 {
5480 /* A name within "std::". */
5481 const char *name;
5482
5483 /* The header name defining it within the C++ Standard Library
5484 (with '<' and '>'). */
5485 const char *header;
5486
5487 /* The dialect of C++ in which this was added. */
5488 enum cxx_dialect min_dialect;
5489 };
5490
5491 /* Subroutine of maybe_suggest_missing_header for handling unrecognized names
5492 for some of the most common names within "std::".
5493 Given non-NULL NAME, return the std_name_hint for it, or NULL. */
5494
5495 static const std_name_hint *
get_std_name_hint(const char * name)5496 get_std_name_hint (const char *name)
5497 {
5498 static const std_name_hint hints[] = {
5499 /* <any>. */
5500 {"any", "<any>", cxx17},
5501 {"any_cast", "<any>", cxx17},
5502 {"make_any", "<any>", cxx17},
5503 /* <array>. */
5504 {"array", "<array>", cxx11},
5505 /* <atomic>. */
5506 {"atomic", "<atomic>", cxx11},
5507 {"atomic_flag", "<atomic>", cxx11},
5508 /* <bitset>. */
5509 {"bitset", "<bitset>", cxx11},
5510 /* <complex>. */
5511 {"complex", "<complex>", cxx98},
5512 {"complex_literals", "<complex>", cxx98},
5513 /* <condition_variable>. */
5514 {"condition_variable", "<condition_variable>", cxx11},
5515 {"condition_variable_any", "<condition_variable>", cxx11},
5516 /* <deque>. */
5517 {"deque", "<deque>", cxx98},
5518 /* <forward_list>. */
5519 {"forward_list", "<forward_list>", cxx11},
5520 /* <fstream>. */
5521 {"basic_filebuf", "<fstream>", cxx98},
5522 {"basic_ifstream", "<fstream>", cxx98},
5523 {"basic_ofstream", "<fstream>", cxx98},
5524 {"basic_fstream", "<fstream>", cxx98},
5525 {"fstream", "<fstream>", cxx98},
5526 {"ifstream", "<fstream>", cxx98},
5527 {"ofstream", "<fstream>", cxx98},
5528 /* <functional>. */
5529 {"bind", "<functional>", cxx11},
5530 {"function", "<functional>", cxx11},
5531 {"hash", "<functional>", cxx11},
5532 {"mem_fn", "<functional>", cxx11},
5533 /* <future>. */
5534 {"async", "<future>", cxx11},
5535 {"future", "<future>", cxx11},
5536 {"packaged_task", "<future>", cxx11},
5537 {"promise", "<future>", cxx11},
5538 /* <iostream>. */
5539 {"cin", "<iostream>", cxx98},
5540 {"cout", "<iostream>", cxx98},
5541 {"cerr", "<iostream>", cxx98},
5542 {"clog", "<iostream>", cxx98},
5543 {"wcin", "<iostream>", cxx98},
5544 {"wcout", "<iostream>", cxx98},
5545 {"wclog", "<iostream>", cxx98},
5546 /* <istream>. */
5547 {"istream", "<istream>", cxx98},
5548 /* <iterator>. */
5549 {"advance", "<iterator>", cxx98},
5550 {"back_inserter", "<iterator>", cxx98},
5551 {"begin", "<iterator>", cxx11},
5552 {"distance", "<iterator>", cxx98},
5553 {"end", "<iterator>", cxx11},
5554 {"front_inserter", "<iterator>", cxx98},
5555 {"inserter", "<iterator>", cxx98},
5556 {"istream_iterator", "<iterator>", cxx98},
5557 {"istreambuf_iterator", "<iterator>", cxx98},
5558 {"iterator_traits", "<iterator>", cxx98},
5559 {"move_iterator", "<iterator>", cxx11},
5560 {"next", "<iterator>", cxx11},
5561 {"ostream_iterator", "<iterator>", cxx98},
5562 {"ostreambuf_iterator", "<iterator>", cxx98},
5563 {"prev", "<iterator>", cxx11},
5564 {"reverse_iterator", "<iterator>", cxx98},
5565 /* <ostream>. */
5566 {"ostream", "<ostream>", cxx98},
5567 /* <list>. */
5568 {"list", "<list>", cxx98},
5569 /* <map>. */
5570 {"map", "<map>", cxx98},
5571 {"multimap", "<map>", cxx98},
5572 /* <memory>. */
5573 {"make_shared", "<memory>", cxx11},
5574 {"make_unique", "<memory>", cxx11},
5575 {"shared_ptr", "<memory>", cxx11},
5576 {"unique_ptr", "<memory>", cxx11},
5577 {"weak_ptr", "<memory>", cxx11},
5578 /* <mutex>. */
5579 {"mutex", "<mutex>", cxx11},
5580 {"timed_mutex", "<mutex>", cxx11},
5581 {"recursive_mutex", "<mutex>", cxx11},
5582 {"recursive_timed_mutex", "<mutex>", cxx11},
5583 {"once_flag", "<mutex>", cxx11},
5584 {"call_once,", "<mutex>", cxx11},
5585 {"lock", "<mutex>", cxx11},
5586 {"scoped_lock", "<mutex>", cxx17},
5587 {"try_lock", "<mutex>", cxx11},
5588 {"lock_guard", "<mutex>", cxx11},
5589 {"unique_lock", "<mutex>", cxx11},
5590 /* <optional>. */
5591 {"optional", "<optional>", cxx17},
5592 {"make_optional", "<optional>", cxx17},
5593 /* <ostream>. */
5594 {"ostream", "<ostream>", cxx98},
5595 {"wostream", "<ostream>", cxx98},
5596 {"ends", "<ostream>", cxx98},
5597 {"flush", "<ostream>", cxx98},
5598 {"endl", "<ostream>", cxx98},
5599 /* <queue>. */
5600 {"queue", "<queue>", cxx98},
5601 {"priority_queue", "<queue>", cxx98},
5602 /* <set>. */
5603 {"set", "<set>", cxx98},
5604 {"multiset", "<set>", cxx98},
5605 /* <shared_mutex>. */
5606 {"shared_lock", "<shared_mutex>", cxx14},
5607 {"shared_mutex", "<shared_mutex>", cxx17},
5608 {"shared_timed_mutex", "<shared_mutex>", cxx14},
5609 /* <sstream>. */
5610 {"basic_stringbuf", "<sstream>", cxx98},
5611 {"basic_istringstream", "<sstream>", cxx98},
5612 {"basic_ostringstream", "<sstream>", cxx98},
5613 {"basic_stringstream", "<sstream>", cxx98},
5614 {"istringstream", "<sstream>", cxx98},
5615 {"ostringstream", "<sstream>", cxx98},
5616 {"stringstream", "<sstream>", cxx98},
5617 /* <stack>. */
5618 {"stack", "<stack>", cxx98},
5619 /* <string>. */
5620 {"basic_string", "<string>", cxx98},
5621 {"string", "<string>", cxx98},
5622 {"wstring", "<string>", cxx98},
5623 {"u16string", "<string>", cxx11},
5624 {"u32string", "<string>", cxx11},
5625 /* <string_view>. */
5626 {"string_view", "<string_view>", cxx17},
5627 /* <thread>. */
5628 {"thread", "<thread>", cxx11},
5629 /* <tuple>. */
5630 {"make_tuple", "<tuple>", cxx11},
5631 {"tuple", "<tuple>", cxx11},
5632 {"tuple_element", "<tuple>", cxx11},
5633 {"tuple_size", "<tuple>", cxx11},
5634 /* <unordered_map>. */
5635 {"unordered_map", "<unordered_map>", cxx11},
5636 {"unordered_multimap", "<unordered_map>", cxx11},
5637 /* <unordered_set>. */
5638 {"unordered_set", "<unordered_set>", cxx11},
5639 {"unordered_multiset", "<unordered_set>", cxx11},
5640 /* <utility>. */
5641 {"declval", "<utility>", cxx11},
5642 {"forward", "<utility>", cxx11},
5643 {"make_pair", "<utility>", cxx98},
5644 {"move", "<utility>", cxx11},
5645 {"pair", "<utility>", cxx98},
5646 /* <variant>. */
5647 {"variant", "<variant>", cxx17},
5648 {"visit", "<variant>", cxx17},
5649 /* <vector>. */
5650 {"vector", "<vector>", cxx98},
5651 };
5652 const size_t num_hints = sizeof (hints) / sizeof (hints[0]);
5653 for (size_t i = 0; i < num_hints; i++)
5654 {
5655 if (strcmp (name, hints[i].name) == 0)
5656 return &hints[i];
5657 }
5658 return NULL;
5659 }
5660
5661 /* Describe DIALECT. */
5662
5663 static const char *
get_cxx_dialect_name(enum cxx_dialect dialect)5664 get_cxx_dialect_name (enum cxx_dialect dialect)
5665 {
5666 switch (dialect)
5667 {
5668 default:
5669 gcc_unreachable ();
5670 case cxx98:
5671 return "C++98";
5672 case cxx11:
5673 return "C++11";
5674 case cxx14:
5675 return "C++14";
5676 case cxx17:
5677 return "C++17";
5678 case cxx2a:
5679 return "C++2a";
5680 }
5681 }
5682
5683 /* Suggest pertinent header files for NAME at LOCATION, for common
5684 names within the "std" namespace.
5685 Return true iff a suggestion was offered. */
5686
5687 static bool
maybe_suggest_missing_std_header(location_t location,tree name)5688 maybe_suggest_missing_std_header (location_t location, tree name)
5689 {
5690 gcc_assert (TREE_CODE (name) == IDENTIFIER_NODE);
5691
5692 const char *name_str = IDENTIFIER_POINTER (name);
5693 const std_name_hint *header_hint = get_std_name_hint (name_str);
5694 if (!header_hint)
5695 return false;
5696
5697 gcc_rich_location richloc (location);
5698 if (cxx_dialect >= header_hint->min_dialect)
5699 {
5700 const char *header = header_hint->header;
5701 maybe_add_include_fixit (&richloc, header);
5702 inform (&richloc,
5703 "%<std::%s%> is defined in header %qs;"
5704 " did you forget to %<#include %s%>?",
5705 name_str, header, header);
5706 }
5707 else
5708 {
5709 inform (&richloc,
5710 "%<std::%s%> is only available from %s onwards",
5711 name_str, get_cxx_dialect_name (header_hint->min_dialect));
5712 }
5713 return true;
5714 }
5715
5716 /* If SCOPE is the "std" namespace, then suggest pertinent header
5717 files for NAME at LOCATION.
5718 Return true iff a suggestion was offered. */
5719
5720 static bool
maybe_suggest_missing_header(location_t location,tree name,tree scope)5721 maybe_suggest_missing_header (location_t location, tree name, tree scope)
5722 {
5723 if (scope == NULL_TREE)
5724 return false;
5725 if (TREE_CODE (scope) != NAMESPACE_DECL)
5726 return false;
5727 /* We only offer suggestions for the "std" namespace. */
5728 if (scope != std_node)
5729 return false;
5730 return maybe_suggest_missing_std_header (location, name);
5731 }
5732
5733 /* Look for alternatives for NAME, an IDENTIFIER_NODE for which name
5734 lookup failed within the explicitly provided SCOPE. Suggest the
5735 the best meaningful candidates (if any) as a fix-it hint.
5736 Return true iff a suggestion was provided. */
5737
5738 bool
suggest_alternative_in_explicit_scope(location_t location,tree name,tree scope)5739 suggest_alternative_in_explicit_scope (location_t location, tree name,
5740 tree scope)
5741 {
5742 /* Something went very wrong; don't suggest anything. */
5743 if (name == error_mark_node)
5744 return false;
5745
5746 /* Resolve any namespace aliases. */
5747 scope = ORIGINAL_NAMESPACE (scope);
5748
5749 if (maybe_suggest_missing_header (location, name, scope))
5750 return true;
5751
5752 cp_binding_level *level = NAMESPACE_LEVEL (scope);
5753
5754 best_match <tree, const char *> bm (name);
5755 consider_binding_level (name, bm, level, false, FUZZY_LOOKUP_NAME);
5756
5757 /* See if we have a good suggesion for the user. */
5758 const char *fuzzy_name = bm.get_best_meaningful_candidate ();
5759 if (fuzzy_name)
5760 {
5761 gcc_rich_location richloc (location);
5762 richloc.add_fixit_replace (fuzzy_name);
5763 inform (&richloc, "suggested alternative: %qs",
5764 fuzzy_name);
5765 return true;
5766 }
5767
5768 return false;
5769 }
5770
5771 /* Look up NAME (an IDENTIFIER_NODE) in SCOPE (either a NAMESPACE_DECL
5772 or a class TYPE).
5773
5774 If PREFER_TYPE is > 0, we only return TYPE_DECLs or namespaces.
5775 If PREFER_TYPE is > 1, we only return TYPE_DECLs.
5776
5777 Returns a DECL (or OVERLOAD, or BASELINK) representing the
5778 declaration found. If no suitable declaration can be found,
5779 ERROR_MARK_NODE is returned. If COMPLAIN is true and SCOPE is
5780 neither a class-type nor a namespace a diagnostic is issued. */
5781
5782 tree
lookup_qualified_name(tree scope,tree name,int prefer_type,bool complain,bool find_hidden)5783 lookup_qualified_name (tree scope, tree name, int prefer_type, bool complain,
5784 bool find_hidden)
5785 {
5786 tree t = NULL_TREE;
5787
5788 if (TREE_CODE (scope) == NAMESPACE_DECL)
5789 {
5790 int flags = lookup_flags (prefer_type, /*namespaces_only*/false);
5791 if (find_hidden)
5792 flags |= LOOKUP_HIDDEN;
5793 name_lookup lookup (name, flags);
5794
5795 if (qualified_namespace_lookup (scope, &lookup))
5796 t = lookup.value;
5797 }
5798 else if (cxx_dialect != cxx98 && TREE_CODE (scope) == ENUMERAL_TYPE)
5799 t = lookup_enumerator (scope, name);
5800 else if (is_class_type (scope, complain))
5801 t = lookup_member (scope, name, 2, prefer_type, tf_warning_or_error);
5802
5803 if (!t)
5804 return error_mark_node;
5805 return t;
5806 }
5807
5808 /* [namespace.qual]
5809 Accepts the NAME to lookup and its qualifying SCOPE.
5810 Returns the name/type pair found into the cxx_binding *RESULT,
5811 or false on error. */
5812
5813 static bool
qualified_namespace_lookup(tree scope,name_lookup * lookup)5814 qualified_namespace_lookup (tree scope, name_lookup *lookup)
5815 {
5816 timevar_start (TV_NAME_LOOKUP);
5817 query_oracle (lookup->name);
5818 bool found = lookup->search_qualified (ORIGINAL_NAMESPACE (scope));
5819 timevar_stop (TV_NAME_LOOKUP);
5820 return found;
5821 }
5822
5823 /* Helper function for lookup_name_fuzzy.
5824 Traverse binding level LVL, looking for good name matches for NAME
5825 (and BM). */
5826 static void
consider_binding_level(tree name,best_match<tree,const char * > & bm,cp_binding_level * lvl,bool look_within_fields,enum lookup_name_fuzzy_kind kind)5827 consider_binding_level (tree name, best_match <tree, const char *> &bm,
5828 cp_binding_level *lvl, bool look_within_fields,
5829 enum lookup_name_fuzzy_kind kind)
5830 {
5831 if (look_within_fields)
5832 if (lvl->this_entity && TREE_CODE (lvl->this_entity) == RECORD_TYPE)
5833 {
5834 tree type = lvl->this_entity;
5835 bool want_type_p = (kind == FUZZY_LOOKUP_TYPENAME);
5836 tree best_matching_field
5837 = lookup_member_fuzzy (type, name, want_type_p);
5838 if (best_matching_field)
5839 bm.consider (IDENTIFIER_POINTER (best_matching_field));
5840 }
5841
5842 /* Only suggest names reserved for the implementation if NAME begins
5843 with an underscore. */
5844 bool consider_implementation_names = (IDENTIFIER_POINTER (name)[0] == '_');
5845
5846 for (tree t = lvl->names; t; t = TREE_CHAIN (t))
5847 {
5848 tree d = t;
5849
5850 /* OVERLOADs or decls from using declaration are wrapped into
5851 TREE_LIST. */
5852 if (TREE_CODE (d) == TREE_LIST)
5853 d = OVL_FIRST (TREE_VALUE (d));
5854
5855 /* Don't use bindings from implicitly declared functions,
5856 as they were likely misspellings themselves. */
5857 if (TREE_TYPE (d) == error_mark_node)
5858 continue;
5859
5860 /* Skip anticipated decls of builtin functions. */
5861 if (TREE_CODE (d) == FUNCTION_DECL
5862 && DECL_BUILT_IN (d)
5863 && DECL_ANTICIPATED (d))
5864 continue;
5865
5866 /* Skip compiler-generated variables (e.g. __for_begin/__for_end
5867 within range for). */
5868 if (TREE_CODE (d) == VAR_DECL
5869 && DECL_ARTIFICIAL (d))
5870 continue;
5871
5872 tree suggestion = DECL_NAME (d);
5873 if (!suggestion)
5874 continue;
5875
5876 /* Don't suggest names that are for anonymous aggregate types, as
5877 they are an implementation detail generated by the compiler. */
5878 if (anon_aggrname_p (suggestion))
5879 continue;
5880
5881 const char *suggestion_str = IDENTIFIER_POINTER (suggestion);
5882
5883 /* Ignore internal names with spaces in them. */
5884 if (strchr (suggestion_str, ' '))
5885 continue;
5886
5887 /* Don't suggest names that are reserved for use by the
5888 implementation, unless NAME began with an underscore. */
5889 if (name_reserved_for_implementation_p (suggestion_str)
5890 && !consider_implementation_names)
5891 continue;
5892
5893 bm.consider (suggestion_str);
5894 }
5895 }
5896
5897 /* Subclass of deferred_diagnostic. Notify the user that the
5898 given macro was used before it was defined.
5899 This can be done in the C++ frontend since tokenization happens
5900 upfront. */
5901
5902 class macro_use_before_def : public deferred_diagnostic
5903 {
5904 public:
5905 /* Factory function. Return a new macro_use_before_def instance if
5906 appropriate, or return NULL. */
5907 static macro_use_before_def *
maybe_make(location_t use_loc,cpp_hashnode * macro)5908 maybe_make (location_t use_loc, cpp_hashnode *macro)
5909 {
5910 source_location def_loc = cpp_macro_definition_location (macro);
5911 if (def_loc == UNKNOWN_LOCATION)
5912 return NULL;
5913
5914 /* We only want to issue a note if the macro was used *before* it was
5915 defined.
5916 We don't want to issue a note for cases where a macro was incorrectly
5917 used, leaving it unexpanded (e.g. by using the wrong argument
5918 count). */
5919 if (!linemap_location_before_p (line_table, use_loc, def_loc))
5920 return NULL;
5921
5922 return new macro_use_before_def (use_loc, macro);
5923 }
5924
5925 private:
5926 /* Ctor. LOC is the location of the usage. MACRO is the
5927 macro that was used. */
macro_use_before_def(location_t loc,cpp_hashnode * macro)5928 macro_use_before_def (location_t loc, cpp_hashnode *macro)
5929 : deferred_diagnostic (loc), m_macro (macro)
5930 {
5931 gcc_assert (macro);
5932 }
5933
~macro_use_before_def()5934 ~macro_use_before_def ()
5935 {
5936 if (is_suppressed_p ())
5937 return;
5938
5939 inform (get_location (), "the macro %qs had not yet been defined",
5940 (const char *)m_macro->ident.str);
5941 inform (cpp_macro_definition_location (m_macro),
5942 "it was later defined here");
5943 }
5944
5945 private:
5946 cpp_hashnode *m_macro;
5947 };
5948
5949 /* Determine if it can ever make sense to offer RID as a suggestion for
5950 a misspelling.
5951
5952 Subroutine of lookup_name_fuzzy. */
5953
5954 static bool
suggest_rid_p(enum rid rid)5955 suggest_rid_p (enum rid rid)
5956 {
5957 switch (rid)
5958 {
5959 /* Support suggesting function-like keywords. */
5960 case RID_STATIC_ASSERT:
5961 return true;
5962
5963 default:
5964 /* Support suggesting the various decl-specifier words, to handle
5965 e.g. "singed" vs "signed" typos. */
5966 if (cp_keyword_starts_decl_specifier_p (rid))
5967 return true;
5968
5969 /* Otherwise, don't offer it. This avoids suggesting e.g. "if"
5970 and "do" for short misspellings, which are likely to lead to
5971 nonsensical results. */
5972 return false;
5973 }
5974 }
5975
5976 /* Search for near-matches for NAME within the current bindings, and within
5977 macro names, returning the best match as a const char *, or NULL if
5978 no reasonable match is found.
5979
5980 Use LOC for any deferred diagnostics. */
5981
5982 name_hint
lookup_name_fuzzy(tree name,enum lookup_name_fuzzy_kind kind,location_t loc)5983 lookup_name_fuzzy (tree name, enum lookup_name_fuzzy_kind kind, location_t loc)
5984 {
5985 gcc_assert (TREE_CODE (name) == IDENTIFIER_NODE);
5986
5987 /* First, try some well-known names in the C++ standard library, in case
5988 the user forgot a #include. */
5989 const char *header_hint
5990 = get_cp_stdlib_header_for_name (IDENTIFIER_POINTER (name));
5991 if (header_hint)
5992 return name_hint (NULL,
5993 new suggest_missing_header (loc,
5994 IDENTIFIER_POINTER (name),
5995 header_hint));
5996
5997 best_match <tree, const char *> bm (name);
5998
5999 cp_binding_level *lvl;
6000 for (lvl = scope_chain->class_bindings; lvl; lvl = lvl->level_chain)
6001 consider_binding_level (name, bm, lvl, true, kind);
6002
6003 for (lvl = current_binding_level; lvl; lvl = lvl->level_chain)
6004 consider_binding_level (name, bm, lvl, false, kind);
6005
6006 /* Consider macros: if the user misspelled a macro name e.g. "SOME_MACRO"
6007 as:
6008 x = SOME_OTHER_MACRO (y);
6009 then "SOME_OTHER_MACRO" will survive to the frontend and show up
6010 as a misspelled identifier.
6011
6012 Use the best distance so far so that a candidate is only set if
6013 a macro is better than anything so far. This allows early rejection
6014 (without calculating the edit distance) of macro names that must have
6015 distance >= bm.get_best_distance (), and means that we only get a
6016 non-NULL result for best_macro_match if it's better than any of
6017 the identifiers already checked. */
6018 best_macro_match bmm (name, bm.get_best_distance (), parse_in);
6019 cpp_hashnode *best_macro = bmm.get_best_meaningful_candidate ();
6020 /* If a macro is the closest so far to NAME, consider it. */
6021 if (best_macro)
6022 bm.consider ((const char *)best_macro->ident.str);
6023 else if (bmm.get_best_distance () == 0)
6024 {
6025 /* If we have an exact match for a macro name, then either the
6026 macro was used with the wrong argument count, or the macro
6027 has been used before it was defined. */
6028 cpp_hashnode *macro = bmm.blithely_get_best_candidate ();
6029 if (macro && (macro->flags & NODE_BUILTIN) == 0)
6030 return name_hint (NULL,
6031 macro_use_before_def::maybe_make (loc, macro));
6032 }
6033
6034 /* Try the "starts_decl_specifier_p" keywords to detect
6035 "singed" vs "signed" typos. */
6036 for (unsigned i = 0; i < num_c_common_reswords; i++)
6037 {
6038 const c_common_resword *resword = &c_common_reswords[i];
6039
6040 if (!suggest_rid_p (resword->rid))
6041 continue;
6042
6043 tree resword_identifier = ridpointers [resword->rid];
6044 if (!resword_identifier)
6045 continue;
6046 gcc_assert (TREE_CODE (resword_identifier) == IDENTIFIER_NODE);
6047
6048 /* Only consider reserved words that survived the
6049 filtering in init_reswords (e.g. for -std). */
6050 if (!IDENTIFIER_KEYWORD_P (resword_identifier))
6051 continue;
6052
6053 bm.consider (IDENTIFIER_POINTER (resword_identifier));
6054 }
6055
6056 return name_hint (bm.get_best_meaningful_candidate (), NULL);
6057 }
6058
6059 /* Subroutine of outer_binding.
6060
6061 Returns TRUE if BINDING is a binding to a template parameter of
6062 SCOPE. In that case SCOPE is the scope of a primary template
6063 parameter -- in the sense of G++, i.e, a template that has its own
6064 template header.
6065
6066 Returns FALSE otherwise. */
6067
6068 static bool
binding_to_template_parms_of_scope_p(cxx_binding * binding,cp_binding_level * scope)6069 binding_to_template_parms_of_scope_p (cxx_binding *binding,
6070 cp_binding_level *scope)
6071 {
6072 tree binding_value, tmpl, tinfo;
6073 int level;
6074
6075 if (!binding || !scope || !scope->this_entity)
6076 return false;
6077
6078 binding_value = binding->value ? binding->value : binding->type;
6079 tinfo = get_template_info (scope->this_entity);
6080
6081 /* BINDING_VALUE must be a template parm. */
6082 if (binding_value == NULL_TREE
6083 || (!DECL_P (binding_value)
6084 || !DECL_TEMPLATE_PARM_P (binding_value)))
6085 return false;
6086
6087 /* The level of BINDING_VALUE. */
6088 level =
6089 template_type_parameter_p (binding_value)
6090 ? TEMPLATE_PARM_LEVEL (TEMPLATE_TYPE_PARM_INDEX
6091 (TREE_TYPE (binding_value)))
6092 : TEMPLATE_PARM_LEVEL (DECL_INITIAL (binding_value));
6093
6094 /* The template of the current scope, iff said scope is a primary
6095 template. */
6096 tmpl = (tinfo
6097 && PRIMARY_TEMPLATE_P (TI_TEMPLATE (tinfo))
6098 ? TI_TEMPLATE (tinfo)
6099 : NULL_TREE);
6100
6101 /* If the level of the parm BINDING_VALUE equals the depth of TMPL,
6102 then BINDING_VALUE is a parameter of TMPL. */
6103 return (tmpl && level == TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (tmpl)));
6104 }
6105
6106 /* Return the innermost non-namespace binding for NAME from a scope
6107 containing BINDING, or, if BINDING is NULL, the current scope.
6108 Please note that for a given template, the template parameters are
6109 considered to be in the scope containing the current scope.
6110 If CLASS_P is false, then class bindings are ignored. */
6111
6112 cxx_binding *
outer_binding(tree name,cxx_binding * binding,bool class_p)6113 outer_binding (tree name,
6114 cxx_binding *binding,
6115 bool class_p)
6116 {
6117 cxx_binding *outer;
6118 cp_binding_level *scope;
6119 cp_binding_level *outer_scope;
6120
6121 if (binding)
6122 {
6123 scope = binding->scope->level_chain;
6124 outer = binding->previous;
6125 }
6126 else
6127 {
6128 scope = current_binding_level;
6129 outer = IDENTIFIER_BINDING (name);
6130 }
6131 outer_scope = outer ? outer->scope : NULL;
6132
6133 /* Because we create class bindings lazily, we might be missing a
6134 class binding for NAME. If there are any class binding levels
6135 between the LAST_BINDING_LEVEL and the scope in which OUTER was
6136 declared, we must lookup NAME in those class scopes. */
6137 if (class_p)
6138 while (scope && scope != outer_scope && scope->kind != sk_namespace)
6139 {
6140 if (scope->kind == sk_class)
6141 {
6142 cxx_binding *class_binding;
6143
6144 class_binding = get_class_binding (name, scope);
6145 if (class_binding)
6146 {
6147 /* Thread this new class-scope binding onto the
6148 IDENTIFIER_BINDING list so that future lookups
6149 find it quickly. */
6150 class_binding->previous = outer;
6151 if (binding)
6152 binding->previous = class_binding;
6153 else
6154 IDENTIFIER_BINDING (name) = class_binding;
6155 return class_binding;
6156 }
6157 }
6158 /* If we are in a member template, the template parms of the member
6159 template are considered to be inside the scope of the containing
6160 class, but within G++ the class bindings are all pushed between the
6161 template parms and the function body. So if the outer binding is
6162 a template parm for the current scope, return it now rather than
6163 look for a class binding. */
6164 if (outer_scope && outer_scope->kind == sk_template_parms
6165 && binding_to_template_parms_of_scope_p (outer, scope))
6166 return outer;
6167
6168 scope = scope->level_chain;
6169 }
6170
6171 return outer;
6172 }
6173
6174 /* Return the innermost block-scope or class-scope value binding for
6175 NAME, or NULL_TREE if there is no such binding. */
6176
6177 tree
innermost_non_namespace_value(tree name)6178 innermost_non_namespace_value (tree name)
6179 {
6180 cxx_binding *binding;
6181 binding = outer_binding (name, /*binding=*/NULL, /*class_p=*/true);
6182 return binding ? binding->value : NULL_TREE;
6183 }
6184
6185 /* Look up NAME in the current binding level and its superiors in the
6186 namespace of variables, functions and typedefs. Return a ..._DECL
6187 node of some kind representing its definition if there is only one
6188 such declaration, or return a TREE_LIST with all the overloaded
6189 definitions if there are many, or return 0 if it is undefined.
6190 Hidden name, either friend declaration or built-in function, are
6191 not ignored.
6192
6193 If PREFER_TYPE is > 0, we prefer TYPE_DECLs or namespaces.
6194 If PREFER_TYPE is > 1, we reject non-type decls (e.g. namespaces).
6195 Otherwise we prefer non-TYPE_DECLs.
6196
6197 If NONCLASS is nonzero, bindings in class scopes are ignored. If
6198 BLOCK_P is false, bindings in block scopes are ignored. */
6199
6200 static tree
lookup_name_real_1(tree name,int prefer_type,int nonclass,bool block_p,int namespaces_only,int flags)6201 lookup_name_real_1 (tree name, int prefer_type, int nonclass, bool block_p,
6202 int namespaces_only, int flags)
6203 {
6204 cxx_binding *iter;
6205 tree val = NULL_TREE;
6206
6207 query_oracle (name);
6208
6209 /* Conversion operators are handled specially because ordinary
6210 unqualified name lookup will not find template conversion
6211 operators. */
6212 if (IDENTIFIER_CONV_OP_P (name))
6213 {
6214 cp_binding_level *level;
6215
6216 for (level = current_binding_level;
6217 level && level->kind != sk_namespace;
6218 level = level->level_chain)
6219 {
6220 tree class_type;
6221 tree operators;
6222
6223 /* A conversion operator can only be declared in a class
6224 scope. */
6225 if (level->kind != sk_class)
6226 continue;
6227
6228 /* Lookup the conversion operator in the class. */
6229 class_type = level->this_entity;
6230 operators = lookup_fnfields (class_type, name, /*protect=*/0);
6231 if (operators)
6232 return operators;
6233 }
6234
6235 return NULL_TREE;
6236 }
6237
6238 flags |= lookup_flags (prefer_type, namespaces_only);
6239
6240 /* First, look in non-namespace scopes. */
6241
6242 if (current_class_type == NULL_TREE)
6243 nonclass = 1;
6244
6245 if (block_p || !nonclass)
6246 for (iter = outer_binding (name, NULL, !nonclass);
6247 iter;
6248 iter = outer_binding (name, iter, !nonclass))
6249 {
6250 tree binding;
6251
6252 /* Skip entities we don't want. */
6253 if (LOCAL_BINDING_P (iter) ? !block_p : nonclass)
6254 continue;
6255
6256 /* If this is the kind of thing we're looking for, we're done. */
6257 if (qualify_lookup (iter->value, flags))
6258 binding = iter->value;
6259 else if ((flags & LOOKUP_PREFER_TYPES)
6260 && qualify_lookup (iter->type, flags))
6261 binding = iter->type;
6262 else
6263 binding = NULL_TREE;
6264
6265 if (binding)
6266 {
6267 if (TREE_CODE (binding) == TYPE_DECL && DECL_HIDDEN_P (binding))
6268 {
6269 /* A non namespace-scope binding can only be hidden in the
6270 presence of a local class, due to friend declarations.
6271
6272 In particular, consider:
6273
6274 struct C;
6275 void f() {
6276 struct A {
6277 friend struct B;
6278 friend struct C;
6279 void g() {
6280 B* b; // error: B is hidden
6281 C* c; // OK, finds ::C
6282 }
6283 };
6284 B *b; // error: B is hidden
6285 C *c; // OK, finds ::C
6286 struct B {};
6287 B *bb; // OK
6288 }
6289
6290 The standard says that "B" is a local class in "f"
6291 (but not nested within "A") -- but that name lookup
6292 for "B" does not find this declaration until it is
6293 declared directly with "f".
6294
6295 In particular:
6296
6297 [class.friend]
6298
6299 If a friend declaration appears in a local class and
6300 the name specified is an unqualified name, a prior
6301 declaration is looked up without considering scopes
6302 that are outside the innermost enclosing non-class
6303 scope. For a friend function declaration, if there is
6304 no prior declaration, the program is ill-formed. For a
6305 friend class declaration, if there is no prior
6306 declaration, the class that is specified belongs to the
6307 innermost enclosing non-class scope, but if it is
6308 subsequently referenced, its name is not found by name
6309 lookup until a matching declaration is provided in the
6310 innermost enclosing nonclass scope.
6311
6312 So just keep looking for a non-hidden binding.
6313 */
6314 gcc_assert (TREE_CODE (binding) == TYPE_DECL);
6315 continue;
6316 }
6317 val = binding;
6318 break;
6319 }
6320 }
6321
6322 /* Now lookup in namespace scopes. */
6323 if (!val)
6324 {
6325 name_lookup lookup (name, flags);
6326 if (lookup.search_unqualified
6327 (current_decl_namespace (), current_binding_level))
6328 val = lookup.value;
6329 }
6330
6331 /* If we have a single function from a using decl, pull it out. */
6332 if (val && TREE_CODE (val) == OVERLOAD && !really_overloaded_fn (val))
6333 val = OVL_FUNCTION (val);
6334
6335 return val;
6336 }
6337
6338 /* Wrapper for lookup_name_real_1. */
6339
6340 tree
lookup_name_real(tree name,int prefer_type,int nonclass,bool block_p,int namespaces_only,int flags)6341 lookup_name_real (tree name, int prefer_type, int nonclass, bool block_p,
6342 int namespaces_only, int flags)
6343 {
6344 tree ret;
6345 bool subtime = timevar_cond_start (TV_NAME_LOOKUP);
6346 ret = lookup_name_real_1 (name, prefer_type, nonclass, block_p,
6347 namespaces_only, flags);
6348 timevar_cond_stop (TV_NAME_LOOKUP, subtime);
6349 return ret;
6350 }
6351
6352 tree
lookup_name_nonclass(tree name)6353 lookup_name_nonclass (tree name)
6354 {
6355 return lookup_name_real (name, 0, 1, /*block_p=*/true, 0, 0);
6356 }
6357
6358 tree
lookup_name(tree name)6359 lookup_name (tree name)
6360 {
6361 return lookup_name_real (name, 0, 0, /*block_p=*/true, 0, 0);
6362 }
6363
6364 tree
lookup_name_prefer_type(tree name,int prefer_type)6365 lookup_name_prefer_type (tree name, int prefer_type)
6366 {
6367 return lookup_name_real (name, prefer_type, 0, /*block_p=*/true, 0, 0);
6368 }
6369
6370 /* Look up NAME for type used in elaborated name specifier in
6371 the scopes given by SCOPE. SCOPE can be either TS_CURRENT or
6372 TS_WITHIN_ENCLOSING_NON_CLASS. Although not implied by the
6373 name, more scopes are checked if cleanup or template parameter
6374 scope is encountered.
6375
6376 Unlike lookup_name_real, we make sure that NAME is actually
6377 declared in the desired scope, not from inheritance, nor using
6378 directive. For using declaration, there is DR138 still waiting
6379 to be resolved. Hidden name coming from an earlier friend
6380 declaration is also returned.
6381
6382 A TYPE_DECL best matching the NAME is returned. Catching error
6383 and issuing diagnostics are caller's responsibility. */
6384
6385 static tree
lookup_type_scope_1(tree name,tag_scope scope)6386 lookup_type_scope_1 (tree name, tag_scope scope)
6387 {
6388 cxx_binding *iter = NULL;
6389 tree val = NULL_TREE;
6390 cp_binding_level *level = NULL;
6391
6392 /* Look in non-namespace scope first. */
6393 if (current_binding_level->kind != sk_namespace)
6394 iter = outer_binding (name, NULL, /*class_p=*/ true);
6395 for (; iter; iter = outer_binding (name, iter, /*class_p=*/ true))
6396 {
6397 /* Check if this is the kind of thing we're looking for.
6398 If SCOPE is TS_CURRENT, also make sure it doesn't come from
6399 base class. For ITER->VALUE, we can simply use
6400 INHERITED_VALUE_BINDING_P. For ITER->TYPE, we have to use
6401 our own check.
6402
6403 We check ITER->TYPE before ITER->VALUE in order to handle
6404 typedef struct C {} C;
6405 correctly. */
6406
6407 if (qualify_lookup (iter->type, LOOKUP_PREFER_TYPES)
6408 && (scope != ts_current
6409 || LOCAL_BINDING_P (iter)
6410 || DECL_CONTEXT (iter->type) == iter->scope->this_entity))
6411 val = iter->type;
6412 else if ((scope != ts_current
6413 || !INHERITED_VALUE_BINDING_P (iter))
6414 && qualify_lookup (iter->value, LOOKUP_PREFER_TYPES))
6415 val = iter->value;
6416
6417 if (val)
6418 break;
6419 }
6420
6421 /* Look in namespace scope. */
6422 if (val)
6423 level = iter->scope;
6424 else
6425 {
6426 tree ns = current_decl_namespace ();
6427
6428 if (tree *slot = find_namespace_slot (ns, name))
6429 {
6430 /* If this is the kind of thing we're looking for, we're done. */
6431 if (tree type = MAYBE_STAT_TYPE (*slot))
6432 if (qualify_lookup (type, LOOKUP_PREFER_TYPES))
6433 val = type;
6434 if (!val)
6435 {
6436 if (tree decl = MAYBE_STAT_DECL (*slot))
6437 if (qualify_lookup (decl, LOOKUP_PREFER_TYPES))
6438 val = decl;
6439 }
6440 level = NAMESPACE_LEVEL (ns);
6441 }
6442 }
6443
6444 /* Type found, check if it is in the allowed scopes, ignoring cleanup
6445 and template parameter scopes. */
6446 if (val)
6447 {
6448 cp_binding_level *b = current_binding_level;
6449 while (b)
6450 {
6451 if (level == b)
6452 return val;
6453
6454 if (b->kind == sk_cleanup || b->kind == sk_template_parms
6455 || b->kind == sk_function_parms)
6456 b = b->level_chain;
6457 else if (b->kind == sk_class
6458 && scope == ts_within_enclosing_non_class)
6459 b = b->level_chain;
6460 else
6461 break;
6462 }
6463 }
6464
6465 return NULL_TREE;
6466 }
6467
6468 /* Wrapper for lookup_type_scope_1. */
6469
6470 tree
lookup_type_scope(tree name,tag_scope scope)6471 lookup_type_scope (tree name, tag_scope scope)
6472 {
6473 tree ret;
6474 bool subtime = timevar_cond_start (TV_NAME_LOOKUP);
6475 ret = lookup_type_scope_1 (name, scope);
6476 timevar_cond_stop (TV_NAME_LOOKUP, subtime);
6477 return ret;
6478 }
6479
6480 /* Returns true iff DECL is a block-scope extern declaration of a function
6481 or variable. */
6482
6483 bool
is_local_extern(tree decl)6484 is_local_extern (tree decl)
6485 {
6486 cxx_binding *binding;
6487
6488 /* For functions, this is easy. */
6489 if (TREE_CODE (decl) == FUNCTION_DECL)
6490 return DECL_LOCAL_FUNCTION_P (decl);
6491
6492 if (!VAR_P (decl))
6493 return false;
6494 if (!current_function_decl)
6495 return false;
6496
6497 /* For variables, this is not easy. We need to look at the binding stack
6498 for the identifier to see whether the decl we have is a local. */
6499 for (binding = IDENTIFIER_BINDING (DECL_NAME (decl));
6500 binding && binding->scope->kind != sk_namespace;
6501 binding = binding->previous)
6502 if (binding->value == decl)
6503 return LOCAL_BINDING_P (binding);
6504
6505 return false;
6506 }
6507
6508 /* The type TYPE is being declared. If it is a class template, or a
6509 specialization of a class template, do any processing required and
6510 perform error-checking. If IS_FRIEND is nonzero, this TYPE is
6511 being declared a friend. B is the binding level at which this TYPE
6512 should be bound.
6513
6514 Returns the TYPE_DECL for TYPE, which may have been altered by this
6515 processing. */
6516
6517 static tree
maybe_process_template_type_declaration(tree type,int is_friend,cp_binding_level * b)6518 maybe_process_template_type_declaration (tree type, int is_friend,
6519 cp_binding_level *b)
6520 {
6521 tree decl = TYPE_NAME (type);
6522
6523 if (processing_template_parmlist)
6524 /* You can't declare a new template type in a template parameter
6525 list. But, you can declare a non-template type:
6526
6527 template <class A*> struct S;
6528
6529 is a forward-declaration of `A'. */
6530 ;
6531 else if (b->kind == sk_namespace
6532 && current_binding_level->kind != sk_namespace)
6533 /* If this new type is being injected into a containing scope,
6534 then it's not a template type. */
6535 ;
6536 else
6537 {
6538 gcc_assert (MAYBE_CLASS_TYPE_P (type)
6539 || TREE_CODE (type) == ENUMERAL_TYPE);
6540
6541 if (processing_template_decl)
6542 {
6543 /* This may change after the call to
6544 push_template_decl_real, but we want the original value. */
6545 tree name = DECL_NAME (decl);
6546
6547 decl = push_template_decl_real (decl, is_friend);
6548 if (decl == error_mark_node)
6549 return error_mark_node;
6550
6551 /* If the current binding level is the binding level for the
6552 template parameters (see the comment in
6553 begin_template_parm_list) and the enclosing level is a class
6554 scope, and we're not looking at a friend, push the
6555 declaration of the member class into the class scope. In the
6556 friend case, push_template_decl will already have put the
6557 friend into global scope, if appropriate. */
6558 if (TREE_CODE (type) != ENUMERAL_TYPE
6559 && !is_friend && b->kind == sk_template_parms
6560 && b->level_chain->kind == sk_class)
6561 {
6562 finish_member_declaration (CLASSTYPE_TI_TEMPLATE (type));
6563
6564 if (!COMPLETE_TYPE_P (current_class_type))
6565 {
6566 maybe_add_class_template_decl_list (current_class_type,
6567 type, /*friend_p=*/0);
6568 /* Put this UTD in the table of UTDs for the class. */
6569 if (CLASSTYPE_NESTED_UTDS (current_class_type) == NULL)
6570 CLASSTYPE_NESTED_UTDS (current_class_type) =
6571 binding_table_new (SCOPE_DEFAULT_HT_SIZE);
6572
6573 binding_table_insert
6574 (CLASSTYPE_NESTED_UTDS (current_class_type), name, type);
6575 }
6576 }
6577 }
6578 }
6579
6580 return decl;
6581 }
6582
6583 /* Push a tag name NAME for struct/class/union/enum type TYPE. In case
6584 that the NAME is a class template, the tag is processed but not pushed.
6585
6586 The pushed scope depend on the SCOPE parameter:
6587 - When SCOPE is TS_CURRENT, put it into the inner-most non-sk_cleanup
6588 scope.
6589 - When SCOPE is TS_GLOBAL, put it in the inner-most non-class and
6590 non-template-parameter scope. This case is needed for forward
6591 declarations.
6592 - When SCOPE is TS_WITHIN_ENCLOSING_NON_CLASS, this is similar to
6593 TS_GLOBAL case except that names within template-parameter scopes
6594 are not pushed at all.
6595
6596 Returns TYPE upon success and ERROR_MARK_NODE otherwise. */
6597
6598 static tree
do_pushtag(tree name,tree type,tag_scope scope)6599 do_pushtag (tree name, tree type, tag_scope scope)
6600 {
6601 tree decl;
6602
6603 cp_binding_level *b = current_binding_level;
6604 while (/* Cleanup scopes are not scopes from the point of view of
6605 the language. */
6606 b->kind == sk_cleanup
6607 /* Neither are function parameter scopes. */
6608 || b->kind == sk_function_parms
6609 /* Neither are the scopes used to hold template parameters
6610 for an explicit specialization. For an ordinary template
6611 declaration, these scopes are not scopes from the point of
6612 view of the language. */
6613 || (b->kind == sk_template_parms
6614 && (b->explicit_spec_p || scope == ts_global))
6615 || (b->kind == sk_class
6616 && (scope != ts_current
6617 /* We may be defining a new type in the initializer
6618 of a static member variable. We allow this when
6619 not pedantic, and it is particularly useful for
6620 type punning via an anonymous union. */
6621 || COMPLETE_TYPE_P (b->this_entity))))
6622 b = b->level_chain;
6623
6624 gcc_assert (identifier_p (name));
6625
6626 /* Do C++ gratuitous typedefing. */
6627 if (identifier_type_value_1 (name) != type)
6628 {
6629 tree tdef;
6630 int in_class = 0;
6631 tree context = TYPE_CONTEXT (type);
6632
6633 if (! context)
6634 {
6635 tree cs = current_scope ();
6636
6637 /* Avoid setting the lambda context to a current_function_decl that
6638 we aren't actually inside, e.g. one set by push_access_scope
6639 during tsubst_default_argument. */
6640 if (cs && TREE_CODE (cs) == FUNCTION_DECL
6641 && LAMBDA_TYPE_P (type)
6642 && !at_function_scope_p ())
6643 cs = DECL_CONTEXT (cs);
6644
6645 if (scope == ts_current
6646 || (cs && TREE_CODE (cs) == FUNCTION_DECL))
6647 context = cs;
6648 else if (cs && TYPE_P (cs))
6649 /* When declaring a friend class of a local class, we want
6650 to inject the newly named class into the scope
6651 containing the local class, not the namespace
6652 scope. */
6653 context = decl_function_context (get_type_decl (cs));
6654 }
6655 if (!context)
6656 context = current_namespace;
6657
6658 if (b->kind == sk_class
6659 || (b->kind == sk_template_parms
6660 && b->level_chain->kind == sk_class))
6661 in_class = 1;
6662
6663 tdef = create_implicit_typedef (name, type);
6664 DECL_CONTEXT (tdef) = FROB_CONTEXT (context);
6665 if (scope == ts_within_enclosing_non_class)
6666 {
6667 /* This is a friend. Make this TYPE_DECL node hidden from
6668 ordinary name lookup. Its corresponding TEMPLATE_DECL
6669 will be marked in push_template_decl_real. */
6670 retrofit_lang_decl (tdef);
6671 DECL_ANTICIPATED (tdef) = 1;
6672 DECL_FRIEND_P (tdef) = 1;
6673 }
6674
6675 decl = maybe_process_template_type_declaration
6676 (type, scope == ts_within_enclosing_non_class, b);
6677 if (decl == error_mark_node)
6678 return decl;
6679
6680 if (b->kind == sk_class)
6681 {
6682 if (!TYPE_BEING_DEFINED (current_class_type)
6683 && !LAMBDA_TYPE_P (type))
6684 return error_mark_node;
6685
6686 if (!PROCESSING_REAL_TEMPLATE_DECL_P ())
6687 /* Put this TYPE_DECL on the TYPE_FIELDS list for the
6688 class. But if it's a member template class, we want
6689 the TEMPLATE_DECL, not the TYPE_DECL, so this is done
6690 later. */
6691 finish_member_declaration (decl);
6692 else
6693 pushdecl_class_level (decl);
6694 }
6695 else if (b->kind != sk_template_parms)
6696 {
6697 decl = do_pushdecl_with_scope (decl, b, /*is_friend=*/false);
6698 if (decl == error_mark_node)
6699 return decl;
6700
6701 if (DECL_CONTEXT (decl) == std_node
6702 && init_list_identifier == DECL_NAME (TYPE_NAME (type))
6703 && !CLASSTYPE_TEMPLATE_INFO (type))
6704 {
6705 error ("declaration of %<std::initializer_list%> does not match "
6706 "%<#include <initializer_list>%>, isn't a template");
6707 return error_mark_node;
6708 }
6709 }
6710
6711 if (! in_class)
6712 set_identifier_type_value_with_scope (name, tdef, b);
6713
6714 TYPE_CONTEXT (type) = DECL_CONTEXT (decl);
6715
6716 /* If this is a local class, keep track of it. We need this
6717 information for name-mangling, and so that it is possible to
6718 find all function definitions in a translation unit in a
6719 convenient way. (It's otherwise tricky to find a member
6720 function definition it's only pointed to from within a local
6721 class.) */
6722 if (TYPE_FUNCTION_SCOPE_P (type))
6723 {
6724 if (processing_template_decl)
6725 {
6726 /* Push a DECL_EXPR so we call pushtag at the right time in
6727 template instantiation rather than in some nested context. */
6728 add_decl_expr (decl);
6729 }
6730 /* Lambdas use LAMBDA_EXPR_DISCRIMINATOR instead. */
6731 else if (!LAMBDA_TYPE_P (type))
6732 vec_safe_push (local_classes, type);
6733 }
6734 }
6735
6736 if (b->kind == sk_class
6737 && !COMPLETE_TYPE_P (current_class_type))
6738 {
6739 maybe_add_class_template_decl_list (current_class_type,
6740 type, /*friend_p=*/0);
6741
6742 if (CLASSTYPE_NESTED_UTDS (current_class_type) == NULL)
6743 CLASSTYPE_NESTED_UTDS (current_class_type)
6744 = binding_table_new (SCOPE_DEFAULT_HT_SIZE);
6745
6746 binding_table_insert
6747 (CLASSTYPE_NESTED_UTDS (current_class_type), name, type);
6748 }
6749
6750 decl = TYPE_NAME (type);
6751 gcc_assert (TREE_CODE (decl) == TYPE_DECL);
6752
6753 /* Set type visibility now if this is a forward declaration. */
6754 TREE_PUBLIC (decl) = 1;
6755 determine_visibility (decl);
6756
6757 return type;
6758 }
6759
6760 /* Wrapper for do_pushtag. */
6761
6762 tree
pushtag(tree name,tree type,tag_scope scope)6763 pushtag (tree name, tree type, tag_scope scope)
6764 {
6765 tree ret;
6766 bool subtime = timevar_cond_start (TV_NAME_LOOKUP);
6767 ret = do_pushtag (name, type, scope);
6768 timevar_cond_stop (TV_NAME_LOOKUP, subtime);
6769 return ret;
6770 }
6771
6772
6773 /* Subroutines for reverting temporarily to top-level for instantiation
6774 of templates and such. We actually need to clear out the class- and
6775 local-value slots of all identifiers, so that only the global values
6776 are at all visible. Simply setting current_binding_level to the global
6777 scope isn't enough, because more binding levels may be pushed. */
6778 struct saved_scope *scope_chain;
6779
6780 /* Return true if ID has not already been marked. */
6781
6782 static inline bool
store_binding_p(tree id)6783 store_binding_p (tree id)
6784 {
6785 if (!id || !IDENTIFIER_BINDING (id))
6786 return false;
6787
6788 if (IDENTIFIER_MARKED (id))
6789 return false;
6790
6791 return true;
6792 }
6793
6794 /* Add an appropriate binding to *OLD_BINDINGS which needs to already
6795 have enough space reserved. */
6796
6797 static void
store_binding(tree id,vec<cxx_saved_binding,va_gc> ** old_bindings)6798 store_binding (tree id, vec<cxx_saved_binding, va_gc> **old_bindings)
6799 {
6800 cxx_saved_binding saved;
6801
6802 gcc_checking_assert (store_binding_p (id));
6803
6804 IDENTIFIER_MARKED (id) = 1;
6805
6806 saved.identifier = id;
6807 saved.binding = IDENTIFIER_BINDING (id);
6808 saved.real_type_value = REAL_IDENTIFIER_TYPE_VALUE (id);
6809 (*old_bindings)->quick_push (saved);
6810 IDENTIFIER_BINDING (id) = NULL;
6811 }
6812
6813 static void
store_bindings(tree names,vec<cxx_saved_binding,va_gc> ** old_bindings)6814 store_bindings (tree names, vec<cxx_saved_binding, va_gc> **old_bindings)
6815 {
6816 static vec<tree> bindings_need_stored;
6817 tree t, id;
6818 size_t i;
6819
6820 bool subtime = timevar_cond_start (TV_NAME_LOOKUP);
6821 for (t = names; t; t = TREE_CHAIN (t))
6822 {
6823 if (TREE_CODE (t) == TREE_LIST)
6824 id = TREE_PURPOSE (t);
6825 else
6826 id = DECL_NAME (t);
6827
6828 if (store_binding_p (id))
6829 bindings_need_stored.safe_push (id);
6830 }
6831 if (!bindings_need_stored.is_empty ())
6832 {
6833 vec_safe_reserve_exact (*old_bindings, bindings_need_stored.length ());
6834 for (i = 0; bindings_need_stored.iterate (i, &id); ++i)
6835 {
6836 /* We can apparently have duplicates in NAMES. */
6837 if (store_binding_p (id))
6838 store_binding (id, old_bindings);
6839 }
6840 bindings_need_stored.truncate (0);
6841 }
6842 timevar_cond_stop (TV_NAME_LOOKUP, subtime);
6843 }
6844
6845 /* Like store_bindings, but NAMES is a vector of cp_class_binding
6846 objects, rather than a TREE_LIST. */
6847
6848 static void
store_class_bindings(vec<cp_class_binding,va_gc> * names,vec<cxx_saved_binding,va_gc> ** old_bindings)6849 store_class_bindings (vec<cp_class_binding, va_gc> *names,
6850 vec<cxx_saved_binding, va_gc> **old_bindings)
6851 {
6852 static vec<tree> bindings_need_stored;
6853 size_t i;
6854 cp_class_binding *cb;
6855
6856 for (i = 0; vec_safe_iterate (names, i, &cb); ++i)
6857 if (store_binding_p (cb->identifier))
6858 bindings_need_stored.safe_push (cb->identifier);
6859 if (!bindings_need_stored.is_empty ())
6860 {
6861 tree id;
6862 vec_safe_reserve_exact (*old_bindings, bindings_need_stored.length ());
6863 for (i = 0; bindings_need_stored.iterate (i, &id); ++i)
6864 store_binding (id, old_bindings);
6865 bindings_need_stored.truncate (0);
6866 }
6867 }
6868
6869 /* A chain of saved_scope structures awaiting reuse. */
6870
6871 static GTY((deletable)) struct saved_scope *free_saved_scope;
6872
6873 static void
do_push_to_top_level(void)6874 do_push_to_top_level (void)
6875 {
6876 struct saved_scope *s;
6877 cp_binding_level *b;
6878 cxx_saved_binding *sb;
6879 size_t i;
6880 bool need_pop;
6881
6882 /* Reuse or create a new structure for this saved scope. */
6883 if (free_saved_scope != NULL)
6884 {
6885 s = free_saved_scope;
6886 free_saved_scope = s->prev;
6887
6888 vec<cxx_saved_binding, va_gc> *old_bindings = s->old_bindings;
6889 memset (s, 0, sizeof (*s));
6890 /* Also reuse the structure's old_bindings vector. */
6891 vec_safe_truncate (old_bindings, 0);
6892 s->old_bindings = old_bindings;
6893 }
6894 else
6895 s = ggc_cleared_alloc<saved_scope> ();
6896
6897 b = scope_chain ? current_binding_level : 0;
6898
6899 /* If we're in the middle of some function, save our state. */
6900 if (cfun)
6901 {
6902 need_pop = true;
6903 push_function_context ();
6904 }
6905 else
6906 need_pop = false;
6907
6908 if (scope_chain && previous_class_level)
6909 store_class_bindings (previous_class_level->class_shadowed,
6910 &s->old_bindings);
6911
6912 /* Have to include the global scope, because class-scope decls
6913 aren't listed anywhere useful. */
6914 for (; b; b = b->level_chain)
6915 {
6916 tree t;
6917
6918 /* Template IDs are inserted into the global level. If they were
6919 inserted into namespace level, finish_file wouldn't find them
6920 when doing pending instantiations. Therefore, don't stop at
6921 namespace level, but continue until :: . */
6922 if (global_scope_p (b))
6923 break;
6924
6925 store_bindings (b->names, &s->old_bindings);
6926 /* We also need to check class_shadowed to save class-level type
6927 bindings, since pushclass doesn't fill in b->names. */
6928 if (b->kind == sk_class)
6929 store_class_bindings (b->class_shadowed, &s->old_bindings);
6930
6931 /* Unwind type-value slots back to top level. */
6932 for (t = b->type_shadowed; t; t = TREE_CHAIN (t))
6933 SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (t), TREE_VALUE (t));
6934 }
6935
6936 FOR_EACH_VEC_SAFE_ELT (s->old_bindings, i, sb)
6937 IDENTIFIER_MARKED (sb->identifier) = 0;
6938
6939 s->prev = scope_chain;
6940 s->bindings = b;
6941 s->need_pop_function_context = need_pop;
6942 s->function_decl = current_function_decl;
6943 s->unevaluated_operand = cp_unevaluated_operand;
6944 s->inhibit_evaluation_warnings = c_inhibit_evaluation_warnings;
6945 s->x_stmt_tree.stmts_are_full_exprs_p = true;
6946
6947 scope_chain = s;
6948 current_function_decl = NULL_TREE;
6949 current_lang_base = NULL;
6950 current_lang_name = lang_name_cplusplus;
6951 current_namespace = global_namespace;
6952 push_class_stack ();
6953 cp_unevaluated_operand = 0;
6954 c_inhibit_evaluation_warnings = 0;
6955 }
6956
6957 static void
do_pop_from_top_level(void)6958 do_pop_from_top_level (void)
6959 {
6960 struct saved_scope *s = scope_chain;
6961 cxx_saved_binding *saved;
6962 size_t i;
6963
6964 /* Clear out class-level bindings cache. */
6965 if (previous_class_level)
6966 invalidate_class_lookup_cache ();
6967 pop_class_stack ();
6968
6969 release_tree_vector (current_lang_base);
6970
6971 scope_chain = s->prev;
6972 FOR_EACH_VEC_SAFE_ELT (s->old_bindings, i, saved)
6973 {
6974 tree id = saved->identifier;
6975
6976 IDENTIFIER_BINDING (id) = saved->binding;
6977 SET_IDENTIFIER_TYPE_VALUE (id, saved->real_type_value);
6978 }
6979
6980 /* If we were in the middle of compiling a function, restore our
6981 state. */
6982 if (s->need_pop_function_context)
6983 pop_function_context ();
6984 current_function_decl = s->function_decl;
6985 cp_unevaluated_operand = s->unevaluated_operand;
6986 c_inhibit_evaluation_warnings = s->inhibit_evaluation_warnings;
6987
6988 /* Make this saved_scope structure available for reuse by
6989 push_to_top_level. */
6990 s->prev = free_saved_scope;
6991 free_saved_scope = s;
6992 }
6993
6994 /* Push into the scope of the namespace NS, even if it is deeply
6995 nested within another namespace. */
6996
6997 static void
do_push_nested_namespace(tree ns)6998 do_push_nested_namespace (tree ns)
6999 {
7000 if (ns == global_namespace)
7001 do_push_to_top_level ();
7002 else
7003 {
7004 do_push_nested_namespace (CP_DECL_CONTEXT (ns));
7005 gcc_checking_assert
7006 (find_namespace_value (current_namespace, DECL_NAME (ns)) == ns);
7007 resume_scope (NAMESPACE_LEVEL (ns));
7008 current_namespace = ns;
7009 }
7010 }
7011
7012 /* Pop back from the scope of the namespace NS, which was previously
7013 entered with push_nested_namespace. */
7014
7015 static void
do_pop_nested_namespace(tree ns)7016 do_pop_nested_namespace (tree ns)
7017 {
7018 while (ns != global_namespace)
7019 {
7020 ns = CP_DECL_CONTEXT (ns);
7021 current_namespace = ns;
7022 leave_scope ();
7023 }
7024
7025 do_pop_from_top_level ();
7026 }
7027
7028 /* Add TARGET to USINGS, if it does not already exist there.
7029 We used to build the complete graph of usings at this point, from
7030 the POV of the source namespaces. Now we build that as we perform
7031 the unqualified search. */
7032
7033 static void
add_using_namespace(vec<tree,va_gc> * & usings,tree target)7034 add_using_namespace (vec<tree, va_gc> *&usings, tree target)
7035 {
7036 if (usings)
7037 for (unsigned ix = usings->length (); ix--;)
7038 if ((*usings)[ix] == target)
7039 return;
7040
7041 vec_safe_push (usings, target);
7042 }
7043
7044 /* Tell the debug system of a using directive. */
7045
7046 static void
emit_debug_info_using_namespace(tree from,tree target,bool implicit)7047 emit_debug_info_using_namespace (tree from, tree target, bool implicit)
7048 {
7049 /* Emit debugging info. */
7050 tree context = from != global_namespace ? from : NULL_TREE;
7051 debug_hooks->imported_module_or_decl (target, NULL_TREE, context, false,
7052 implicit);
7053 }
7054
7055 /* Process a namespace-scope using directive. */
7056
7057 void
finish_namespace_using_directive(tree target,tree attribs)7058 finish_namespace_using_directive (tree target, tree attribs)
7059 {
7060 gcc_checking_assert (namespace_bindings_p ());
7061 if (target == error_mark_node)
7062 return;
7063
7064 add_using_namespace (DECL_NAMESPACE_USING (current_namespace),
7065 ORIGINAL_NAMESPACE (target));
7066 emit_debug_info_using_namespace (current_namespace,
7067 ORIGINAL_NAMESPACE (target), false);
7068
7069 if (attribs == error_mark_node)
7070 return;
7071
7072 for (tree a = attribs; a; a = TREE_CHAIN (a))
7073 {
7074 tree name = get_attribute_name (a);
7075 if (is_attribute_p ("strong", name))
7076 {
7077 warning (0, "strong using directive no longer supported");
7078 if (CP_DECL_CONTEXT (target) == current_namespace)
7079 inform (DECL_SOURCE_LOCATION (target),
7080 "you may use an inline namespace instead");
7081 }
7082 else
7083 warning (OPT_Wattributes, "%qD attribute directive ignored", name);
7084 }
7085 }
7086
7087 /* Process a function-scope using-directive. */
7088
7089 void
finish_local_using_directive(tree target,tree attribs)7090 finish_local_using_directive (tree target, tree attribs)
7091 {
7092 gcc_checking_assert (local_bindings_p ());
7093 if (target == error_mark_node)
7094 return;
7095
7096 if (attribs)
7097 warning (OPT_Wattributes, "attributes ignored on local using directive");
7098
7099 add_stmt (build_stmt (input_location, USING_STMT, target));
7100
7101 add_using_namespace (current_binding_level->using_directives,
7102 ORIGINAL_NAMESPACE (target));
7103 }
7104
7105 /* Pushes X into the global namespace. */
7106
7107 tree
pushdecl_top_level(tree x,bool is_friend)7108 pushdecl_top_level (tree x, bool is_friend)
7109 {
7110 bool subtime = timevar_cond_start (TV_NAME_LOOKUP);
7111 do_push_to_top_level ();
7112 x = pushdecl_namespace_level (x, is_friend);
7113 do_pop_from_top_level ();
7114 timevar_cond_stop (TV_NAME_LOOKUP, subtime);
7115 return x;
7116 }
7117
7118 /* Pushes X into the global namespace and calls cp_finish_decl to
7119 register the variable, initializing it with INIT. */
7120
7121 tree
pushdecl_top_level_and_finish(tree x,tree init)7122 pushdecl_top_level_and_finish (tree x, tree init)
7123 {
7124 bool subtime = timevar_cond_start (TV_NAME_LOOKUP);
7125 do_push_to_top_level ();
7126 x = pushdecl_namespace_level (x, false);
7127 cp_finish_decl (x, init, false, NULL_TREE, 0);
7128 do_pop_from_top_level ();
7129 timevar_cond_stop (TV_NAME_LOOKUP, subtime);
7130 return x;
7131 }
7132
7133 /* Enter the namespaces from current_namerspace to NS. */
7134
7135 static int
push_inline_namespaces(tree ns)7136 push_inline_namespaces (tree ns)
7137 {
7138 int count = 0;
7139 if (ns != current_namespace)
7140 {
7141 gcc_assert (ns != global_namespace);
7142 count += push_inline_namespaces (CP_DECL_CONTEXT (ns));
7143 resume_scope (NAMESPACE_LEVEL (ns));
7144 current_namespace = ns;
7145 count++;
7146 }
7147 return count;
7148 }
7149
7150 /* Push into the scope of the NAME namespace. If NAME is NULL_TREE,
7151 then we enter an anonymous namespace. If MAKE_INLINE is true, then
7152 we create an inline namespace (it is up to the caller to check upon
7153 redefinition). Return the number of namespaces entered. */
7154
7155 int
push_namespace(tree name,bool make_inline)7156 push_namespace (tree name, bool make_inline)
7157 {
7158 bool subtime = timevar_cond_start (TV_NAME_LOOKUP);
7159 int count = 0;
7160
7161 /* We should not get here if the global_namespace is not yet constructed
7162 nor if NAME designates the global namespace: The global scope is
7163 constructed elsewhere. */
7164 gcc_checking_assert (global_namespace != NULL && name != global_identifier);
7165
7166 tree ns = NULL_TREE;
7167 {
7168 name_lookup lookup (name, 0);
7169 if (!lookup.search_qualified (current_namespace, /*usings=*/false))
7170 ;
7171 else if (TREE_CODE (lookup.value) != NAMESPACE_DECL)
7172 ;
7173 else if (tree dna = DECL_NAMESPACE_ALIAS (lookup.value))
7174 {
7175 /* A namespace alias is not allowed here, but if the alias
7176 is for a namespace also inside the current scope,
7177 accept it with a diagnostic. That's better than dying
7178 horribly. */
7179 if (is_nested_namespace (current_namespace, CP_DECL_CONTEXT (dna)))
7180 {
7181 error ("namespace alias %qD not allowed here, "
7182 "assuming %qD", lookup.value, dna);
7183 ns = dna;
7184 }
7185 }
7186 else
7187 ns = lookup.value;
7188 }
7189
7190 bool new_ns = false;
7191 if (ns)
7192 /* DR2061. NS might be a member of an inline namespace. We
7193 need to push into those namespaces. */
7194 count += push_inline_namespaces (CP_DECL_CONTEXT (ns));
7195 else
7196 {
7197 ns = build_lang_decl (NAMESPACE_DECL, name, void_type_node);
7198 SCOPE_DEPTH (ns) = SCOPE_DEPTH (current_namespace) + 1;
7199 if (!SCOPE_DEPTH (ns))
7200 /* We only allow depth 255. */
7201 sorry ("cannot nest more than %d namespaces",
7202 SCOPE_DEPTH (current_namespace));
7203 DECL_CONTEXT (ns) = FROB_CONTEXT (current_namespace);
7204 new_ns = true;
7205
7206 if (pushdecl (ns) == error_mark_node)
7207 ns = NULL_TREE;
7208 else
7209 {
7210 if (!name)
7211 {
7212 SET_DECL_ASSEMBLER_NAME (ns, anon_identifier);
7213
7214 if (!make_inline)
7215 add_using_namespace (DECL_NAMESPACE_USING (current_namespace),
7216 ns);
7217 }
7218 else if (TREE_PUBLIC (current_namespace))
7219 TREE_PUBLIC (ns) = 1;
7220
7221 if (make_inline)
7222 {
7223 DECL_NAMESPACE_INLINE_P (ns) = true;
7224 vec_safe_push (DECL_NAMESPACE_INLINEES (current_namespace), ns);
7225 }
7226
7227 if (!name || make_inline)
7228 emit_debug_info_using_namespace (current_namespace, ns, true);
7229 }
7230 }
7231
7232 if (ns)
7233 {
7234 if (make_inline && !DECL_NAMESPACE_INLINE_P (ns))
7235 {
7236 error ("inline namespace must be specified at initial definition");
7237 inform (DECL_SOURCE_LOCATION (ns), "%qD defined here", ns);
7238 }
7239 if (new_ns)
7240 begin_scope (sk_namespace, ns);
7241 else
7242 resume_scope (NAMESPACE_LEVEL (ns));
7243 current_namespace = ns;
7244 count++;
7245 }
7246
7247 timevar_cond_stop (TV_NAME_LOOKUP, subtime);
7248 return count;
7249 }
7250
7251 /* Pop from the scope of the current namespace. */
7252
7253 void
pop_namespace(void)7254 pop_namespace (void)
7255 {
7256 bool subtime = timevar_cond_start (TV_NAME_LOOKUP);
7257
7258 gcc_assert (current_namespace != global_namespace);
7259 current_namespace = CP_DECL_CONTEXT (current_namespace);
7260 /* The binding level is not popped, as it might be re-opened later. */
7261 leave_scope ();
7262
7263 timevar_cond_stop (TV_NAME_LOOKUP, subtime);
7264 }
7265
7266 /* External entry points for do_{push_to/pop_from}_top_level. */
7267
7268 void
push_to_top_level(void)7269 push_to_top_level (void)
7270 {
7271 bool subtime = timevar_cond_start (TV_NAME_LOOKUP);
7272 do_push_to_top_level ();
7273 timevar_cond_stop (TV_NAME_LOOKUP, subtime);
7274 }
7275
7276 void
pop_from_top_level(void)7277 pop_from_top_level (void)
7278 {
7279 bool subtime = timevar_cond_start (TV_NAME_LOOKUP);
7280 do_pop_from_top_level ();
7281 timevar_cond_stop (TV_NAME_LOOKUP, subtime);
7282 }
7283
7284 /* External entry points for do_{push,pop}_nested_namespace. */
7285
7286 void
push_nested_namespace(tree ns)7287 push_nested_namespace (tree ns)
7288 {
7289 bool subtime = timevar_cond_start (TV_NAME_LOOKUP);
7290 do_push_nested_namespace (ns);
7291 timevar_cond_stop (TV_NAME_LOOKUP, subtime);
7292 }
7293
7294 void
pop_nested_namespace(tree ns)7295 pop_nested_namespace (tree ns)
7296 {
7297 bool subtime = timevar_cond_start (TV_NAME_LOOKUP);
7298 gcc_assert (current_namespace == ns);
7299 do_pop_nested_namespace (ns);
7300 timevar_cond_stop (TV_NAME_LOOKUP, subtime);
7301 }
7302
7303 /* Pop off extraneous binding levels left over due to syntax errors.
7304 We don't pop past namespaces, as they might be valid. */
7305
7306 void
pop_everything(void)7307 pop_everything (void)
7308 {
7309 if (ENABLE_SCOPE_CHECKING)
7310 verbatim ("XXX entering pop_everything ()\n");
7311 while (!namespace_bindings_p ())
7312 {
7313 if (current_binding_level->kind == sk_class)
7314 pop_nested_class ();
7315 else
7316 poplevel (0, 0, 0);
7317 }
7318 if (ENABLE_SCOPE_CHECKING)
7319 verbatim ("XXX leaving pop_everything ()\n");
7320 }
7321
7322 /* Emit debugging information for using declarations and directives.
7323 If input tree is overloaded fn then emit debug info for all
7324 candidates. */
7325
7326 void
cp_emit_debug_info_for_using(tree t,tree context)7327 cp_emit_debug_info_for_using (tree t, tree context)
7328 {
7329 /* Don't try to emit any debug information if we have errors. */
7330 if (seen_error ())
7331 return;
7332
7333 /* Ignore this FUNCTION_DECL if it refers to a builtin declaration
7334 of a builtin function. */
7335 if (TREE_CODE (t) == FUNCTION_DECL
7336 && DECL_EXTERNAL (t)
7337 && DECL_BUILT_IN (t))
7338 return;
7339
7340 /* Do not supply context to imported_module_or_decl, if
7341 it is a global namespace. */
7342 if (context == global_namespace)
7343 context = NULL_TREE;
7344
7345 t = MAYBE_BASELINK_FUNCTIONS (t);
7346
7347 /* FIXME: Handle TEMPLATE_DECLs. */
7348 for (lkp_iterator iter (t); iter; ++iter)
7349 {
7350 tree fn = *iter;
7351 if (TREE_CODE (fn) != TEMPLATE_DECL)
7352 {
7353 if (building_stmt_list_p ())
7354 add_stmt (build_stmt (input_location, USING_STMT, fn));
7355 else
7356 debug_hooks->imported_module_or_decl (fn, NULL_TREE, context,
7357 false, false);
7358 }
7359 }
7360 }
7361
7362 #include "gt-cp-name-lookup.h"
7363