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>
5 This file is part of GCC.
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)
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.
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/>. */
22 #define INCLUDE_UNIQUE_PTR
24 #include "coretypes.h"
27 #include "stringpool.h"
28 #include "print-tree.h"
31 #include "c-family/c-pragma.h"
33 #include "gcc-rich-location.h"
34 #include "spellcheck-tree.h"
36 #include "c-family/name-hint.h"
37 #include "c-family/known-headers.h"
38 #include "c-family/c-spellcheck.h"
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,
44 static bool maybe_suggest_missing_std_header (location_t location, tree name);
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. */
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)
56 /* Create a STAT_HACK node with DECL as the value binding and TYPE as
60 stat_hack (tree decl = NULL_TREE, tree type = NULL_TREE)
62 tree result = make_node (OVERLOAD);
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;
71 /* Create a local binding level for NAME. */
74 create_local_binding (cp_binding_level *level, tree name)
76 cxx_binding *binding = cxx_binding_make (NULL, NULL);
78 INHERITED_VALUE_BINDING_P (binding) = false;
79 LOCAL_BINDING_P (binding) = true;
80 binding->scope = level;
81 binding->previous = IDENTIFIER_BINDING (name);
83 IDENTIFIER_BINDING (name) = binding;
88 /* Find the binding for NAME in namespace NS. If CREATE_P is true,
89 make an empty binding if there wasn't one. */
92 find_namespace_slot (tree ns, tree name, bool create_p = false)
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);
101 find_namespace_value (tree ns, tree name)
103 tree *b = find_namespace_slot (ns, name);
105 return b ? MAYBE_STAT_DECL (*b) : NULL_TREE;
108 /* Add DECL to the list of things declared in B. */
111 add_decl_to_level (cp_binding_level *b, tree decl)
113 gcc_assert (b->kind != sk_class);
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);
120 /* We build up the list in reverse order, and reverse it later if
122 TREE_CHAIN (decl) = b->names;
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
129 if (b->kind == sk_namespace
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);
139 /* Find the binding for NAME in the local binding level B. */
142 find_local_binding (cp_binding_level *b, tree name)
144 if (cxx_binding *binding = IDENTIFIER_BINDING (name))
145 for (;; b = b->level_chain)
147 if (binding->scope == b
148 && !(VAR_P (binding->value)
149 && DECL_DEAD_FOR_LOCAL (binding->value)))
152 /* Cleanup contours are transparent to the language. */
153 if (b->kind != sk_cleanup)
162 typedef std::pair<tree, tree> using_pair;
163 typedef vec<using_pair, va_heap, vl_embed> using_queue;
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
172 vec<tree, va_heap, vl_embed> *scopes;
173 name_lookup *previous; /* Previously active lookup. */
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;
182 name_lookup (tree n, int f = 0)
183 : name (n), value (NULL_TREE), type (NULL_TREE), flags (f),
184 deduping (false), scopes (NULL), previous (NULL)
193 private: /* Uncopyable, unmovable, unassignable. I am a rock. */
194 name_lookup (const name_lookup &);
195 name_lookup &operator= (const name_lookup &);
198 static bool seen_p (tree scope)
200 return LOOKUP_SEEN_P (scope);
202 static bool found_p (tree scope)
204 return LOOKUP_FOUND_P (scope);
207 void mark_seen (tree scope); /* Mark and add to scope vector. */
208 static void mark_found (tree scope)
210 gcc_checking_assert (seen_p (scope));
211 LOOKUP_FOUND_P (scope) = true;
213 bool see_and_mark (tree scope)
215 bool ret = seen_p (scope);
220 bool find_and_mark (tree scope);
223 void preserve_state ();
224 void restore_state ();
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);
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);
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);
246 using_queue *queue_usings (using_queue *queue, int depth,
247 vec<tree, va_gc> *usings)
250 queue = do_queue_usings (queue, depth, usings);
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);
267 /* Search namespace + inlines + maybe usings as qualified lookup. */
268 bool search_qualified (tree scope, bool usings = true);
270 /* Search namespace + inlines + usings as unqualified lookup. */
271 bool search_unqualified (tree scope, cp_binding_level *);
273 /* ADL lookup of ARGS. */
274 tree search_adl (tree fns, vec<tree, va_gc> *args);
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;
281 /* Currently active lookup. */
282 name_lookup *name_lookup::active;
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. */
291 name_lookup::preserve_state ()
296 unsigned length = vec_safe_length (previous->scopes);
297 vec_safe_reserve (previous->scopes, length * 2);
298 for (unsigned ix = length; ix--;)
300 tree decl = (*previous->scopes)[ix];
302 gcc_checking_assert (LOOKUP_SEEN_P (decl));
303 LOOKUP_SEEN_P (decl) = false;
305 /* Preserve the FOUND_P state on the interrupted lookup's
307 if (LOOKUP_FOUND_P (decl))
309 LOOKUP_FOUND_P (decl) = false;
310 previous->scopes->quick_push (decl);
314 /* Unmark the outer partial lookup. */
315 if (previous->deduping)
316 lookup_mark (previous->value, false);
319 scopes = shared_scopes;
323 /* Restore the marking state of a lookup we interrupted. */
326 name_lookup::restore_state ()
329 lookup_mark (value, false);
331 /* Unmark and empty this lookup's scope stack. */
332 for (unsigned ix = vec_safe_length (scopes); ix--;)
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;
345 unsigned length = vec_safe_length (previous->scopes);
346 for (unsigned ix = 0; ix != length; ix++)
348 tree decl = (*previous->scopes)[ix];
349 if (LOOKUP_SEEN_P (decl))
351 /* The remainder of the scope stack must be recording
352 FOUND_P decls, which we want to pop off. */
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;
360 while (++ix != length);
364 gcc_checking_assert (!LOOKUP_FOUND_P (decl));
365 LOOKUP_SEEN_P (decl) = true;
368 /* Remark the outer partial lookup. */
369 if (previous->deduping)
370 lookup_mark (previous->value, true);
373 shared_scopes = scopes;
377 name_lookup::mark_seen (tree scope)
379 gcc_checking_assert (!seen_p (scope));
380 LOOKUP_SEEN_P (scope) = true;
381 vec_safe_push (scopes, scope);
385 name_lookup::find_and_mark (tree scope)
387 bool result = LOOKUP_FOUND_P (scope);
390 LOOKUP_FOUND_P (scope) = true;
391 if (!LOOKUP_SEEN_P (scope))
392 vec_safe_push (scopes, scope);
398 /* THING and CURRENT are ambiguous, concatenate them. */
401 name_lookup::ambiguous (tree thing, tree current)
403 if (TREE_CODE (current) != TREE_LIST)
405 current = build_tree_list (NULL_TREE, current);
406 TREE_TYPE (current) = error_mark_node;
408 current = tree_cons (NULL_TREE, thing, current);
409 TREE_TYPE (current) = error_mark_node;
414 /* FNS is a new overload set to add to the exising set. */
417 name_lookup::add_overload (tree fns)
419 if (!deduping && TREE_CODE (fns) == OVERLOAD)
422 if (flags & LOOKUP_HIDDEN)
423 probe = ovl_skip_hidden (probe);
424 if (probe && TREE_CODE (probe) == OVERLOAD && OVL_USING_P (probe))
426 /* We're about to add something found by a using
427 declaration, so need to engage deduping mode. */
428 lookup_mark (value, true);
433 value = lookup_maybe_add (fns, value, deduping);
436 /* Add a NEW_VAL, a found value binding into the current value binding. */
439 name_lookup::add_value (tree new_val)
441 if (OVL_P (new_val) && (!value || OVL_P (value)))
442 add_overload (new_val);
445 else if (value == new_val)
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
456 value = ORIGINAL_NAMESPACE (value);
461 /* Disengage deduping mode. */
462 lookup_mark (value, false);
465 value = ambiguous (new_val, value);
469 /* Add a NEW_TYPE, a found type binding into the current type binding. */
472 name_lookup::add_type (tree 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);
481 /* Process a found binding containing NEW_VAL and NEW_TYPE. Returns
482 true if we actually found something noteworthy. */
485 name_lookup::process_binding (tree new_val, tree new_type)
487 /* Did we really see a 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;
495 if (new_val && !(flags & LOOKUP_HIDDEN))
496 new_val = ovl_skip_hidden (new_val);
498 /* Do we really see a value? */
500 switch (TREE_CODE (new_val))
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)))
510 if (LOOKUP_NAMESPACES_ONLY (flags)
511 || (new_type && (flags & LOOKUP_PREFER_TYPES)))
515 if (LOOKUP_TYPES_ONLY (flags))
519 if (LOOKUP_QUALIFIERS_ONLY (flags))
526 new_type = NULL_TREE;
529 /* Merge into the lookup */
535 return new_val != NULL_TREE;
538 /* Look in exactly namespace SCOPE. */
541 name_lookup::search_namespace_only (tree scope)
545 if (tree *binding = find_namespace_slot (scope, name))
546 found |= process_binding (MAYBE_STAT_DECL (*binding),
547 MAYBE_STAT_TYPE (*binding));
552 /* Conditionally look in namespace SCOPE and inline children. */
555 name_lookup::search_namespace (tree scope)
557 if (see_and_mark (scope))
558 /* We've visited this scope before. Return what we found then. */
559 return found_p (scope);
561 /* Look in exactly namespace. */
562 bool found = search_namespace_only (scope);
564 /* Recursively look in its inline children. */
565 if (vec<tree, va_gc> *inlinees = DECL_NAMESPACE_INLINEES (scope))
566 for (unsigned ix = inlinees->length (); ix--;)
567 found |= search_namespace ((*inlinees)[ix]);
575 /* Recursively follow using directives of SCOPE & its inline children.
576 Such following is essentially a flood-fill algorithm. */
579 name_lookup::search_usings (tree scope)
581 /* We do not check seen_p here, as that was already set during the
582 namespace_only walk. */
587 if (vec<tree, va_gc> *usings = DECL_NAMESPACE_USING (scope))
588 for (unsigned ix = usings->length (); ix--;)
589 found |= search_qualified ((*usings)[ix], true);
591 /* Look in its inline children. */
592 if (vec<tree, va_gc> *inlinees = DECL_NAMESPACE_INLINEES (scope))
593 for (unsigned ix = inlinees->length (); ix--;)
594 found |= search_usings ((*inlinees)[ix]);
602 /* Qualified namespace lookup in SCOPE.
603 1) Look in SCOPE (+inlines). If found, we're done.
604 2) Otherwise, if USINGS is true,
605 recurse for every using directive of SCOPE (+inlines).
607 Trickiness is (a) loops and (b) multiple paths to same namespace.
608 In both cases we want to not repeat any lookups, and know whether
609 to stop the caller's step #2. Do this via the FOUND_P marker. */
612 name_lookup::search_qualified (tree scope, bool usings)
617 found = found_p (scope);
620 found = search_namespace (scope);
621 if (!found && usings)
622 found = search_usings (scope);
628 /* Add SCOPE to the unqualified search queue, recursively add its
629 inlines and those via using directives. */
631 name_lookup::using_queue *
632 name_lookup::queue_namespace (using_queue *queue, int depth, tree scope)
634 if (see_and_mark (scope))
639 while (SCOPE_DEPTH (common) > depth)
640 common = CP_DECL_CONTEXT (common);
641 vec_safe_push (queue, using_pair (common, scope));
643 /* Queue its inline children. */
644 if (vec<tree, va_gc> *inlinees = DECL_NAMESPACE_INLINEES (scope))
645 for (unsigned ix = inlinees->length (); ix--;)
646 queue = queue_namespace (queue, depth, (*inlinees)[ix]);
648 /* Queue its using targets. */
649 queue = queue_usings (queue, depth, DECL_NAMESPACE_USING (scope));
654 /* Add the namespaces in USINGS to the unqualified search queue. */
656 name_lookup::using_queue *
657 name_lookup::do_queue_usings (using_queue *queue, int depth,
658 vec<tree, va_gc> *usings)
660 for (unsigned ix = usings->length (); ix--;)
661 queue = queue_namespace (queue, depth, (*usings)[ix]);
666 /* Unqualified namespace lookup in SCOPE.
667 1) add scope+inlins to worklist.
668 2) recursively add target of every using directive
669 3) for each worklist item where SCOPE is common ancestor, search it
670 4) if nothing find, scope=parent, goto 1. */
673 name_lookup::search_unqualified (tree scope, cp_binding_level *level)
675 /* Make static to avoid continual reallocation. We're not
677 static using_queue *queue = NULL;
679 int length = vec_safe_length (queue);
681 /* Queue local using-directives. */
682 for (; level->kind != sk_namespace; level = level->level_chain)
683 queue = queue_usings (queue, SCOPE_DEPTH (scope), level->using_directives);
685 for (; !found; scope = CP_DECL_CONTEXT (scope))
687 gcc_assert (!DECL_NAMESPACE_ALIAS (scope));
688 int depth = SCOPE_DEPTH (scope);
690 /* Queue namespaces reachable from SCOPE. */
691 queue = queue_namespace (queue, depth, scope);
693 /* Search every queued namespace where SCOPE is the common
694 ancestor. Adjust the others. */
695 unsigned ix = length;
698 using_pair &pair = (*queue)[ix];
699 while (pair.first == scope)
701 found |= search_namespace_only (pair.second);
702 pair = queue->pop ();
703 if (ix == queue->length ())
706 /* The depth is the same as SCOPE, find the parent scope. */
707 if (SCOPE_DEPTH (pair.first) == depth)
708 pair.first = CP_DECL_CONTEXT (pair.first);
711 while (ix < queue->length ());
713 if (scope == global_namespace)
716 /* If looking for hidden names, we only look in the innermost
717 namespace scope. [namespace.memdef]/3 If a friend
718 declaration in a non-local class first declares a class,
719 function, class template or function template the friend is a
720 member of the innermost enclosing namespace. See also
721 [basic.lookup.unqual]/7 */
722 if (flags & LOOKUP_HIDDEN)
726 vec_safe_truncate (queue, length);
731 /* FNS is a value binding. If it is a (set of overloaded) functions,
732 add them into the current value. */
735 name_lookup::add_fns (tree fns)
739 else if (TREE_CODE (fns) == OVERLOAD)
741 if (TREE_TYPE (fns) != unknown_type_node)
742 fns = OVL_FUNCTION (fns);
744 else if (!DECL_DECLARES_FUNCTION_P (fns))
750 /* Add functions of a namespace to the lookup structure. */
753 name_lookup::adl_namespace_only (tree scope)
757 /* Look down into inline namespaces. */
758 if (vec<tree, va_gc> *inlinees = DECL_NAMESPACE_INLINEES (scope))
759 for (unsigned ix = inlinees->length (); ix--;)
760 adl_namespace_only ((*inlinees)[ix]);
762 if (tree fns = find_namespace_value (scope, name))
763 add_fns (ovl_skip_hidden (fns));
766 /* Find the containing non-inlined namespace, add it and all its
770 name_lookup::adl_namespace (tree scope)
775 /* Find the containing non-inline namespace. */
776 while (DECL_NAMESPACE_INLINE_P (scope))
777 scope = CP_DECL_CONTEXT (scope);
779 adl_namespace_only (scope);
782 /* Adds the class and its friends to the lookup structure. */
785 name_lookup::adl_class_only (tree type)
787 /* Backend-built structures, such as __builtin_va_list, aren't
788 affected by all this. */
789 if (!CLASS_TYPE_P (type))
792 type = TYPE_MAIN_VARIANT (type);
794 if (see_and_mark (type))
797 tree context = decl_namespace_context (type);
798 adl_namespace (context);
800 complete_type (type);
803 for (tree list = DECL_FRIENDLIST (TYPE_MAIN_DECL (type)); list;
804 list = TREE_CHAIN (list))
805 if (name == FRIEND_NAME (list))
806 for (tree friends = FRIEND_DECLS (list); friends;
807 friends = TREE_CHAIN (friends))
809 tree fn = TREE_VALUE (friends);
811 /* Only interested in global functions with potentially hidden
812 (i.e. unqualified) declarations. */
813 if (CP_DECL_CONTEXT (fn) != context)
816 /* Only interested in anticipated friends. (Non-anticipated
817 ones will have been inserted during the namespace
819 if (!DECL_ANTICIPATED (fn))
822 /* Template specializations are never found by name lookup.
823 (Templates themselves can be found, but not template
825 if (TREE_CODE (fn) == FUNCTION_DECL && DECL_USE_TEMPLATE (fn))
832 /* Adds the class and its bases to the lookup structure.
833 Returns true on error. */
836 name_lookup::adl_bases (tree type)
838 adl_class_only (type);
840 /* Process baseclasses. */
841 if (tree binfo = TYPE_BINFO (type))
846 for (i = 0; BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
847 adl_bases (BINFO_TYPE (base_binfo));
851 /* Adds everything associated with a class argument type to the lookup
852 structure. Returns true on error.
854 If T is a class type (including unions), its associated classes are: the
855 class itself; the class of which it is a member, if any; and its direct
856 and indirect base classes. Its associated namespaces are the namespaces
857 of which its associated classes are members. Furthermore, if T is a
858 class template specialization, its associated namespaces and classes
859 also include: the namespaces and classes associated with the types of
860 the template arguments provided for template type parameters (excluding
861 template template parameters); the namespaces of which any template
862 template arguments are members; and the classes of which any member
863 templates used as template template arguments are members. [ Note:
864 non-type template arguments do not contribute to the set of associated
865 namespaces. --end note] */
868 name_lookup::adl_class (tree type)
870 /* Backend build structures, such as __builtin_va_list, aren't
871 affected by all this. */
872 if (!CLASS_TYPE_P (type))
875 type = TYPE_MAIN_VARIANT (type);
876 /* We don't set found here because we have to have set seen first,
877 which is done in the adl_bases walk. */
884 if (TYPE_CLASS_SCOPE_P (type))
885 adl_class_only (TYPE_CONTEXT (type));
887 /* Process template arguments. */
888 if (CLASSTYPE_TEMPLATE_INFO (type)
889 && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (type)))
891 tree list = INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (type));
892 for (int i = 0; i < TREE_VEC_LENGTH (list); ++i)
893 adl_template_arg (TREE_VEC_ELT (list, i));
898 name_lookup::adl_expr (tree expr)
903 gcc_assert (!TYPE_P (expr));
905 if (TREE_TYPE (expr) != unknown_type_node)
907 adl_type (TREE_TYPE (expr));
911 if (TREE_CODE (expr) == ADDR_EXPR)
912 expr = TREE_OPERAND (expr, 0);
913 if (TREE_CODE (expr) == COMPONENT_REF
914 || TREE_CODE (expr) == OFFSET_REF)
915 expr = TREE_OPERAND (expr, 1);
916 expr = MAYBE_BASELINK_FUNCTIONS (expr);
919 for (lkp_iterator iter (expr); iter; ++iter)
920 adl_type (TREE_TYPE (*iter));
921 else if (TREE_CODE (expr) == TEMPLATE_ID_EXPR)
923 /* The working paper doesn't currently say how to handle
924 template-id arguments. The sensible thing would seem to be
925 to handle the list of template candidates like a normal
926 overload set, and handle the template arguments like we do
927 for class template specializations. */
929 /* First the templates. */
930 adl_expr (TREE_OPERAND (expr, 0));
932 /* Now the arguments. */
933 if (tree args = TREE_OPERAND (expr, 1))
934 for (int ix = TREE_VEC_LENGTH (args); ix--;)
935 adl_template_arg (TREE_VEC_ELT (args, ix));
940 name_lookup::adl_type (tree type)
945 if (TYPE_PTRDATAMEM_P (type))
947 /* Pointer to member: associate class type and value type. */
948 adl_type (TYPE_PTRMEM_CLASS_TYPE (type));
949 adl_type (TYPE_PTRMEM_POINTED_TO_TYPE (type));
953 switch (TREE_CODE (type))
956 if (TYPE_PTRMEMFUNC_P (type))
958 adl_type (TYPE_PTRMEMFUNC_FN_TYPE (type));
967 /* The basetype is referenced in the first arg type, so just
970 /* Associate the parameter types. */
971 for (tree args = TYPE_ARG_TYPES (type); args; args = TREE_CHAIN (args))
972 adl_type (TREE_VALUE (args));
978 adl_type (TREE_TYPE (type));
982 if (TYPE_CLASS_SCOPE_P (type))
983 adl_class_only (TYPE_CONTEXT (type));
984 adl_namespace (decl_namespace_context (type));
988 gcc_assert (type == unknown_type_node
989 || type == init_list_type_node);
992 case TYPE_PACK_EXPANSION:
993 adl_type (PACK_EXPANSION_PATTERN (type));
1001 /* Adds everything associated with a template argument to the lookup
1005 name_lookup::adl_template_arg (tree arg)
1007 /* [basic.lookup.koenig]
1009 If T is a template-id, its associated namespaces and classes are
1010 ... the namespaces and classes associated with the types of the
1011 template arguments provided for template type parameters
1012 (excluding template template parameters); the namespaces in which
1013 any template template arguments are defined; and the classes in
1014 which any member templates used as template template arguments
1015 are defined. [Note: non-type template arguments do not
1016 contribute to the set of associated namespaces. ] */
1018 /* Consider first template template arguments. */
1019 if (TREE_CODE (arg) == TEMPLATE_TEMPLATE_PARM
1020 || TREE_CODE (arg) == UNBOUND_CLASS_TEMPLATE)
1022 else if (TREE_CODE (arg) == TEMPLATE_DECL)
1024 tree ctx = CP_DECL_CONTEXT (arg);
1026 /* It's not a member template. */
1027 if (TREE_CODE (ctx) == NAMESPACE_DECL)
1028 adl_namespace (ctx);
1029 /* Otherwise, it must be member template. */
1031 adl_class_only (ctx);
1033 /* It's an argument pack; handle it recursively. */
1034 else if (ARGUMENT_PACK_P (arg))
1036 tree args = ARGUMENT_PACK_ARGS (arg);
1037 int i, len = TREE_VEC_LENGTH (args);
1038 for (i = 0; i < len; ++i)
1039 adl_template_arg (TREE_VEC_ELT (args, i));
1041 /* It's not a template template argument, but it is a type template
1043 else if (TYPE_P (arg))
1047 /* Perform ADL lookup. FNS is the existing lookup result and ARGS are
1048 the call arguments. */
1051 name_lookup::search_adl (tree fns, vec<tree, va_gc> *args)
1056 lookup_mark (fns, true);
1063 FOR_EACH_VEC_ELT_REVERSE (*args, ix, arg)
1064 /* OMP reduction operators put an ADL-significant type as the
1076 static bool qualified_namespace_lookup (tree, name_lookup *);
1077 static void consider_binding_level (tree name,
1078 best_match <tree, const char *> &bm,
1079 cp_binding_level *lvl,
1080 bool look_within_fields,
1081 enum lookup_name_fuzzy_kind kind);
1082 static void diagnose_name_conflict (tree, tree);
1084 /* ADL lookup of NAME. FNS is the result of regular lookup, and we
1085 don't add duplicates to it. ARGS is the vector of call
1086 arguments (which will not be empty). */
1089 lookup_arg_dependent (tree name, tree fns, vec<tree, va_gc> *args)
1091 bool subtime = timevar_cond_start (TV_NAME_LOOKUP);
1092 name_lookup lookup (name);
1093 fns = lookup.search_adl (fns, args);
1094 timevar_cond_stop (TV_NAME_LOOKUP, subtime);
1098 /* FNS is an overload set of conversion functions. Return the
1099 overloads converting to TYPE. */
1102 extract_conversion_operator (tree fns, tree type)
1104 tree convs = NULL_TREE;
1105 tree tpls = NULL_TREE;
1107 for (ovl_iterator iter (fns); iter; ++iter)
1109 if (same_type_p (DECL_CONV_FN_TYPE (*iter), type))
1110 convs = lookup_add (*iter, convs);
1112 if (TREE_CODE (*iter) == TEMPLATE_DECL)
1113 tpls = lookup_add (*iter, tpls);
1122 /* Binary search of (ordered) MEMBER_VEC for NAME. */
1125 member_vec_binary_search (vec<tree, va_gc> *member_vec, tree name)
1127 for (unsigned lo = 0, hi = member_vec->length (); lo < hi;)
1129 unsigned mid = (lo + hi) / 2;
1130 tree binding = (*member_vec)[mid];
1131 tree binding_name = OVL_NAME (binding);
1133 if (binding_name > name)
1135 else if (binding_name < name)
1144 /* Linear search of (unordered) MEMBER_VEC for NAME. */
1147 member_vec_linear_search (vec<tree, va_gc> *member_vec, tree name)
1149 for (int ix = member_vec->length (); ix--;)
1150 if (tree binding = (*member_vec)[ix])
1151 if (OVL_NAME (binding) == name)
1157 /* Linear search of (partially ordered) fields of KLASS for NAME. */
1160 fields_linear_search (tree klass, tree name, bool want_type)
1162 for (tree fields = TYPE_FIELDS (klass); fields; fields = DECL_CHAIN (fields))
1166 if (TREE_CODE (decl) == FIELD_DECL
1167 && ANON_AGGR_TYPE_P (TREE_TYPE (decl)))
1169 if (tree temp = search_anon_aggr (TREE_TYPE (decl), name, want_type))
1173 if (DECL_NAME (decl) != name)
1176 if (TREE_CODE (decl) == USING_DECL)
1178 decl = strip_using_decl (decl);
1179 if (is_overloaded_fn (decl))
1183 if (DECL_DECLARES_FUNCTION_P (decl))
1184 /* Functions are found separately. */
1187 if (!want_type || DECL_DECLARES_TYPE_P (decl))
1194 /* Look for NAME member inside of anonymous aggregate ANON. Although
1195 such things should only contain FIELD_DECLs, we check that too
1196 late, and would give very confusing errors if we weren't
1200 search_anon_aggr (tree anon, tree name, bool want_type)
1202 gcc_assert (COMPLETE_TYPE_P (anon));
1203 tree ret = get_class_binding_direct (anon, name, want_type);
1207 /* Look for NAME as an immediate member of KLASS (including
1208 anon-members or unscoped enum member). TYPE_OR_FNS is zero for
1209 regular search. >0 to get a type binding (if there is one) and <0
1210 if you want (just) the member function binding.
1212 Use this if you do not want lazy member creation. */
1215 get_class_binding_direct (tree klass, tree name, int type_or_fns)
1217 gcc_checking_assert (RECORD_OR_UNION_TYPE_P (klass));
1219 /* Conversion operators can only be found by the marker conversion
1221 bool conv_op = IDENTIFIER_CONV_OP_P (name);
1222 tree lookup = conv_op ? conv_op_identifier : name;
1223 tree val = NULL_TREE;
1224 vec<tree, va_gc> *member_vec = CLASSTYPE_MEMBER_VEC (klass);
1226 if (COMPLETE_TYPE_P (klass) && member_vec)
1228 val = member_vec_binary_search (member_vec, lookup);
1231 else if (type_or_fns > 0)
1233 if (STAT_HACK_P (val))
1234 val = STAT_TYPE (val);
1235 else if (!DECL_DECLARES_TYPE_P (val))
1238 else if (STAT_HACK_P (val))
1239 val = STAT_DECL (val);
1241 if (val && TREE_CODE (val) == OVERLOAD
1242 && TREE_CODE (OVL_FUNCTION (val)) == USING_DECL)
1244 /* An overload with a dependent USING_DECL. Does the caller
1245 want the USING_DECL or the functions? */
1246 if (type_or_fns < 0)
1247 val = OVL_CHAIN (val);
1249 val = OVL_FUNCTION (val);
1254 if (member_vec && type_or_fns <= 0)
1255 val = member_vec_linear_search (member_vec, lookup);
1257 if (type_or_fns < 0)
1258 /* Don't bother looking for field. We don't want it. */;
1259 else if (!val || (TREE_CODE (val) == OVERLOAD && OVL_USING_P (val)))
1260 /* Dependent using declarations are a 'field', make sure we
1261 return that even if we saw an overload already. */
1262 if (tree field_val = fields_linear_search (klass, lookup,
1264 if (!val || TREE_CODE (field_val) == USING_DECL)
1268 /* Extract the conversion operators asked for, unless the general
1269 conversion operator was requested. */
1272 gcc_checking_assert (OVL_FUNCTION (val) == conv_op_marker);
1273 val = OVL_CHAIN (val);
1274 if (tree type = TREE_TYPE (name))
1275 val = extract_conversion_operator (val, type);
1281 /* Look for NAME's binding in exactly KLASS. See
1282 get_class_binding_direct for argument description. Does lazy
1283 special function creation as necessary. */
1286 get_class_binding (tree klass, tree name, int type_or_fns)
1288 klass = complete_type (klass);
1290 if (COMPLETE_TYPE_P (klass))
1292 /* Lazily declare functions, if we're going to search these. */
1293 if (IDENTIFIER_CTOR_P (name))
1295 if (CLASSTYPE_LAZY_DEFAULT_CTOR (klass))
1296 lazily_declare_fn (sfk_constructor, klass);
1297 if (CLASSTYPE_LAZY_COPY_CTOR (klass))
1298 lazily_declare_fn (sfk_copy_constructor, klass);
1299 if (CLASSTYPE_LAZY_MOVE_CTOR (klass))
1300 lazily_declare_fn (sfk_move_constructor, klass);
1302 else if (IDENTIFIER_DTOR_P (name))
1304 if (CLASSTYPE_LAZY_DESTRUCTOR (klass))
1305 lazily_declare_fn (sfk_destructor, klass);
1307 else if (name == assign_op_identifier)
1309 if (CLASSTYPE_LAZY_COPY_ASSIGN (klass))
1310 lazily_declare_fn (sfk_copy_assignment, klass);
1311 if (CLASSTYPE_LAZY_MOVE_ASSIGN (klass))
1312 lazily_declare_fn (sfk_move_assignment, klass);
1316 return get_class_binding_direct (klass, name, type_or_fns);
1319 /* Find the slot containing overloads called 'NAME'. If there is no
1320 such slot and the class is complete, create an empty one, at the
1321 correct point in the sorted member vector. Otherwise return NULL.
1322 Deals with conv_op marker handling. */
1325 find_member_slot (tree klass, tree name)
1327 bool complete_p = COMPLETE_TYPE_P (klass);
1329 vec<tree, va_gc> *member_vec = CLASSTYPE_MEMBER_VEC (klass);
1332 vec_alloc (member_vec, 8);
1333 CLASSTYPE_MEMBER_VEC (klass) = member_vec;
1336 /* If the class is complete but had no member_vec, we need
1337 to add the TYPE_FIELDS into it. We're also most likely
1338 to be adding ctors & dtors, so ask for 6 spare slots (the
1339 abstract cdtors and their clones). */
1340 set_class_bindings (klass, 6);
1341 member_vec = CLASSTYPE_MEMBER_VEC (klass);
1345 if (IDENTIFIER_CONV_OP_P (name))
1346 name = conv_op_identifier;
1348 unsigned ix, length = member_vec->length ();
1349 for (ix = 0; ix < length; ix++)
1351 tree *slot = &(*member_vec)[ix];
1352 tree fn_name = OVL_NAME (*slot);
1354 if (fn_name == name)
1356 /* If we found an existing slot, it must be a function set.
1357 Even with insertion after completion, because those only
1358 happen with artificial fns that have unspellable names.
1359 This means we do not have to deal with the stat hack
1361 gcc_checking_assert (OVL_P (*slot));
1362 if (name == conv_op_identifier)
1364 gcc_checking_assert (OVL_FUNCTION (*slot) == conv_op_marker);
1365 /* Skip the conv-op marker. */
1366 slot = &OVL_CHAIN (*slot);
1371 if (complete_p && fn_name > name)
1375 /* No slot found, add one if the class is complete. */
1378 /* Do exact allocation, as we don't expect to add many. */
1379 gcc_assert (name != conv_op_identifier);
1380 vec_safe_reserve_exact (member_vec, 1);
1381 CLASSTYPE_MEMBER_VEC (klass) = member_vec;
1382 member_vec->quick_insert (ix, NULL_TREE);
1383 return &(*member_vec)[ix];
1389 /* KLASS is an incomplete class to which we're adding a method NAME.
1390 Add a slot and deal with conv_op marker handling. */
1393 add_member_slot (tree klass, tree name)
1395 gcc_assert (!COMPLETE_TYPE_P (klass));
1397 vec<tree, va_gc> *member_vec = CLASSTYPE_MEMBER_VEC (klass);
1398 vec_safe_push (member_vec, NULL_TREE);
1399 CLASSTYPE_MEMBER_VEC (klass) = member_vec;
1401 tree *slot = &member_vec->last ();
1402 if (IDENTIFIER_CONV_OP_P (name))
1404 /* Install the marker prefix. */
1405 *slot = ovl_make (conv_op_marker, NULL_TREE);
1406 slot = &OVL_CHAIN (*slot);
1412 /* Comparison function to compare two MEMBER_VEC entries by name.
1413 Because we can have duplicates during insertion of TYPE_FIELDS, we
1414 do extra checking so deduping doesn't have to deal with so many
1418 member_name_cmp (const void *a_p, const void *b_p)
1420 tree a = *(const tree *)a_p;
1421 tree b = *(const tree *)b_p;
1422 tree name_a = DECL_NAME (TREE_CODE (a) == OVERLOAD ? OVL_FUNCTION (a) : a);
1423 tree name_b = DECL_NAME (TREE_CODE (b) == OVERLOAD ? OVL_FUNCTION (b) : b);
1425 gcc_checking_assert (name_a && name_b);
1426 if (name_a != name_b)
1427 return name_a < name_b ? -1 : +1;
1429 if (name_a == conv_op_identifier)
1431 /* Strip the conv-op markers. */
1432 gcc_checking_assert (OVL_FUNCTION (a) == conv_op_marker
1433 && OVL_FUNCTION (b) == conv_op_marker);
1438 if (TREE_CODE (a) == OVERLOAD)
1439 a = OVL_FUNCTION (a);
1440 if (TREE_CODE (b) == OVERLOAD)
1441 b = OVL_FUNCTION (b);
1443 /* We're in STAT_HACK or USING_DECL territory (or possibly error-land). */
1444 if (TREE_CODE (a) != TREE_CODE (b))
1446 /* If one of them is a TYPE_DECL, it loses. */
1447 if (TREE_CODE (a) == TYPE_DECL)
1449 else if (TREE_CODE (b) == TYPE_DECL)
1452 /* If one of them is a USING_DECL, it loses. */
1453 if (TREE_CODE (a) == USING_DECL)
1455 else if (TREE_CODE (b) == USING_DECL)
1458 /* There are no other cases with different kinds of decls, as
1459 duplicate detection should have kicked in earlier. However,
1460 some erroneous cases get though. */
1461 gcc_assert (errorcount);
1464 /* Using source location would be the best thing here, but we can
1465 get identically-located decls in the following circumstances:
1467 1) duplicate artificial type-decls for the same type.
1469 2) pack expansions of using-decls.
1471 We should not be doing #1, but in either case it doesn't matter
1472 how we order these. Use UID as a proxy for source ordering, so
1473 that identically-located decls still have a well-defined stable
1475 if (DECL_UID (a) != DECL_UID (b))
1476 return DECL_UID (a) < DECL_UID (b) ? -1 : +1;
1477 gcc_assert (a == b);
1482 gt_pointer_operator new_value;
1486 /* This routine compares two fields like member_name_cmp but using the
1487 pointer operator in resort_field_decl_data. We don't have to deal
1488 with duplicates here. */
1491 resort_member_name_cmp (const void *a_p, const void *b_p)
1493 tree a = *(const tree *)a_p;
1494 tree b = *(const tree *)b_p;
1495 tree name_a = OVL_NAME (a);
1496 tree name_b = OVL_NAME (b);
1498 resort_data.new_value (&name_a, resort_data.cookie);
1499 resort_data.new_value (&name_b, resort_data.cookie);
1501 gcc_checking_assert (name_a != name_b);
1503 return name_a < name_b ? -1 : +1;
1506 /* Resort CLASSTYPE_MEMBER_VEC because pointers have been reordered. */
1509 resort_type_member_vec (void *obj, void */*orig_obj*/,
1510 gt_pointer_operator new_value, void* cookie)
1512 if (vec<tree, va_gc> *member_vec = (vec<tree, va_gc> *) obj)
1514 resort_data.new_value = new_value;
1515 resort_data.cookie = cookie;
1516 member_vec->qsort (resort_member_name_cmp);
1520 /* Recursively count the number of fields in KLASS, including anonymous
1524 count_class_fields (tree klass)
1526 unsigned n_fields = 0;
1528 for (tree fields = TYPE_FIELDS (klass); fields; fields = DECL_CHAIN (fields))
1529 if (DECL_DECLARES_FUNCTION_P (fields))
1530 /* Functions are dealt with separately. */;
1531 else if (TREE_CODE (fields) == FIELD_DECL
1532 && ANON_AGGR_TYPE_P (TREE_TYPE (fields)))
1533 n_fields += count_class_fields (TREE_TYPE (fields));
1534 else if (DECL_NAME (fields))
1540 /* Append all the nonfunction members fields of KLASS to MEMBER_VEC.
1541 Recurse for anonymous members. MEMBER_VEC must have space. */
1544 member_vec_append_class_fields (vec<tree, va_gc> *member_vec, tree klass)
1546 for (tree fields = TYPE_FIELDS (klass); fields; fields = DECL_CHAIN (fields))
1547 if (DECL_DECLARES_FUNCTION_P (fields))
1548 /* Functions are handled separately. */;
1549 else if (TREE_CODE (fields) == FIELD_DECL
1550 && ANON_AGGR_TYPE_P (TREE_TYPE (fields)))
1551 member_vec_append_class_fields (member_vec, TREE_TYPE (fields));
1552 else if (DECL_NAME (fields))
1554 tree field = fields;
1555 /* Mark a conv-op USING_DECL with the conv-op-marker. */
1556 if (TREE_CODE (field) == USING_DECL
1557 && IDENTIFIER_CONV_OP_P (DECL_NAME (field)))
1558 field = ovl_make (conv_op_marker, field);
1559 member_vec->quick_push (field);
1563 /* Append all of the enum values of ENUMTYPE to MEMBER_VEC.
1564 MEMBER_VEC must have space. */
1567 member_vec_append_enum_values (vec<tree, va_gc> *member_vec, tree enumtype)
1569 for (tree values = TYPE_VALUES (enumtype);
1570 values; values = TREE_CHAIN (values))
1571 member_vec->quick_push (TREE_VALUE (values));
1574 /* MEMBER_VEC has just had new DECLs added to it, but is sorted.
1575 DeDup adjacent DECLS of the same name. We already dealt with
1576 conflict resolution when adding the fields or methods themselves.
1577 There are three cases (which could all be combined):
1578 1) a TYPE_DECL and non TYPE_DECL. Deploy STAT_HACK as appropriate.
1579 2) a USING_DECL and an overload. If the USING_DECL is dependent,
1580 it wins. Otherwise the OVERLOAD does.
1581 3) two USING_DECLS. ...
1583 member_name_cmp will have ordered duplicates as
1584 <fns><using><type> */
1587 member_vec_dedup (vec<tree, va_gc> *member_vec)
1589 unsigned len = member_vec->length ();
1595 tree name = OVL_NAME ((*member_vec)[0]);
1596 for (unsigned jx, ix = 0; ix < len; ix = jx)
1598 tree current = NULL_TREE;
1599 tree to_type = NULL_TREE;
1600 tree to_using = NULL_TREE;
1601 tree marker = NULL_TREE;
1603 for (jx = ix; jx < len; jx++)
1605 tree next = (*member_vec)[jx];
1608 tree next_name = OVL_NAME (next);
1609 if (next_name != name)
1616 if (IDENTIFIER_CONV_OP_P (name))
1619 next = OVL_CHAIN (next);
1622 if (TREE_CODE (next) == USING_DECL)
1624 if (IDENTIFIER_CTOR_P (name))
1625 /* Dependent inherited ctor. */
1628 next = strip_using_decl (next);
1629 if (TREE_CODE (next) == USING_DECL)
1635 if (is_overloaded_fn (next))
1639 if (DECL_DECLARES_TYPE_P (next))
1654 current = ovl_make (to_using, current);
1662 current = stat_hack (current, to_type);
1669 OVL_CHAIN (marker) = current;
1672 (*member_vec)[store++] = current;
1676 while (store++ < len)
1680 /* Add the non-function members to CLASSTYPE_MEMBER_VEC. If there is
1681 no existing MEMBER_VEC and fewer than 8 fields, do nothing. We
1682 know there must be at least 1 field -- the self-reference
1683 TYPE_DECL, except for anon aggregates, which will have at least
1687 set_class_bindings (tree klass, unsigned extra)
1689 unsigned n_fields = count_class_fields (klass);
1690 vec<tree, va_gc> *member_vec = CLASSTYPE_MEMBER_VEC (klass);
1692 if (member_vec || n_fields >= 8)
1694 /* Append the new fields. */
1695 vec_safe_reserve_exact (member_vec, extra + n_fields);
1696 member_vec_append_class_fields (member_vec, klass);
1701 CLASSTYPE_MEMBER_VEC (klass) = member_vec;
1702 member_vec->qsort (member_name_cmp);
1703 member_vec_dedup (member_vec);
1707 /* Insert lately defined enum ENUMTYPE into KLASS for the sorted case. */
1710 insert_late_enum_def_bindings (tree klass, tree enumtype)
1713 vec<tree, va_gc> *member_vec = CLASSTYPE_MEMBER_VEC (klass);
1715 /* The enum bindings will already be on the TYPE_FIELDS, so don't
1716 count them twice. */
1718 n_fields = count_class_fields (klass);
1720 n_fields = list_length (TYPE_VALUES (enumtype));
1722 if (member_vec || n_fields >= 8)
1724 vec_safe_reserve_exact (member_vec, n_fields);
1725 if (CLASSTYPE_MEMBER_VEC (klass))
1726 member_vec_append_enum_values (member_vec, enumtype);
1728 member_vec_append_class_fields (member_vec, klass);
1729 CLASSTYPE_MEMBER_VEC (klass) = member_vec;
1730 member_vec->qsort (member_name_cmp);
1731 member_vec_dedup (member_vec);
1735 /* Compute the chain index of a binding_entry given the HASH value of its
1736 name and the total COUNT of chains. COUNT is assumed to be a power
1739 #define ENTRY_INDEX(HASH, COUNT) (((HASH) >> 3) & ((COUNT) - 1))
1741 /* A free list of "binding_entry"s awaiting for re-use. */
1743 static GTY((deletable)) binding_entry free_binding_entry = NULL;
1745 /* The binding oracle; see cp-tree.h. */
1747 cp_binding_oracle_function *cp_binding_oracle;
1749 /* If we have a binding oracle, ask it for all namespace-scoped
1750 definitions of NAME. */
1753 query_oracle (tree name)
1755 if (!cp_binding_oracle)
1758 /* LOOKED_UP holds the set of identifiers that we have already
1759 looked up with the oracle. */
1760 static hash_set<tree> looked_up;
1761 if (looked_up.add (name))
1764 cp_binding_oracle (CP_ORACLE_IDENTIFIER, name);
1767 /* Create a binding_entry object for (NAME, TYPE). */
1769 static inline binding_entry
1770 binding_entry_make (tree name, tree type)
1772 binding_entry entry;
1774 if (free_binding_entry)
1776 entry = free_binding_entry;
1777 free_binding_entry = entry->chain;
1780 entry = ggc_alloc<binding_entry_s> ();
1784 entry->chain = NULL;
1789 /* Put ENTRY back on the free list. */
1792 binding_entry_free (binding_entry entry)
1796 entry->chain = free_binding_entry;
1797 free_binding_entry = entry;
1801 /* The datatype used to implement the mapping from names to types at
1803 struct GTY(()) binding_table_s {
1804 /* Array of chains of "binding_entry"s */
1805 binding_entry * GTY((length ("%h.chain_count"))) chain;
1807 /* The number of chains in this table. This is the length of the
1808 member "chain" considered as an array. */
1811 /* Number of "binding_entry"s in this table. */
1815 /* Construct TABLE with an initial CHAIN_COUNT. */
1818 binding_table_construct (binding_table table, size_t chain_count)
1820 table->chain_count = chain_count;
1821 table->entry_count = 0;
1822 table->chain = ggc_cleared_vec_alloc<binding_entry> (table->chain_count);
1825 /* Make TABLE's entries ready for reuse. */
1828 binding_table_free (binding_table table)
1836 for (i = 0, count = table->chain_count; i < count; ++i)
1838 binding_entry temp = table->chain[i];
1839 while (temp != NULL)
1841 binding_entry entry = temp;
1842 temp = entry->chain;
1843 binding_entry_free (entry);
1845 table->chain[i] = NULL;
1847 table->entry_count = 0;
1851 /* Allocate a table with CHAIN_COUNT, assumed to be a power of two. */
1853 static inline binding_table
1854 binding_table_new (size_t chain_count)
1856 binding_table table = ggc_alloc<binding_table_s> ();
1857 table->chain = NULL;
1858 binding_table_construct (table, chain_count);
1862 /* Expand TABLE to twice its current chain_count. */
1865 binding_table_expand (binding_table table)
1867 const size_t old_chain_count = table->chain_count;
1868 const size_t old_entry_count = table->entry_count;
1869 const size_t new_chain_count = 2 * old_chain_count;
1870 binding_entry *old_chains = table->chain;
1873 binding_table_construct (table, new_chain_count);
1874 for (i = 0; i < old_chain_count; ++i)
1876 binding_entry entry = old_chains[i];
1877 for (; entry != NULL; entry = old_chains[i])
1879 const unsigned int hash = IDENTIFIER_HASH_VALUE (entry->name);
1880 const size_t j = ENTRY_INDEX (hash, new_chain_count);
1882 old_chains[i] = entry->chain;
1883 entry->chain = table->chain[j];
1884 table->chain[j] = entry;
1887 table->entry_count = old_entry_count;
1890 /* Insert a binding for NAME to TYPE into TABLE. */
1893 binding_table_insert (binding_table table, tree name, tree type)
1895 const unsigned int hash = IDENTIFIER_HASH_VALUE (name);
1896 const size_t i = ENTRY_INDEX (hash, table->chain_count);
1897 binding_entry entry = binding_entry_make (name, type);
1899 entry->chain = table->chain[i];
1900 table->chain[i] = entry;
1901 ++table->entry_count;
1903 if (3 * table->chain_count < 5 * table->entry_count)
1904 binding_table_expand (table);
1907 /* Return the binding_entry, if any, that maps NAME. */
1910 binding_table_find (binding_table table, tree name)
1912 const unsigned int hash = IDENTIFIER_HASH_VALUE (name);
1913 binding_entry entry = table->chain[ENTRY_INDEX (hash, table->chain_count)];
1915 while (entry != NULL && entry->name != name)
1916 entry = entry->chain;
1921 /* Apply PROC -- with DATA -- to all entries in TABLE. */
1924 binding_table_foreach (binding_table table, bt_foreach_proc proc, void *data)
1932 chain_count = table->chain_count;
1933 for (i = 0; i < chain_count; ++i)
1935 binding_entry entry = table->chain[i];
1936 for (; entry != NULL; entry = entry->chain)
1941 #ifndef ENABLE_SCOPE_CHECKING
1942 # define ENABLE_SCOPE_CHECKING 0
1944 # define ENABLE_SCOPE_CHECKING 1
1947 /* A free list of "cxx_binding"s, connected by their PREVIOUS. */
1949 static GTY((deletable)) cxx_binding *free_bindings;
1951 /* Initialize VALUE and TYPE field for BINDING, and set the PREVIOUS
1955 cxx_binding_init (cxx_binding *binding, tree value, tree type)
1957 binding->value = value;
1958 binding->type = type;
1959 binding->previous = NULL;
1962 /* (GC)-allocate a binding object with VALUE and TYPE member initialized. */
1964 static cxx_binding *
1965 cxx_binding_make (tree value, tree type)
1967 cxx_binding *binding;
1970 binding = free_bindings;
1971 free_bindings = binding->previous;
1974 binding = ggc_alloc<cxx_binding> ();
1976 cxx_binding_init (binding, value, type);
1981 /* Put BINDING back on the free list. */
1984 cxx_binding_free (cxx_binding *binding)
1986 binding->scope = NULL;
1987 binding->previous = free_bindings;
1988 free_bindings = binding;
1991 /* Create a new binding for NAME (with the indicated VALUE and TYPE
1992 bindings) in the class scope indicated by SCOPE. */
1994 static cxx_binding *
1995 new_class_binding (tree name, tree value, tree type, cp_binding_level *scope)
1997 cp_class_binding cb = {cxx_binding_make (value, type), name};
1998 cxx_binding *binding = cb.base;
1999 vec_safe_push (scope->class_shadowed, cb);
2000 binding->scope = scope;
2004 /* Make DECL the innermost binding for ID. The LEVEL is the binding
2005 level at which this declaration is being bound. */
2008 push_binding (tree id, tree decl, cp_binding_level* level)
2010 cxx_binding *binding;
2012 if (level != class_binding_level)
2014 binding = cxx_binding_make (decl, NULL_TREE);
2015 binding->scope = level;
2018 binding = new_class_binding (id, decl, /*type=*/NULL_TREE, level);
2020 /* Now, fill in the binding information. */
2021 binding->previous = IDENTIFIER_BINDING (id);
2022 INHERITED_VALUE_BINDING_P (binding) = 0;
2023 LOCAL_BINDING_P (binding) = (level != class_binding_level);
2025 /* And put it on the front of the list of bindings for ID. */
2026 IDENTIFIER_BINDING (id) = binding;
2029 /* Remove the binding for DECL which should be the innermost binding
2033 pop_local_binding (tree id, tree decl)
2035 cxx_binding *binding;
2037 if (id == NULL_TREE)
2038 /* It's easiest to write the loops that call this function without
2039 checking whether or not the entities involved have names. We
2040 get here for such an entity. */
2043 /* Get the innermost binding for ID. */
2044 binding = IDENTIFIER_BINDING (id);
2046 /* The name should be bound. */
2047 gcc_assert (binding != NULL);
2049 /* The DECL will be either the ordinary binding or the type
2050 binding for this identifier. Remove that binding. */
2051 if (binding->value == decl)
2052 binding->value = NULL_TREE;
2055 gcc_assert (binding->type == decl);
2056 binding->type = NULL_TREE;
2059 if (!binding->value && !binding->type)
2061 /* We're completely done with the innermost binding for this
2062 identifier. Unhook it from the list of bindings. */
2063 IDENTIFIER_BINDING (id) = binding->previous;
2065 /* Add it to the free list. */
2066 cxx_binding_free (binding);
2070 /* Remove the bindings for the decls of the current level and leave
2071 the current scope. */
2074 pop_bindings_and_leave_scope (void)
2076 for (tree t = get_local_decls (); t; t = DECL_CHAIN (t))
2078 tree decl = TREE_CODE (t) == TREE_LIST ? TREE_VALUE (t) : t;
2079 tree name = OVL_NAME (decl);
2081 pop_local_binding (name, decl);
2087 /* Strip non dependent using declarations. If DECL is dependent,
2088 surreptitiously create a typename_type and return it. */
2091 strip_using_decl (tree decl)
2093 if (decl == NULL_TREE)
2096 while (TREE_CODE (decl) == USING_DECL && !DECL_DEPENDENT_P (decl))
2097 decl = USING_DECL_DECLS (decl);
2099 if (TREE_CODE (decl) == USING_DECL && DECL_DEPENDENT_P (decl)
2100 && USING_DECL_TYPENAME_P (decl))
2102 /* We have found a type introduced by a using
2103 declaration at class scope that refers to a dependent
2106 using typename :: [opt] nested-name-specifier unqualified-id ;
2108 decl = make_typename_type (TREE_TYPE (decl),
2110 typename_type, tf_error);
2111 if (decl != error_mark_node)
2112 decl = TYPE_NAME (decl);
2118 /* Return true if OVL is an overload for an anticipated builtin. */
2121 anticipated_builtin_p (tree ovl)
2123 if (TREE_CODE (ovl) != OVERLOAD)
2126 if (!OVL_HIDDEN_P (ovl))
2129 tree fn = OVL_FUNCTION (ovl);
2130 gcc_checking_assert (DECL_ANTICIPATED (fn));
2132 if (DECL_HIDDEN_FRIEND_P (fn))
2138 /* BINDING records an existing declaration for a name in the current scope.
2139 But, DECL is another declaration for that same identifier in the
2140 same scope. This is the `struct stat' hack whereby a non-typedef
2141 class name or enum-name can be bound at the same level as some other
2145 A class name (9.1) or enumeration name (7.2) can be hidden by the
2146 name of an object, function, or enumerator declared in the same scope.
2147 If a class or enumeration name and an object, function, or enumerator
2148 are declared in the same scope (in any order) with the same name, the
2149 class or enumeration name is hidden wherever the object, function, or
2150 enumerator name is visible.
2152 It's the responsibility of the caller to check that
2153 inserting this name is valid here. Returns nonzero if the new binding
2157 supplement_binding_1 (cxx_binding *binding, tree decl)
2159 tree bval = binding->value;
2161 tree target_bval = strip_using_decl (bval);
2162 tree target_decl = strip_using_decl (decl);
2164 if (TREE_CODE (target_decl) == TYPE_DECL && DECL_ARTIFICIAL (target_decl)
2165 && target_decl != target_bval
2166 && (TREE_CODE (target_bval) != TYPE_DECL
2167 /* We allow pushing an enum multiple times in a class
2168 template in order to handle late matching of underlying
2169 type on an opaque-enum-declaration followed by an
2171 || (processing_template_decl
2172 && TREE_CODE (TREE_TYPE (target_decl)) == ENUMERAL_TYPE
2173 && TREE_CODE (TREE_TYPE (target_bval)) == ENUMERAL_TYPE
2174 && (dependent_type_p (ENUM_UNDERLYING_TYPE
2175 (TREE_TYPE (target_decl)))
2176 || dependent_type_p (ENUM_UNDERLYING_TYPE
2177 (TREE_TYPE (target_bval)))))))
2178 /* The new name is the type name. */
2179 binding->type = decl;
2180 else if (/* TARGET_BVAL is null when push_class_level_binding moves
2181 an inherited type-binding out of the way to make room
2182 for a new value binding. */
2184 /* TARGET_BVAL is error_mark_node when TARGET_DECL's name
2185 has been used in a non-class scope prior declaration.
2186 In that case, we should have already issued a
2187 diagnostic; for graceful error recovery purpose, pretend
2188 this was the intended declaration for that name. */
2189 || target_bval == error_mark_node
2190 /* If TARGET_BVAL is anticipated but has not yet been
2191 declared, pretend it is not there at all. */
2192 || anticipated_builtin_p (target_bval))
2193 binding->value = decl;
2194 else if (TREE_CODE (target_bval) == TYPE_DECL
2195 && DECL_ARTIFICIAL (target_bval)
2196 && target_decl != target_bval
2197 && (TREE_CODE (target_decl) != TYPE_DECL
2198 || same_type_p (TREE_TYPE (target_decl),
2199 TREE_TYPE (target_bval))))
2201 /* The old binding was a type name. It was placed in
2202 VALUE field because it was thought, at the point it was
2203 declared, to be the only entity with such a name. Move the
2204 type name into the type slot; it is now hidden by the new
2206 binding->type = bval;
2207 binding->value = decl;
2208 binding->value_is_inherited = false;
2210 else if (TREE_CODE (target_bval) == TYPE_DECL
2211 && TREE_CODE (target_decl) == TYPE_DECL
2212 && DECL_NAME (target_decl) == DECL_NAME (target_bval)
2213 && binding->scope->kind != sk_class
2214 && (same_type_p (TREE_TYPE (target_decl), TREE_TYPE (target_bval))
2215 /* If either type involves template parameters, we must
2216 wait until instantiation. */
2217 || uses_template_parms (TREE_TYPE (target_decl))
2218 || uses_template_parms (TREE_TYPE (target_bval))))
2219 /* We have two typedef-names, both naming the same type to have
2220 the same name. In general, this is OK because of:
2224 In a given scope, a typedef specifier can be used to redefine
2225 the name of any type declared in that scope to refer to the
2226 type to which it already refers.
2228 However, in class scopes, this rule does not apply due to the
2229 stricter language in [class.mem] prohibiting redeclarations of
2232 /* There can be two block-scope declarations of the same variable,
2233 so long as they are `extern' declarations. However, there cannot
2234 be two declarations of the same static data member:
2238 A member shall not be declared twice in the
2239 member-specification. */
2240 else if (VAR_P (target_decl)
2241 && VAR_P (target_bval)
2242 && DECL_EXTERNAL (target_decl) && DECL_EXTERNAL (target_bval)
2243 && !DECL_CLASS_SCOPE_P (target_decl))
2245 duplicate_decls (decl, binding->value, /*newdecl_is_friend=*/false);
2248 else if (TREE_CODE (decl) == NAMESPACE_DECL
2249 && TREE_CODE (bval) == NAMESPACE_DECL
2250 && DECL_NAMESPACE_ALIAS (decl)
2251 && DECL_NAMESPACE_ALIAS (bval)
2252 && ORIGINAL_NAMESPACE (bval) == ORIGINAL_NAMESPACE (decl))
2253 /* [namespace.alias]
2255 In a declarative region, a namespace-alias-definition can be
2256 used to redefine a namespace-alias declared in that declarative
2257 region to refer only to the namespace to which it already
2262 if (!error_operand_p (bval))
2263 diagnose_name_conflict (decl, bval);
2270 /* Diagnose a name conflict between DECL and BVAL. */
2273 diagnose_name_conflict (tree decl, tree bval)
2275 if (TREE_CODE (decl) == TREE_CODE (bval)
2276 && TREE_CODE (decl) != NAMESPACE_DECL
2277 && !DECL_DECLARES_FUNCTION_P (decl)
2278 && (TREE_CODE (decl) != TYPE_DECL
2279 || DECL_ARTIFICIAL (decl) == DECL_ARTIFICIAL (bval))
2280 && CP_DECL_CONTEXT (decl) == CP_DECL_CONTEXT (bval))
2281 error ("redeclaration of %q#D", decl);
2283 error ("%q#D conflicts with a previous declaration", decl);
2285 inform (location_of (bval), "previous declaration %q#D", bval);
2288 /* Wrapper for supplement_binding_1. */
2291 supplement_binding (cxx_binding *binding, tree decl)
2294 bool subtime = timevar_cond_start (TV_NAME_LOOKUP);
2295 ret = supplement_binding_1 (binding, decl);
2296 timevar_cond_stop (TV_NAME_LOOKUP, subtime);
2300 /* Replace BINDING's current value on its scope's name list with
2304 update_local_overload (cxx_binding *binding, tree newval)
2308 for (d = &binding->scope->names; ; d = &TREE_CHAIN (*d))
2309 if (*d == binding->value)
2311 /* Stitch new list node in. */
2312 *d = tree_cons (NULL_TREE, NULL_TREE, TREE_CHAIN (*d));
2315 else if (TREE_CODE (*d) == TREE_LIST && TREE_VALUE (*d) == binding->value)
2318 TREE_VALUE (*d) = newval;
2321 /* Compares the parameter-type-lists of ONE and TWO and
2322 returns false if they are different. If the DECLs are template
2323 functions, the return types and the template parameter lists are
2324 compared too (DR 565). */
2327 matching_fn_p (tree one, tree two)
2329 if (!compparms (TYPE_ARG_TYPES (TREE_TYPE (one)),
2330 TYPE_ARG_TYPES (TREE_TYPE (two))))
2333 if (TREE_CODE (one) == TEMPLATE_DECL
2334 && TREE_CODE (two) == TEMPLATE_DECL)
2336 /* Compare template parms. */
2337 if (!comp_template_parms (DECL_TEMPLATE_PARMS (one),
2338 DECL_TEMPLATE_PARMS (two)))
2341 /* And return type. */
2342 if (!same_type_p (TREE_TYPE (TREE_TYPE (one)),
2343 TREE_TYPE (TREE_TYPE (two))))
2350 /* Push DECL into nonclass LEVEL BINDING or SLOT. OLD is the current
2351 binding value (possibly with anticipated builtins stripped).
2352 Diagnose conflicts and return updated decl. */
2355 update_binding (cp_binding_level *level, cxx_binding *binding, tree *slot,
2356 tree old, tree decl, bool is_friend)
2359 tree old_type = slot ? MAYBE_STAT_TYPE (*slot) : binding->type;
2360 tree to_type = old_type;
2362 gcc_assert (level->kind == sk_namespace ? !binding
2363 : level->kind != sk_class && !slot);
2364 if (old == error_mark_node)
2367 if (TREE_CODE (decl) == TYPE_DECL && DECL_ARTIFICIAL (decl))
2369 tree other = to_type;
2371 if (old && TREE_CODE (old) == TYPE_DECL && DECL_ARTIFICIAL (old))
2374 /* Pushing an artificial typedef. See if this matches either
2375 the type slot or the old value slot. */
2378 else if (same_type_p (TREE_TYPE (other), TREE_TYPE (decl)))
2379 /* Two artificial decls to same type. Do nothing. */
2386 /* Slide decl into the type slot, keep old unaltered */
2393 if (old && TREE_CODE (old) == TYPE_DECL && DECL_ARTIFICIAL (old))
2395 /* Slide old into the type slot. */
2400 if (DECL_DECLARES_FUNCTION_P (decl))
2404 else if (OVL_P (old))
2406 for (ovl_iterator iter (old); iter; ++iter)
2410 if (iter.using_p () && matching_fn_p (fn, decl))
2412 /* If a function declaration in namespace scope or
2413 block scope has the same name and the same
2414 parameter-type- list (8.3.5) as a function
2415 introduced by a using-declaration, and the
2416 declarations do not declare the same function,
2417 the program is ill-formed. [namespace.udecl]/14 */
2418 if (tree match = duplicate_decls (decl, fn, is_friend))
2421 /* FIXME: To preserve existing error behavior, we
2422 still push the decl. This might change. */
2423 diagnose_name_conflict (decl, fn);
2430 if (to_type != old_type
2432 && MAYBE_CLASS_TYPE_P (TREE_TYPE (to_type))
2433 && !(DECL_IN_SYSTEM_HEADER (decl)
2434 && DECL_IN_SYSTEM_HEADER (to_type)))
2435 warning (OPT_Wshadow, "%q#D hides constructor for %q#D",
2438 to_val = ovl_insert (decl, old);
2442 else if (TREE_CODE (old) != TREE_CODE (decl))
2443 /* Different kinds of decls conflict. */
2445 else if (TREE_CODE (old) == TYPE_DECL)
2447 if (same_type_p (TREE_TYPE (old), TREE_TYPE (decl)))
2448 /* Two type decls to the same type. Do nothing. */
2453 else if (TREE_CODE (old) == NAMESPACE_DECL)
2455 /* Two maybe-aliased namespaces. If they're to the same target
2456 namespace, that's ok. */
2457 if (ORIGINAL_NAMESPACE (old) != ORIGINAL_NAMESPACE (decl))
2460 /* The new one must be an alias at this point. */
2461 gcc_assert (DECL_NAMESPACE_ALIAS (decl));
2464 else if (TREE_CODE (old) == VAR_DECL)
2466 /* There can be two block-scope declarations of the same
2467 variable, so long as they are `extern' declarations. */
2468 if (!DECL_EXTERNAL (old) || !DECL_EXTERNAL (decl))
2470 else if (tree match = duplicate_decls (decl, old, false))
2478 diagnose_name_conflict (decl, old);
2485 if (level->kind == sk_namespace || to_type == decl || to_val == decl)
2486 add_decl_to_level (level, decl);
2489 gcc_checking_assert (binding->value && OVL_P (binding->value));
2490 update_local_overload (binding, to_val);
2495 if (STAT_HACK_P (*slot))
2497 STAT_TYPE (*slot) = to_type;
2498 STAT_DECL (*slot) = to_val;
2501 *slot = stat_hack (to_val, to_type);
2507 binding->type = to_type;
2508 binding->value = to_val;
2515 /* Table of identifiers to extern C declarations (or LISTS thereof). */
2517 static GTY(()) hash_table<named_decl_hash> *extern_c_decls;
2519 /* DECL has C linkage. If we have an existing instance, make sure the
2520 new one is compatible. Make sure it has the same exception
2521 specification [7.5, 7.6]. Add DECL to the map. */
2524 check_extern_c_conflict (tree decl)
2526 /* Ignore artificial or system header decls. */
2527 if (DECL_ARTIFICIAL (decl) || DECL_IN_SYSTEM_HEADER (decl))
2530 /* This only applies to decls at namespace scope. */
2531 if (!DECL_NAMESPACE_SCOPE_P (decl))
2534 if (!extern_c_decls)
2535 extern_c_decls = hash_table<named_decl_hash>::create_ggc (127);
2537 tree *slot = extern_c_decls
2538 ->find_slot_with_hash (DECL_NAME (decl),
2539 IDENTIFIER_HASH_VALUE (DECL_NAME (decl)), INSERT);
2540 if (tree old = *slot)
2542 if (TREE_CODE (old) == OVERLOAD)
2543 old = OVL_FUNCTION (old);
2546 if (DECL_CONTEXT (old) == DECL_CONTEXT (decl))
2547 ; /* If they're in the same context, we'll have already complained
2548 about a (possible) mismatch, when inserting the decl. */
2549 else if (!decls_match (decl, old))
2551 else if (TREE_CODE (decl) == FUNCTION_DECL
2552 && !comp_except_specs (TYPE_RAISES_EXCEPTIONS (TREE_TYPE (old)),
2553 TYPE_RAISES_EXCEPTIONS (TREE_TYPE (decl)),
2556 else if (DECL_ASSEMBLER_NAME_SET_P (old))
2557 SET_DECL_ASSEMBLER_NAME (decl, DECL_ASSEMBLER_NAME (old));
2561 pedwarn (input_location, 0,
2562 "conflicting C language linkage declaration %q#D", decl);
2563 inform (DECL_SOURCE_LOCATION (old),
2564 "previous declaration %q#D", old);
2566 inform (input_location,
2567 "due to different exception specifications");
2572 /* The hash table expects OVERLOADS, so construct one with
2573 OLD as both the function and the chain. This allocate
2574 an excess OVERLOAD node, but it's rare to have multiple
2575 extern "C" decls of the same name. And we save
2576 complicating the hash table logic (which is used
2578 *slot = ovl_make (old, old);
2580 slot = &OVL_CHAIN (*slot);
2582 /* Chain it on for c_linkage_binding's use. */
2583 *slot = tree_cons (NULL_TREE, decl, *slot);
2590 /* Returns a list of C-linkage decls with the name NAME. Used in
2591 c-family/c-pragma.c to implement redefine_extname pragma. */
2594 c_linkage_bindings (tree name)
2597 if (tree *slot = extern_c_decls
2598 ->find_slot_with_hash (name, IDENTIFIER_HASH_VALUE (name), NO_INSERT))
2600 tree result = *slot;
2601 if (TREE_CODE (result) == OVERLOAD)
2602 result = OVL_CHAIN (result);
2609 /* DECL is being declared at a local scope. Emit suitable shadow
2613 check_local_shadow (tree decl)
2615 /* Don't complain about the parms we push and then pop
2616 while tentatively parsing a function declarator. */
2617 if (TREE_CODE (decl) == PARM_DECL && !DECL_CONTEXT (decl))
2620 /* Inline decls shadow nothing. */
2621 if (DECL_FROM_INLINE (decl))
2624 /* External decls are something else. */
2625 if (DECL_EXTERNAL (decl))
2628 tree old = NULL_TREE;
2629 cp_binding_level *old_scope = NULL;
2630 if (cxx_binding *binding = outer_binding (DECL_NAME (decl), NULL, true))
2632 old = binding->value;
2633 old_scope = binding->scope;
2635 while (old && VAR_P (old) && DECL_DEAD_FOR_LOCAL (old))
2636 old = DECL_SHADOWED_FOR_VAR (old);
2638 tree shadowed = NULL_TREE;
2640 && (TREE_CODE (old) == PARM_DECL
2642 || (TREE_CODE (old) == TYPE_DECL
2643 && (!DECL_ARTIFICIAL (old)
2644 || TREE_CODE (decl) == TYPE_DECL)))
2645 && (!DECL_ARTIFICIAL (decl)
2646 || DECL_IMPLICIT_TYPEDEF_P (decl)
2647 || (VAR_P (decl) && DECL_ANON_UNION_VAR_P (decl))))
2649 /* DECL shadows a local thing possibly of interest. */
2651 /* Don't complain if it's from an enclosing function. */
2652 if (DECL_CONTEXT (old) == current_function_decl
2653 && TREE_CODE (decl) != PARM_DECL
2654 && TREE_CODE (old) == PARM_DECL)
2656 /* Go to where the parms should be and see if we find
2658 cp_binding_level *b = current_binding_level->level_chain;
2660 if (FUNCTION_NEEDS_BODY_BLOCK (current_function_decl))
2661 /* Skip the ctor/dtor cleanup level. */
2665 if (b->kind == sk_function_parms)
2667 error ("declaration of %q#D shadows a parameter", decl);
2672 /* The local structure or class can't use parameters of
2673 the containing function anyway. */
2674 if (DECL_CONTEXT (old) != current_function_decl)
2676 for (cp_binding_level *scope = current_binding_level;
2677 scope != old_scope; scope = scope->level_chain)
2678 if (scope->kind == sk_class
2679 && !LAMBDA_TYPE_P (scope->this_entity))
2682 /* Error if redeclaring a local declared in a
2683 init-statement or in the condition of an if or
2684 switch statement when the new declaration is in the
2685 outermost block of the controlled statement.
2686 Redeclaring a variable from a for or while condition is
2687 detected elsewhere. */
2688 else if (VAR_P (old)
2689 && old_scope == current_binding_level->level_chain
2690 && (old_scope->kind == sk_cond || old_scope->kind == sk_for))
2692 error ("redeclaration of %q#D", decl);
2693 inform (DECL_SOURCE_LOCATION (old),
2694 "%q#D previously declared here", old);
2698 3.3.3/3: The name declared in an exception-declaration (...)
2699 shall not be redeclared in the outermost block of the handler.
2700 3.3.3/2: A parameter name shall not be redeclared (...) in
2701 the outermost block of any handler associated with a
2703 3.4.1/15: The function parameter names shall not be redeclared
2704 in the exception-declaration nor in the outermost block of a
2705 handler for the function-try-block. */
2706 else if ((TREE_CODE (old) == VAR_DECL
2707 && old_scope == current_binding_level->level_chain
2708 && old_scope->kind == sk_catch)
2709 || (TREE_CODE (old) == PARM_DECL
2710 && (current_binding_level->kind == sk_catch
2711 || current_binding_level->level_chain->kind == sk_catch)
2712 && in_function_try_handler))
2714 if (permerror (input_location, "redeclaration of %q#D", decl))
2715 inform (DECL_SOURCE_LOCATION (old),
2716 "%q#D previously declared here", old);
2720 /* If '-Wshadow=compatible-local' is specified without other
2721 -Wshadow= flags, we will warn only when the type of the
2722 shadowing variable (DECL) can be converted to that of the
2723 shadowed parameter (OLD_LOCAL). The reason why we only check
2724 if DECL's type can be converted to OLD_LOCAL's type (but not the
2725 other way around) is because when users accidentally shadow a
2726 parameter, more than often they would use the variable
2727 thinking (mistakenly) it's still the parameter. It would be
2728 rare that users would use the variable in the place that
2729 expects the parameter but thinking it's a new decl. */
2731 enum opt_code warning_code;
2733 warning_code = OPT_Wshadow;
2734 else if (warn_shadow_local)
2735 warning_code = OPT_Wshadow_local;
2736 else if (warn_shadow_compatible_local
2737 && (same_type_p (TREE_TYPE (old), TREE_TYPE (decl))
2738 || (!dependent_type_p (TREE_TYPE (decl))
2739 && !dependent_type_p (TREE_TYPE (old))
2740 && can_convert (TREE_TYPE (old), TREE_TYPE (decl),
2742 warning_code = OPT_Wshadow_compatible_local;
2747 if (TREE_CODE (old) == PARM_DECL)
2748 msg = "declaration of %q#D shadows a parameter";
2749 else if (is_capture_proxy (old))
2750 msg = "declaration of %qD shadows a lambda capture";
2752 msg = "declaration of %qD shadows a previous local";
2754 if (warning_at (input_location, warning_code, msg, decl))
2757 goto inform_shadowed;
2765 /* Don't warn for artificial things that are not implicit typedefs. */
2766 if (DECL_ARTIFICIAL (decl) && !DECL_IMPLICIT_TYPEDEF_P (decl))
2769 if (nonlambda_method_basetype ())
2770 if (tree member = lookup_member (current_nonlambda_class_type (),
2771 DECL_NAME (decl), /*protect=*/0,
2772 /*want_type=*/false, tf_warning_or_error))
2774 member = MAYBE_BASELINK_FUNCTIONS (member);
2776 /* Warn if a variable shadows a non-function, or the variable
2777 is a function or a pointer-to-function. */
2779 || TREE_CODE (decl) == FUNCTION_DECL
2780 || TYPE_PTRFN_P (TREE_TYPE (decl))
2781 || TYPE_PTRMEMFUNC_P (TREE_TYPE (decl)))
2783 if (warning_at (input_location, OPT_Wshadow,
2784 "declaration of %qD shadows a member of %qT",
2785 decl, current_nonlambda_class_type ())
2789 goto inform_shadowed;
2795 /* Now look for a namespace shadow. */
2796 old = find_namespace_value (current_namespace, DECL_NAME (decl));
2799 || (TREE_CODE (old) == TYPE_DECL
2800 && (!DECL_ARTIFICIAL (old)
2801 || TREE_CODE (decl) == TYPE_DECL)))
2802 && !instantiating_current_function_p ())
2803 /* XXX shadow warnings in outer-more namespaces */
2805 if (warning_at (input_location, OPT_Wshadow,
2806 "declaration of %qD shadows a global declaration",
2810 goto inform_shadowed;
2818 inform (DECL_SOURCE_LOCATION (shadowed), "shadowed declaration is here");
2821 /* DECL is being pushed inside function CTX. Set its context, if
2825 set_decl_context_in_fn (tree ctx, tree decl)
2827 if (!DECL_CONTEXT (decl)
2828 /* A local declaration for a function doesn't constitute
2830 && TREE_CODE (decl) != FUNCTION_DECL
2831 /* A local declaration for an `extern' variable is in the
2832 scope of the current namespace, not the current
2834 && !(VAR_P (decl) && DECL_EXTERNAL (decl))
2835 /* When parsing the parameter list of a function declarator,
2836 don't set DECL_CONTEXT to an enclosing function. When we
2837 push the PARM_DECLs in order to process the function body,
2838 current_binding_level->this_entity will be set. */
2839 && !(TREE_CODE (decl) == PARM_DECL
2840 && current_binding_level->kind == sk_function_parms
2841 && current_binding_level->this_entity == NULL))
2842 DECL_CONTEXT (decl) = ctx;
2844 /* If this is the declaration for a namespace-scope function,
2845 but the declaration itself is in a local scope, mark the
2847 if (TREE_CODE (decl) == FUNCTION_DECL && DECL_NAMESPACE_SCOPE_P (decl))
2848 DECL_LOCAL_FUNCTION_P (decl) = 1;
2851 /* DECL is a local-scope decl with linkage. SHADOWED is true if the
2852 name is already bound at the current level.
2854 [basic.link] If there is a visible declaration of an entity with
2855 linkage having the same name and type, ignoring entities declared
2856 outside the innermost enclosing namespace scope, the block scope
2857 declaration declares that same entity and receives the linkage of
2858 the previous declaration.
2860 Also, make sure that this decl matches any existing external decl
2861 in the enclosing namespace. */
2864 set_local_extern_decl_linkage (tree decl, bool shadowed)
2866 tree ns_value = decl; /* Unique marker. */
2870 tree loc_value = innermost_non_namespace_value (DECL_NAME (decl));
2874 = find_namespace_value (current_namespace, DECL_NAME (decl));
2875 loc_value = ns_value;
2877 if (loc_value == error_mark_node
2878 /* An ambiguous lookup. */
2879 || (loc_value && TREE_CODE (loc_value) == TREE_LIST))
2880 loc_value = NULL_TREE;
2882 for (ovl_iterator iter (loc_value); iter; ++iter)
2883 if (!iter.hidden_p ()
2884 && (TREE_STATIC (*iter) || DECL_EXTERNAL (*iter))
2885 && decls_match (*iter, decl))
2887 /* The standard only says that the local extern inherits
2888 linkage from the previous decl; in particular, default
2889 args are not shared. Add the decl into a hash table to
2890 make sure only the previous decl in this case is seen
2891 by the middle end. */
2892 struct cxx_int_tree_map *h;
2894 /* We inherit the outer decl's linkage. But we're a
2896 TREE_PUBLIC (decl) = TREE_PUBLIC (*iter);
2898 if (cp_function_chain->extern_decl_map == NULL)
2899 cp_function_chain->extern_decl_map
2900 = hash_table<cxx_int_tree_map_hasher>::create_ggc (20);
2902 h = ggc_alloc<cxx_int_tree_map> ();
2903 h->uid = DECL_UID (decl);
2905 cxx_int_tree_map **loc = cp_function_chain->extern_decl_map
2906 ->find_slot (h, INSERT);
2912 if (TREE_PUBLIC (decl))
2914 /* DECL is externally visible. Make sure it matches a matching
2915 decl in the namespace scope. We only really need to check
2916 this when inserting the decl, not when we find an existing
2917 match in the current scope. However, in practice we're
2918 going to be inserting a new decl in the majority of cases --
2919 who writes multiple extern decls for the same thing in the
2920 same local scope? Doing it here often avoids a duplicate
2921 namespace lookup. */
2923 /* Avoid repeating a lookup. */
2924 if (ns_value == decl)
2925 ns_value = find_namespace_value (current_namespace, DECL_NAME (decl));
2927 if (ns_value == error_mark_node
2928 || (ns_value && TREE_CODE (ns_value) == TREE_LIST))
2929 ns_value = NULL_TREE;
2931 for (ovl_iterator iter (ns_value); iter; ++iter)
2935 if (!(TREE_PUBLIC (other) || DECL_EXTERNAL (other)))
2936 ; /* Not externally visible. */
2937 else if (DECL_EXTERN_C_P (decl) && DECL_EXTERN_C_P (other))
2938 ; /* Both are extern "C", we'll check via that mechanism. */
2939 else if (TREE_CODE (other) != TREE_CODE (decl)
2940 || ((VAR_P (decl) || matching_fn_p (other, decl))
2941 && !comptypes (TREE_TYPE (decl), TREE_TYPE (other),
2942 COMPARE_REDECLARATION)))
2944 if (permerror (DECL_SOURCE_LOCATION (decl),
2945 "local external declaration %q#D", decl))
2946 inform (DECL_SOURCE_LOCATION (other),
2947 "does not match previous declaration %q#D", other);
2954 /* Record DECL as belonging to the current lexical scope. Check for
2955 errors (such as an incompatible declaration for the same name
2956 already seen in the same scope). IS_FRIEND is true if DECL is
2957 declared as a friend.
2959 Returns either DECL or an old decl for the same name. If an old
2960 decl is returned, it may have been smashed to agree with what DECL
2964 do_pushdecl (tree decl, bool is_friend)
2966 if (decl == error_mark_node)
2967 return error_mark_node;
2969 if (!DECL_TEMPLATE_PARM_P (decl) && current_function_decl)
2970 set_decl_context_in_fn (current_function_decl, decl);
2972 /* The binding level we will be pushing into. During local class
2973 pushing, we want to push to the containing scope. */
2974 cp_binding_level *level = current_binding_level;
2975 while (level->kind == sk_class)
2976 level = level->level_chain;
2978 /* An anonymous namespace has a NULL DECL_NAME, but we still want to
2979 insert it. Other NULL-named decls, not so much. */
2980 tree name = DECL_NAME (decl);
2981 if (name || TREE_CODE (decl) == NAMESPACE_DECL)
2983 cxx_binding *binding = NULL; /* Local scope binding. */
2984 tree ns = NULL_TREE; /* Searched namespace. */
2985 tree *slot = NULL; /* Binding slot in namespace. */
2986 tree old = NULL_TREE;
2988 if (level->kind == sk_namespace)
2990 /* We look in the decl's namespace for an existing
2991 declaration, even though we push into the current
2993 ns = (DECL_NAMESPACE_SCOPE_P (decl)
2994 ? CP_DECL_CONTEXT (decl) : current_namespace);
2995 /* Create the binding, if this is current namespace, because
2996 that's where we'll be pushing anyway. */
2997 slot = find_namespace_slot (ns, name, ns == current_namespace);
2999 old = MAYBE_STAT_DECL (*slot);
3003 binding = find_local_binding (level, name);
3005 old = binding->value;
3008 if (current_function_decl && VAR_OR_FUNCTION_DECL_P (decl)
3009 && DECL_EXTERNAL (decl))
3010 set_local_extern_decl_linkage (decl, old != NULL_TREE);
3012 if (old == error_mark_node)
3015 for (ovl_iterator iter (old); iter; ++iter)
3016 if (iter.using_p ())
3017 ; /* Ignore using decls here. */
3018 else if (tree match = duplicate_decls (decl, *iter, is_friend))
3020 if (match == error_mark_node)
3022 else if (TREE_CODE (match) == TYPE_DECL)
3023 /* The IDENTIFIER will have the type referring to the
3024 now-smashed TYPE_DECL, because ...? Reset it. */
3025 SET_IDENTIFIER_TYPE_VALUE (name, TREE_TYPE (match));
3026 else if (iter.hidden_p () && !DECL_HIDDEN_P (match))
3028 /* Unhiding a previously hidden decl. */
3029 tree head = iter.reveal_node (old);
3034 update_local_overload (binding, head);
3035 binding->value = head;
3037 else if (STAT_HACK_P (*slot))
3038 STAT_DECL (*slot) = head;
3042 if (DECL_EXTERN_C_P (match))
3043 /* We need to check and register the decl now. */
3044 check_extern_c_conflict (match);
3049 /* We are pushing a new decl. */
3051 /* Skip a hidden builtin we failed to match already. There can
3053 if (old && anticipated_builtin_p (old))
3054 old = OVL_CHAIN (old);
3056 check_template_shadow (decl);
3057 bool visible_injection = false;
3059 if (DECL_DECLARES_FUNCTION_P (decl))
3061 check_default_args (decl);
3065 if (level->kind != sk_namespace)
3067 /* In a local class, a friend function declaration must
3068 find a matching decl in the innermost non-class scope.
3069 [class.friend/11] */
3070 error ("friend declaration %qD in local class without "
3071 "prior local declaration", decl);
3072 /* Don't attempt to push it. */
3073 return error_mark_node;
3075 if (!flag_friend_injection)
3076 /* Hide it from ordinary lookup. */
3077 DECL_ANTICIPATED (decl) = DECL_HIDDEN_FRIEND_P (decl) = true;
3079 visible_injection = true;
3083 if (level->kind != sk_namespace)
3085 check_local_shadow (decl);
3087 if (TREE_CODE (decl) == NAMESPACE_DECL)
3088 /* A local namespace alias. */
3089 set_identifier_type_value (name, NULL_TREE);
3092 binding = create_local_binding (level, name);
3096 ns = current_namespace;
3097 slot = find_namespace_slot (ns, name, true);
3098 /* Update OLD to reflect the namespace we're going to be
3100 old = MAYBE_STAT_DECL (*slot);
3103 old = update_binding (level, binding, slot, old, decl, is_friend);
3106 /* An existing decl matched, use it. */
3108 else if (TREE_CODE (decl) == TYPE_DECL)
3110 tree type = TREE_TYPE (decl);
3112 if (type != error_mark_node)
3114 if (TYPE_NAME (type) != decl)
3115 set_underlying_type (decl);
3118 set_identifier_type_value_with_scope (name, decl, level);
3120 SET_IDENTIFIER_TYPE_VALUE (name, global_type_node);
3123 /* If this is a locally defined typedef in a function that
3124 is not a template instantation, record it to implement
3125 -Wunused-local-typedefs. */
3126 if (!instantiating_current_function_p ())
3127 record_locally_defined_typedef (decl);
3129 else if (VAR_P (decl))
3130 maybe_register_incomplete_var (decl);
3131 else if (visible_injection)
3132 warning (0, "injected friend %qD is visible"
3133 " due to %<-ffriend-injection%>", decl);
3135 if ((VAR_P (decl) || TREE_CODE (decl) == FUNCTION_DECL)
3136 && DECL_EXTERN_C_P (decl))
3137 check_extern_c_conflict (decl);
3140 add_decl_to_level (level, decl);
3145 /* Record a decl-node X as belonging to the current lexical scope.
3146 It's a friend if IS_FRIEND is true -- which affects exactly where
3150 pushdecl (tree x, bool is_friend)
3152 bool subtime = timevar_cond_start (TV_NAME_LOOKUP);
3153 tree ret = do_pushdecl (x, is_friend);
3154 timevar_cond_stop (TV_NAME_LOOKUP, subtime);
3158 /* Enter DECL into the symbol table, if that's appropriate. Returns
3159 DECL, or a modified version thereof. */
3162 maybe_push_decl (tree decl)
3164 tree type = TREE_TYPE (decl);
3166 /* Add this decl to the current binding level, but not if it comes
3167 from another scope, e.g. a static member variable. TEM may equal
3168 DECL or it may be a previous decl of the same name. */
3169 if (decl == error_mark_node
3170 || (TREE_CODE (decl) != PARM_DECL
3171 && DECL_CONTEXT (decl) != NULL_TREE
3172 /* Definitions of namespace members outside their namespace are
3174 && !DECL_NAMESPACE_SCOPE_P (decl))
3175 || (TREE_CODE (decl) == TEMPLATE_DECL && !namespace_bindings_p ())
3176 || type == unknown_type_node
3177 /* The declaration of a template specialization does not affect
3178 the functions available for overload resolution, so we do not
3180 || (TREE_CODE (decl) == FUNCTION_DECL
3181 && DECL_TEMPLATE_SPECIALIZATION (decl)))
3184 return pushdecl (decl);
3187 /* Bind DECL to ID in the current_binding_level, assumed to be a local
3188 binding level. If IS_USING is true, DECL got here through a
3189 using-declaration. */
3192 push_local_binding (tree id, tree decl, bool is_using)
3194 /* Skip over any local classes. This makes sense if we call
3195 push_local_binding with a friend decl of a local class. */
3196 cp_binding_level *b = innermost_nonclass_level ();
3198 gcc_assert (b->kind != sk_namespace);
3199 if (find_local_binding (b, id))
3201 /* Supplement the existing binding. */
3202 if (!supplement_binding (IDENTIFIER_BINDING (id), decl))
3203 /* It didn't work. Something else must be bound at this
3204 level. Do not add DECL to the list of things to pop
3209 /* Create a new binding. */
3210 push_binding (id, decl, b);
3212 if (TREE_CODE (decl) == OVERLOAD || is_using)
3213 /* We must put the OVERLOAD or using into a TREE_LIST since we
3214 cannot use the decl's chain itself. */
3215 decl = build_tree_list (NULL_TREE, decl);
3217 /* And put DECL on the list of things declared by the current
3219 add_decl_to_level (b, decl);
3222 /* Check to see whether or not DECL is a variable that would have been
3223 in scope under the ARM, but is not in scope under the ANSI/ISO
3224 standard. If so, issue an error message. If name lookup would
3225 work in both cases, but return a different result, this function
3226 returns the result of ANSI/ISO lookup. Otherwise, it returns
3229 FIXME: Scheduled for removal after GCC-8 is done. */
3232 check_for_out_of_scope_variable (tree decl)
3236 /* We only care about out of scope variables. */
3237 if (!(VAR_P (decl) && DECL_DEAD_FOR_LOCAL (decl)))
3240 shadowed = DECL_HAS_SHADOWED_FOR_VAR_P (decl)
3241 ? DECL_SHADOWED_FOR_VAR (decl) : NULL_TREE ;
3242 while (shadowed != NULL_TREE && VAR_P (shadowed)
3243 && DECL_DEAD_FOR_LOCAL (shadowed))
3244 shadowed = DECL_HAS_SHADOWED_FOR_VAR_P (shadowed)
3245 ? DECL_SHADOWED_FOR_VAR (shadowed) : NULL_TREE;
3247 shadowed = find_namespace_value (current_namespace, DECL_NAME (decl));
3250 if (!DECL_ERROR_REPORTED (decl)
3252 && warning (0, "name lookup of %qD changed", DECL_NAME (decl)))
3254 inform (DECL_SOURCE_LOCATION (shadowed),
3255 "matches this %qD under ISO standard rules", shadowed);
3256 inform (DECL_SOURCE_LOCATION (decl),
3257 " matches this %qD under old rules", decl);
3259 DECL_ERROR_REPORTED (decl) = 1;
3263 /* If we have already complained about this declaration, there's no
3264 need to do it again. */
3265 if (DECL_ERROR_REPORTED (decl))
3268 DECL_ERROR_REPORTED (decl) = 1;
3270 if (TREE_TYPE (decl) == error_mark_node)
3273 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TREE_TYPE (decl)))
3275 error ("name lookup of %qD changed for ISO %<for%> scoping",
3277 inform (DECL_SOURCE_LOCATION (decl),
3278 "cannot use obsolete binding %qD because it has a destructor",
3280 return error_mark_node;
3284 permerror (input_location,
3285 "name lookup of %qD changed for ISO %<for%> scoping",
3287 if (flag_permissive)
3288 inform (DECL_SOURCE_LOCATION (decl),
3289 "using obsolete binding %qD", decl);
3292 inform (input_location, flag_permissive
3293 ? "this flexibility is deprecated and will be removed"
3294 : "if you use %<-fpermissive%> G++ will accept your code");
3301 /* true means unconditionally make a BLOCK for the next level pushed. */
3303 static bool keep_next_level_flag;
3305 static int binding_depth = 0;
3312 for (i = 0; i < depth * 2; i++)
3316 /* Return a string describing the kind of SCOPE we have. */
3318 cp_binding_level_descriptor (cp_binding_level *scope)
3320 /* The order of this table must match the "scope_kind"
3322 static const char* scope_kind_names[] = {
3328 "function-parameter-scope",
3331 "template-parameter-scope",
3332 "template-explicit-spec-scope"
3334 const scope_kind kind = scope->explicit_spec_p
3335 ? sk_template_spec : scope->kind;
3337 return scope_kind_names[kind];
3340 /* Output a debugging information about SCOPE when performing
3343 cp_binding_level_debug (cp_binding_level *scope, int line, const char *action)
3345 const char *desc = cp_binding_level_descriptor (scope);
3346 if (scope->this_entity)
3347 verbatim ("%s %<%s(%E)%> %p %d\n", action, desc,
3348 scope->this_entity, (void *) scope, line);
3350 verbatim ("%s %s %p %d\n", action, desc, (void *) scope, line);
3353 /* Return the estimated initial size of the hashtable of a NAMESPACE
3356 static inline size_t
3357 namespace_scope_ht_size (tree ns)
3359 tree name = DECL_NAME (ns);
3361 return name == std_identifier
3362 ? NAMESPACE_STD_HT_SIZE
3363 : (name == global_identifier
3364 ? GLOBAL_SCOPE_HT_SIZE
3365 : NAMESPACE_ORDINARY_HT_SIZE);
3368 /* A chain of binding_level structures awaiting reuse. */
3370 static GTY((deletable)) cp_binding_level *free_binding_level;
3372 /* Insert SCOPE as the innermost binding level. */
3375 push_binding_level (cp_binding_level *scope)
3377 /* Add it to the front of currently active scopes stack. */
3378 scope->level_chain = current_binding_level;
3379 current_binding_level = scope;
3380 keep_next_level_flag = false;
3382 if (ENABLE_SCOPE_CHECKING)
3384 scope->binding_depth = binding_depth;
3385 indent (binding_depth);
3386 cp_binding_level_debug (scope, LOCATION_LINE (input_location),
3392 /* Create a new KIND scope and make it the top of the active scopes stack.
3393 ENTITY is the scope of the associated C++ entity (namespace, class,
3394 function, C++0x enumeration); it is NULL otherwise. */
3397 begin_scope (scope_kind kind, tree entity)
3399 cp_binding_level *scope;
3401 /* Reuse or create a struct for this binding level. */
3402 if (!ENABLE_SCOPE_CHECKING && free_binding_level)
3404 scope = free_binding_level;
3405 free_binding_level = scope->level_chain;
3406 memset (scope, 0, sizeof (cp_binding_level));
3409 scope = ggc_cleared_alloc<cp_binding_level> ();
3411 scope->this_entity = entity;
3412 scope->more_cleanups_ok = true;
3419 case sk_template_spec:
3420 scope->explicit_spec_p = true;
3421 kind = sk_template_parms;
3423 case sk_template_parms:
3430 case sk_scoped_enum:
3431 case sk_function_parms:
3432 case sk_transaction:
3434 scope->keep = keep_next_level_flag;
3438 NAMESPACE_LEVEL (entity) = scope;
3442 /* Should not happen. */
3448 push_binding_level (scope);
3453 /* We're about to leave current scope. Pop the top of the stack of
3454 currently active scopes. Return the enclosing scope, now active. */
3459 cp_binding_level *scope = current_binding_level;
3461 if (scope->kind == sk_namespace && class_binding_level)
3462 current_binding_level = class_binding_level;
3464 /* We cannot leave a scope, if there are none left. */
3465 if (NAMESPACE_LEVEL (global_namespace))
3466 gcc_assert (!global_scope_p (scope));
3468 if (ENABLE_SCOPE_CHECKING)
3470 indent (--binding_depth);
3471 cp_binding_level_debug (scope, LOCATION_LINE (input_location),
3475 /* Move one nesting level up. */
3476 current_binding_level = scope->level_chain;
3478 /* Namespace-scopes are left most probably temporarily, not
3479 completely; they can be reopened later, e.g. in namespace-extension
3480 or any name binding activity that requires us to resume a
3481 namespace. For classes, we cache some binding levels. For other
3482 scopes, we just make the structure available for reuse. */
3483 if (scope->kind != sk_namespace
3484 && scope->kind != sk_class)
3486 scope->level_chain = free_binding_level;
3487 gcc_assert (!ENABLE_SCOPE_CHECKING
3488 || scope->binding_depth == binding_depth);
3489 free_binding_level = scope;
3492 if (scope->kind == sk_class)
3494 /* Reset DEFINING_CLASS_P to allow for reuse of a
3495 class-defining scope in a non-defining context. */
3496 scope->defining_class_p = 0;
3498 /* Find the innermost enclosing class scope, and reset
3499 CLASS_BINDING_LEVEL appropriately. */
3500 class_binding_level = NULL;
3501 for (scope = current_binding_level; scope; scope = scope->level_chain)
3502 if (scope->kind == sk_class)
3504 class_binding_level = scope;
3509 return current_binding_level;
3513 resume_scope (cp_binding_level* b)
3515 /* Resuming binding levels is meant only for namespaces,
3516 and those cannot nest into classes. */
3517 gcc_assert (!class_binding_level);
3518 /* Also, resuming a non-directly nested namespace is a no-no. */
3519 gcc_assert (b->level_chain == current_binding_level);
3520 current_binding_level = b;
3521 if (ENABLE_SCOPE_CHECKING)
3523 b->binding_depth = binding_depth;
3524 indent (binding_depth);
3525 cp_binding_level_debug (b, LOCATION_LINE (input_location), "resume");
3530 /* Return the innermost binding level that is not for a class scope. */
3532 static cp_binding_level *
3533 innermost_nonclass_level (void)
3535 cp_binding_level *b;
3537 b = current_binding_level;
3538 while (b->kind == sk_class)
3544 /* We're defining an object of type TYPE. If it needs a cleanup, but
3545 we're not allowed to add any more objects with cleanups to the current
3546 scope, create a new binding level. */
3549 maybe_push_cleanup_level (tree type)
3551 if (type != error_mark_node
3552 && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type)
3553 && current_binding_level->more_cleanups_ok == 0)
3555 begin_scope (sk_cleanup, NULL);
3556 current_binding_level->statement_list = push_stmt_list ();
3560 /* Return true if we are in the global binding level. */
3563 global_bindings_p (void)
3565 return global_scope_p (current_binding_level);
3568 /* True if we are currently in a toplevel binding level. This
3569 means either the global binding level or a namespace in a toplevel
3570 binding level. Since there are no non-toplevel namespace levels,
3571 this really means any namespace or template parameter level. We
3572 also include a class whose context is toplevel. */
3575 toplevel_bindings_p (void)
3577 cp_binding_level *b = innermost_nonclass_level ();
3579 return b->kind == sk_namespace || b->kind == sk_template_parms;
3582 /* True if this is a namespace scope, or if we are defining a class
3583 which is itself at namespace scope, or whose enclosing class is
3584 such a class, etc. */
3587 namespace_bindings_p (void)
3589 cp_binding_level *b = innermost_nonclass_level ();
3591 return b->kind == sk_namespace;
3594 /* True if the innermost non-class scope is a block scope. */
3597 local_bindings_p (void)
3599 cp_binding_level *b = innermost_nonclass_level ();
3600 return b->kind < sk_function_parms || b->kind == sk_omp;
3603 /* True if the current level needs to have a BLOCK made. */
3608 return (current_binding_level->blocks != NULL_TREE
3609 || current_binding_level->keep
3610 || current_binding_level->kind == sk_cleanup
3611 || current_binding_level->names != NULL_TREE
3612 || current_binding_level->using_directives);
3615 /* Returns the kind of the innermost scope. */
3618 innermost_scope_kind (void)
3620 return current_binding_level->kind;
3623 /* Returns true if this scope was created to store template parameters. */
3626 template_parm_scope_p (void)
3628 return innermost_scope_kind () == sk_template_parms;
3631 /* If KEEP is true, make a BLOCK node for the next binding level,
3632 unconditionally. Otherwise, use the normal logic to decide whether
3633 or not to create a BLOCK. */
3636 keep_next_level (bool keep)
3638 keep_next_level_flag = keep;
3641 /* Return the list of declarations of the current local scope. */
3644 get_local_decls (void)
3646 gcc_assert (current_binding_level->kind != sk_namespace
3647 && current_binding_level->kind != sk_class);
3648 return current_binding_level->names;
3651 /* Return how many function prototypes we are currently nested inside. */
3654 function_parm_depth (void)
3657 cp_binding_level *b;
3659 for (b = current_binding_level;
3660 b->kind == sk_function_parms;
3667 /* For debugging. */
3668 static int no_print_functions = 0;
3669 static int no_print_builtins = 0;
3672 print_binding_level (cp_binding_level* lvl)
3676 fprintf (stderr, " blocks=%p", (void *) lvl->blocks);
3677 if (lvl->more_cleanups_ok)
3678 fprintf (stderr, " more-cleanups-ok");
3679 if (lvl->have_cleanups)
3680 fprintf (stderr, " have-cleanups");
3681 fprintf (stderr, "\n");
3684 fprintf (stderr, " names:\t");
3685 /* We can probably fit 3 names to a line? */
3686 for (t = lvl->names; t; t = TREE_CHAIN (t))
3688 if (no_print_functions && (TREE_CODE (t) == FUNCTION_DECL))
3690 if (no_print_builtins
3691 && (TREE_CODE (t) == TYPE_DECL)
3692 && DECL_IS_BUILTIN (t))
3695 /* Function decls tend to have longer names. */
3696 if (TREE_CODE (t) == FUNCTION_DECL)
3703 fprintf (stderr, "\n\t");
3706 print_node_brief (stderr, "", t, 0);
3707 if (t == error_mark_node)
3711 fprintf (stderr, "\n");
3713 if (vec_safe_length (lvl->class_shadowed))
3716 cp_class_binding *b;
3717 fprintf (stderr, " class-shadowed:");
3718 FOR_EACH_VEC_ELT (*lvl->class_shadowed, i, b)
3719 fprintf (stderr, " %s ", IDENTIFIER_POINTER (b->identifier));
3720 fprintf (stderr, "\n");
3722 if (lvl->type_shadowed)
3724 fprintf (stderr, " type-shadowed:");
3725 for (t = lvl->type_shadowed; t; t = TREE_CHAIN (t))
3727 fprintf (stderr, " %s ", IDENTIFIER_POINTER (TREE_PURPOSE (t)));
3729 fprintf (stderr, "\n");
3734 debug (cp_binding_level &ref)
3736 print_binding_level (&ref);
3740 debug (cp_binding_level *ptr)
3745 fprintf (stderr, "<nil>\n");
3750 print_other_binding_stack (cp_binding_level *stack)
3752 cp_binding_level *level;
3753 for (level = stack; !global_scope_p (level); level = level->level_chain)
3755 fprintf (stderr, "binding level %p\n", (void *) level);
3756 print_binding_level (level);
3761 print_binding_stack (void)
3763 cp_binding_level *b;
3764 fprintf (stderr, "current_binding_level=%p\n"
3765 "class_binding_level=%p\n"
3766 "NAMESPACE_LEVEL (global_namespace)=%p\n",
3767 (void *) current_binding_level, (void *) class_binding_level,
3768 (void *) NAMESPACE_LEVEL (global_namespace));
3769 if (class_binding_level)
3771 for (b = class_binding_level; b; b = b->level_chain)
3772 if (b == current_binding_level)
3775 b = class_binding_level;
3777 b = current_binding_level;
3780 b = current_binding_level;
3781 print_other_binding_stack (b);
3782 fprintf (stderr, "global:\n");
3783 print_binding_level (NAMESPACE_LEVEL (global_namespace));
3786 /* Return the type associated with ID. */
3789 identifier_type_value_1 (tree id)
3791 /* There is no type with that name, anywhere. */
3792 if (REAL_IDENTIFIER_TYPE_VALUE (id) == NULL_TREE)
3794 /* This is not the type marker, but the real thing. */
3795 if (REAL_IDENTIFIER_TYPE_VALUE (id) != global_type_node)
3796 return REAL_IDENTIFIER_TYPE_VALUE (id);
3797 /* Have to search for it. It must be on the global level, now.
3798 Ask lookup_name not to return non-types. */
3799 id = lookup_name_real (id, 2, 1, /*block_p=*/true, 0, 0);
3801 return TREE_TYPE (id);
3805 /* Wrapper for identifier_type_value_1. */
3808 identifier_type_value (tree id)
3811 timevar_start (TV_NAME_LOOKUP);
3812 ret = identifier_type_value_1 (id);
3813 timevar_stop (TV_NAME_LOOKUP);
3817 /* Push a definition of struct, union or enum tag named ID. into
3818 binding_level B. DECL is a TYPE_DECL for the type. We assume that
3819 the tag ID is not already defined. */
3822 set_identifier_type_value_with_scope (tree id, tree decl, cp_binding_level *b)
3826 if (b->kind != sk_namespace)
3828 /* Shadow the marker, not the real thing, so that the marker
3829 gets restored later. */
3830 tree old_type_value = REAL_IDENTIFIER_TYPE_VALUE (id);
3832 = tree_cons (id, old_type_value, b->type_shadowed);
3833 type = decl ? TREE_TYPE (decl) : NULL_TREE;
3834 TREE_TYPE (b->type_shadowed) = type;
3838 tree *slot = find_namespace_slot (current_namespace, id, true);
3840 update_binding (b, NULL, slot, MAYBE_STAT_DECL (*slot), decl, false);
3842 /* Store marker instead of real type. */
3843 type = global_type_node;
3845 SET_IDENTIFIER_TYPE_VALUE (id, type);
3848 /* As set_identifier_type_value_with_scope, but using
3849 current_binding_level. */
3852 set_identifier_type_value (tree id, tree decl)
3854 set_identifier_type_value_with_scope (id, decl, current_binding_level);
3857 /* Return the name for the constructor (or destructor) for the
3861 constructor_name (tree type)
3863 tree decl = TYPE_NAME (TYPE_MAIN_VARIANT (type));
3865 return decl ? DECL_NAME (decl) : NULL_TREE;
3868 /* Returns TRUE if NAME is the name for the constructor for TYPE,
3869 which must be a class type. */
3872 constructor_name_p (tree name, tree type)
3874 gcc_assert (MAYBE_CLASS_TYPE_P (type));
3876 /* These don't have names. */
3877 if (TREE_CODE (type) == DECLTYPE_TYPE
3878 || TREE_CODE (type) == TYPEOF_TYPE)
3881 if (name && name == constructor_name (type))
3887 /* Counter used to create anonymous type names. */
3889 static GTY(()) int anon_cnt;
3891 /* Return an IDENTIFIER which can be used as a name for
3892 unnamed structs and unions. */
3895 make_anon_name (void)
3899 sprintf (buf, anon_aggrname_format (), anon_cnt++);
3900 return get_identifier (buf);
3903 /* This code is practically identical to that for creating
3904 anonymous names, but is just used for lambdas instead. This isn't really
3905 necessary, but it's convenient to avoid treating lambdas like other
3908 static GTY(()) int lambda_cnt = 0;
3911 make_lambda_name (void)
3915 sprintf (buf, LAMBDANAME_FORMAT, lambda_cnt++);
3916 return get_identifier (buf);
3919 /* Insert another USING_DECL into the current binding level, returning
3920 this declaration. If this is a redeclaration, do nothing, and
3921 return NULL_TREE if this not in namespace scope (in namespace
3922 scope, a using decl might extend any previous bindings). */
3925 push_using_decl_1 (tree scope, tree name)
3929 gcc_assert (TREE_CODE (scope) == NAMESPACE_DECL);
3930 gcc_assert (identifier_p (name));
3931 for (decl = current_binding_level->usings; decl; decl = DECL_CHAIN (decl))
3932 if (USING_DECL_SCOPE (decl) == scope && DECL_NAME (decl) == name)
3935 return namespace_bindings_p () ? decl : NULL_TREE;
3936 decl = build_lang_decl (USING_DECL, name, NULL_TREE);
3937 USING_DECL_SCOPE (decl) = scope;
3938 DECL_CHAIN (decl) = current_binding_level->usings;
3939 current_binding_level->usings = decl;
3943 /* Wrapper for push_using_decl_1. */
3946 push_using_decl (tree scope, tree name)
3949 timevar_start (TV_NAME_LOOKUP);
3950 ret = push_using_decl_1 (scope, name);
3951 timevar_stop (TV_NAME_LOOKUP);
3955 /* Same as pushdecl, but define X in binding-level LEVEL. We rely on the
3956 caller to set DECL_CONTEXT properly.
3958 Note that this must only be used when X will be the new innermost
3959 binding for its name, as we tack it onto the front of IDENTIFIER_BINDING
3960 without checking to see if the current IDENTIFIER_BINDING comes from a
3961 closer binding level than LEVEL. */
3964 do_pushdecl_with_scope (tree x, cp_binding_level *level, bool is_friend)
3966 cp_binding_level *b;
3968 if (level->kind == sk_class)
3970 b = class_binding_level;
3971 class_binding_level = level;
3972 pushdecl_class_level (x);
3973 class_binding_level = b;
3977 tree function_decl = current_function_decl;
3978 if (level->kind == sk_namespace)
3979 current_function_decl = NULL_TREE;
3980 b = current_binding_level;
3981 current_binding_level = level;
3982 x = pushdecl (x, is_friend);
3983 current_binding_level = b;
3984 current_function_decl = function_decl;
3989 /* Inject X into the local scope just before the function parms. */
3992 pushdecl_outermost_localscope (tree x)
3994 cp_binding_level *b = NULL;
3995 bool subtime = timevar_cond_start (TV_NAME_LOOKUP);
3997 /* Find the scope just inside the function parms. */
3998 for (cp_binding_level *n = current_binding_level;
3999 n->kind != sk_function_parms; n = b->level_chain)
4002 tree ret = b ? do_pushdecl_with_scope (x, b, false) : error_mark_node;
4003 timevar_cond_stop (TV_NAME_LOOKUP, subtime);
4008 /* Check a non-member using-declaration. Return the name and scope
4009 being used, and the USING_DECL, or NULL_TREE on failure. */
4012 validate_nonmember_using_decl (tree decl, tree scope, tree name)
4014 /* [namespace.udecl]
4015 A using-declaration for a class member shall be a
4016 member-declaration. */
4019 error ("%qT is not a namespace or unscoped enum", scope);
4022 else if (scope == error_mark_node)
4025 if (TREE_CODE (decl) == TEMPLATE_ID_EXPR)
4028 A using-declaration shall not name a template-id. */
4029 error ("a using-declaration cannot specify a template-id. "
4030 "Try %<using %D%>", name);
4034 if (TREE_CODE (decl) == NAMESPACE_DECL)
4036 error ("namespace %qD not allowed in using-declaration", decl);
4040 if (TREE_CODE (decl) == SCOPE_REF)
4042 /* It's a nested name with template parameter dependent scope.
4043 This can only be using-declaration for class member. */
4044 error ("%qT is not a namespace", TREE_OPERAND (decl, 0));
4048 decl = OVL_FIRST (decl);
4050 /* Make a USING_DECL. */
4051 tree using_decl = push_using_decl (scope, name);
4053 if (using_decl == NULL_TREE
4054 && at_function_scope_p ()
4056 /* C++11 7.3.3/10. */
4057 error ("%qD is already declared in this scope", name);
4062 /* Process a local-scope or namespace-scope using declaration. SCOPE
4063 is the nominated scope to search for NAME. VALUE_P and TYPE_P
4064 point to the binding for NAME in the current scope and are
4068 do_nonmember_using_decl (tree scope, tree name, tree *value_p, tree *type_p)
4070 name_lookup lookup (name, 0);
4072 if (!qualified_namespace_lookup (scope, &lookup))
4074 error ("%qD not declared", name);
4077 else if (TREE_CODE (lookup.value) == TREE_LIST)
4079 error ("reference to %qD is ambiguous", name);
4080 print_candidates (lookup.value);
4081 lookup.value = NULL_TREE;
4084 if (lookup.type && TREE_CODE (lookup.type) == TREE_LIST)
4086 error ("reference to %qD is ambiguous", name);
4087 print_candidates (lookup.type);
4088 lookup.type = NULL_TREE;
4091 tree value = *value_p;
4092 tree type = *type_p;
4094 /* Shift the old and new bindings around so we're comparing class and
4095 enumeration names to each other. */
4096 if (value && DECL_IMPLICIT_TYPEDEF_P (value))
4102 if (lookup.value && DECL_IMPLICIT_TYPEDEF_P (lookup.value))
4104 lookup.type = lookup.value;
4105 lookup.value = NULL_TREE;
4108 if (lookup.value && lookup.value != value)
4110 /* Check for using functions. */
4111 if (OVL_P (lookup.value) && (!value || OVL_P (value)))
4113 for (lkp_iterator usings (lookup.value); usings; ++usings)
4115 tree new_fn = *usings;
4117 /* [namespace.udecl]
4119 If a function declaration in namespace scope or block
4120 scope has the same name and the same parameter types as a
4121 function introduced by a using declaration the program is
4124 for (ovl_iterator old (value); !found && old; ++old)
4128 if (new_fn == old_fn)
4129 /* The function already exists in the current
4132 else if (old.using_p ())
4133 continue; /* This is a using decl. */
4134 else if (old.hidden_p () && !DECL_HIDDEN_FRIEND_P (old_fn))
4135 continue; /* This is an anticipated builtin. */
4136 else if (!matching_fn_p (new_fn, old_fn))
4137 continue; /* Parameters do not match. */
4138 else if (decls_match (new_fn, old_fn))
4142 diagnose_name_conflict (new_fn, old_fn);
4148 /* Unlike the overload case we don't drop anticipated
4149 builtins here. They don't cause a problem, and
4150 we'd like to match them with a future
4152 value = ovl_insert (new_fn, value, true);
4156 /* Ignore anticipated builtins. */
4157 && !anticipated_builtin_p (value)
4158 && !decls_match (lookup.value, value))
4159 diagnose_name_conflict (lookup.value, value);
4161 value = lookup.value;
4164 if (lookup.type && lookup.type != type)
4166 if (type && !decls_match (lookup.type, type))
4167 diagnose_name_conflict (lookup.type, type);
4172 /* If bind->value is empty, shift any class or enumeration name back. */
4183 /* Returns true if ANCESTOR encloses DESCENDANT, including matching.
4184 Both are namespaces. */
4187 is_nested_namespace (tree ancestor, tree descendant, bool inline_only)
4189 int depth = SCOPE_DEPTH (ancestor);
4191 if (!depth && !inline_only)
4192 /* The global namespace encloses everything. */
4195 while (SCOPE_DEPTH (descendant) > depth
4196 && (!inline_only || DECL_NAMESPACE_INLINE_P (descendant)))
4197 descendant = CP_DECL_CONTEXT (descendant);
4199 return ancestor == descendant;
4202 /* Returns true if ROOT (a namespace, class, or function) encloses
4203 CHILD. CHILD may be either a class type or a namespace. */
4206 is_ancestor (tree root, tree child)
4208 gcc_assert ((TREE_CODE (root) == NAMESPACE_DECL
4209 || TREE_CODE (root) == FUNCTION_DECL
4210 || CLASS_TYPE_P (root)));
4211 gcc_assert ((TREE_CODE (child) == NAMESPACE_DECL
4212 || CLASS_TYPE_P (child)));
4214 /* The global namespace encloses everything. */
4215 if (root == global_namespace)
4218 /* Search until we reach namespace scope. */
4219 while (TREE_CODE (child) != NAMESPACE_DECL)
4221 /* If we've reached the ROOT, it encloses CHILD. */
4224 /* Go out one level. */
4226 child = TYPE_NAME (child);
4227 child = CP_DECL_CONTEXT (child);
4230 if (TREE_CODE (root) == NAMESPACE_DECL)
4231 return is_nested_namespace (root, child);
4236 /* Enter the class or namespace scope indicated by T suitable for name
4237 lookup. T can be arbitrary scope, not necessary nested inside the
4238 current scope. Returns a non-null scope to pop iff pop_scope
4239 should be called later to exit this scope. */
4244 if (TREE_CODE (t) == NAMESPACE_DECL)
4245 push_decl_namespace (t);
4246 else if (CLASS_TYPE_P (t))
4248 if (!at_class_scope_p ()
4249 || !same_type_p (current_class_type, t))
4250 push_nested_class (t);
4252 /* T is the same as the current scope. There is therefore no
4253 need to re-enter the scope. Since we are not actually
4254 pushing a new scope, our caller should not call
4262 /* Leave scope pushed by push_scope. */
4269 if (TREE_CODE (t) == NAMESPACE_DECL)
4270 pop_decl_namespace ();
4271 else if CLASS_TYPE_P (t)
4272 pop_nested_class ();
4275 /* Subroutine of push_inner_scope. */
4278 push_inner_scope_r (tree outer, tree inner)
4283 || (TREE_CODE (inner) != NAMESPACE_DECL && !CLASS_TYPE_P (inner)))
4286 prev = CP_DECL_CONTEXT (TREE_CODE (inner) == NAMESPACE_DECL ? inner : TYPE_NAME (inner));
4288 push_inner_scope_r (outer, prev);
4289 if (TREE_CODE (inner) == NAMESPACE_DECL)
4291 cp_binding_level *save_template_parm = 0;
4292 /* Temporary take out template parameter scopes. They are saved
4293 in reversed order in save_template_parm. */
4294 while (current_binding_level->kind == sk_template_parms)
4296 cp_binding_level *b = current_binding_level;
4297 current_binding_level = b->level_chain;
4298 b->level_chain = save_template_parm;
4299 save_template_parm = b;
4302 resume_scope (NAMESPACE_LEVEL (inner));
4303 current_namespace = inner;
4305 /* Restore template parameter scopes. */
4306 while (save_template_parm)
4308 cp_binding_level *b = save_template_parm;
4309 save_template_parm = b->level_chain;
4310 b->level_chain = current_binding_level;
4311 current_binding_level = b;
4318 /* Enter the scope INNER from current scope. INNER must be a scope
4319 nested inside current scope. This works with both name lookup and
4320 pushing name into scope. In case a template parameter scope is present,
4321 namespace is pushed under the template parameter scope according to
4322 name lookup rule in 14.6.1/6.
4324 Return the former current scope suitable for pop_inner_scope. */
4327 push_inner_scope (tree inner)
4329 tree outer = current_scope ();
4331 outer = current_namespace;
4333 push_inner_scope_r (outer, inner);
4337 /* Exit the current scope INNER back to scope OUTER. */
4340 pop_inner_scope (tree outer, tree inner)
4343 || (TREE_CODE (inner) != NAMESPACE_DECL && !CLASS_TYPE_P (inner)))
4346 while (outer != inner)
4348 if (TREE_CODE (inner) == NAMESPACE_DECL)
4350 cp_binding_level *save_template_parm = 0;
4351 /* Temporary take out template parameter scopes. They are saved
4352 in reversed order in save_template_parm. */
4353 while (current_binding_level->kind == sk_template_parms)
4355 cp_binding_level *b = current_binding_level;
4356 current_binding_level = b->level_chain;
4357 b->level_chain = save_template_parm;
4358 save_template_parm = b;
4363 /* Restore template parameter scopes. */
4364 while (save_template_parm)
4366 cp_binding_level *b = save_template_parm;
4367 save_template_parm = b->level_chain;
4368 b->level_chain = current_binding_level;
4369 current_binding_level = b;
4375 inner = CP_DECL_CONTEXT (TREE_CODE (inner) == NAMESPACE_DECL ? inner : TYPE_NAME (inner));
4379 /* Do a pushlevel for class declarations. */
4382 pushlevel_class (void)
4384 class_binding_level = begin_scope (sk_class, current_class_type);
4387 /* ...and a poplevel for class declarations. */
4390 poplevel_class (void)
4392 cp_binding_level *level = class_binding_level;
4393 cp_class_binding *cb;
4397 bool subtime = timevar_cond_start (TV_NAME_LOOKUP);
4398 gcc_assert (level != 0);
4400 /* If we're leaving a toplevel class, cache its binding level. */
4401 if (current_class_depth == 1)
4402 previous_class_level = level;
4403 for (shadowed = level->type_shadowed;
4405 shadowed = TREE_CHAIN (shadowed))
4406 SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (shadowed), TREE_VALUE (shadowed));
4408 /* Remove the bindings for all of the class-level declarations. */
4409 if (level->class_shadowed)
4411 FOR_EACH_VEC_ELT (*level->class_shadowed, i, cb)
4413 IDENTIFIER_BINDING (cb->identifier) = cb->base->previous;
4414 cxx_binding_free (cb->base);
4416 ggc_free (level->class_shadowed);
4417 level->class_shadowed = NULL;
4420 /* Now, pop out of the binding level which we created up in the
4421 `pushlevel_class' routine. */
4422 gcc_assert (current_binding_level == level);
4424 timevar_cond_stop (TV_NAME_LOOKUP, subtime);
4427 /* Set INHERITED_VALUE_BINDING_P on BINDING to true or false, as
4428 appropriate. DECL is the value to which a name has just been
4429 bound. CLASS_TYPE is the class in which the lookup occurred. */
4432 set_inherited_value_binding_p (cxx_binding *binding, tree decl,
4435 if (binding->value == decl && TREE_CODE (decl) != TREE_LIST)
4439 if (TREE_CODE (decl) == OVERLOAD)
4440 context = ovl_scope (decl);
4443 gcc_assert (DECL_P (decl));
4444 context = context_for_name_lookup (decl);
4447 if (is_properly_derived_from (class_type, context))
4448 INHERITED_VALUE_BINDING_P (binding) = 1;
4450 INHERITED_VALUE_BINDING_P (binding) = 0;
4452 else if (binding->value == decl)
4453 /* We only encounter a TREE_LIST when there is an ambiguity in the
4454 base classes. Such an ambiguity can be overridden by a
4455 definition in this class. */
4456 INHERITED_VALUE_BINDING_P (binding) = 1;
4458 INHERITED_VALUE_BINDING_P (binding) = 0;
4461 /* Make the declaration of X appear in CLASS scope. */
4464 pushdecl_class_level (tree x)
4466 bool is_valid = true;
4469 /* Do nothing if we're adding to an outer lambda closure type,
4470 outer_binding will add it later if it's needed. */
4471 if (current_class_type != class_binding_level->this_entity)
4474 subtime = timevar_cond_start (TV_NAME_LOOKUP);
4475 /* Get the name of X. */
4476 tree name = OVL_NAME (x);
4480 is_valid = push_class_level_binding (name, x);
4481 if (TREE_CODE (x) == TYPE_DECL)
4482 set_identifier_type_value (name, x);
4484 else if (ANON_AGGR_TYPE_P (TREE_TYPE (x)))
4486 /* If X is an anonymous aggregate, all of its members are
4487 treated as if they were members of the class containing the
4488 aggregate, for naming purposes. */
4489 location_t save_location = input_location;
4490 tree anon = TREE_TYPE (x);
4491 if (vec<tree, va_gc> *member_vec = CLASSTYPE_MEMBER_VEC (anon))
4492 for (unsigned ix = member_vec->length (); ix--;)
4494 tree binding = (*member_vec)[ix];
4495 if (STAT_HACK_P (binding))
4497 if (!pushdecl_class_level (STAT_TYPE (binding)))
4499 binding = STAT_DECL (binding);
4501 if (!pushdecl_class_level (binding))
4505 for (tree f = TYPE_FIELDS (anon); f; f = DECL_CHAIN (f))
4506 if (TREE_CODE (f) == FIELD_DECL)
4508 input_location = DECL_SOURCE_LOCATION (f);
4509 if (!pushdecl_class_level (f))
4512 input_location = save_location;
4514 timevar_cond_stop (TV_NAME_LOOKUP, subtime);
4518 /* Return the BINDING (if any) for NAME in SCOPE, which is a class
4519 scope. If the value returned is non-NULL, and the PREVIOUS field
4520 is not set, callers must set the PREVIOUS field explicitly. */
4522 static cxx_binding *
4523 get_class_binding (tree name, cp_binding_level *scope)
4528 cxx_binding *binding;
4530 class_type = scope->this_entity;
4532 /* Get the type binding. */
4533 type_binding = lookup_member (class_type, name,
4534 /*protect=*/2, /*want_type=*/true,
4535 tf_warning_or_error);
4536 /* Get the value binding. */
4537 value_binding = lookup_member (class_type, name,
4538 /*protect=*/2, /*want_type=*/false,
4539 tf_warning_or_error);
4542 && (TREE_CODE (value_binding) == TYPE_DECL
4543 || DECL_CLASS_TEMPLATE_P (value_binding)
4544 || (TREE_CODE (value_binding) == TREE_LIST
4545 && TREE_TYPE (value_binding) == error_mark_node
4546 && (TREE_CODE (TREE_VALUE (value_binding))
4548 /* We found a type binding, even when looking for a non-type
4549 binding. This means that we already processed this binding
4552 else if (value_binding)
4554 if (TREE_CODE (value_binding) == TREE_LIST
4555 && TREE_TYPE (value_binding) == error_mark_node)
4556 /* NAME is ambiguous. */
4558 else if (BASELINK_P (value_binding))
4559 /* NAME is some overloaded functions. */
4560 value_binding = BASELINK_FUNCTIONS (value_binding);
4563 /* If we found either a type binding or a value binding, create a
4564 new binding object. */
4565 if (type_binding || value_binding)
4567 binding = new_class_binding (name,
4571 /* This is a class-scope binding, not a block-scope binding. */
4572 LOCAL_BINDING_P (binding) = 0;
4573 set_inherited_value_binding_p (binding, value_binding, class_type);
4581 /* Make the declaration(s) of X appear in CLASS scope under the name
4582 NAME. Returns true if the binding is valid. */
4585 push_class_level_binding_1 (tree name, tree x)
4587 cxx_binding *binding;
4591 /* The class_binding_level will be NULL if x is a template
4592 parameter name in a member template. */
4593 if (!class_binding_level)
4596 if (name == error_mark_node)
4599 /* Can happen for an erroneous declaration (c++/60384). */
4600 if (!identifier_p (name))
4602 gcc_assert (errorcount || sorrycount);
4606 /* Check for invalid member names. But don't worry about a default
4607 argument-scope lambda being pushed after the class is complete. */
4608 gcc_assert (TYPE_BEING_DEFINED (current_class_type)
4609 || LAMBDA_TYPE_P (TREE_TYPE (decl)));
4610 /* Check that we're pushing into the right binding level. */
4611 gcc_assert (current_class_type == class_binding_level->this_entity);
4613 /* We could have been passed a tree list if this is an ambiguous
4614 declaration. If so, pull the declaration out because
4615 check_template_shadow will not handle a TREE_LIST. */
4616 if (TREE_CODE (decl) == TREE_LIST
4617 && TREE_TYPE (decl) == error_mark_node)
4618 decl = TREE_VALUE (decl);
4620 if (!check_template_shadow (decl))
4625 If T is the name of a class, then each of the following shall
4626 have a name different from T:
4628 -- every static data member of class T;
4630 -- every member of class T that is itself a type;
4632 -- every enumerator of every member of class T that is an
4635 -- every member of every anonymous union that is a member of
4638 (Non-static data members were also forbidden to have the same
4639 name as T until TC1.) */
4641 || TREE_CODE (x) == CONST_DECL
4642 || (TREE_CODE (x) == TYPE_DECL
4643 && !DECL_SELF_REFERENCE_P (x))
4644 /* A data member of an anonymous union. */
4645 || (TREE_CODE (x) == FIELD_DECL
4646 && DECL_CONTEXT (x) != current_class_type))
4647 && DECL_NAME (x) == DECL_NAME (TYPE_NAME (current_class_type)))
4649 tree scope = context_for_name_lookup (x);
4650 if (TYPE_P (scope) && same_type_p (scope, current_class_type))
4652 error ("%qD has the same name as the class in which it is "
4659 /* Get the current binding for NAME in this class, if any. */
4660 binding = IDENTIFIER_BINDING (name);
4661 if (!binding || binding->scope != class_binding_level)
4663 binding = get_class_binding (name, class_binding_level);
4664 /* If a new binding was created, put it at the front of the
4665 IDENTIFIER_BINDING list. */
4668 binding->previous = IDENTIFIER_BINDING (name);
4669 IDENTIFIER_BINDING (name) = binding;
4673 /* If there is already a binding, then we may need to update the
4675 if (binding && binding->value)
4677 tree bval = binding->value;
4678 tree old_decl = NULL_TREE;
4679 tree target_decl = strip_using_decl (decl);
4680 tree target_bval = strip_using_decl (bval);
4682 if (INHERITED_VALUE_BINDING_P (binding))
4684 /* If the old binding was from a base class, and was for a
4685 tag name, slide it over to make room for the new binding.
4686 The old binding is still visible if explicitly qualified
4687 with a class-key. */
4688 if (TREE_CODE (target_bval) == TYPE_DECL
4689 && DECL_ARTIFICIAL (target_bval)
4690 && !(TREE_CODE (target_decl) == TYPE_DECL
4691 && DECL_ARTIFICIAL (target_decl)))
4693 old_decl = binding->type;
4694 binding->type = bval;
4695 binding->value = NULL_TREE;
4696 INHERITED_VALUE_BINDING_P (binding) = 0;
4701 /* Any inherited type declaration is hidden by the type
4702 declaration in the derived class. */
4703 if (TREE_CODE (target_decl) == TYPE_DECL
4704 && DECL_ARTIFICIAL (target_decl))
4705 binding->type = NULL_TREE;
4708 else if (TREE_CODE (target_decl) == OVERLOAD
4709 && OVL_P (target_bval))
4711 else if (TREE_CODE (decl) == USING_DECL
4712 && TREE_CODE (bval) == USING_DECL
4713 && same_type_p (USING_DECL_SCOPE (decl),
4714 USING_DECL_SCOPE (bval)))
4715 /* This is a using redeclaration that will be diagnosed later
4716 in supplement_binding */
4718 else if (TREE_CODE (decl) == USING_DECL
4719 && TREE_CODE (bval) == USING_DECL
4720 && DECL_DEPENDENT_P (decl)
4721 && DECL_DEPENDENT_P (bval))
4723 else if (TREE_CODE (decl) == USING_DECL
4724 && OVL_P (target_bval))
4726 else if (TREE_CODE (bval) == USING_DECL
4727 && OVL_P (target_decl))
4730 if (old_decl && binding->scope == class_binding_level)
4733 /* It is always safe to clear INHERITED_VALUE_BINDING_P
4734 here. This function is only used to register bindings
4735 from with the class definition itself. */
4736 INHERITED_VALUE_BINDING_P (binding) = 0;
4741 /* Note that we declared this value so that we can issue an error if
4742 this is an invalid redeclaration of a name already used for some
4744 note_name_declared_in_class (name, decl);
4746 /* If we didn't replace an existing binding, put the binding on the
4747 stack of bindings for the identifier, and update the shadowed
4749 if (binding && binding->scope == class_binding_level)
4750 /* Supplement the existing binding. */
4751 ok = supplement_binding (binding, decl);
4754 /* Create a new binding. */
4755 push_binding (name, decl, class_binding_level);
4762 /* Wrapper for push_class_level_binding_1. */
4765 push_class_level_binding (tree name, tree x)
4768 bool subtime = timevar_cond_start (TV_NAME_LOOKUP);
4769 ret = push_class_level_binding_1 (name, x);
4770 timevar_cond_stop (TV_NAME_LOOKUP, subtime);
4774 /* Process "using SCOPE::NAME" in a class scope. Return the
4775 USING_DECL created. */
4778 do_class_using_decl (tree scope, tree name)
4780 if (name == error_mark_node)
4783 if (!scope || !TYPE_P (scope))
4785 error ("using-declaration for non-member at class scope");
4789 /* Make sure the name is not invalid */
4790 if (TREE_CODE (name) == BIT_NOT_EXPR)
4792 error ("%<%T::%D%> names destructor", scope, name);
4796 /* Using T::T declares inheriting ctors, even if T is a typedef. */
4797 if (MAYBE_CLASS_TYPE_P (scope)
4798 && (name == TYPE_IDENTIFIER (scope)
4799 || constructor_name_p (name, scope)))
4801 maybe_warn_cpp0x (CPP0X_INHERITING_CTORS);
4802 name = ctor_identifier;
4803 CLASSTYPE_NON_AGGREGATE (current_class_type) = true;
4806 /* Cannot introduce a constructor name. */
4807 if (constructor_name_p (name, current_class_type))
4809 error ("%<%T::%D%> names constructor in %qT",
4810 scope, name, current_class_type);
4814 /* From [namespace.udecl]:
4816 A using-declaration used as a member-declaration shall refer to a
4817 member of a base class of the class being defined.
4819 In general, we cannot check this constraint in a template because
4820 we do not know the entire set of base classes of the current
4821 class type. Morover, if SCOPE is dependent, it might match a
4822 non-dependent base. */
4824 tree decl = NULL_TREE;
4825 if (!dependent_scope_p (scope))
4828 tree binfo = lookup_base (current_class_type, scope, ba_any, &b_kind,
4829 tf_warning_or_error);
4830 if (b_kind < bk_proper_base)
4832 /* If there are dependent bases, scope might resolve at
4833 instantiation time, even if it isn't exactly one of the
4835 if (b_kind == bk_same_type || !any_dependent_bases_p ())
4837 error_not_base_type (scope, current_class_type);
4841 else if (name == ctor_identifier && !binfo_direct_p (binfo))
4843 error ("cannot inherit constructors from indirect base %qT", scope);
4846 else if (!IDENTIFIER_CONV_OP_P (name)
4847 || !dependent_type_p (TREE_TYPE (name)))
4849 decl = lookup_member (binfo, name, 0, false, tf_warning_or_error);
4852 error ("no members matching %<%T::%D%> in %q#T", scope, name,
4857 /* The binfo from which the functions came does not matter. */
4858 if (BASELINK_P (decl))
4859 decl = BASELINK_FUNCTIONS (decl);
4863 tree value = build_lang_decl (USING_DECL, name, NULL_TREE);
4864 USING_DECL_DECLS (value) = decl;
4865 USING_DECL_SCOPE (value) = scope;
4866 DECL_DEPENDENT_P (value) = !decl;
4872 /* Return the binding for NAME in NS. If NS is NULL, look in
4873 global_namespace. */
4876 get_namespace_binding (tree ns, tree name)
4878 bool subtime = timevar_cond_start (TV_NAME_LOOKUP);
4880 ns = global_namespace;
4881 gcc_checking_assert (!DECL_NAMESPACE_ALIAS (ns));
4882 tree ret = find_namespace_value (ns, name);
4883 timevar_cond_stop (TV_NAME_LOOKUP, subtime);
4887 /* Push internal DECL into the global namespace. Does not do the
4888 full overload fn handling and does not add it to the list of things
4889 in the namespace. */
4892 set_global_binding (tree decl)
4894 bool subtime = timevar_cond_start (TV_NAME_LOOKUP);
4896 tree *slot = find_namespace_slot (global_namespace, DECL_NAME (decl), true);
4899 /* The user's placed something in the implementor's namespace. */
4900 diagnose_name_conflict (decl, MAYBE_STAT_DECL (*slot));
4902 /* Force the binding, so compiler internals continue to work. */
4905 timevar_cond_stop (TV_NAME_LOOKUP, subtime);
4908 /* Set the context of a declaration to scope. Complain if we are not
4912 set_decl_namespace (tree decl, tree scope, bool friendp)
4914 /* Get rid of namespace aliases. */
4915 scope = ORIGINAL_NAMESPACE (scope);
4917 /* It is ok for friends to be qualified in parallel space. */
4918 if (!friendp && !is_nested_namespace (current_namespace, scope))
4919 error ("declaration of %qD not in a namespace surrounding %qD",
4921 DECL_CONTEXT (decl) = FROB_CONTEXT (scope);
4923 /* See whether this has been declared in the namespace or inline
4925 tree old = NULL_TREE;
4927 name_lookup lookup (DECL_NAME (decl), LOOKUP_HIDDEN);
4928 if (!lookup.search_qualified (scope, /*usings=*/false))
4929 /* No old declaration at all. */
4934 /* If it's a TREE_LIST, the result of the lookup was ambiguous. */
4935 if (TREE_CODE (old) == TREE_LIST)
4938 DECL_CONTEXT (decl) = FROB_CONTEXT (scope);
4939 error ("reference to %qD is ambiguous", decl);
4940 print_candidates (old);
4944 if (!DECL_DECLARES_FUNCTION_P (decl))
4946 /* Don't compare non-function decls with decls_match here, since
4947 it can't check for the correct constness at this
4948 point. pushdecl will find those errors later. */
4950 /* We might have found it in an inline namespace child of SCOPE. */
4951 if (TREE_CODE (decl) == TREE_CODE (old))
4952 DECL_CONTEXT (decl) = DECL_CONTEXT (old);
4955 /* Writing "N::i" to declare something directly in "N" is invalid. */
4956 if (CP_DECL_CONTEXT (decl) == current_namespace
4957 && at_namespace_scope_p ())
4958 error ("explicit qualification in declaration of %qD", decl);
4962 /* Since decl is a function, old should contain a function decl. */
4966 /* We handle these in check_explicit_instantiation_namespace. */
4967 if (processing_explicit_instantiation)
4969 if (processing_template_decl || processing_specialization)
4970 /* We have not yet called push_template_decl to turn a
4971 FUNCTION_DECL into a TEMPLATE_DECL, so the declarations won't
4972 match. But, we'll check later, when we construct the
4975 /* Instantiations or specializations of templates may be declared as
4976 friends in any namespace. */
4977 if (friendp && DECL_USE_TEMPLATE (decl))
4983 for (lkp_iterator iter (old); iter; ++iter)
4985 if (iter.using_p ())
4990 /* Adjust DECL_CONTEXT first so decls_match will return true
4991 if DECL will match a declaration in an inline namespace. */
4992 DECL_CONTEXT (decl) = DECL_CONTEXT (ofn);
4993 if (decls_match (decl, ofn))
4997 /* We found more than one matching declaration. */
4998 DECL_CONTEXT (decl) = FROB_CONTEXT (scope);
5007 if (DECL_HIDDEN_FRIEND_P (found))
5009 pedwarn (DECL_SOURCE_LOCATION (decl), 0,
5010 "%qD has not been declared within %qD", decl, scope);
5011 inform (DECL_SOURCE_LOCATION (found),
5012 "only here as a %<friend%>");
5014 DECL_CONTEXT (decl) = DECL_CONTEXT (found);
5019 /* It didn't work, go back to the explicit scope. */
5020 DECL_CONTEXT (decl) = FROB_CONTEXT (scope);
5021 error ("%qD should have been declared inside %qD", decl, scope);
5024 /* Return the namespace where the current declaration is declared. */
5027 current_decl_namespace (void)
5030 /* If we have been pushed into a different namespace, use it. */
5031 if (!vec_safe_is_empty (decl_namespace_list))
5032 return decl_namespace_list->last ();
5034 if (current_class_type)
5035 result = decl_namespace_context (current_class_type);
5036 else if (current_function_decl)
5037 result = decl_namespace_context (current_function_decl);
5039 result = current_namespace;
5043 /* Process any ATTRIBUTES on a namespace definition. Returns true if
5044 attribute visibility is seen. */
5047 handle_namespace_attrs (tree ns, tree attributes)
5050 bool saw_vis = false;
5052 if (attributes == error_mark_node)
5055 for (d = attributes; d; d = TREE_CHAIN (d))
5057 tree name = get_attribute_name (d);
5058 tree args = TREE_VALUE (d);
5060 if (is_attribute_p ("visibility", name))
5062 /* attribute visibility is a property of the syntactic block
5063 rather than the namespace as a whole, so we don't touch the
5064 NAMESPACE_DECL at all. */
5065 tree x = args ? TREE_VALUE (args) : NULL_TREE;
5066 if (x == NULL_TREE || TREE_CODE (x) != STRING_CST || TREE_CHAIN (args))
5068 warning (OPT_Wattributes,
5069 "%qD attribute requires a single NTBS argument",
5074 if (!TREE_PUBLIC (ns))
5075 warning (OPT_Wattributes,
5076 "%qD attribute is meaningless since members of the "
5077 "anonymous namespace get local symbols", name);
5079 push_visibility (TREE_STRING_POINTER (x), 1);
5082 else if (is_attribute_p ("abi_tag", name))
5084 if (!DECL_NAME (ns))
5086 warning (OPT_Wattributes, "ignoring %qD attribute on anonymous "
5090 if (!DECL_NAMESPACE_INLINE_P (ns))
5092 warning (OPT_Wattributes, "ignoring %qD attribute on non-inline "
5098 tree dn = DECL_NAME (ns);
5099 args = build_string (IDENTIFIER_LENGTH (dn) + 1,
5100 IDENTIFIER_POINTER (dn));
5101 TREE_TYPE (args) = char_array_type_node;
5102 args = fix_string_type (args);
5103 args = build_tree_list (NULL_TREE, args);
5105 if (check_abi_tag_args (args, name))
5106 DECL_ATTRIBUTES (ns) = tree_cons (name, args,
5107 DECL_ATTRIBUTES (ns));
5111 warning (OPT_Wattributes, "%qD attribute directive ignored",
5120 /* Temporarily set the namespace for the current declaration. */
5123 push_decl_namespace (tree decl)
5125 if (TREE_CODE (decl) != NAMESPACE_DECL)
5126 decl = decl_namespace_context (decl);
5127 vec_safe_push (decl_namespace_list, ORIGINAL_NAMESPACE (decl));
5130 /* [namespace.memdef]/2 */
5133 pop_decl_namespace (void)
5135 decl_namespace_list->pop ();
5138 /* Process a namespace-alias declaration. */
5141 do_namespace_alias (tree alias, tree name_space)
5143 if (name_space == error_mark_node)
5146 gcc_assert (TREE_CODE (name_space) == NAMESPACE_DECL);
5148 name_space = ORIGINAL_NAMESPACE (name_space);
5150 /* Build the alias. */
5151 alias = build_lang_decl (NAMESPACE_DECL, alias, void_type_node);
5152 DECL_NAMESPACE_ALIAS (alias) = name_space;
5153 DECL_EXTERNAL (alias) = 1;
5154 DECL_CONTEXT (alias) = FROB_CONTEXT (current_scope ());
5157 /* Emit debug info for namespace alias. */
5158 if (!building_stmt_list_p ())
5159 (*debug_hooks->early_global_decl) (alias);
5162 /* Like pushdecl, only it places X in the current namespace,
5166 pushdecl_namespace_level (tree x, bool is_friend)
5168 cp_binding_level *b = current_binding_level;
5171 bool subtime = timevar_cond_start (TV_NAME_LOOKUP);
5172 t = do_pushdecl_with_scope
5173 (x, NAMESPACE_LEVEL (current_namespace), is_friend);
5175 /* Now, the type_shadowed stack may screw us. Munge it so it does
5177 if (TREE_CODE (t) == TYPE_DECL)
5179 tree name = DECL_NAME (t);
5181 tree *ptr = (tree *)0;
5182 for (; !global_scope_p (b); b = b->level_chain)
5184 tree shadowed = b->type_shadowed;
5185 for (; shadowed; shadowed = TREE_CHAIN (shadowed))
5186 if (TREE_PURPOSE (shadowed) == name)
5188 ptr = &TREE_VALUE (shadowed);
5189 /* Can't break out of the loop here because sometimes
5190 a binding level will have duplicate bindings for
5191 PT names. It's gross, but I haven't time to fix it. */
5194 newval = TREE_TYPE (t);
5195 if (ptr == (tree *)0)
5197 /* @@ This shouldn't be needed. My test case "zstring.cc" trips
5198 up here if this is changed to an assertion. --KR */
5199 SET_IDENTIFIER_TYPE_VALUE (name, t);
5206 timevar_cond_stop (TV_NAME_LOOKUP, subtime);
5210 /* Process a using-declaration appearing in namespace scope. */
5213 finish_namespace_using_decl (tree decl, tree scope, tree name)
5215 tree orig_decl = decl;
5217 gcc_checking_assert (current_binding_level->kind == sk_namespace
5218 && !processing_template_decl);
5219 decl = validate_nonmember_using_decl (decl, scope, name);
5220 if (decl == NULL_TREE)
5223 tree *slot = find_namespace_slot (current_namespace, name, true);
5224 tree val = slot ? MAYBE_STAT_DECL (*slot) : NULL_TREE;
5225 tree type = slot ? MAYBE_STAT_TYPE (*slot) : NULL_TREE;
5226 do_nonmember_using_decl (scope, name, &val, &type);
5227 if (STAT_HACK_P (*slot))
5229 STAT_DECL (*slot) = val;
5230 STAT_TYPE (*slot) = type;
5233 *slot = stat_hack (val, type);
5237 /* Emit debug info. */
5238 cp_emit_debug_info_for_using (orig_decl, current_namespace);
5241 /* Process a using-declaration at function scope. */
5244 finish_local_using_decl (tree decl, tree scope, tree name)
5246 tree orig_decl = decl;
5248 gcc_checking_assert (current_binding_level->kind != sk_class
5249 && current_binding_level->kind != sk_namespace);
5250 decl = validate_nonmember_using_decl (decl, scope, name);
5251 if (decl == NULL_TREE)
5254 add_decl_expr (decl);
5256 cxx_binding *binding = find_local_binding (current_binding_level, name);
5257 tree value = binding ? binding->value : NULL_TREE;
5258 tree type = binding ? binding->type : NULL_TREE;
5260 do_nonmember_using_decl (scope, name, &value, &type);
5264 else if (binding && value == binding->value)
5266 else if (binding && binding->value && TREE_CODE (value) == OVERLOAD)
5268 update_local_overload (IDENTIFIER_BINDING (name), value);
5269 IDENTIFIER_BINDING (name)->value = value;
5272 /* Install the new binding. */
5273 push_local_binding (name, value, true);
5277 else if (binding && type == binding->type)
5281 push_local_binding (name, type, true);
5282 set_identifier_type_value (name, type);
5285 /* Emit debug info. */
5286 if (!processing_template_decl)
5287 cp_emit_debug_info_for_using (orig_decl, current_scope ());
5290 /* Return the declarations that are members of the namespace NS. */
5293 cp_namespace_decls (tree ns)
5295 return NAMESPACE_LEVEL (ns)->names;
5298 /* Combine prefer_type and namespaces_only into flags. */
5301 lookup_flags (int prefer_type, int namespaces_only)
5303 if (namespaces_only)
5304 return LOOKUP_PREFER_NAMESPACES;
5305 if (prefer_type > 1)
5306 return LOOKUP_PREFER_TYPES;
5307 if (prefer_type > 0)
5308 return LOOKUP_PREFER_BOTH;
5312 /* Given a lookup that returned VAL, use FLAGS to decide if we want to
5313 ignore it or not. Subroutine of lookup_name_real and
5314 lookup_type_scope. */
5317 qualify_lookup (tree val, int flags)
5319 if (val == NULL_TREE)
5321 if ((flags & LOOKUP_PREFER_NAMESPACES) && TREE_CODE (val) == NAMESPACE_DECL)
5323 if (flags & LOOKUP_PREFER_TYPES)
5325 tree target_val = strip_using_decl (val);
5326 if (TREE_CODE (target_val) == TYPE_DECL
5327 || TREE_CODE (target_val) == TEMPLATE_DECL)
5330 if (flags & (LOOKUP_PREFER_NAMESPACES | LOOKUP_PREFER_TYPES))
5332 /* Look through lambda things that we shouldn't be able to see. */
5333 if (!(flags & LOOKUP_HIDDEN) && is_lambda_ignored_entity (val))
5338 /* Is there a "using namespace std;" directive within USINGS? */
5341 using_directives_contain_std_p (vec<tree, va_gc> *usings)
5346 for (unsigned ix = usings->length (); ix--;)
5347 if ((*usings)[ix] == std_node)
5353 /* Is there a "using namespace std;" directive within the current
5354 namespace (or its ancestors)?
5355 Compare with name_lookup::search_unqualified. */
5358 has_using_namespace_std_directive_p ()
5360 /* Look at local using-directives. */
5361 for (cp_binding_level *level = current_binding_level;
5362 level->kind != sk_namespace;
5363 level = level->level_chain)
5364 if (using_directives_contain_std_p (level->using_directives))
5367 /* Look at this namespace and its ancestors. */
5368 for (tree scope = current_namespace; scope; scope = CP_DECL_CONTEXT (scope))
5370 if (using_directives_contain_std_p (DECL_NAMESPACE_USING (scope)))
5373 if (scope == global_namespace)
5380 /* Suggest alternatives for NAME, an IDENTIFIER_NODE for which name
5381 lookup failed. Search through all available namespaces and print out
5382 possible candidates. If no exact matches are found, and
5383 SUGGEST_MISSPELLINGS is true, then also look for near-matches and
5384 suggest the best near-match, if there is one. */
5387 suggest_alternatives_for (location_t location, tree name,
5388 bool suggest_misspellings)
5390 vec<tree> candidates = vNULL;
5391 vec<tree> worklist = vNULL;
5392 unsigned limit = PARAM_VALUE (CXX_MAX_NAMESPACES_FOR_DIAGNOSTIC_HELP);
5393 bool limited = false;
5395 /* Breadth-first search of namespaces. Up to limit namespaces
5396 searched (limit zero == unlimited). */
5397 worklist.safe_push (global_namespace);
5398 for (unsigned ix = 0; ix != worklist.length (); ix++)
5400 tree ns = worklist[ix];
5401 name_lookup lookup (name);
5403 if (lookup.search_qualified (ns, false))
5404 candidates.safe_push (lookup.value);
5408 /* Look for child namespaces. We have to do this
5409 indirectly because they are chained in reverse order,
5410 which is confusing to the user. */
5411 vec<tree> children = vNULL;
5413 for (tree decl = NAMESPACE_LEVEL (ns)->names;
5414 decl; decl = TREE_CHAIN (decl))
5415 if (TREE_CODE (decl) == NAMESPACE_DECL
5416 && !DECL_NAMESPACE_ALIAS (decl)
5417 && !DECL_NAMESPACE_INLINE_P (decl))
5418 children.safe_push (decl);
5420 while (!limited && !children.is_empty ())
5422 if (worklist.length () == limit)
5424 /* Unconditionally warn that the search was truncated. */
5426 "maximum limit of %d namespaces searched for %qE",
5431 worklist.safe_push (children.pop ());
5433 children.release ();
5436 worklist.release ();
5438 if (candidates.length ())
5440 inform_n (location, candidates.length (),
5441 "suggested alternative:",
5442 "suggested alternatives:");
5443 for (unsigned ix = 0; ix != candidates.length (); ix++)
5445 tree val = candidates[ix];
5447 inform (location_of (val), " %qE", val);
5449 candidates.release ();
5453 /* No candidates were found in the available namespaces. */
5455 /* If there's a "using namespace std;" active, and this
5456 is one of the most common "std::" names, then it's probably a
5457 missing #include. */
5458 if (has_using_namespace_std_directive_p ())
5459 if (maybe_suggest_missing_std_header (location, name))
5462 /* Otherwise, consider misspellings. */
5463 if (!suggest_misspellings)
5465 if (name_hint hint = lookup_name_fuzzy (name, FUZZY_LOOKUP_NAME,
5468 /* Show a spelling correction. */
5469 gcc_rich_location richloc (location);
5471 richloc.add_fixit_replace (hint.suggestion ());
5472 inform (&richloc, "suggested alternative: %qs", hint.suggestion ());
5476 /* A well-known name within the C++ standard library, returned by
5477 get_std_name_hint. */
5479 struct std_name_hint
5481 /* A name within "std::". */
5484 /* The header name defining it within the C++ Standard Library
5485 (with '<' and '>'). */
5488 /* The dialect of C++ in which this was added. */
5489 enum cxx_dialect min_dialect;
5492 /* Subroutine of maybe_suggest_missing_header for handling unrecognized names
5493 for some of the most common names within "std::".
5494 Given non-NULL NAME, return the std_name_hint for it, or NULL. */
5496 static const std_name_hint *
5497 get_std_name_hint (const char *name)
5499 static const std_name_hint hints[] = {
5501 {"any", "<any>", cxx17},
5502 {"any_cast", "<any>", cxx17},
5503 {"make_any", "<any>", cxx17},
5505 {"array", "<array>", cxx11},
5507 {"atomic", "<atomic>", cxx11},
5508 {"atomic_flag", "<atomic>", cxx11},
5510 {"bitset", "<bitset>", cxx11},
5512 {"complex", "<complex>", cxx98},
5513 {"complex_literals", "<complex>", cxx98},
5514 /* <condition_variable>. */
5515 {"condition_variable", "<condition_variable>", cxx11},
5516 {"condition_variable_any", "<condition_variable>", cxx11},
5518 {"deque", "<deque>", cxx98},
5519 /* <forward_list>. */
5520 {"forward_list", "<forward_list>", cxx11},
5522 {"basic_filebuf", "<fstream>", cxx98},
5523 {"basic_ifstream", "<fstream>", cxx98},
5524 {"basic_ofstream", "<fstream>", cxx98},
5525 {"basic_fstream", "<fstream>", cxx98},
5526 {"fstream", "<fstream>", cxx98},
5527 {"ifstream", "<fstream>", cxx98},
5528 {"ofstream", "<fstream>", cxx98},
5530 {"bind", "<functional>", cxx11},
5531 {"function", "<functional>", cxx11},
5532 {"hash", "<functional>", cxx11},
5533 {"mem_fn", "<functional>", cxx11},
5535 {"async", "<future>", cxx11},
5536 {"future", "<future>", cxx11},
5537 {"packaged_task", "<future>", cxx11},
5538 {"promise", "<future>", cxx11},
5540 {"cin", "<iostream>", cxx98},
5541 {"cout", "<iostream>", cxx98},
5542 {"cerr", "<iostream>", cxx98},
5543 {"clog", "<iostream>", cxx98},
5544 {"wcin", "<iostream>", cxx98},
5545 {"wcout", "<iostream>", cxx98},
5546 {"wclog", "<iostream>", cxx98},
5548 {"istream", "<istream>", cxx98},
5550 {"advance", "<iterator>", cxx98},
5551 {"back_inserter", "<iterator>", cxx98},
5552 {"begin", "<iterator>", cxx11},
5553 {"distance", "<iterator>", cxx98},
5554 {"end", "<iterator>", cxx11},
5555 {"front_inserter", "<iterator>", cxx98},
5556 {"inserter", "<iterator>", cxx98},
5557 {"istream_iterator", "<iterator>", cxx98},
5558 {"istreambuf_iterator", "<iterator>", cxx98},
5559 {"iterator_traits", "<iterator>", cxx98},
5560 {"move_iterator", "<iterator>", cxx11},
5561 {"next", "<iterator>", cxx11},
5562 {"ostream_iterator", "<iterator>", cxx98},
5563 {"ostreambuf_iterator", "<iterator>", cxx98},
5564 {"prev", "<iterator>", cxx11},
5565 {"reverse_iterator", "<iterator>", cxx98},
5567 {"ostream", "<ostream>", cxx98},
5569 {"list", "<list>", cxx98},
5571 {"map", "<map>", cxx98},
5572 {"multimap", "<map>", cxx98},
5574 {"make_shared", "<memory>", cxx11},
5575 {"make_unique", "<memory>", cxx11},
5576 {"shared_ptr", "<memory>", cxx11},
5577 {"unique_ptr", "<memory>", cxx11},
5578 {"weak_ptr", "<memory>", cxx11},
5580 {"mutex", "<mutex>", cxx11},
5581 {"timed_mutex", "<mutex>", cxx11},
5582 {"recursive_mutex", "<mutex>", cxx11},
5583 {"recursive_timed_mutex", "<mutex>", cxx11},
5584 {"once_flag", "<mutex>", cxx11},
5585 {"call_once,", "<mutex>", cxx11},
5586 {"lock", "<mutex>", cxx11},
5587 {"scoped_lock", "<mutex>", cxx17},
5588 {"try_lock", "<mutex>", cxx11},
5589 {"lock_guard", "<mutex>", cxx11},
5590 {"unique_lock", "<mutex>", cxx11},
5592 {"optional", "<optional>", cxx17},
5593 {"make_optional", "<optional>", cxx17},
5595 {"ostream", "<ostream>", cxx98},
5596 {"wostream", "<ostream>", cxx98},
5597 {"ends", "<ostream>", cxx98},
5598 {"flush", "<ostream>", cxx98},
5599 {"endl", "<ostream>", cxx98},
5601 {"queue", "<queue>", cxx98},
5602 {"priority_queue", "<queue>", cxx98},
5604 {"set", "<set>", cxx98},
5605 {"multiset", "<set>", cxx98},
5606 /* <shared_mutex>. */
5607 {"shared_lock", "<shared_mutex>", cxx14},
5608 {"shared_mutex", "<shared_mutex>", cxx17},
5609 {"shared_timed_mutex", "<shared_mutex>", cxx14},
5611 {"basic_stringbuf", "<sstream>", cxx98},
5612 {"basic_istringstream", "<sstream>", cxx98},
5613 {"basic_ostringstream", "<sstream>", cxx98},
5614 {"basic_stringstream", "<sstream>", cxx98},
5615 {"istringstream", "<sstream>", cxx98},
5616 {"ostringstream", "<sstream>", cxx98},
5617 {"stringstream", "<sstream>", cxx98},
5619 {"stack", "<stack>", cxx98},
5621 {"basic_string", "<string>", cxx98},
5622 {"string", "<string>", cxx98},
5623 {"wstring", "<string>", cxx98},
5624 {"u16string", "<string>", cxx11},
5625 {"u32string", "<string>", cxx11},
5626 /* <string_view>. */
5627 {"string_view", "<string_view>", cxx17},
5629 {"thread", "<thread>", cxx11},
5631 {"make_tuple", "<tuple>", cxx11},
5632 {"tuple", "<tuple>", cxx11},
5633 {"tuple_element", "<tuple>", cxx11},
5634 {"tuple_size", "<tuple>", cxx11},
5635 /* <unordered_map>. */
5636 {"unordered_map", "<unordered_map>", cxx11},
5637 {"unordered_multimap", "<unordered_map>", cxx11},
5638 /* <unordered_set>. */
5639 {"unordered_set", "<unordered_set>", cxx11},
5640 {"unordered_multiset", "<unordered_set>", cxx11},
5642 {"declval", "<utility>", cxx11},
5643 {"forward", "<utility>", cxx11},
5644 {"make_pair", "<utility>", cxx98},
5645 {"move", "<utility>", cxx11},
5646 {"pair", "<utility>", cxx98},
5648 {"variant", "<variant>", cxx17},
5649 {"visit", "<variant>", cxx17},
5651 {"vector", "<vector>", cxx98},
5653 const size_t num_hints = sizeof (hints) / sizeof (hints[0]);
5654 for (size_t i = 0; i < num_hints; i++)
5656 if (strcmp (name, hints[i].name) == 0)
5662 /* Describe DIALECT. */
5665 get_cxx_dialect_name (enum cxx_dialect dialect)
5684 /* Suggest pertinent header files for NAME at LOCATION, for common
5685 names within the "std" namespace.
5686 Return true iff a suggestion was offered. */
5689 maybe_suggest_missing_std_header (location_t location, tree name)
5691 gcc_assert (TREE_CODE (name) == IDENTIFIER_NODE);
5693 const char *name_str = IDENTIFIER_POINTER (name);
5694 const std_name_hint *header_hint = get_std_name_hint (name_str);
5698 gcc_rich_location richloc (location);
5699 if (cxx_dialect >= header_hint->min_dialect)
5701 const char *header = header_hint->header;
5702 maybe_add_include_fixit (&richloc, header);
5704 "%<std::%s%> is defined in header %qs;"
5705 " did you forget to %<#include %s%>?",
5706 name_str, header, header);
5711 "%<std::%s%> is only available from %s onwards",
5712 name_str, get_cxx_dialect_name (header_hint->min_dialect));
5717 /* If SCOPE is the "std" namespace, then suggest pertinent header
5718 files for NAME at LOCATION.
5719 Return true iff a suggestion was offered. */
5722 maybe_suggest_missing_header (location_t location, tree name, tree scope)
5724 if (scope == NULL_TREE)
5726 if (TREE_CODE (scope) != NAMESPACE_DECL)
5728 /* We only offer suggestions for the "std" namespace. */
5729 if (scope != std_node)
5731 return maybe_suggest_missing_std_header (location, name);
5734 /* Look for alternatives for NAME, an IDENTIFIER_NODE for which name
5735 lookup failed within the explicitly provided SCOPE. Suggest the
5736 the best meaningful candidates (if any) as a fix-it hint.
5737 Return true iff a suggestion was provided. */
5740 suggest_alternative_in_explicit_scope (location_t location, tree name,
5743 /* Something went very wrong; don't suggest anything. */
5744 if (name == error_mark_node)
5747 /* Resolve any namespace aliases. */
5748 scope = ORIGINAL_NAMESPACE (scope);
5750 if (maybe_suggest_missing_header (location, name, scope))
5753 cp_binding_level *level = NAMESPACE_LEVEL (scope);
5755 best_match <tree, const char *> bm (name);
5756 consider_binding_level (name, bm, level, false, FUZZY_LOOKUP_NAME);
5758 /* See if we have a good suggesion for the user. */
5759 const char *fuzzy_name = bm.get_best_meaningful_candidate ();
5762 gcc_rich_location richloc (location);
5763 richloc.add_fixit_replace (fuzzy_name);
5764 inform (&richloc, "suggested alternative: %qs",
5772 /* Look up NAME (an IDENTIFIER_NODE) in SCOPE (either a NAMESPACE_DECL
5775 If PREFER_TYPE is > 0, we only return TYPE_DECLs or namespaces.
5776 If PREFER_TYPE is > 1, we only return TYPE_DECLs.
5778 Returns a DECL (or OVERLOAD, or BASELINK) representing the
5779 declaration found. If no suitable declaration can be found,
5780 ERROR_MARK_NODE is returned. If COMPLAIN is true and SCOPE is
5781 neither a class-type nor a namespace a diagnostic is issued. */
5784 lookup_qualified_name (tree scope, tree name, int prefer_type, bool complain,
5789 if (TREE_CODE (scope) == NAMESPACE_DECL)
5791 int flags = lookup_flags (prefer_type, /*namespaces_only*/false);
5793 flags |= LOOKUP_HIDDEN;
5794 name_lookup lookup (name, flags);
5796 if (qualified_namespace_lookup (scope, &lookup))
5799 else if (cxx_dialect != cxx98 && TREE_CODE (scope) == ENUMERAL_TYPE)
5800 t = lookup_enumerator (scope, name);
5801 else if (is_class_type (scope, complain))
5802 t = lookup_member (scope, name, 2, prefer_type, tf_warning_or_error);
5805 return error_mark_node;
5810 Accepts the NAME to lookup and its qualifying SCOPE.
5811 Returns the name/type pair found into the cxx_binding *RESULT,
5812 or false on error. */
5815 qualified_namespace_lookup (tree scope, name_lookup *lookup)
5817 timevar_start (TV_NAME_LOOKUP);
5818 query_oracle (lookup->name);
5819 bool found = lookup->search_qualified (ORIGINAL_NAMESPACE (scope));
5820 timevar_stop (TV_NAME_LOOKUP);
5824 /* Helper function for lookup_name_fuzzy.
5825 Traverse binding level LVL, looking for good name matches for NAME
5828 consider_binding_level (tree name, best_match <tree, const char *> &bm,
5829 cp_binding_level *lvl, bool look_within_fields,
5830 enum lookup_name_fuzzy_kind kind)
5832 if (look_within_fields)
5833 if (lvl->this_entity && TREE_CODE (lvl->this_entity) == RECORD_TYPE)
5835 tree type = lvl->this_entity;
5836 bool want_type_p = (kind == FUZZY_LOOKUP_TYPENAME);
5837 tree best_matching_field
5838 = lookup_member_fuzzy (type, name, want_type_p);
5839 if (best_matching_field)
5840 bm.consider (IDENTIFIER_POINTER (best_matching_field));
5843 /* Only suggest names reserved for the implementation if NAME begins
5844 with an underscore. */
5845 bool consider_implementation_names = (IDENTIFIER_POINTER (name)[0] == '_');
5847 for (tree t = lvl->names; t; t = TREE_CHAIN (t))
5851 /* OVERLOADs or decls from using declaration are wrapped into
5853 if (TREE_CODE (d) == TREE_LIST)
5854 d = OVL_FIRST (TREE_VALUE (d));
5856 /* Don't use bindings from implicitly declared functions,
5857 as they were likely misspellings themselves. */
5858 if (TREE_TYPE (d) == error_mark_node)
5861 /* Skip anticipated decls of builtin functions. */
5862 if (TREE_CODE (d) == FUNCTION_DECL
5863 && DECL_BUILT_IN (d)
5864 && DECL_ANTICIPATED (d))
5867 tree suggestion = DECL_NAME (d);
5871 const char *suggestion_str = IDENTIFIER_POINTER (suggestion);
5873 /* Ignore internal names with spaces in them. */
5874 if (strchr (suggestion_str, ' '))
5877 /* Don't suggest names that are reserved for use by the
5878 implementation, unless NAME began with an underscore. */
5879 if (name_reserved_for_implementation_p (suggestion_str)
5880 && !consider_implementation_names)
5883 bm.consider (suggestion_str);
5887 /* Subclass of deferred_diagnostic. Notify the user that the
5888 given macro was used before it was defined.
5889 This can be done in the C++ frontend since tokenization happens
5892 class macro_use_before_def : public deferred_diagnostic
5895 /* Factory function. Return a new macro_use_before_def instance if
5896 appropriate, or return NULL. */
5897 static macro_use_before_def *
5898 maybe_make (location_t use_loc, cpp_hashnode *macro)
5900 source_location def_loc = cpp_macro_definition_location (macro);
5901 if (def_loc == UNKNOWN_LOCATION)
5904 /* We only want to issue a note if the macro was used *before* it was
5906 We don't want to issue a note for cases where a macro was incorrectly
5907 used, leaving it unexpanded (e.g. by using the wrong argument
5909 if (!linemap_location_before_p (line_table, use_loc, def_loc))
5912 return new macro_use_before_def (use_loc, macro);
5916 /* Ctor. LOC is the location of the usage. MACRO is the
5917 macro that was used. */
5918 macro_use_before_def (location_t loc, cpp_hashnode *macro)
5919 : deferred_diagnostic (loc), m_macro (macro)
5924 ~macro_use_before_def ()
5926 if (is_suppressed_p ())
5929 inform (get_location (), "the macro %qs had not yet been defined",
5930 (const char *)m_macro->ident.str);
5931 inform (cpp_macro_definition_location (m_macro),
5932 "it was later defined here");
5936 cpp_hashnode *m_macro;
5939 /* Determine if it can ever make sense to offer RID as a suggestion for
5942 Subroutine of lookup_name_fuzzy. */
5945 suggest_rid_p (enum rid rid)
5949 /* Support suggesting function-like keywords. */
5950 case RID_STATIC_ASSERT:
5954 /* Support suggesting the various decl-specifier words, to handle
5955 e.g. "singed" vs "signed" typos. */
5956 if (cp_keyword_starts_decl_specifier_p (rid))
5959 /* Otherwise, don't offer it. This avoids suggesting e.g. "if"
5960 and "do" for short misspellings, which are likely to lead to
5961 nonsensical results. */
5966 /* Search for near-matches for NAME within the current bindings, and within
5967 macro names, returning the best match as a const char *, or NULL if
5968 no reasonable match is found.
5970 Use LOC for any deferred diagnostics. */
5973 lookup_name_fuzzy (tree name, enum lookup_name_fuzzy_kind kind, location_t loc)
5975 gcc_assert (TREE_CODE (name) == IDENTIFIER_NODE);
5977 /* First, try some well-known names in the C++ standard library, in case
5978 the user forgot a #include. */
5979 const char *header_hint
5980 = get_cp_stdlib_header_for_name (IDENTIFIER_POINTER (name));
5982 return name_hint (NULL,
5983 new suggest_missing_header (loc,
5984 IDENTIFIER_POINTER (name),
5987 best_match <tree, const char *> bm (name);
5989 cp_binding_level *lvl;
5990 for (lvl = scope_chain->class_bindings; lvl; lvl = lvl->level_chain)
5991 consider_binding_level (name, bm, lvl, true, kind);
5993 for (lvl = current_binding_level; lvl; lvl = lvl->level_chain)
5994 consider_binding_level (name, bm, lvl, false, kind);
5996 /* Consider macros: if the user misspelled a macro name e.g. "SOME_MACRO"
5998 x = SOME_OTHER_MACRO (y);
5999 then "SOME_OTHER_MACRO" will survive to the frontend and show up
6000 as a misspelled identifier.
6002 Use the best distance so far so that a candidate is only set if
6003 a macro is better than anything so far. This allows early rejection
6004 (without calculating the edit distance) of macro names that must have
6005 distance >= bm.get_best_distance (), and means that we only get a
6006 non-NULL result for best_macro_match if it's better than any of
6007 the identifiers already checked. */
6008 best_macro_match bmm (name, bm.get_best_distance (), parse_in);
6009 cpp_hashnode *best_macro = bmm.get_best_meaningful_candidate ();
6010 /* If a macro is the closest so far to NAME, consider it. */
6012 bm.consider ((const char *)best_macro->ident.str);
6013 else if (bmm.get_best_distance () == 0)
6015 /* If we have an exact match for a macro name, then either the
6016 macro was used with the wrong argument count, or the macro
6017 has been used before it was defined. */
6018 cpp_hashnode *macro = bmm.blithely_get_best_candidate ();
6019 if (macro && (macro->flags & NODE_BUILTIN) == 0)
6020 return name_hint (NULL,
6021 macro_use_before_def::maybe_make (loc, macro));
6024 /* Try the "starts_decl_specifier_p" keywords to detect
6025 "singed" vs "signed" typos. */
6026 for (unsigned i = 0; i < num_c_common_reswords; i++)
6028 const c_common_resword *resword = &c_common_reswords[i];
6030 if (!suggest_rid_p (resword->rid))
6033 tree resword_identifier = ridpointers [resword->rid];
6034 if (!resword_identifier)
6036 gcc_assert (TREE_CODE (resword_identifier) == IDENTIFIER_NODE);
6038 /* Only consider reserved words that survived the
6039 filtering in init_reswords (e.g. for -std). */
6040 if (!IDENTIFIER_KEYWORD_P (resword_identifier))
6043 bm.consider (IDENTIFIER_POINTER (resword_identifier));
6046 return name_hint (bm.get_best_meaningful_candidate (), NULL);
6049 /* Subroutine of outer_binding.
6051 Returns TRUE if BINDING is a binding to a template parameter of
6052 SCOPE. In that case SCOPE is the scope of a primary template
6053 parameter -- in the sense of G++, i.e, a template that has its own
6056 Returns FALSE otherwise. */
6059 binding_to_template_parms_of_scope_p (cxx_binding *binding,
6060 cp_binding_level *scope)
6062 tree binding_value, tmpl, tinfo;
6065 if (!binding || !scope || !scope->this_entity)
6068 binding_value = binding->value ? binding->value : binding->type;
6069 tinfo = get_template_info (scope->this_entity);
6071 /* BINDING_VALUE must be a template parm. */
6072 if (binding_value == NULL_TREE
6073 || (!DECL_P (binding_value)
6074 || !DECL_TEMPLATE_PARM_P (binding_value)))
6077 /* The level of BINDING_VALUE. */
6079 template_type_parameter_p (binding_value)
6080 ? TEMPLATE_PARM_LEVEL (TEMPLATE_TYPE_PARM_INDEX
6081 (TREE_TYPE (binding_value)))
6082 : TEMPLATE_PARM_LEVEL (DECL_INITIAL (binding_value));
6084 /* The template of the current scope, iff said scope is a primary
6087 && PRIMARY_TEMPLATE_P (TI_TEMPLATE (tinfo))
6088 ? TI_TEMPLATE (tinfo)
6091 /* If the level of the parm BINDING_VALUE equals the depth of TMPL,
6092 then BINDING_VALUE is a parameter of TMPL. */
6093 return (tmpl && level == TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (tmpl)));
6096 /* Return the innermost non-namespace binding for NAME from a scope
6097 containing BINDING, or, if BINDING is NULL, the current scope.
6098 Please note that for a given template, the template parameters are
6099 considered to be in the scope containing the current scope.
6100 If CLASS_P is false, then class bindings are ignored. */
6103 outer_binding (tree name,
6104 cxx_binding *binding,
6108 cp_binding_level *scope;
6109 cp_binding_level *outer_scope;
6113 scope = binding->scope->level_chain;
6114 outer = binding->previous;
6118 scope = current_binding_level;
6119 outer = IDENTIFIER_BINDING (name);
6121 outer_scope = outer ? outer->scope : NULL;
6123 /* Because we create class bindings lazily, we might be missing a
6124 class binding for NAME. If there are any class binding levels
6125 between the LAST_BINDING_LEVEL and the scope in which OUTER was
6126 declared, we must lookup NAME in those class scopes. */
6128 while (scope && scope != outer_scope && scope->kind != sk_namespace)
6130 if (scope->kind == sk_class)
6132 cxx_binding *class_binding;
6134 class_binding = get_class_binding (name, scope);
6137 /* Thread this new class-scope binding onto the
6138 IDENTIFIER_BINDING list so that future lookups
6140 class_binding->previous = outer;
6142 binding->previous = class_binding;
6144 IDENTIFIER_BINDING (name) = class_binding;
6145 return class_binding;
6148 /* If we are in a member template, the template parms of the member
6149 template are considered to be inside the scope of the containing
6150 class, but within G++ the class bindings are all pushed between the
6151 template parms and the function body. So if the outer binding is
6152 a template parm for the current scope, return it now rather than
6153 look for a class binding. */
6154 if (outer_scope && outer_scope->kind == sk_template_parms
6155 && binding_to_template_parms_of_scope_p (outer, scope))
6158 scope = scope->level_chain;
6164 /* Return the innermost block-scope or class-scope value binding for
6165 NAME, or NULL_TREE if there is no such binding. */
6168 innermost_non_namespace_value (tree name)
6170 cxx_binding *binding;
6171 binding = outer_binding (name, /*binding=*/NULL, /*class_p=*/true);
6172 return binding ? binding->value : NULL_TREE;
6175 /* Look up NAME in the current binding level and its superiors in the
6176 namespace of variables, functions and typedefs. Return a ..._DECL
6177 node of some kind representing its definition if there is only one
6178 such declaration, or return a TREE_LIST with all the overloaded
6179 definitions if there are many, or return 0 if it is undefined.
6180 Hidden name, either friend declaration or built-in function, are
6183 If PREFER_TYPE is > 0, we prefer TYPE_DECLs or namespaces.
6184 If PREFER_TYPE is > 1, we reject non-type decls (e.g. namespaces).
6185 Otherwise we prefer non-TYPE_DECLs.
6187 If NONCLASS is nonzero, bindings in class scopes are ignored. If
6188 BLOCK_P is false, bindings in block scopes are ignored. */
6191 lookup_name_real_1 (tree name, int prefer_type, int nonclass, bool block_p,
6192 int namespaces_only, int flags)
6195 tree val = NULL_TREE;
6197 query_oracle (name);
6199 /* Conversion operators are handled specially because ordinary
6200 unqualified name lookup will not find template conversion
6202 if (IDENTIFIER_CONV_OP_P (name))
6204 cp_binding_level *level;
6206 for (level = current_binding_level;
6207 level && level->kind != sk_namespace;
6208 level = level->level_chain)
6213 /* A conversion operator can only be declared in a class
6215 if (level->kind != sk_class)
6218 /* Lookup the conversion operator in the class. */
6219 class_type = level->this_entity;
6220 operators = lookup_fnfields (class_type, name, /*protect=*/0);
6228 flags |= lookup_flags (prefer_type, namespaces_only);
6230 /* First, look in non-namespace scopes. */
6232 if (current_class_type == NULL_TREE)
6235 if (block_p || !nonclass)
6236 for (iter = outer_binding (name, NULL, !nonclass);
6238 iter = outer_binding (name, iter, !nonclass))
6242 /* Skip entities we don't want. */
6243 if (LOCAL_BINDING_P (iter) ? !block_p : nonclass)
6246 /* If this is the kind of thing we're looking for, we're done. */
6247 if (qualify_lookup (iter->value, flags))
6248 binding = iter->value;
6249 else if ((flags & LOOKUP_PREFER_TYPES)
6250 && qualify_lookup (iter->type, flags))
6251 binding = iter->type;
6253 binding = NULL_TREE;
6257 if (TREE_CODE (binding) == TYPE_DECL && DECL_HIDDEN_P (binding))
6259 /* A non namespace-scope binding can only be hidden in the
6260 presence of a local class, due to friend declarations.
6262 In particular, consider:
6270 B* b; // error: B is hidden
6271 C* c; // OK, finds ::C
6274 B *b; // error: B is hidden
6275 C *c; // OK, finds ::C
6280 The standard says that "B" is a local class in "f"
6281 (but not nested within "A") -- but that name lookup
6282 for "B" does not find this declaration until it is
6283 declared directly with "f".
6289 If a friend declaration appears in a local class and
6290 the name specified is an unqualified name, a prior
6291 declaration is looked up without considering scopes
6292 that are outside the innermost enclosing non-class
6293 scope. For a friend function declaration, if there is
6294 no prior declaration, the program is ill-formed. For a
6295 friend class declaration, if there is no prior
6296 declaration, the class that is specified belongs to the
6297 innermost enclosing non-class scope, but if it is
6298 subsequently referenced, its name is not found by name
6299 lookup until a matching declaration is provided in the
6300 innermost enclosing nonclass scope.
6302 So just keep looking for a non-hidden binding.
6304 gcc_assert (TREE_CODE (binding) == TYPE_DECL);
6312 /* Now lookup in namespace scopes. */
6315 name_lookup lookup (name, flags);
6316 if (lookup.search_unqualified
6317 (current_decl_namespace (), current_binding_level))
6321 /* If we have a single function from a using decl, pull it out. */
6322 if (val && TREE_CODE (val) == OVERLOAD && !really_overloaded_fn (val))
6323 val = OVL_FUNCTION (val);
6328 /* Wrapper for lookup_name_real_1. */
6331 lookup_name_real (tree name, int prefer_type, int nonclass, bool block_p,
6332 int namespaces_only, int flags)
6335 bool subtime = timevar_cond_start (TV_NAME_LOOKUP);
6336 ret = lookup_name_real_1 (name, prefer_type, nonclass, block_p,
6337 namespaces_only, flags);
6338 timevar_cond_stop (TV_NAME_LOOKUP, subtime);
6343 lookup_name_nonclass (tree name)
6345 return lookup_name_real (name, 0, 1, /*block_p=*/true, 0, 0);
6349 lookup_name (tree name)
6351 return lookup_name_real (name, 0, 0, /*block_p=*/true, 0, 0);
6355 lookup_name_prefer_type (tree name, int prefer_type)
6357 return lookup_name_real (name, prefer_type, 0, /*block_p=*/true, 0, 0);
6360 /* Look up NAME for type used in elaborated name specifier in
6361 the scopes given by SCOPE. SCOPE can be either TS_CURRENT or
6362 TS_WITHIN_ENCLOSING_NON_CLASS. Although not implied by the
6363 name, more scopes are checked if cleanup or template parameter
6364 scope is encountered.
6366 Unlike lookup_name_real, we make sure that NAME is actually
6367 declared in the desired scope, not from inheritance, nor using
6368 directive. For using declaration, there is DR138 still waiting
6369 to be resolved. Hidden name coming from an earlier friend
6370 declaration is also returned.
6372 A TYPE_DECL best matching the NAME is returned. Catching error
6373 and issuing diagnostics are caller's responsibility. */
6376 lookup_type_scope_1 (tree name, tag_scope scope)
6378 cxx_binding *iter = NULL;
6379 tree val = NULL_TREE;
6380 cp_binding_level *level = NULL;
6382 /* Look in non-namespace scope first. */
6383 if (current_binding_level->kind != sk_namespace)
6384 iter = outer_binding (name, NULL, /*class_p=*/ true);
6385 for (; iter; iter = outer_binding (name, iter, /*class_p=*/ true))
6387 /* Check if this is the kind of thing we're looking for.
6388 If SCOPE is TS_CURRENT, also make sure it doesn't come from
6389 base class. For ITER->VALUE, we can simply use
6390 INHERITED_VALUE_BINDING_P. For ITER->TYPE, we have to use
6393 We check ITER->TYPE before ITER->VALUE in order to handle
6394 typedef struct C {} C;
6397 if (qualify_lookup (iter->type, LOOKUP_PREFER_TYPES)
6398 && (scope != ts_current
6399 || LOCAL_BINDING_P (iter)
6400 || DECL_CONTEXT (iter->type) == iter->scope->this_entity))
6402 else if ((scope != ts_current
6403 || !INHERITED_VALUE_BINDING_P (iter))
6404 && qualify_lookup (iter->value, LOOKUP_PREFER_TYPES))
6411 /* Look in namespace scope. */
6413 level = iter->scope;
6416 tree ns = current_decl_namespace ();
6418 if (tree *slot = find_namespace_slot (ns, name))
6420 /* If this is the kind of thing we're looking for, we're done. */
6421 if (tree type = MAYBE_STAT_TYPE (*slot))
6422 if (qualify_lookup (type, LOOKUP_PREFER_TYPES))
6426 if (tree decl = MAYBE_STAT_DECL (*slot))
6427 if (qualify_lookup (decl, LOOKUP_PREFER_TYPES))
6430 level = NAMESPACE_LEVEL (ns);
6434 /* Type found, check if it is in the allowed scopes, ignoring cleanup
6435 and template parameter scopes. */
6438 cp_binding_level *b = current_binding_level;
6444 if (b->kind == sk_cleanup || b->kind == sk_template_parms
6445 || b->kind == sk_function_parms)
6447 else if (b->kind == sk_class
6448 && scope == ts_within_enclosing_non_class)
6458 /* Wrapper for lookup_type_scope_1. */
6461 lookup_type_scope (tree name, tag_scope scope)
6464 bool subtime = timevar_cond_start (TV_NAME_LOOKUP);
6465 ret = lookup_type_scope_1 (name, scope);
6466 timevar_cond_stop (TV_NAME_LOOKUP, subtime);
6470 /* Returns true iff DECL is a block-scope extern declaration of a function
6474 is_local_extern (tree decl)
6476 cxx_binding *binding;
6478 /* For functions, this is easy. */
6479 if (TREE_CODE (decl) == FUNCTION_DECL)
6480 return DECL_LOCAL_FUNCTION_P (decl);
6484 if (!current_function_decl)
6487 /* For variables, this is not easy. We need to look at the binding stack
6488 for the identifier to see whether the decl we have is a local. */
6489 for (binding = IDENTIFIER_BINDING (DECL_NAME (decl));
6490 binding && binding->scope->kind != sk_namespace;
6491 binding = binding->previous)
6492 if (binding->value == decl)
6493 return LOCAL_BINDING_P (binding);
6498 /* The type TYPE is being declared. If it is a class template, or a
6499 specialization of a class template, do any processing required and
6500 perform error-checking. If IS_FRIEND is nonzero, this TYPE is
6501 being declared a friend. B is the binding level at which this TYPE
6504 Returns the TYPE_DECL for TYPE, which may have been altered by this
6508 maybe_process_template_type_declaration (tree type, int is_friend,
6509 cp_binding_level *b)
6511 tree decl = TYPE_NAME (type);
6513 if (processing_template_parmlist)
6514 /* You can't declare a new template type in a template parameter
6515 list. But, you can declare a non-template type:
6517 template <class A*> struct S;
6519 is a forward-declaration of `A'. */
6521 else if (b->kind == sk_namespace
6522 && current_binding_level->kind != sk_namespace)
6523 /* If this new type is being injected into a containing scope,
6524 then it's not a template type. */
6528 gcc_assert (MAYBE_CLASS_TYPE_P (type)
6529 || TREE_CODE (type) == ENUMERAL_TYPE);
6531 if (processing_template_decl)
6533 /* This may change after the call to
6534 push_template_decl_real, but we want the original value. */
6535 tree name = DECL_NAME (decl);
6537 decl = push_template_decl_real (decl, is_friend);
6538 if (decl == error_mark_node)
6539 return error_mark_node;
6541 /* If the current binding level is the binding level for the
6542 template parameters (see the comment in
6543 begin_template_parm_list) and the enclosing level is a class
6544 scope, and we're not looking at a friend, push the
6545 declaration of the member class into the class scope. In the
6546 friend case, push_template_decl will already have put the
6547 friend into global scope, if appropriate. */
6548 if (TREE_CODE (type) != ENUMERAL_TYPE
6549 && !is_friend && b->kind == sk_template_parms
6550 && b->level_chain->kind == sk_class)
6552 finish_member_declaration (CLASSTYPE_TI_TEMPLATE (type));
6554 if (!COMPLETE_TYPE_P (current_class_type))
6556 maybe_add_class_template_decl_list (current_class_type,
6557 type, /*friend_p=*/0);
6558 /* Put this UTD in the table of UTDs for the class. */
6559 if (CLASSTYPE_NESTED_UTDS (current_class_type) == NULL)
6560 CLASSTYPE_NESTED_UTDS (current_class_type) =
6561 binding_table_new (SCOPE_DEFAULT_HT_SIZE);
6563 binding_table_insert
6564 (CLASSTYPE_NESTED_UTDS (current_class_type), name, type);
6573 /* Push a tag name NAME for struct/class/union/enum type TYPE. In case
6574 that the NAME is a class template, the tag is processed but not pushed.
6576 The pushed scope depend on the SCOPE parameter:
6577 - When SCOPE is TS_CURRENT, put it into the inner-most non-sk_cleanup
6579 - When SCOPE is TS_GLOBAL, put it in the inner-most non-class and
6580 non-template-parameter scope. This case is needed for forward
6582 - When SCOPE is TS_WITHIN_ENCLOSING_NON_CLASS, this is similar to
6583 TS_GLOBAL case except that names within template-parameter scopes
6584 are not pushed at all.
6586 Returns TYPE upon success and ERROR_MARK_NODE otherwise. */
6589 do_pushtag (tree name, tree type, tag_scope scope)
6593 cp_binding_level *b = current_binding_level;
6594 while (/* Cleanup scopes are not scopes from the point of view of
6596 b->kind == sk_cleanup
6597 /* Neither are function parameter scopes. */
6598 || b->kind == sk_function_parms
6599 /* Neither are the scopes used to hold template parameters
6600 for an explicit specialization. For an ordinary template
6601 declaration, these scopes are not scopes from the point of
6602 view of the language. */
6603 || (b->kind == sk_template_parms
6604 && (b->explicit_spec_p || scope == ts_global))
6605 || (b->kind == sk_class
6606 && (scope != ts_current
6607 /* We may be defining a new type in the initializer
6608 of a static member variable. We allow this when
6609 not pedantic, and it is particularly useful for
6610 type punning via an anonymous union. */
6611 || COMPLETE_TYPE_P (b->this_entity))))
6614 gcc_assert (identifier_p (name));
6616 /* Do C++ gratuitous typedefing. */
6617 if (identifier_type_value_1 (name) != type)
6621 tree context = TYPE_CONTEXT (type);
6625 tree cs = current_scope ();
6627 if (scope == ts_current
6628 || (cs && TREE_CODE (cs) == FUNCTION_DECL))
6630 else if (cs && TYPE_P (cs))
6631 /* When declaring a friend class of a local class, we want
6632 to inject the newly named class into the scope
6633 containing the local class, not the namespace
6635 context = decl_function_context (get_type_decl (cs));
6638 context = current_namespace;
6640 if (b->kind == sk_class
6641 || (b->kind == sk_template_parms
6642 && b->level_chain->kind == sk_class))
6645 tdef = create_implicit_typedef (name, type);
6646 DECL_CONTEXT (tdef) = FROB_CONTEXT (context);
6647 if (scope == ts_within_enclosing_non_class)
6649 /* This is a friend. Make this TYPE_DECL node hidden from
6650 ordinary name lookup. Its corresponding TEMPLATE_DECL
6651 will be marked in push_template_decl_real. */
6652 retrofit_lang_decl (tdef);
6653 DECL_ANTICIPATED (tdef) = 1;
6654 DECL_FRIEND_P (tdef) = 1;
6657 decl = maybe_process_template_type_declaration
6658 (type, scope == ts_within_enclosing_non_class, b);
6659 if (decl == error_mark_node)
6662 if (b->kind == sk_class)
6664 if (!TYPE_BEING_DEFINED (current_class_type)
6665 && !LAMBDA_TYPE_P (type))
6666 return error_mark_node;
6668 if (!PROCESSING_REAL_TEMPLATE_DECL_P ())
6669 /* Put this TYPE_DECL on the TYPE_FIELDS list for the
6670 class. But if it's a member template class, we want
6671 the TEMPLATE_DECL, not the TYPE_DECL, so this is done
6673 finish_member_declaration (decl);
6675 pushdecl_class_level (decl);
6677 else if (b->kind != sk_template_parms)
6679 decl = do_pushdecl_with_scope (decl, b, /*is_friend=*/false);
6680 if (decl == error_mark_node)
6683 if (DECL_CONTEXT (decl) == std_node
6684 && init_list_identifier == DECL_NAME (TYPE_NAME (type))
6685 && !CLASSTYPE_TEMPLATE_INFO (type))
6687 error ("declaration of %<std::initializer_list%> does not match "
6688 "%<#include <initializer_list>%>, isn't a template");
6689 return error_mark_node;
6694 set_identifier_type_value_with_scope (name, tdef, b);
6696 TYPE_CONTEXT (type) = DECL_CONTEXT (decl);
6698 /* If this is a local class, keep track of it. We need this
6699 information for name-mangling, and so that it is possible to
6700 find all function definitions in a translation unit in a
6701 convenient way. (It's otherwise tricky to find a member
6702 function definition it's only pointed to from within a local
6704 if (TYPE_FUNCTION_SCOPE_P (type))
6706 if (processing_template_decl)
6708 /* Push a DECL_EXPR so we call pushtag at the right time in
6709 template instantiation rather than in some nested context. */
6710 add_decl_expr (decl);
6712 /* Lambdas use LAMBDA_EXPR_DISCRIMINATOR instead. */
6713 else if (!LAMBDA_TYPE_P (type))
6714 vec_safe_push (local_classes, type);
6718 if (b->kind == sk_class
6719 && !COMPLETE_TYPE_P (current_class_type))
6721 maybe_add_class_template_decl_list (current_class_type,
6722 type, /*friend_p=*/0);
6724 if (CLASSTYPE_NESTED_UTDS (current_class_type) == NULL)
6725 CLASSTYPE_NESTED_UTDS (current_class_type)
6726 = binding_table_new (SCOPE_DEFAULT_HT_SIZE);
6728 binding_table_insert
6729 (CLASSTYPE_NESTED_UTDS (current_class_type), name, type);
6732 decl = TYPE_NAME (type);
6733 gcc_assert (TREE_CODE (decl) == TYPE_DECL);
6735 /* Set type visibility now if this is a forward declaration. */
6736 TREE_PUBLIC (decl) = 1;
6737 determine_visibility (decl);
6742 /* Wrapper for do_pushtag. */
6745 pushtag (tree name, tree type, tag_scope scope)
6748 bool subtime = timevar_cond_start (TV_NAME_LOOKUP);
6749 ret = do_pushtag (name, type, scope);
6750 timevar_cond_stop (TV_NAME_LOOKUP, subtime);
6755 /* Subroutines for reverting temporarily to top-level for instantiation
6756 of templates and such. We actually need to clear out the class- and
6757 local-value slots of all identifiers, so that only the global values
6758 are at all visible. Simply setting current_binding_level to the global
6759 scope isn't enough, because more binding levels may be pushed. */
6760 struct saved_scope *scope_chain;
6762 /* Return true if ID has not already been marked. */
6765 store_binding_p (tree id)
6767 if (!id || !IDENTIFIER_BINDING (id))
6770 if (IDENTIFIER_MARKED (id))
6776 /* Add an appropriate binding to *OLD_BINDINGS which needs to already
6777 have enough space reserved. */
6780 store_binding (tree id, vec<cxx_saved_binding, va_gc> **old_bindings)
6782 cxx_saved_binding saved;
6784 gcc_checking_assert (store_binding_p (id));
6786 IDENTIFIER_MARKED (id) = 1;
6788 saved.identifier = id;
6789 saved.binding = IDENTIFIER_BINDING (id);
6790 saved.real_type_value = REAL_IDENTIFIER_TYPE_VALUE (id);
6791 (*old_bindings)->quick_push (saved);
6792 IDENTIFIER_BINDING (id) = NULL;
6796 store_bindings (tree names, vec<cxx_saved_binding, va_gc> **old_bindings)
6798 static vec<tree> bindings_need_stored;
6802 bool subtime = timevar_cond_start (TV_NAME_LOOKUP);
6803 for (t = names; t; t = TREE_CHAIN (t))
6805 if (TREE_CODE (t) == TREE_LIST)
6806 id = TREE_PURPOSE (t);
6810 if (store_binding_p (id))
6811 bindings_need_stored.safe_push (id);
6813 if (!bindings_need_stored.is_empty ())
6815 vec_safe_reserve_exact (*old_bindings, bindings_need_stored.length ());
6816 for (i = 0; bindings_need_stored.iterate (i, &id); ++i)
6818 /* We can apparently have duplicates in NAMES. */
6819 if (store_binding_p (id))
6820 store_binding (id, old_bindings);
6822 bindings_need_stored.truncate (0);
6824 timevar_cond_stop (TV_NAME_LOOKUP, subtime);
6827 /* Like store_bindings, but NAMES is a vector of cp_class_binding
6828 objects, rather than a TREE_LIST. */
6831 store_class_bindings (vec<cp_class_binding, va_gc> *names,
6832 vec<cxx_saved_binding, va_gc> **old_bindings)
6834 static vec<tree> bindings_need_stored;
6836 cp_class_binding *cb;
6838 for (i = 0; vec_safe_iterate (names, i, &cb); ++i)
6839 if (store_binding_p (cb->identifier))
6840 bindings_need_stored.safe_push (cb->identifier);
6841 if (!bindings_need_stored.is_empty ())
6844 vec_safe_reserve_exact (*old_bindings, bindings_need_stored.length ());
6845 for (i = 0; bindings_need_stored.iterate (i, &id); ++i)
6846 store_binding (id, old_bindings);
6847 bindings_need_stored.truncate (0);
6851 /* A chain of saved_scope structures awaiting reuse. */
6853 static GTY((deletable)) struct saved_scope *free_saved_scope;
6856 do_push_to_top_level (void)
6858 struct saved_scope *s;
6859 cp_binding_level *b;
6860 cxx_saved_binding *sb;
6864 /* Reuse or create a new structure for this saved scope. */
6865 if (free_saved_scope != NULL)
6867 s = free_saved_scope;
6868 free_saved_scope = s->prev;
6870 vec<cxx_saved_binding, va_gc> *old_bindings = s->old_bindings;
6871 memset (s, 0, sizeof (*s));
6872 /* Also reuse the structure's old_bindings vector. */
6873 vec_safe_truncate (old_bindings, 0);
6874 s->old_bindings = old_bindings;
6877 s = ggc_cleared_alloc<saved_scope> ();
6879 b = scope_chain ? current_binding_level : 0;
6881 /* If we're in the middle of some function, save our state. */
6885 push_function_context ();
6890 if (scope_chain && previous_class_level)
6891 store_class_bindings (previous_class_level->class_shadowed,
6894 /* Have to include the global scope, because class-scope decls
6895 aren't listed anywhere useful. */
6896 for (; b; b = b->level_chain)
6900 /* Template IDs are inserted into the global level. If they were
6901 inserted into namespace level, finish_file wouldn't find them
6902 when doing pending instantiations. Therefore, don't stop at
6903 namespace level, but continue until :: . */
6904 if (global_scope_p (b))
6907 store_bindings (b->names, &s->old_bindings);
6908 /* We also need to check class_shadowed to save class-level type
6909 bindings, since pushclass doesn't fill in b->names. */
6910 if (b->kind == sk_class)
6911 store_class_bindings (b->class_shadowed, &s->old_bindings);
6913 /* Unwind type-value slots back to top level. */
6914 for (t = b->type_shadowed; t; t = TREE_CHAIN (t))
6915 SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (t), TREE_VALUE (t));
6918 FOR_EACH_VEC_SAFE_ELT (s->old_bindings, i, sb)
6919 IDENTIFIER_MARKED (sb->identifier) = 0;
6921 s->prev = scope_chain;
6923 s->need_pop_function_context = need_pop;
6924 s->function_decl = current_function_decl;
6925 s->unevaluated_operand = cp_unevaluated_operand;
6926 s->inhibit_evaluation_warnings = c_inhibit_evaluation_warnings;
6927 s->x_stmt_tree.stmts_are_full_exprs_p = true;
6930 current_function_decl = NULL_TREE;
6931 vec_alloc (current_lang_base, 10);
6932 current_lang_name = lang_name_cplusplus;
6933 current_namespace = global_namespace;
6934 push_class_stack ();
6935 cp_unevaluated_operand = 0;
6936 c_inhibit_evaluation_warnings = 0;
6940 do_pop_from_top_level (void)
6942 struct saved_scope *s = scope_chain;
6943 cxx_saved_binding *saved;
6946 /* Clear out class-level bindings cache. */
6947 if (previous_class_level)
6948 invalidate_class_lookup_cache ();
6951 current_lang_base = 0;
6953 scope_chain = s->prev;
6954 FOR_EACH_VEC_SAFE_ELT (s->old_bindings, i, saved)
6956 tree id = saved->identifier;
6958 IDENTIFIER_BINDING (id) = saved->binding;
6959 SET_IDENTIFIER_TYPE_VALUE (id, saved->real_type_value);
6962 /* If we were in the middle of compiling a function, restore our
6964 if (s->need_pop_function_context)
6965 pop_function_context ();
6966 current_function_decl = s->function_decl;
6967 cp_unevaluated_operand = s->unevaluated_operand;
6968 c_inhibit_evaluation_warnings = s->inhibit_evaluation_warnings;
6970 /* Make this saved_scope structure available for reuse by
6971 push_to_top_level. */
6972 s->prev = free_saved_scope;
6973 free_saved_scope = s;
6976 /* Push into the scope of the namespace NS, even if it is deeply
6977 nested within another namespace. */
6980 do_push_nested_namespace (tree ns)
6982 if (ns == global_namespace)
6983 do_push_to_top_level ();
6986 do_push_nested_namespace (CP_DECL_CONTEXT (ns));
6988 (find_namespace_value (current_namespace, DECL_NAME (ns)) == ns);
6989 resume_scope (NAMESPACE_LEVEL (ns));
6990 current_namespace = ns;
6994 /* Pop back from the scope of the namespace NS, which was previously
6995 entered with push_nested_namespace. */
6998 do_pop_nested_namespace (tree ns)
7000 while (ns != global_namespace)
7002 ns = CP_DECL_CONTEXT (ns);
7003 current_namespace = ns;
7007 do_pop_from_top_level ();
7010 /* Add TARGET to USINGS, if it does not already exist there.
7011 We used to build the complete graph of usings at this point, from
7012 the POV of the source namespaces. Now we build that as we perform
7013 the unqualified search. */
7016 add_using_namespace (vec<tree, va_gc> *&usings, tree target)
7019 for (unsigned ix = usings->length (); ix--;)
7020 if ((*usings)[ix] == target)
7023 vec_safe_push (usings, target);
7026 /* Tell the debug system of a using directive. */
7029 emit_debug_info_using_namespace (tree from, tree target, bool implicit)
7031 /* Emit debugging info. */
7032 tree context = from != global_namespace ? from : NULL_TREE;
7033 debug_hooks->imported_module_or_decl (target, NULL_TREE, context, false,
7037 /* Process a namespace-scope using directive. */
7040 finish_namespace_using_directive (tree target, tree attribs)
7042 gcc_checking_assert (namespace_bindings_p ());
7043 if (target == error_mark_node)
7046 add_using_namespace (DECL_NAMESPACE_USING (current_namespace),
7047 ORIGINAL_NAMESPACE (target));
7048 emit_debug_info_using_namespace (current_namespace,
7049 ORIGINAL_NAMESPACE (target), false);
7051 if (attribs == error_mark_node)
7054 for (tree a = attribs; a; a = TREE_CHAIN (a))
7056 tree name = get_attribute_name (a);
7057 if (is_attribute_p ("strong", name))
7059 warning (0, "strong using directive no longer supported");
7060 if (CP_DECL_CONTEXT (target) == current_namespace)
7061 inform (DECL_SOURCE_LOCATION (target),
7062 "you may use an inline namespace instead");
7065 warning (OPT_Wattributes, "%qD attribute directive ignored", name);
7069 /* Process a function-scope using-directive. */
7072 finish_local_using_directive (tree target, tree attribs)
7074 gcc_checking_assert (local_bindings_p ());
7075 if (target == error_mark_node)
7079 warning (OPT_Wattributes, "attributes ignored on local using directive");
7081 add_stmt (build_stmt (input_location, USING_STMT, target));
7083 add_using_namespace (current_binding_level->using_directives,
7084 ORIGINAL_NAMESPACE (target));
7087 /* Pushes X into the global namespace. */
7090 pushdecl_top_level (tree x, bool is_friend)
7092 bool subtime = timevar_cond_start (TV_NAME_LOOKUP);
7093 do_push_to_top_level ();
7094 x = pushdecl_namespace_level (x, is_friend);
7095 do_pop_from_top_level ();
7096 timevar_cond_stop (TV_NAME_LOOKUP, subtime);
7100 /* Pushes X into the global namespace and calls cp_finish_decl to
7101 register the variable, initializing it with INIT. */
7104 pushdecl_top_level_and_finish (tree x, tree init)
7106 bool subtime = timevar_cond_start (TV_NAME_LOOKUP);
7107 do_push_to_top_level ();
7108 x = pushdecl_namespace_level (x, false);
7109 cp_finish_decl (x, init, false, NULL_TREE, 0);
7110 do_pop_from_top_level ();
7111 timevar_cond_stop (TV_NAME_LOOKUP, subtime);
7115 /* Enter the namespaces from current_namerspace to NS. */
7118 push_inline_namespaces (tree ns)
7121 if (ns != current_namespace)
7123 gcc_assert (ns != global_namespace);
7124 count += push_inline_namespaces (CP_DECL_CONTEXT (ns));
7125 resume_scope (NAMESPACE_LEVEL (ns));
7126 current_namespace = ns;
7132 /* Push into the scope of the NAME namespace. If NAME is NULL_TREE,
7133 then we enter an anonymous namespace. If MAKE_INLINE is true, then
7134 we create an inline namespace (it is up to the caller to check upon
7135 redefinition). Return the number of namespaces entered. */
7138 push_namespace (tree name, bool make_inline)
7140 bool subtime = timevar_cond_start (TV_NAME_LOOKUP);
7143 /* We should not get here if the global_namespace is not yet constructed
7144 nor if NAME designates the global namespace: The global scope is
7145 constructed elsewhere. */
7146 gcc_checking_assert (global_namespace != NULL && name != global_identifier);
7148 tree ns = NULL_TREE;
7150 name_lookup lookup (name, 0);
7151 if (!lookup.search_qualified (current_namespace, /*usings=*/false))
7153 else if (TREE_CODE (lookup.value) != NAMESPACE_DECL)
7155 else if (tree dna = DECL_NAMESPACE_ALIAS (lookup.value))
7157 /* A namespace alias is not allowed here, but if the alias
7158 is for a namespace also inside the current scope,
7159 accept it with a diagnostic. That's better than dying
7161 if (is_nested_namespace (current_namespace, CP_DECL_CONTEXT (dna)))
7163 error ("namespace alias %qD not allowed here, "
7164 "assuming %qD", lookup.value, dna);
7172 bool new_ns = false;
7174 /* DR2061. NS might be a member of an inline namespace. We
7175 need to push into those namespaces. */
7176 count += push_inline_namespaces (CP_DECL_CONTEXT (ns));
7179 ns = build_lang_decl (NAMESPACE_DECL, name, void_type_node);
7180 SCOPE_DEPTH (ns) = SCOPE_DEPTH (current_namespace) + 1;
7181 if (!SCOPE_DEPTH (ns))
7182 /* We only allow depth 255. */
7183 sorry ("cannot nest more than %d namespaces",
7184 SCOPE_DEPTH (current_namespace));
7185 DECL_CONTEXT (ns) = FROB_CONTEXT (current_namespace);
7188 if (pushdecl (ns) == error_mark_node)
7194 SET_DECL_ASSEMBLER_NAME (ns, anon_identifier);
7197 add_using_namespace (DECL_NAMESPACE_USING (current_namespace),
7200 else if (TREE_PUBLIC (current_namespace))
7201 TREE_PUBLIC (ns) = 1;
7205 DECL_NAMESPACE_INLINE_P (ns) = true;
7206 vec_safe_push (DECL_NAMESPACE_INLINEES (current_namespace), ns);
7209 if (!name || make_inline)
7210 emit_debug_info_using_namespace (current_namespace, ns, true);
7216 if (make_inline && !DECL_NAMESPACE_INLINE_P (ns))
7218 error ("inline namespace must be specified at initial definition");
7219 inform (DECL_SOURCE_LOCATION (ns), "%qD defined here", ns);
7222 begin_scope (sk_namespace, ns);
7224 resume_scope (NAMESPACE_LEVEL (ns));
7225 current_namespace = ns;
7229 timevar_cond_stop (TV_NAME_LOOKUP, subtime);
7233 /* Pop from the scope of the current namespace. */
7236 pop_namespace (void)
7238 bool subtime = timevar_cond_start (TV_NAME_LOOKUP);
7240 gcc_assert (current_namespace != global_namespace);
7241 current_namespace = CP_DECL_CONTEXT (current_namespace);
7242 /* The binding level is not popped, as it might be re-opened later. */
7245 timevar_cond_stop (TV_NAME_LOOKUP, subtime);
7248 /* External entry points for do_{push_to/pop_from}_top_level. */
7251 push_to_top_level (void)
7253 bool subtime = timevar_cond_start (TV_NAME_LOOKUP);
7254 do_push_to_top_level ();
7255 timevar_cond_stop (TV_NAME_LOOKUP, subtime);
7259 pop_from_top_level (void)
7261 bool subtime = timevar_cond_start (TV_NAME_LOOKUP);
7262 do_pop_from_top_level ();
7263 timevar_cond_stop (TV_NAME_LOOKUP, subtime);
7266 /* External entry points for do_{push,pop}_nested_namespace. */
7269 push_nested_namespace (tree ns)
7271 bool subtime = timevar_cond_start (TV_NAME_LOOKUP);
7272 do_push_nested_namespace (ns);
7273 timevar_cond_stop (TV_NAME_LOOKUP, subtime);
7277 pop_nested_namespace (tree ns)
7279 bool subtime = timevar_cond_start (TV_NAME_LOOKUP);
7280 gcc_assert (current_namespace == ns);
7281 do_pop_nested_namespace (ns);
7282 timevar_cond_stop (TV_NAME_LOOKUP, subtime);
7285 /* Pop off extraneous binding levels left over due to syntax errors.
7286 We don't pop past namespaces, as they might be valid. */
7289 pop_everything (void)
7291 if (ENABLE_SCOPE_CHECKING)
7292 verbatim ("XXX entering pop_everything ()\n");
7293 while (!namespace_bindings_p ())
7295 if (current_binding_level->kind == sk_class)
7296 pop_nested_class ();
7300 if (ENABLE_SCOPE_CHECKING)
7301 verbatim ("XXX leaving pop_everything ()\n");
7304 /* Emit debugging information for using declarations and directives.
7305 If input tree is overloaded fn then emit debug info for all
7309 cp_emit_debug_info_for_using (tree t, tree context)
7311 /* Don't try to emit any debug information if we have errors. */
7315 /* Ignore this FUNCTION_DECL if it refers to a builtin declaration
7316 of a builtin function. */
7317 if (TREE_CODE (t) == FUNCTION_DECL
7318 && DECL_EXTERNAL (t)
7319 && DECL_BUILT_IN (t))
7322 /* Do not supply context to imported_module_or_decl, if
7323 it is a global namespace. */
7324 if (context == global_namespace)
7325 context = NULL_TREE;
7327 t = MAYBE_BASELINK_FUNCTIONS (t);
7329 /* FIXME: Handle TEMPLATE_DECLs. */
7330 for (lkp_iterator iter (t); iter; ++iter)
7333 if (TREE_CODE (fn) != TEMPLATE_DECL)
7335 if (building_stmt_list_p ())
7336 add_stmt (build_stmt (input_location, USING_STMT, fn));
7338 debug_hooks->imported_module_or_decl (fn, NULL_TREE, context,
7344 #include "gt-cp-name-lookup.h"