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 /* Don't look into inline children, if we're looking for an
565 anonymous name -- it must be in the current scope, if anywhere. */
567 /* Recursively look in its inline children. */
568 if (vec<tree, va_gc> *inlinees = DECL_NAMESPACE_INLINEES (scope))
569 for (unsigned ix = inlinees->length (); ix--;)
570 found |= search_namespace ((*inlinees)[ix]);
578 /* Recursively follow using directives of SCOPE & its inline children.
579 Such following is essentially a flood-fill algorithm. */
582 name_lookup::search_usings (tree scope)
584 /* We do not check seen_p here, as that was already set during the
585 namespace_only walk. */
590 if (vec<tree, va_gc> *usings = DECL_NAMESPACE_USING (scope))
591 for (unsigned ix = usings->length (); ix--;)
592 found |= search_qualified ((*usings)[ix], true);
594 /* Look in its inline children. */
595 if (vec<tree, va_gc> *inlinees = DECL_NAMESPACE_INLINEES (scope))
596 for (unsigned ix = inlinees->length (); ix--;)
597 found |= search_usings ((*inlinees)[ix]);
605 /* Qualified namespace lookup in SCOPE.
606 1) Look in SCOPE (+inlines). If found, we're done.
607 2) Otherwise, if USINGS is true,
608 recurse for every using directive of SCOPE (+inlines).
610 Trickiness is (a) loops and (b) multiple paths to same namespace.
611 In both cases we want to not repeat any lookups, and know whether
612 to stop the caller's step #2. Do this via the FOUND_P marker. */
615 name_lookup::search_qualified (tree scope, bool usings)
620 found = found_p (scope);
623 found = search_namespace (scope);
624 if (!found && usings)
625 found = search_usings (scope);
631 /* Add SCOPE to the unqualified search queue, recursively add its
632 inlines and those via using directives. */
634 name_lookup::using_queue *
635 name_lookup::queue_namespace (using_queue *queue, int depth, tree scope)
637 if (see_and_mark (scope))
642 while (SCOPE_DEPTH (common) > depth)
643 common = CP_DECL_CONTEXT (common);
644 vec_safe_push (queue, using_pair (common, scope));
646 /* Queue its inline children. */
647 if (vec<tree, va_gc> *inlinees = DECL_NAMESPACE_INLINEES (scope))
648 for (unsigned ix = inlinees->length (); ix--;)
649 queue = queue_namespace (queue, depth, (*inlinees)[ix]);
651 /* Queue its using targets. */
652 queue = queue_usings (queue, depth, DECL_NAMESPACE_USING (scope));
657 /* Add the namespaces in USINGS to the unqualified search queue. */
659 name_lookup::using_queue *
660 name_lookup::do_queue_usings (using_queue *queue, int depth,
661 vec<tree, va_gc> *usings)
663 for (unsigned ix = usings->length (); ix--;)
664 queue = queue_namespace (queue, depth, (*usings)[ix]);
669 /* Unqualified namespace lookup in SCOPE.
670 1) add scope+inlins to worklist.
671 2) recursively add target of every using directive
672 3) for each worklist item where SCOPE is common ancestor, search it
673 4) if nothing find, scope=parent, goto 1. */
676 name_lookup::search_unqualified (tree scope, cp_binding_level *level)
678 /* Make static to avoid continual reallocation. We're not
680 static using_queue *queue = NULL;
682 int length = vec_safe_length (queue);
684 /* Queue local using-directives. */
685 for (; level->kind != sk_namespace; level = level->level_chain)
686 queue = queue_usings (queue, SCOPE_DEPTH (scope), level->using_directives);
688 for (; !found; scope = CP_DECL_CONTEXT (scope))
690 gcc_assert (!DECL_NAMESPACE_ALIAS (scope));
691 int depth = SCOPE_DEPTH (scope);
693 /* Queue namespaces reachable from SCOPE. */
694 queue = queue_namespace (queue, depth, scope);
696 /* Search every queued namespace where SCOPE is the common
697 ancestor. Adjust the others. */
698 unsigned ix = length;
701 using_pair &pair = (*queue)[ix];
702 while (pair.first == scope)
704 found |= search_namespace_only (pair.second);
705 pair = queue->pop ();
706 if (ix == queue->length ())
709 /* The depth is the same as SCOPE, find the parent scope. */
710 if (SCOPE_DEPTH (pair.first) == depth)
711 pair.first = CP_DECL_CONTEXT (pair.first);
714 while (ix < queue->length ());
716 if (scope == global_namespace)
719 /* If looking for hidden names, we only look in the innermost
720 namespace scope. [namespace.memdef]/3 If a friend
721 declaration in a non-local class first declares a class,
722 function, class template or function template the friend is a
723 member of the innermost enclosing namespace. See also
724 [basic.lookup.unqual]/7 */
725 if (flags & LOOKUP_HIDDEN)
729 vec_safe_truncate (queue, length);
734 /* FNS is a value binding. If it is a (set of overloaded) functions,
735 add them into the current value. */
738 name_lookup::add_fns (tree fns)
742 else if (TREE_CODE (fns) == OVERLOAD)
744 if (TREE_TYPE (fns) != unknown_type_node)
745 fns = OVL_FUNCTION (fns);
747 else if (!DECL_DECLARES_FUNCTION_P (fns))
753 /* Add functions of a namespace to the lookup structure. */
756 name_lookup::adl_namespace_only (tree scope)
760 /* Look down into inline namespaces. */
761 if (vec<tree, va_gc> *inlinees = DECL_NAMESPACE_INLINEES (scope))
762 for (unsigned ix = inlinees->length (); ix--;)
763 adl_namespace_only ((*inlinees)[ix]);
765 if (tree fns = find_namespace_value (scope, name))
766 add_fns (ovl_skip_hidden (fns));
769 /* Find the containing non-inlined namespace, add it and all its
773 name_lookup::adl_namespace (tree scope)
778 /* Find the containing non-inline namespace. */
779 while (DECL_NAMESPACE_INLINE_P (scope))
780 scope = CP_DECL_CONTEXT (scope);
782 adl_namespace_only (scope);
785 /* Adds the class and its friends to the lookup structure. */
788 name_lookup::adl_class_only (tree type)
790 /* Backend-built structures, such as __builtin_va_list, aren't
791 affected by all this. */
792 if (!CLASS_TYPE_P (type))
795 type = TYPE_MAIN_VARIANT (type);
797 if (see_and_mark (type))
800 tree context = decl_namespace_context (type);
801 adl_namespace (context);
803 complete_type (type);
806 for (tree list = DECL_FRIENDLIST (TYPE_MAIN_DECL (type)); list;
807 list = TREE_CHAIN (list))
808 if (name == FRIEND_NAME (list))
809 for (tree friends = FRIEND_DECLS (list); friends;
810 friends = TREE_CHAIN (friends))
812 tree fn = TREE_VALUE (friends);
814 /* Only interested in global functions with potentially hidden
815 (i.e. unqualified) declarations. */
816 if (CP_DECL_CONTEXT (fn) != context)
819 /* Only interested in anticipated friends. (Non-anticipated
820 ones will have been inserted during the namespace
822 if (!DECL_ANTICIPATED (fn))
825 /* Template specializations are never found by name lookup.
826 (Templates themselves can be found, but not template
828 if (TREE_CODE (fn) == FUNCTION_DECL && DECL_USE_TEMPLATE (fn))
835 /* Adds the class and its bases to the lookup structure.
836 Returns true on error. */
839 name_lookup::adl_bases (tree type)
841 adl_class_only (type);
843 /* Process baseclasses. */
844 if (tree binfo = TYPE_BINFO (type))
849 for (i = 0; BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
850 adl_bases (BINFO_TYPE (base_binfo));
854 /* Adds everything associated with a class argument type to the lookup
855 structure. Returns true on error.
857 If T is a class type (including unions), its associated classes are: the
858 class itself; the class of which it is a member, if any; and its direct
859 and indirect base classes. Its associated namespaces are the namespaces
860 of which its associated classes are members. Furthermore, if T is a
861 class template specialization, its associated namespaces and classes
862 also include: the namespaces and classes associated with the types of
863 the template arguments provided for template type parameters (excluding
864 template template parameters); the namespaces of which any template
865 template arguments are members; and the classes of which any member
866 templates used as template template arguments are members. [ Note:
867 non-type template arguments do not contribute to the set of associated
868 namespaces. --end note] */
871 name_lookup::adl_class (tree type)
873 /* Backend build structures, such as __builtin_va_list, aren't
874 affected by all this. */
875 if (!CLASS_TYPE_P (type))
878 type = TYPE_MAIN_VARIANT (type);
879 /* We don't set found here because we have to have set seen first,
880 which is done in the adl_bases walk. */
887 if (TYPE_CLASS_SCOPE_P (type))
888 adl_class_only (TYPE_CONTEXT (type));
890 /* Process template arguments. */
891 if (CLASSTYPE_TEMPLATE_INFO (type)
892 && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (type)))
894 tree list = INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (type));
895 for (int i = 0; i < TREE_VEC_LENGTH (list); ++i)
896 adl_template_arg (TREE_VEC_ELT (list, i));
901 name_lookup::adl_expr (tree expr)
906 gcc_assert (!TYPE_P (expr));
908 if (TREE_TYPE (expr) != unknown_type_node)
910 adl_type (TREE_TYPE (expr));
914 if (TREE_CODE (expr) == ADDR_EXPR)
915 expr = TREE_OPERAND (expr, 0);
916 if (TREE_CODE (expr) == COMPONENT_REF
917 || TREE_CODE (expr) == OFFSET_REF)
918 expr = TREE_OPERAND (expr, 1);
919 expr = MAYBE_BASELINK_FUNCTIONS (expr);
922 for (lkp_iterator iter (expr); iter; ++iter)
923 adl_type (TREE_TYPE (*iter));
924 else if (TREE_CODE (expr) == TEMPLATE_ID_EXPR)
926 /* The working paper doesn't currently say how to handle
927 template-id arguments. The sensible thing would seem to be
928 to handle the list of template candidates like a normal
929 overload set, and handle the template arguments like we do
930 for class template specializations. */
932 /* First the templates. */
933 adl_expr (TREE_OPERAND (expr, 0));
935 /* Now the arguments. */
936 if (tree args = TREE_OPERAND (expr, 1))
937 for (int ix = TREE_VEC_LENGTH (args); ix--;)
938 adl_template_arg (TREE_VEC_ELT (args, ix));
943 name_lookup::adl_type (tree type)
948 if (TYPE_PTRDATAMEM_P (type))
950 /* Pointer to member: associate class type and value type. */
951 adl_type (TYPE_PTRMEM_CLASS_TYPE (type));
952 adl_type (TYPE_PTRMEM_POINTED_TO_TYPE (type));
956 switch (TREE_CODE (type))
959 if (TYPE_PTRMEMFUNC_P (type))
961 adl_type (TYPE_PTRMEMFUNC_FN_TYPE (type));
970 /* The basetype is referenced in the first arg type, so just
973 /* Associate the parameter types. */
974 for (tree args = TYPE_ARG_TYPES (type); args; args = TREE_CHAIN (args))
975 adl_type (TREE_VALUE (args));
981 adl_type (TREE_TYPE (type));
985 if (TYPE_CLASS_SCOPE_P (type))
986 adl_class_only (TYPE_CONTEXT (type));
987 adl_namespace (decl_namespace_context (type));
991 gcc_assert (type == unknown_type_node
992 || type == init_list_type_node);
995 case TYPE_PACK_EXPANSION:
996 adl_type (PACK_EXPANSION_PATTERN (type));
1004 /* Adds everything associated with a template argument to the lookup
1008 name_lookup::adl_template_arg (tree arg)
1010 /* [basic.lookup.koenig]
1012 If T is a template-id, its associated namespaces and classes are
1013 ... the namespaces and classes associated with the types of the
1014 template arguments provided for template type parameters
1015 (excluding template template parameters); the namespaces in which
1016 any template template arguments are defined; and the classes in
1017 which any member templates used as template template arguments
1018 are defined. [Note: non-type template arguments do not
1019 contribute to the set of associated namespaces. ] */
1021 /* Consider first template template arguments. */
1022 if (TREE_CODE (arg) == TEMPLATE_TEMPLATE_PARM
1023 || TREE_CODE (arg) == UNBOUND_CLASS_TEMPLATE)
1025 else if (TREE_CODE (arg) == TEMPLATE_DECL)
1027 tree ctx = CP_DECL_CONTEXT (arg);
1029 /* It's not a member template. */
1030 if (TREE_CODE (ctx) == NAMESPACE_DECL)
1031 adl_namespace (ctx);
1032 /* Otherwise, it must be member template. */
1034 adl_class_only (ctx);
1036 /* It's an argument pack; handle it recursively. */
1037 else if (ARGUMENT_PACK_P (arg))
1039 tree args = ARGUMENT_PACK_ARGS (arg);
1040 int i, len = TREE_VEC_LENGTH (args);
1041 for (i = 0; i < len; ++i)
1042 adl_template_arg (TREE_VEC_ELT (args, i));
1044 /* It's not a template template argument, but it is a type template
1046 else if (TYPE_P (arg))
1050 /* Perform ADL lookup. FNS is the existing lookup result and ARGS are
1051 the call arguments. */
1054 name_lookup::search_adl (tree fns, vec<tree, va_gc> *args)
1059 lookup_mark (fns, true);
1066 FOR_EACH_VEC_ELT_REVERSE (*args, ix, arg)
1067 /* OMP reduction operators put an ADL-significant type as the
1079 static bool qualified_namespace_lookup (tree, name_lookup *);
1080 static void consider_binding_level (tree name,
1081 best_match <tree, const char *> &bm,
1082 cp_binding_level *lvl,
1083 bool look_within_fields,
1084 enum lookup_name_fuzzy_kind kind);
1085 static void diagnose_name_conflict (tree, tree);
1087 /* ADL lookup of NAME. FNS is the result of regular lookup, and we
1088 don't add duplicates to it. ARGS is the vector of call
1089 arguments (which will not be empty). */
1092 lookup_arg_dependent (tree name, tree fns, vec<tree, va_gc> *args)
1094 bool subtime = timevar_cond_start (TV_NAME_LOOKUP);
1095 name_lookup lookup (name);
1096 fns = lookup.search_adl (fns, args);
1097 timevar_cond_stop (TV_NAME_LOOKUP, subtime);
1101 /* FNS is an overload set of conversion functions. Return the
1102 overloads converting to TYPE. */
1105 extract_conversion_operator (tree fns, tree type)
1107 tree convs = NULL_TREE;
1108 tree tpls = NULL_TREE;
1110 for (ovl_iterator iter (fns); iter; ++iter)
1112 if (same_type_p (DECL_CONV_FN_TYPE (*iter), type))
1113 convs = lookup_add (*iter, convs);
1115 if (TREE_CODE (*iter) == TEMPLATE_DECL)
1116 tpls = lookup_add (*iter, tpls);
1125 /* Binary search of (ordered) MEMBER_VEC for NAME. */
1128 member_vec_binary_search (vec<tree, va_gc> *member_vec, tree name)
1130 for (unsigned lo = 0, hi = member_vec->length (); lo < hi;)
1132 unsigned mid = (lo + hi) / 2;
1133 tree binding = (*member_vec)[mid];
1134 tree binding_name = OVL_NAME (binding);
1136 if (binding_name > name)
1138 else if (binding_name < name)
1147 /* Linear search of (unordered) MEMBER_VEC for NAME. */
1150 member_vec_linear_search (vec<tree, va_gc> *member_vec, tree name)
1152 for (int ix = member_vec->length (); ix--;)
1153 if (tree binding = (*member_vec)[ix])
1154 if (OVL_NAME (binding) == name)
1160 /* Linear search of (partially ordered) fields of KLASS for NAME. */
1163 fields_linear_search (tree klass, tree name, bool want_type)
1165 for (tree fields = TYPE_FIELDS (klass); fields; fields = DECL_CHAIN (fields))
1169 if (TREE_CODE (decl) == FIELD_DECL
1170 && ANON_AGGR_TYPE_P (TREE_TYPE (decl)))
1172 if (tree temp = search_anon_aggr (TREE_TYPE (decl), name, want_type))
1176 if (DECL_NAME (decl) != name)
1179 if (TREE_CODE (decl) == USING_DECL)
1181 decl = strip_using_decl (decl);
1182 if (is_overloaded_fn (decl))
1186 if (DECL_DECLARES_FUNCTION_P (decl))
1187 /* Functions are found separately. */
1190 if (!want_type || DECL_DECLARES_TYPE_P (decl))
1197 /* Look for NAME member inside of anonymous aggregate ANON. Although
1198 such things should only contain FIELD_DECLs, we check that too
1199 late, and would give very confusing errors if we weren't
1203 search_anon_aggr (tree anon, tree name, bool want_type)
1205 gcc_assert (COMPLETE_TYPE_P (anon));
1206 tree ret = get_class_binding_direct (anon, name, want_type);
1210 /* Look for NAME as an immediate member of KLASS (including
1211 anon-members or unscoped enum member). TYPE_OR_FNS is zero for
1212 regular search. >0 to get a type binding (if there is one) and <0
1213 if you want (just) the member function binding.
1215 Use this if you do not want lazy member creation. */
1218 get_class_binding_direct (tree klass, tree name, int type_or_fns)
1220 gcc_checking_assert (RECORD_OR_UNION_TYPE_P (klass));
1222 /* Conversion operators can only be found by the marker conversion
1224 bool conv_op = IDENTIFIER_CONV_OP_P (name);
1225 tree lookup = conv_op ? conv_op_identifier : name;
1226 tree val = NULL_TREE;
1227 vec<tree, va_gc> *member_vec = CLASSTYPE_MEMBER_VEC (klass);
1229 if (COMPLETE_TYPE_P (klass) && member_vec)
1231 val = member_vec_binary_search (member_vec, lookup);
1234 else if (type_or_fns > 0)
1236 if (STAT_HACK_P (val))
1237 val = STAT_TYPE (val);
1238 else if (!DECL_DECLARES_TYPE_P (val))
1241 else if (STAT_HACK_P (val))
1242 val = STAT_DECL (val);
1246 if (member_vec && type_or_fns <= 0)
1247 val = member_vec_linear_search (member_vec, lookup);
1249 if (type_or_fns < 0)
1250 /* Don't bother looking for field. We don't want it. */;
1251 else if (!val || (TREE_CODE (val) == OVERLOAD && OVL_USING_P (val)))
1252 /* Dependent using declarations are a 'field', make sure we
1253 return that even if we saw an overload already. */
1254 if (tree field_val = fields_linear_search (klass, lookup,
1256 if (!val || TREE_CODE (field_val) == USING_DECL)
1260 /* Extract the conversion operators asked for, unless the general
1261 conversion operator was requested. */
1264 gcc_checking_assert (OVL_FUNCTION (val) == conv_op_marker);
1265 val = OVL_CHAIN (val);
1266 if (tree type = TREE_TYPE (name))
1267 val = extract_conversion_operator (val, type);
1273 /* Look for NAME's binding in exactly KLASS. See
1274 get_class_binding_direct for argument description. Does lazy
1275 special function creation as necessary. */
1278 get_class_binding (tree klass, tree name, int type_or_fns)
1280 klass = complete_type (klass);
1282 if (COMPLETE_TYPE_P (klass))
1284 /* Lazily declare functions, if we're going to search these. */
1285 if (IDENTIFIER_CTOR_P (name))
1287 if (CLASSTYPE_LAZY_DEFAULT_CTOR (klass))
1288 lazily_declare_fn (sfk_constructor, klass);
1289 if (CLASSTYPE_LAZY_COPY_CTOR (klass))
1290 lazily_declare_fn (sfk_copy_constructor, klass);
1291 if (CLASSTYPE_LAZY_MOVE_CTOR (klass))
1292 lazily_declare_fn (sfk_move_constructor, klass);
1294 else if (IDENTIFIER_DTOR_P (name))
1296 if (CLASSTYPE_LAZY_DESTRUCTOR (klass))
1297 lazily_declare_fn (sfk_destructor, klass);
1299 else if (name == assign_op_identifier)
1301 if (CLASSTYPE_LAZY_COPY_ASSIGN (klass))
1302 lazily_declare_fn (sfk_copy_assignment, klass);
1303 if (CLASSTYPE_LAZY_MOVE_ASSIGN (klass))
1304 lazily_declare_fn (sfk_move_assignment, klass);
1308 return get_class_binding_direct (klass, name, type_or_fns);
1311 /* Find the slot containing overloads called 'NAME'. If there is no
1312 such slot and the class is complete, create an empty one, at the
1313 correct point in the sorted member vector. Otherwise return NULL.
1314 Deals with conv_op marker handling. */
1317 find_member_slot (tree klass, tree name)
1319 bool complete_p = COMPLETE_TYPE_P (klass);
1321 vec<tree, va_gc> *member_vec = CLASSTYPE_MEMBER_VEC (klass);
1324 vec_alloc (member_vec, 8);
1325 CLASSTYPE_MEMBER_VEC (klass) = member_vec;
1328 /* If the class is complete but had no member_vec, we need
1329 to add the TYPE_FIELDS into it. We're also most likely
1330 to be adding ctors & dtors, so ask for 6 spare slots (the
1331 abstract cdtors and their clones). */
1332 set_class_bindings (klass, 6);
1333 member_vec = CLASSTYPE_MEMBER_VEC (klass);
1337 if (IDENTIFIER_CONV_OP_P (name))
1338 name = conv_op_identifier;
1340 unsigned ix, length = member_vec->length ();
1341 for (ix = 0; ix < length; ix++)
1343 tree *slot = &(*member_vec)[ix];
1344 tree fn_name = OVL_NAME (*slot);
1346 if (fn_name == name)
1348 /* If we found an existing slot, it must be a function set.
1349 Even with insertion after completion, because those only
1350 happen with artificial fns that have unspellable names.
1351 This means we do not have to deal with the stat hack
1353 gcc_checking_assert (OVL_P (*slot));
1354 if (name == conv_op_identifier)
1356 gcc_checking_assert (OVL_FUNCTION (*slot) == conv_op_marker);
1357 /* Skip the conv-op marker. */
1358 slot = &OVL_CHAIN (*slot);
1363 if (complete_p && fn_name > name)
1367 /* No slot found, add one if the class is complete. */
1370 /* Do exact allocation, as we don't expect to add many. */
1371 gcc_assert (name != conv_op_identifier);
1372 vec_safe_reserve_exact (member_vec, 1);
1373 CLASSTYPE_MEMBER_VEC (klass) = member_vec;
1374 member_vec->quick_insert (ix, NULL_TREE);
1375 return &(*member_vec)[ix];
1381 /* KLASS is an incomplete class to which we're adding a method NAME.
1382 Add a slot and deal with conv_op marker handling. */
1385 add_member_slot (tree klass, tree name)
1387 gcc_assert (!COMPLETE_TYPE_P (klass));
1389 vec<tree, va_gc> *member_vec = CLASSTYPE_MEMBER_VEC (klass);
1390 vec_safe_push (member_vec, NULL_TREE);
1391 CLASSTYPE_MEMBER_VEC (klass) = member_vec;
1393 tree *slot = &member_vec->last ();
1394 if (IDENTIFIER_CONV_OP_P (name))
1396 /* Install the marker prefix. */
1397 *slot = ovl_make (conv_op_marker, NULL_TREE);
1398 slot = &OVL_CHAIN (*slot);
1404 /* Comparison function to compare two MEMBER_VEC entries by name.
1405 Because we can have duplicates during insertion of TYPE_FIELDS, we
1406 do extra checking so deduping doesn't have to deal with so many
1410 member_name_cmp (const void *a_p, const void *b_p)
1412 tree a = *(const tree *)a_p;
1413 tree b = *(const tree *)b_p;
1414 tree name_a = DECL_NAME (TREE_CODE (a) == OVERLOAD ? OVL_FUNCTION (a) : a);
1415 tree name_b = DECL_NAME (TREE_CODE (b) == OVERLOAD ? OVL_FUNCTION (b) : b);
1417 gcc_checking_assert (name_a && name_b);
1418 if (name_a != name_b)
1419 return name_a < name_b ? -1 : +1;
1421 if (name_a == conv_op_identifier)
1423 /* Strip the conv-op markers. */
1424 gcc_checking_assert (OVL_FUNCTION (a) == conv_op_marker
1425 && OVL_FUNCTION (b) == conv_op_marker);
1430 if (TREE_CODE (a) == OVERLOAD)
1431 a = OVL_FUNCTION (a);
1432 if (TREE_CODE (b) == OVERLOAD)
1433 b = OVL_FUNCTION (b);
1435 /* We're in STAT_HACK or USING_DECL territory (or possibly error-land). */
1436 if (TREE_CODE (a) != TREE_CODE (b))
1438 /* If one of them is a TYPE_DECL, it loses. */
1439 if (TREE_CODE (a) == TYPE_DECL)
1441 else if (TREE_CODE (b) == TYPE_DECL)
1444 /* If one of them is a USING_DECL, it loses. */
1445 if (TREE_CODE (a) == USING_DECL)
1447 else if (TREE_CODE (b) == USING_DECL)
1450 /* There are no other cases with different kinds of decls, as
1451 duplicate detection should have kicked in earlier. However,
1452 some erroneous cases get though. */
1453 gcc_assert (errorcount);
1456 /* Using source location would be the best thing here, but we can
1457 get identically-located decls in the following circumstances:
1459 1) duplicate artificial type-decls for the same type.
1461 2) pack expansions of using-decls.
1463 We should not be doing #1, but in either case it doesn't matter
1464 how we order these. Use UID as a proxy for source ordering, so
1465 that identically-located decls still have a well-defined stable
1467 if (DECL_UID (a) != DECL_UID (b))
1468 return DECL_UID (a) < DECL_UID (b) ? -1 : +1;
1469 gcc_assert (a == b);
1474 gt_pointer_operator new_value;
1478 /* This routine compares two fields like member_name_cmp but using the
1479 pointer operator in resort_field_decl_data. We don't have to deal
1480 with duplicates here. */
1483 resort_member_name_cmp (const void *a_p, const void *b_p)
1485 tree a = *(const tree *)a_p;
1486 tree b = *(const tree *)b_p;
1487 tree name_a = OVL_NAME (a);
1488 tree name_b = OVL_NAME (b);
1490 resort_data.new_value (&name_a, resort_data.cookie);
1491 resort_data.new_value (&name_b, resort_data.cookie);
1493 gcc_checking_assert (name_a != name_b);
1495 return name_a < name_b ? -1 : +1;
1498 /* Resort CLASSTYPE_MEMBER_VEC because pointers have been reordered. */
1501 resort_type_member_vec (void *obj, void */*orig_obj*/,
1502 gt_pointer_operator new_value, void* cookie)
1504 if (vec<tree, va_gc> *member_vec = (vec<tree, va_gc> *) obj)
1506 resort_data.new_value = new_value;
1507 resort_data.cookie = cookie;
1508 member_vec->qsort (resort_member_name_cmp);
1512 /* Recursively count the number of fields in KLASS, including anonymous
1516 count_class_fields (tree klass)
1518 unsigned n_fields = 0;
1520 for (tree fields = TYPE_FIELDS (klass); fields; fields = DECL_CHAIN (fields))
1521 if (DECL_DECLARES_FUNCTION_P (fields))
1522 /* Functions are dealt with separately. */;
1523 else if (TREE_CODE (fields) == FIELD_DECL
1524 && ANON_AGGR_TYPE_P (TREE_TYPE (fields)))
1525 n_fields += count_class_fields (TREE_TYPE (fields));
1526 else if (DECL_NAME (fields))
1532 /* Append all the nonfunction members fields of KLASS to MEMBER_VEC.
1533 Recurse for anonymous members. MEMBER_VEC must have space. */
1536 member_vec_append_class_fields (vec<tree, va_gc> *member_vec, tree klass)
1538 for (tree fields = TYPE_FIELDS (klass); fields; fields = DECL_CHAIN (fields))
1539 if (DECL_DECLARES_FUNCTION_P (fields))
1540 /* Functions are handled separately. */;
1541 else if (TREE_CODE (fields) == FIELD_DECL
1542 && ANON_AGGR_TYPE_P (TREE_TYPE (fields)))
1543 member_vec_append_class_fields (member_vec, TREE_TYPE (fields));
1544 else if (DECL_NAME (fields))
1546 tree field = fields;
1547 /* Mark a conv-op USING_DECL with the conv-op-marker. */
1548 if (TREE_CODE (field) == USING_DECL
1549 && IDENTIFIER_CONV_OP_P (DECL_NAME (field)))
1550 field = ovl_make (conv_op_marker, field);
1551 member_vec->quick_push (field);
1555 /* Append all of the enum values of ENUMTYPE to MEMBER_VEC.
1556 MEMBER_VEC must have space. */
1559 member_vec_append_enum_values (vec<tree, va_gc> *member_vec, tree enumtype)
1561 for (tree values = TYPE_VALUES (enumtype);
1562 values; values = TREE_CHAIN (values))
1563 member_vec->quick_push (TREE_VALUE (values));
1566 /* MEMBER_VEC has just had new DECLs added to it, but is sorted.
1567 DeDup adjacent DECLS of the same name. We already dealt with
1568 conflict resolution when adding the fields or methods themselves.
1569 There are three cases (which could all be combined):
1570 1) a TYPE_DECL and non TYPE_DECL. Deploy STAT_HACK as appropriate.
1571 2) a USING_DECL and an overload. If the USING_DECL is dependent,
1572 it wins. Otherwise the OVERLOAD does.
1573 3) two USING_DECLS. ...
1575 member_name_cmp will have ordered duplicates as
1576 <fns><using><type> */
1579 member_vec_dedup (vec<tree, va_gc> *member_vec)
1581 unsigned len = member_vec->length ();
1587 tree name = OVL_NAME ((*member_vec)[0]);
1588 for (unsigned jx, ix = 0; ix < len; ix = jx)
1590 tree current = NULL_TREE;
1591 tree to_type = NULL_TREE;
1592 tree to_using = NULL_TREE;
1593 tree marker = NULL_TREE;
1595 for (jx = ix; jx < len; jx++)
1597 tree next = (*member_vec)[jx];
1600 tree next_name = OVL_NAME (next);
1601 if (next_name != name)
1608 if (IDENTIFIER_CONV_OP_P (name))
1611 next = OVL_CHAIN (next);
1614 if (TREE_CODE (next) == USING_DECL)
1616 if (IDENTIFIER_CTOR_P (name))
1617 /* Dependent inherited ctor. */
1620 next = strip_using_decl (next);
1621 if (TREE_CODE (next) == USING_DECL)
1627 if (is_overloaded_fn (next))
1631 if (DECL_DECLARES_TYPE_P (next))
1646 current = ovl_make (to_using, current);
1654 current = stat_hack (current, to_type);
1661 OVL_CHAIN (marker) = current;
1664 (*member_vec)[store++] = current;
1668 while (store++ < len)
1672 /* Add the non-function members to CLASSTYPE_MEMBER_VEC. If there is
1673 no existing MEMBER_VEC and fewer than 8 fields, do nothing. We
1674 know there must be at least 1 field -- the self-reference
1675 TYPE_DECL, except for anon aggregates, which will have at least
1679 set_class_bindings (tree klass, unsigned extra)
1681 unsigned n_fields = count_class_fields (klass);
1682 vec<tree, va_gc> *member_vec = CLASSTYPE_MEMBER_VEC (klass);
1684 if (member_vec || n_fields >= 8)
1686 /* Append the new fields. */
1687 vec_safe_reserve_exact (member_vec, extra + n_fields);
1688 member_vec_append_class_fields (member_vec, klass);
1693 CLASSTYPE_MEMBER_VEC (klass) = member_vec;
1694 member_vec->qsort (member_name_cmp);
1695 member_vec_dedup (member_vec);
1699 /* Insert lately defined enum ENUMTYPE into KLASS for the sorted case. */
1702 insert_late_enum_def_bindings (tree klass, tree enumtype)
1705 vec<tree, va_gc> *member_vec = CLASSTYPE_MEMBER_VEC (klass);
1707 /* The enum bindings will already be on the TYPE_FIELDS, so don't
1708 count them twice. */
1710 n_fields = count_class_fields (klass);
1712 n_fields = list_length (TYPE_VALUES (enumtype));
1714 if (member_vec || n_fields >= 8)
1716 vec_safe_reserve_exact (member_vec, n_fields);
1717 if (CLASSTYPE_MEMBER_VEC (klass))
1718 member_vec_append_enum_values (member_vec, enumtype);
1720 member_vec_append_class_fields (member_vec, klass);
1721 CLASSTYPE_MEMBER_VEC (klass) = member_vec;
1722 member_vec->qsort (member_name_cmp);
1723 member_vec_dedup (member_vec);
1727 /* Compute the chain index of a binding_entry given the HASH value of its
1728 name and the total COUNT of chains. COUNT is assumed to be a power
1731 #define ENTRY_INDEX(HASH, COUNT) (((HASH) >> 3) & ((COUNT) - 1))
1733 /* A free list of "binding_entry"s awaiting for re-use. */
1735 static GTY((deletable)) binding_entry free_binding_entry = NULL;
1737 /* The binding oracle; see cp-tree.h. */
1739 cp_binding_oracle_function *cp_binding_oracle;
1741 /* If we have a binding oracle, ask it for all namespace-scoped
1742 definitions of NAME. */
1745 query_oracle (tree name)
1747 if (!cp_binding_oracle)
1750 /* LOOKED_UP holds the set of identifiers that we have already
1751 looked up with the oracle. */
1752 static hash_set<tree> looked_up;
1753 if (looked_up.add (name))
1756 cp_binding_oracle (CP_ORACLE_IDENTIFIER, name);
1759 /* Create a binding_entry object for (NAME, TYPE). */
1761 static inline binding_entry
1762 binding_entry_make (tree name, tree type)
1764 binding_entry entry;
1766 if (free_binding_entry)
1768 entry = free_binding_entry;
1769 free_binding_entry = entry->chain;
1772 entry = ggc_alloc<binding_entry_s> ();
1776 entry->chain = NULL;
1781 /* Put ENTRY back on the free list. */
1784 binding_entry_free (binding_entry entry)
1788 entry->chain = free_binding_entry;
1789 free_binding_entry = entry;
1793 /* The datatype used to implement the mapping from names to types at
1795 struct GTY(()) binding_table_s {
1796 /* Array of chains of "binding_entry"s */
1797 binding_entry * GTY((length ("%h.chain_count"))) chain;
1799 /* The number of chains in this table. This is the length of the
1800 member "chain" considered as an array. */
1803 /* Number of "binding_entry"s in this table. */
1807 /* Construct TABLE with an initial CHAIN_COUNT. */
1810 binding_table_construct (binding_table table, size_t chain_count)
1812 table->chain_count = chain_count;
1813 table->entry_count = 0;
1814 table->chain = ggc_cleared_vec_alloc<binding_entry> (table->chain_count);
1817 /* Make TABLE's entries ready for reuse. */
1820 binding_table_free (binding_table table)
1828 for (i = 0, count = table->chain_count; i < count; ++i)
1830 binding_entry temp = table->chain[i];
1831 while (temp != NULL)
1833 binding_entry entry = temp;
1834 temp = entry->chain;
1835 binding_entry_free (entry);
1837 table->chain[i] = NULL;
1839 table->entry_count = 0;
1843 /* Allocate a table with CHAIN_COUNT, assumed to be a power of two. */
1845 static inline binding_table
1846 binding_table_new (size_t chain_count)
1848 binding_table table = ggc_alloc<binding_table_s> ();
1849 table->chain = NULL;
1850 binding_table_construct (table, chain_count);
1854 /* Expand TABLE to twice its current chain_count. */
1857 binding_table_expand (binding_table table)
1859 const size_t old_chain_count = table->chain_count;
1860 const size_t old_entry_count = table->entry_count;
1861 const size_t new_chain_count = 2 * old_chain_count;
1862 binding_entry *old_chains = table->chain;
1865 binding_table_construct (table, new_chain_count);
1866 for (i = 0; i < old_chain_count; ++i)
1868 binding_entry entry = old_chains[i];
1869 for (; entry != NULL; entry = old_chains[i])
1871 const unsigned int hash = IDENTIFIER_HASH_VALUE (entry->name);
1872 const size_t j = ENTRY_INDEX (hash, new_chain_count);
1874 old_chains[i] = entry->chain;
1875 entry->chain = table->chain[j];
1876 table->chain[j] = entry;
1879 table->entry_count = old_entry_count;
1882 /* Insert a binding for NAME to TYPE into TABLE. */
1885 binding_table_insert (binding_table table, tree name, tree type)
1887 const unsigned int hash = IDENTIFIER_HASH_VALUE (name);
1888 const size_t i = ENTRY_INDEX (hash, table->chain_count);
1889 binding_entry entry = binding_entry_make (name, type);
1891 entry->chain = table->chain[i];
1892 table->chain[i] = entry;
1893 ++table->entry_count;
1895 if (3 * table->chain_count < 5 * table->entry_count)
1896 binding_table_expand (table);
1899 /* Return the binding_entry, if any, that maps NAME. */
1902 binding_table_find (binding_table table, tree name)
1904 const unsigned int hash = IDENTIFIER_HASH_VALUE (name);
1905 binding_entry entry = table->chain[ENTRY_INDEX (hash, table->chain_count)];
1907 while (entry != NULL && entry->name != name)
1908 entry = entry->chain;
1913 /* Apply PROC -- with DATA -- to all entries in TABLE. */
1916 binding_table_foreach (binding_table table, bt_foreach_proc proc, void *data)
1924 chain_count = table->chain_count;
1925 for (i = 0; i < chain_count; ++i)
1927 binding_entry entry = table->chain[i];
1928 for (; entry != NULL; entry = entry->chain)
1933 #ifndef ENABLE_SCOPE_CHECKING
1934 # define ENABLE_SCOPE_CHECKING 0
1936 # define ENABLE_SCOPE_CHECKING 1
1939 /* A free list of "cxx_binding"s, connected by their PREVIOUS. */
1941 static GTY((deletable)) cxx_binding *free_bindings;
1943 /* Initialize VALUE and TYPE field for BINDING, and set the PREVIOUS
1947 cxx_binding_init (cxx_binding *binding, tree value, tree type)
1949 binding->value = value;
1950 binding->type = type;
1951 binding->previous = NULL;
1954 /* (GC)-allocate a binding object with VALUE and TYPE member initialized. */
1956 static cxx_binding *
1957 cxx_binding_make (tree value, tree type)
1959 cxx_binding *binding;
1962 binding = free_bindings;
1963 free_bindings = binding->previous;
1966 binding = ggc_alloc<cxx_binding> ();
1968 cxx_binding_init (binding, value, type);
1973 /* Put BINDING back on the free list. */
1976 cxx_binding_free (cxx_binding *binding)
1978 binding->scope = NULL;
1979 binding->previous = free_bindings;
1980 free_bindings = binding;
1983 /* Create a new binding for NAME (with the indicated VALUE and TYPE
1984 bindings) in the class scope indicated by SCOPE. */
1986 static cxx_binding *
1987 new_class_binding (tree name, tree value, tree type, cp_binding_level *scope)
1989 cp_class_binding cb = {cxx_binding_make (value, type), name};
1990 cxx_binding *binding = cb.base;
1991 vec_safe_push (scope->class_shadowed, cb);
1992 binding->scope = scope;
1996 /* Make DECL the innermost binding for ID. The LEVEL is the binding
1997 level at which this declaration is being bound. */
2000 push_binding (tree id, tree decl, cp_binding_level* level)
2002 cxx_binding *binding;
2004 if (level != class_binding_level)
2006 binding = cxx_binding_make (decl, NULL_TREE);
2007 binding->scope = level;
2010 binding = new_class_binding (id, decl, /*type=*/NULL_TREE, level);
2012 /* Now, fill in the binding information. */
2013 binding->previous = IDENTIFIER_BINDING (id);
2014 INHERITED_VALUE_BINDING_P (binding) = 0;
2015 LOCAL_BINDING_P (binding) = (level != class_binding_level);
2017 /* And put it on the front of the list of bindings for ID. */
2018 IDENTIFIER_BINDING (id) = binding;
2021 /* Remove the binding for DECL which should be the innermost binding
2025 pop_local_binding (tree id, tree decl)
2027 cxx_binding *binding;
2029 if (id == NULL_TREE)
2030 /* It's easiest to write the loops that call this function without
2031 checking whether or not the entities involved have names. We
2032 get here for such an entity. */
2035 /* Get the innermost binding for ID. */
2036 binding = IDENTIFIER_BINDING (id);
2038 /* The name should be bound. */
2039 gcc_assert (binding != NULL);
2041 /* The DECL will be either the ordinary binding or the type
2042 binding for this identifier. Remove that binding. */
2043 if (binding->value == decl)
2044 binding->value = NULL_TREE;
2047 gcc_assert (binding->type == decl);
2048 binding->type = NULL_TREE;
2051 if (!binding->value && !binding->type)
2053 /* We're completely done with the innermost binding for this
2054 identifier. Unhook it from the list of bindings. */
2055 IDENTIFIER_BINDING (id) = binding->previous;
2057 /* Add it to the free list. */
2058 cxx_binding_free (binding);
2062 /* Remove the bindings for the decls of the current level and leave
2063 the current scope. */
2066 pop_bindings_and_leave_scope (void)
2068 for (tree t = get_local_decls (); t; t = DECL_CHAIN (t))
2070 tree decl = TREE_CODE (t) == TREE_LIST ? TREE_VALUE (t) : t;
2071 tree name = OVL_NAME (decl);
2073 pop_local_binding (name, decl);
2079 /* Strip non dependent using declarations. If DECL is dependent,
2080 surreptitiously create a typename_type and return it. */
2083 strip_using_decl (tree decl)
2085 if (decl == NULL_TREE)
2088 while (TREE_CODE (decl) == USING_DECL && !DECL_DEPENDENT_P (decl))
2089 decl = USING_DECL_DECLS (decl);
2091 if (TREE_CODE (decl) == USING_DECL && DECL_DEPENDENT_P (decl)
2092 && USING_DECL_TYPENAME_P (decl))
2094 /* We have found a type introduced by a using
2095 declaration at class scope that refers to a dependent
2098 using typename :: [opt] nested-name-specifier unqualified-id ;
2100 decl = make_typename_type (TREE_TYPE (decl),
2102 typename_type, tf_error);
2103 if (decl != error_mark_node)
2104 decl = TYPE_NAME (decl);
2110 /* Return true if OVL is an overload for an anticipated builtin. */
2113 anticipated_builtin_p (tree ovl)
2115 if (TREE_CODE (ovl) != OVERLOAD)
2118 if (!OVL_HIDDEN_P (ovl))
2121 tree fn = OVL_FUNCTION (ovl);
2122 gcc_checking_assert (DECL_ANTICIPATED (fn));
2124 if (DECL_HIDDEN_FRIEND_P (fn))
2130 /* BINDING records an existing declaration for a name in the current scope.
2131 But, DECL is another declaration for that same identifier in the
2132 same scope. This is the `struct stat' hack whereby a non-typedef
2133 class name or enum-name can be bound at the same level as some other
2137 A class name (9.1) or enumeration name (7.2) can be hidden by the
2138 name of an object, function, or enumerator declared in the same scope.
2139 If a class or enumeration name and an object, function, or enumerator
2140 are declared in the same scope (in any order) with the same name, the
2141 class or enumeration name is hidden wherever the object, function, or
2142 enumerator name is visible.
2144 It's the responsibility of the caller to check that
2145 inserting this name is valid here. Returns nonzero if the new binding
2149 supplement_binding_1 (cxx_binding *binding, tree decl)
2151 tree bval = binding->value;
2153 tree target_bval = strip_using_decl (bval);
2154 tree target_decl = strip_using_decl (decl);
2156 if (TREE_CODE (target_decl) == TYPE_DECL && DECL_ARTIFICIAL (target_decl)
2157 && target_decl != target_bval
2158 && (TREE_CODE (target_bval) != TYPE_DECL
2159 /* We allow pushing an enum multiple times in a class
2160 template in order to handle late matching of underlying
2161 type on an opaque-enum-declaration followed by an
2163 || (processing_template_decl
2164 && TREE_CODE (TREE_TYPE (target_decl)) == ENUMERAL_TYPE
2165 && TREE_CODE (TREE_TYPE (target_bval)) == ENUMERAL_TYPE
2166 && (dependent_type_p (ENUM_UNDERLYING_TYPE
2167 (TREE_TYPE (target_decl)))
2168 || dependent_type_p (ENUM_UNDERLYING_TYPE
2169 (TREE_TYPE (target_bval)))))))
2170 /* The new name is the type name. */
2171 binding->type = decl;
2172 else if (/* TARGET_BVAL is null when push_class_level_binding moves
2173 an inherited type-binding out of the way to make room
2174 for a new value binding. */
2176 /* TARGET_BVAL is error_mark_node when TARGET_DECL's name
2177 has been used in a non-class scope prior declaration.
2178 In that case, we should have already issued a
2179 diagnostic; for graceful error recovery purpose, pretend
2180 this was the intended declaration for that name. */
2181 || target_bval == error_mark_node
2182 /* If TARGET_BVAL is anticipated but has not yet been
2183 declared, pretend it is not there at all. */
2184 || anticipated_builtin_p (target_bval))
2185 binding->value = decl;
2186 else if (TREE_CODE (target_bval) == TYPE_DECL
2187 && DECL_ARTIFICIAL (target_bval)
2188 && target_decl != target_bval
2189 && (TREE_CODE (target_decl) != TYPE_DECL
2190 || same_type_p (TREE_TYPE (target_decl),
2191 TREE_TYPE (target_bval))))
2193 /* The old binding was a type name. It was placed in
2194 VALUE field because it was thought, at the point it was
2195 declared, to be the only entity with such a name. Move the
2196 type name into the type slot; it is now hidden by the new
2198 binding->type = bval;
2199 binding->value = decl;
2200 binding->value_is_inherited = false;
2202 else if (TREE_CODE (target_bval) == TYPE_DECL
2203 && TREE_CODE (target_decl) == TYPE_DECL
2204 && DECL_NAME (target_decl) == DECL_NAME (target_bval)
2205 && binding->scope->kind != sk_class
2206 && (same_type_p (TREE_TYPE (target_decl), TREE_TYPE (target_bval))
2207 /* If either type involves template parameters, we must
2208 wait until instantiation. */
2209 || uses_template_parms (TREE_TYPE (target_decl))
2210 || uses_template_parms (TREE_TYPE (target_bval))))
2211 /* We have two typedef-names, both naming the same type to have
2212 the same name. In general, this is OK because of:
2216 In a given scope, a typedef specifier can be used to redefine
2217 the name of any type declared in that scope to refer to the
2218 type to which it already refers.
2220 However, in class scopes, this rule does not apply due to the
2221 stricter language in [class.mem] prohibiting redeclarations of
2224 /* There can be two block-scope declarations of the same variable,
2225 so long as they are `extern' declarations. However, there cannot
2226 be two declarations of the same static data member:
2230 A member shall not be declared twice in the
2231 member-specification. */
2232 else if (VAR_P (target_decl)
2233 && VAR_P (target_bval)
2234 && DECL_EXTERNAL (target_decl) && DECL_EXTERNAL (target_bval)
2235 && !DECL_CLASS_SCOPE_P (target_decl))
2237 duplicate_decls (decl, binding->value, /*newdecl_is_friend=*/false);
2240 else if (TREE_CODE (decl) == NAMESPACE_DECL
2241 && TREE_CODE (bval) == NAMESPACE_DECL
2242 && DECL_NAMESPACE_ALIAS (decl)
2243 && DECL_NAMESPACE_ALIAS (bval)
2244 && ORIGINAL_NAMESPACE (bval) == ORIGINAL_NAMESPACE (decl))
2245 /* [namespace.alias]
2247 In a declarative region, a namespace-alias-definition can be
2248 used to redefine a namespace-alias declared in that declarative
2249 region to refer only to the namespace to which it already
2254 if (!error_operand_p (bval))
2255 diagnose_name_conflict (decl, bval);
2262 /* Diagnose a name conflict between DECL and BVAL. */
2265 diagnose_name_conflict (tree decl, tree bval)
2267 if (TREE_CODE (decl) == TREE_CODE (bval)
2268 && TREE_CODE (decl) != NAMESPACE_DECL
2269 && !DECL_DECLARES_FUNCTION_P (decl)
2270 && (TREE_CODE (decl) != TYPE_DECL
2271 || DECL_ARTIFICIAL (decl) == DECL_ARTIFICIAL (bval))
2272 && CP_DECL_CONTEXT (decl) == CP_DECL_CONTEXT (bval))
2273 error ("redeclaration of %q#D", decl);
2275 error ("%q#D conflicts with a previous declaration", decl);
2277 inform (location_of (bval), "previous declaration %q#D", bval);
2280 /* Wrapper for supplement_binding_1. */
2283 supplement_binding (cxx_binding *binding, tree decl)
2286 bool subtime = timevar_cond_start (TV_NAME_LOOKUP);
2287 ret = supplement_binding_1 (binding, decl);
2288 timevar_cond_stop (TV_NAME_LOOKUP, subtime);
2292 /* Replace BINDING's current value on its scope's name list with
2296 update_local_overload (cxx_binding *binding, tree newval)
2300 for (d = &binding->scope->names; ; d = &TREE_CHAIN (*d))
2301 if (*d == binding->value)
2303 /* Stitch new list node in. */
2304 *d = tree_cons (NULL_TREE, NULL_TREE, TREE_CHAIN (*d));
2307 else if (TREE_CODE (*d) == TREE_LIST && TREE_VALUE (*d) == binding->value)
2310 TREE_VALUE (*d) = newval;
2313 /* Compares the parameter-type-lists of ONE and TWO and
2314 returns false if they are different. If the DECLs are template
2315 functions, the return types and the template parameter lists are
2316 compared too (DR 565). */
2319 matching_fn_p (tree one, tree two)
2321 if (!compparms (TYPE_ARG_TYPES (TREE_TYPE (one)),
2322 TYPE_ARG_TYPES (TREE_TYPE (two))))
2325 if (TREE_CODE (one) == TEMPLATE_DECL
2326 && TREE_CODE (two) == TEMPLATE_DECL)
2328 /* Compare template parms. */
2329 if (!comp_template_parms (DECL_TEMPLATE_PARMS (one),
2330 DECL_TEMPLATE_PARMS (two)))
2333 /* And return type. */
2334 if (!same_type_p (TREE_TYPE (TREE_TYPE (one)),
2335 TREE_TYPE (TREE_TYPE (two))))
2342 /* Push DECL into nonclass LEVEL BINDING or SLOT. OLD is the current
2343 binding value (possibly with anticipated builtins stripped).
2344 Diagnose conflicts and return updated decl. */
2347 update_binding (cp_binding_level *level, cxx_binding *binding, tree *slot,
2348 tree old, tree decl, bool is_friend)
2351 tree old_type = slot ? MAYBE_STAT_TYPE (*slot) : binding->type;
2352 tree to_type = old_type;
2354 gcc_assert (level->kind == sk_namespace ? !binding
2355 : level->kind != sk_class && !slot);
2356 if (old == error_mark_node)
2359 if (TREE_CODE (decl) == TYPE_DECL && DECL_ARTIFICIAL (decl))
2361 tree other = to_type;
2363 if (old && TREE_CODE (old) == TYPE_DECL && DECL_ARTIFICIAL (old))
2366 /* Pushing an artificial typedef. See if this matches either
2367 the type slot or the old value slot. */
2370 else if (same_type_p (TREE_TYPE (other), TREE_TYPE (decl)))
2371 /* Two artificial decls to same type. Do nothing. */
2378 /* Slide decl into the type slot, keep old unaltered */
2385 if (old && TREE_CODE (old) == TYPE_DECL && DECL_ARTIFICIAL (old))
2387 /* Slide old into the type slot. */
2392 if (DECL_DECLARES_FUNCTION_P (decl))
2396 else if (OVL_P (old))
2398 for (ovl_iterator iter (old); iter; ++iter)
2402 if (iter.using_p () && matching_fn_p (fn, decl))
2404 /* If a function declaration in namespace scope or
2405 block scope has the same name and the same
2406 parameter-type- list (8.3.5) as a function
2407 introduced by a using-declaration, and the
2408 declarations do not declare the same function,
2409 the program is ill-formed. [namespace.udecl]/14 */
2410 if (tree match = duplicate_decls (decl, fn, is_friend))
2413 /* FIXME: To preserve existing error behavior, we
2414 still push the decl. This might change. */
2415 diagnose_name_conflict (decl, fn);
2422 if (to_type != old_type
2424 && MAYBE_CLASS_TYPE_P (TREE_TYPE (to_type))
2425 && !(DECL_IN_SYSTEM_HEADER (decl)
2426 && DECL_IN_SYSTEM_HEADER (to_type)))
2427 warning (OPT_Wshadow, "%q#D hides constructor for %q#D",
2430 to_val = ovl_insert (decl, old);
2434 else if (TREE_CODE (old) != TREE_CODE (decl))
2435 /* Different kinds of decls conflict. */
2437 else if (TREE_CODE (old) == TYPE_DECL)
2439 if (same_type_p (TREE_TYPE (old), TREE_TYPE (decl)))
2440 /* Two type decls to the same type. Do nothing. */
2445 else if (TREE_CODE (old) == NAMESPACE_DECL)
2447 /* Two maybe-aliased namespaces. If they're to the same target
2448 namespace, that's ok. */
2449 if (ORIGINAL_NAMESPACE (old) != ORIGINAL_NAMESPACE (decl))
2452 /* The new one must be an alias at this point. */
2453 gcc_assert (DECL_NAMESPACE_ALIAS (decl));
2456 else if (TREE_CODE (old) == VAR_DECL)
2458 /* There can be two block-scope declarations of the same
2459 variable, so long as they are `extern' declarations. */
2460 if (!DECL_EXTERNAL (old) || !DECL_EXTERNAL (decl))
2462 else if (tree match = duplicate_decls (decl, old, false))
2470 diagnose_name_conflict (decl, old);
2477 if (level->kind == sk_namespace || to_type == decl || to_val == decl)
2478 add_decl_to_level (level, decl);
2481 gcc_checking_assert (binding->value && OVL_P (binding->value));
2482 update_local_overload (binding, to_val);
2487 if (STAT_HACK_P (*slot))
2489 STAT_TYPE (*slot) = to_type;
2490 STAT_DECL (*slot) = to_val;
2493 *slot = stat_hack (to_val, to_type);
2499 binding->type = to_type;
2500 binding->value = to_val;
2507 /* Table of identifiers to extern C declarations (or LISTS thereof). */
2509 static GTY(()) hash_table<named_decl_hash> *extern_c_decls;
2511 /* DECL has C linkage. If we have an existing instance, make sure the
2512 new one is compatible. Make sure it has the same exception
2513 specification [7.5, 7.6]. Add DECL to the map. */
2516 check_extern_c_conflict (tree decl)
2518 /* Ignore artificial or system header decls. */
2519 if (DECL_ARTIFICIAL (decl) || DECL_IN_SYSTEM_HEADER (decl))
2522 /* This only applies to decls at namespace scope. */
2523 if (!DECL_NAMESPACE_SCOPE_P (decl))
2526 if (!extern_c_decls)
2527 extern_c_decls = hash_table<named_decl_hash>::create_ggc (127);
2529 tree *slot = extern_c_decls
2530 ->find_slot_with_hash (DECL_NAME (decl),
2531 IDENTIFIER_HASH_VALUE (DECL_NAME (decl)), INSERT);
2532 if (tree old = *slot)
2534 if (TREE_CODE (old) == OVERLOAD)
2535 old = OVL_FUNCTION (old);
2538 if (DECL_CONTEXT (old) == DECL_CONTEXT (decl))
2539 ; /* If they're in the same context, we'll have already complained
2540 about a (possible) mismatch, when inserting the decl. */
2541 else if (!decls_match (decl, old))
2543 else if (TREE_CODE (decl) == FUNCTION_DECL
2544 && !comp_except_specs (TYPE_RAISES_EXCEPTIONS (TREE_TYPE (old)),
2545 TYPE_RAISES_EXCEPTIONS (TREE_TYPE (decl)),
2548 else if (DECL_ASSEMBLER_NAME_SET_P (old))
2549 SET_DECL_ASSEMBLER_NAME (decl, DECL_ASSEMBLER_NAME (old));
2553 pedwarn (input_location, 0,
2554 "conflicting C language linkage declaration %q#D", decl);
2555 inform (DECL_SOURCE_LOCATION (old),
2556 "previous declaration %q#D", old);
2558 inform (input_location,
2559 "due to different exception specifications");
2564 /* The hash table expects OVERLOADS, so construct one with
2565 OLD as both the function and the chain. This allocate
2566 an excess OVERLOAD node, but it's rare to have multiple
2567 extern "C" decls of the same name. And we save
2568 complicating the hash table logic (which is used
2570 *slot = ovl_make (old, old);
2572 slot = &OVL_CHAIN (*slot);
2574 /* Chain it on for c_linkage_binding's use. */
2575 *slot = tree_cons (NULL_TREE, decl, *slot);
2582 /* Returns a list of C-linkage decls with the name NAME. Used in
2583 c-family/c-pragma.c to implement redefine_extname pragma. */
2586 c_linkage_bindings (tree name)
2589 if (tree *slot = extern_c_decls
2590 ->find_slot_with_hash (name, IDENTIFIER_HASH_VALUE (name), NO_INSERT))
2592 tree result = *slot;
2593 if (TREE_CODE (result) == OVERLOAD)
2594 result = OVL_CHAIN (result);
2601 /* DECL is being declared at a local scope. Emit suitable shadow
2605 check_local_shadow (tree decl)
2607 /* Don't complain about the parms we push and then pop
2608 while tentatively parsing a function declarator. */
2609 if (TREE_CODE (decl) == PARM_DECL && !DECL_CONTEXT (decl))
2612 /* Inline decls shadow nothing. */
2613 if (DECL_FROM_INLINE (decl))
2616 /* External decls are something else. */
2617 if (DECL_EXTERNAL (decl))
2620 tree old = NULL_TREE;
2621 cp_binding_level *old_scope = NULL;
2622 if (cxx_binding *binding = outer_binding (DECL_NAME (decl), NULL, true))
2624 old = binding->value;
2625 old_scope = binding->scope;
2627 while (old && VAR_P (old) && DECL_DEAD_FOR_LOCAL (old))
2628 old = DECL_SHADOWED_FOR_VAR (old);
2630 tree shadowed = NULL_TREE;
2632 && (TREE_CODE (old) == PARM_DECL
2634 || (TREE_CODE (old) == TYPE_DECL
2635 && (!DECL_ARTIFICIAL (old)
2636 || TREE_CODE (decl) == TYPE_DECL)))
2637 && (!DECL_ARTIFICIAL (decl)
2638 || DECL_IMPLICIT_TYPEDEF_P (decl)
2639 || (VAR_P (decl) && DECL_ANON_UNION_VAR_P (decl))))
2641 /* DECL shadows a local thing possibly of interest. */
2643 /* Don't complain if it's from an enclosing function. */
2644 if (DECL_CONTEXT (old) == current_function_decl
2645 && TREE_CODE (decl) != PARM_DECL
2646 && TREE_CODE (old) == PARM_DECL)
2648 /* Go to where the parms should be and see if we find
2650 cp_binding_level *b = current_binding_level->level_chain;
2652 if (FUNCTION_NEEDS_BODY_BLOCK (current_function_decl))
2653 /* Skip the ctor/dtor cleanup level. */
2657 if (b->kind == sk_function_parms)
2659 error ("declaration of %q#D shadows a parameter", decl);
2664 /* The local structure or class can't use parameters of
2665 the containing function anyway. */
2666 if (DECL_CONTEXT (old) != current_function_decl)
2668 for (cp_binding_level *scope = current_binding_level;
2669 scope != old_scope; scope = scope->level_chain)
2670 if (scope->kind == sk_class
2671 && !LAMBDA_TYPE_P (scope->this_entity))
2674 /* Error if redeclaring a local declared in a
2675 init-statement or in the condition of an if or
2676 switch statement when the new declaration is in the
2677 outermost block of the controlled statement.
2678 Redeclaring a variable from a for or while condition is
2679 detected elsewhere. */
2680 else if (VAR_P (old)
2681 && old_scope == current_binding_level->level_chain
2682 && (old_scope->kind == sk_cond || old_scope->kind == sk_for))
2684 error ("redeclaration of %q#D", decl);
2685 inform (DECL_SOURCE_LOCATION (old),
2686 "%q#D previously declared here", old);
2690 3.3.3/3: The name declared in an exception-declaration (...)
2691 shall not be redeclared in the outermost block of the handler.
2692 3.3.3/2: A parameter name shall not be redeclared (...) in
2693 the outermost block of any handler associated with a
2695 3.4.1/15: The function parameter names shall not be redeclared
2696 in the exception-declaration nor in the outermost block of a
2697 handler for the function-try-block. */
2698 else if ((TREE_CODE (old) == VAR_DECL
2699 && old_scope == current_binding_level->level_chain
2700 && old_scope->kind == sk_catch)
2701 || (TREE_CODE (old) == PARM_DECL
2702 && (current_binding_level->kind == sk_catch
2703 || current_binding_level->level_chain->kind == sk_catch)
2704 && in_function_try_handler))
2706 if (permerror (input_location, "redeclaration of %q#D", decl))
2707 inform (DECL_SOURCE_LOCATION (old),
2708 "%q#D previously declared here", old);
2712 /* If '-Wshadow=compatible-local' is specified without other
2713 -Wshadow= flags, we will warn only when the type of the
2714 shadowing variable (DECL) can be converted to that of the
2715 shadowed parameter (OLD_LOCAL). The reason why we only check
2716 if DECL's type can be converted to OLD_LOCAL's type (but not the
2717 other way around) is because when users accidentally shadow a
2718 parameter, more than often they would use the variable
2719 thinking (mistakenly) it's still the parameter. It would be
2720 rare that users would use the variable in the place that
2721 expects the parameter but thinking it's a new decl. */
2723 enum opt_code warning_code;
2725 warning_code = OPT_Wshadow;
2726 else if (warn_shadow_local)
2727 warning_code = OPT_Wshadow_local;
2728 else if (warn_shadow_compatible_local
2729 && (same_type_p (TREE_TYPE (old), TREE_TYPE (decl))
2730 || (!dependent_type_p (TREE_TYPE (decl))
2731 && !dependent_type_p (TREE_TYPE (old))
2732 /* If the new decl uses auto, we don't yet know
2733 its type (the old type cannot be using auto
2734 at this point, without also being
2735 dependent). This is an indication we're
2736 (now) doing the shadow checking too
2738 && !type_uses_auto (TREE_TYPE (decl))
2739 && can_convert (TREE_TYPE (old), TREE_TYPE (decl),
2741 warning_code = OPT_Wshadow_compatible_local;
2746 if (TREE_CODE (old) == PARM_DECL)
2747 msg = "declaration of %q#D shadows a parameter";
2748 else if (is_capture_proxy (old))
2749 msg = "declaration of %qD shadows a lambda capture";
2751 msg = "declaration of %qD shadows a previous local";
2753 if (warning_at (input_location, warning_code, msg, decl))
2756 goto inform_shadowed;
2764 /* Don't warn for artificial things that are not implicit typedefs. */
2765 if (DECL_ARTIFICIAL (decl) && !DECL_IMPLICIT_TYPEDEF_P (decl))
2768 if (nonlambda_method_basetype ())
2769 if (tree member = lookup_member (current_nonlambda_class_type (),
2770 DECL_NAME (decl), /*protect=*/0,
2771 /*want_type=*/false, tf_warning_or_error))
2773 member = MAYBE_BASELINK_FUNCTIONS (member);
2775 /* Warn if a variable shadows a non-function, or the variable
2776 is a function or a pointer-to-function. */
2778 || TREE_CODE (decl) == FUNCTION_DECL
2779 || TYPE_PTRFN_P (TREE_TYPE (decl))
2780 || TYPE_PTRMEMFUNC_P (TREE_TYPE (decl)))
2782 if (warning_at (input_location, OPT_Wshadow,
2783 "declaration of %qD shadows a member of %qT",
2784 decl, current_nonlambda_class_type ())
2788 goto inform_shadowed;
2794 /* Now look for a namespace shadow. */
2795 old = find_namespace_value (current_namespace, DECL_NAME (decl));
2798 || (TREE_CODE (old) == TYPE_DECL
2799 && (!DECL_ARTIFICIAL (old)
2800 || TREE_CODE (decl) == TYPE_DECL)))
2801 && !instantiating_current_function_p ())
2802 /* XXX shadow warnings in outer-more namespaces */
2804 if (warning_at (input_location, OPT_Wshadow,
2805 "declaration of %qD shadows a global declaration",
2809 goto inform_shadowed;
2817 inform (DECL_SOURCE_LOCATION (shadowed), "shadowed declaration is here");
2820 /* DECL is being pushed inside function CTX. Set its context, if
2824 set_decl_context_in_fn (tree ctx, tree decl)
2826 if (!DECL_CONTEXT (decl)
2827 /* A local declaration for a function doesn't constitute
2829 && TREE_CODE (decl) != FUNCTION_DECL
2830 /* A local declaration for an `extern' variable is in the
2831 scope of the current namespace, not the current
2833 && !(VAR_P (decl) && DECL_EXTERNAL (decl))
2834 /* When parsing the parameter list of a function declarator,
2835 don't set DECL_CONTEXT to an enclosing function. When we
2836 push the PARM_DECLs in order to process the function body,
2837 current_binding_level->this_entity will be set. */
2838 && !(TREE_CODE (decl) == PARM_DECL
2839 && current_binding_level->kind == sk_function_parms
2840 && current_binding_level->this_entity == NULL))
2841 DECL_CONTEXT (decl) = ctx;
2843 /* If this is the declaration for a namespace-scope function,
2844 but the declaration itself is in a local scope, mark the
2846 if (TREE_CODE (decl) == FUNCTION_DECL && DECL_NAMESPACE_SCOPE_P (decl))
2847 DECL_LOCAL_FUNCTION_P (decl) = 1;
2850 /* DECL is a local-scope decl with linkage. SHADOWED is true if the
2851 name is already bound at the current level.
2853 [basic.link] If there is a visible declaration of an entity with
2854 linkage having the same name and type, ignoring entities declared
2855 outside the innermost enclosing namespace scope, the block scope
2856 declaration declares that same entity and receives the linkage of
2857 the previous declaration.
2859 Also, make sure that this decl matches any existing external decl
2860 in the enclosing namespace. */
2863 set_local_extern_decl_linkage (tree decl, bool shadowed)
2865 tree ns_value = decl; /* Unique marker. */
2869 tree loc_value = innermost_non_namespace_value (DECL_NAME (decl));
2873 = find_namespace_value (current_namespace, DECL_NAME (decl));
2874 loc_value = ns_value;
2876 if (loc_value == error_mark_node
2877 /* An ambiguous lookup. */
2878 || (loc_value && TREE_CODE (loc_value) == TREE_LIST))
2879 loc_value = NULL_TREE;
2881 for (ovl_iterator iter (loc_value); iter; ++iter)
2882 if (!iter.hidden_p ()
2883 && (TREE_STATIC (*iter) || DECL_EXTERNAL (*iter))
2884 && decls_match (*iter, decl))
2886 /* The standard only says that the local extern inherits
2887 linkage from the previous decl; in particular, default
2888 args are not shared. Add the decl into a hash table to
2889 make sure only the previous decl in this case is seen
2890 by the middle end. */
2891 struct cxx_int_tree_map *h;
2893 /* We inherit the outer decl's linkage. But we're a
2895 TREE_PUBLIC (decl) = TREE_PUBLIC (*iter);
2897 if (cp_function_chain->extern_decl_map == NULL)
2898 cp_function_chain->extern_decl_map
2899 = hash_table<cxx_int_tree_map_hasher>::create_ggc (20);
2901 h = ggc_alloc<cxx_int_tree_map> ();
2902 h->uid = DECL_UID (decl);
2904 cxx_int_tree_map **loc = cp_function_chain->extern_decl_map
2905 ->find_slot (h, INSERT);
2911 if (TREE_PUBLIC (decl))
2913 /* DECL is externally visible. Make sure it matches a matching
2914 decl in the namespace scope. We only really need to check
2915 this when inserting the decl, not when we find an existing
2916 match in the current scope. However, in practice we're
2917 going to be inserting a new decl in the majority of cases --
2918 who writes multiple extern decls for the same thing in the
2919 same local scope? Doing it here often avoids a duplicate
2920 namespace lookup. */
2922 /* Avoid repeating a lookup. */
2923 if (ns_value == decl)
2924 ns_value = find_namespace_value (current_namespace, DECL_NAME (decl));
2926 if (ns_value == error_mark_node
2927 || (ns_value && TREE_CODE (ns_value) == TREE_LIST))
2928 ns_value = NULL_TREE;
2930 for (ovl_iterator iter (ns_value); iter; ++iter)
2934 if (!(TREE_PUBLIC (other) || DECL_EXTERNAL (other)))
2935 ; /* Not externally visible. */
2936 else if (DECL_EXTERN_C_P (decl) && DECL_EXTERN_C_P (other))
2937 ; /* Both are extern "C", we'll check via that mechanism. */
2938 else if (TREE_CODE (other) != TREE_CODE (decl)
2939 || ((VAR_P (decl) || matching_fn_p (other, decl))
2940 && !comptypes (TREE_TYPE (decl), TREE_TYPE (other),
2941 COMPARE_REDECLARATION)))
2943 if (permerror (DECL_SOURCE_LOCATION (decl),
2944 "local external declaration %q#D", decl))
2945 inform (DECL_SOURCE_LOCATION (other),
2946 "does not match previous declaration %q#D", other);
2953 /* Record DECL as belonging to the current lexical scope. Check for
2954 errors (such as an incompatible declaration for the same name
2955 already seen in the same scope). IS_FRIEND is true if DECL is
2956 declared as a friend.
2958 Returns either DECL or an old decl for the same name. If an old
2959 decl is returned, it may have been smashed to agree with what DECL
2963 do_pushdecl (tree decl, bool is_friend)
2965 if (decl == error_mark_node)
2966 return error_mark_node;
2968 if (!DECL_TEMPLATE_PARM_P (decl) && current_function_decl)
2969 set_decl_context_in_fn (current_function_decl, decl);
2971 /* The binding level we will be pushing into. During local class
2972 pushing, we want to push to the containing scope. */
2973 cp_binding_level *level = current_binding_level;
2974 while (level->kind == sk_class)
2975 level = level->level_chain;
2977 /* An anonymous namespace has a NULL DECL_NAME, but we still want to
2978 insert it. Other NULL-named decls, not so much. */
2979 tree name = DECL_NAME (decl);
2980 if (name || TREE_CODE (decl) == NAMESPACE_DECL)
2982 cxx_binding *binding = NULL; /* Local scope binding. */
2983 tree ns = NULL_TREE; /* Searched namespace. */
2984 tree *slot = NULL; /* Binding slot in namespace. */
2985 tree old = NULL_TREE;
2987 if (level->kind == sk_namespace)
2989 /* We look in the decl's namespace for an existing
2990 declaration, even though we push into the current
2992 ns = (DECL_NAMESPACE_SCOPE_P (decl)
2993 ? CP_DECL_CONTEXT (decl) : current_namespace);
2994 /* Create the binding, if this is current namespace, because
2995 that's where we'll be pushing anyway. */
2996 slot = find_namespace_slot (ns, name, ns == current_namespace);
2998 old = MAYBE_STAT_DECL (*slot);
3002 binding = find_local_binding (level, name);
3004 old = binding->value;
3007 if (current_function_decl && VAR_OR_FUNCTION_DECL_P (decl)
3008 && DECL_EXTERNAL (decl))
3009 set_local_extern_decl_linkage (decl, old != NULL_TREE);
3011 if (old == error_mark_node)
3014 for (ovl_iterator iter (old); iter; ++iter)
3015 if (iter.using_p ())
3016 ; /* Ignore using decls here. */
3017 else if (tree match = duplicate_decls (decl, *iter, is_friend))
3019 if (match == error_mark_node)
3021 else if (TREE_CODE (match) == TYPE_DECL)
3022 /* The IDENTIFIER will have the type referring to the
3023 now-smashed TYPE_DECL, because ...? Reset it. */
3024 SET_IDENTIFIER_TYPE_VALUE (name, TREE_TYPE (match));
3025 else if (iter.hidden_p () && !DECL_HIDDEN_P (match))
3027 /* Unhiding a previously hidden decl. */
3028 tree head = iter.reveal_node (old);
3033 update_local_overload (binding, head);
3034 binding->value = head;
3036 else if (STAT_HACK_P (*slot))
3037 STAT_DECL (*slot) = head;
3041 if (DECL_EXTERN_C_P (match))
3042 /* We need to check and register the decl now. */
3043 check_extern_c_conflict (match);
3048 /* We are pushing a new decl. */
3050 /* Skip a hidden builtin we failed to match already. There can
3052 if (old && anticipated_builtin_p (old))
3053 old = OVL_CHAIN (old);
3055 check_template_shadow (decl);
3056 bool visible_injection = false;
3058 if (DECL_DECLARES_FUNCTION_P (decl))
3060 check_default_args (decl);
3064 if (level->kind != sk_namespace)
3066 /* In a local class, a friend function declaration must
3067 find a matching decl in the innermost non-class scope.
3068 [class.friend/11] */
3069 error ("friend declaration %qD in local class without "
3070 "prior local declaration", decl);
3071 /* Don't attempt to push it. */
3072 return error_mark_node;
3074 if (!flag_friend_injection)
3075 /* Hide it from ordinary lookup. */
3076 DECL_ANTICIPATED (decl) = DECL_HIDDEN_FRIEND_P (decl) = true;
3078 visible_injection = true;
3082 if (level->kind != sk_namespace)
3084 check_local_shadow (decl);
3086 if (TREE_CODE (decl) == NAMESPACE_DECL)
3087 /* A local namespace alias. */
3088 set_identifier_type_value (name, NULL_TREE);
3091 binding = create_local_binding (level, name);
3095 ns = current_namespace;
3096 slot = find_namespace_slot (ns, name, true);
3097 /* Update OLD to reflect the namespace we're going to be
3099 old = MAYBE_STAT_DECL (*slot);
3102 old = update_binding (level, binding, slot, old, decl, is_friend);
3105 /* An existing decl matched, use it. */
3107 else if (TREE_CODE (decl) == TYPE_DECL)
3109 tree type = TREE_TYPE (decl);
3111 if (type != error_mark_node)
3113 if (TYPE_NAME (type) != decl)
3114 set_underlying_type (decl);
3117 set_identifier_type_value_with_scope (name, decl, level);
3119 SET_IDENTIFIER_TYPE_VALUE (name, global_type_node);
3122 /* If this is a locally defined typedef in a function that
3123 is not a template instantation, record it to implement
3124 -Wunused-local-typedefs. */
3125 if (!instantiating_current_function_p ())
3126 record_locally_defined_typedef (decl);
3128 else if (VAR_P (decl))
3129 maybe_register_incomplete_var (decl);
3130 else if (visible_injection)
3131 warning (0, "injected friend %qD is visible"
3132 " due to %<-ffriend-injection%>", decl);
3134 if ((VAR_P (decl) || TREE_CODE (decl) == FUNCTION_DECL)
3135 && DECL_EXTERN_C_P (decl))
3136 check_extern_c_conflict (decl);
3139 add_decl_to_level (level, decl);
3144 /* Record a decl-node X as belonging to the current lexical scope.
3145 It's a friend if IS_FRIEND is true -- which affects exactly where
3149 pushdecl (tree x, bool is_friend)
3151 bool subtime = timevar_cond_start (TV_NAME_LOOKUP);
3152 tree ret = do_pushdecl (x, is_friend);
3153 timevar_cond_stop (TV_NAME_LOOKUP, subtime);
3157 /* Enter DECL into the symbol table, if that's appropriate. Returns
3158 DECL, or a modified version thereof. */
3161 maybe_push_decl (tree decl)
3163 tree type = TREE_TYPE (decl);
3165 /* Add this decl to the current binding level, but not if it comes
3166 from another scope, e.g. a static member variable. TEM may equal
3167 DECL or it may be a previous decl of the same name. */
3168 if (decl == error_mark_node
3169 || (TREE_CODE (decl) != PARM_DECL
3170 && DECL_CONTEXT (decl) != NULL_TREE
3171 /* Definitions of namespace members outside their namespace are
3173 && !DECL_NAMESPACE_SCOPE_P (decl))
3174 || (TREE_CODE (decl) == TEMPLATE_DECL && !namespace_bindings_p ())
3175 || type == unknown_type_node
3176 /* The declaration of a template specialization does not affect
3177 the functions available for overload resolution, so we do not
3179 || (TREE_CODE (decl) == FUNCTION_DECL
3180 && DECL_TEMPLATE_SPECIALIZATION (decl)))
3183 return pushdecl (decl);
3186 /* Bind DECL to ID in the current_binding_level, assumed to be a local
3187 binding level. If IS_USING is true, DECL got here through a
3188 using-declaration. */
3191 push_local_binding (tree id, tree decl, bool is_using)
3193 /* Skip over any local classes. This makes sense if we call
3194 push_local_binding with a friend decl of a local class. */
3195 cp_binding_level *b = innermost_nonclass_level ();
3197 gcc_assert (b->kind != sk_namespace);
3198 if (find_local_binding (b, id))
3200 /* Supplement the existing binding. */
3201 if (!supplement_binding (IDENTIFIER_BINDING (id), decl))
3202 /* It didn't work. Something else must be bound at this
3203 level. Do not add DECL to the list of things to pop
3208 /* Create a new binding. */
3209 push_binding (id, decl, b);
3211 if (TREE_CODE (decl) == OVERLOAD || is_using)
3212 /* We must put the OVERLOAD or using into a TREE_LIST since we
3213 cannot use the decl's chain itself. */
3214 decl = build_tree_list (NULL_TREE, decl);
3216 /* And put DECL on the list of things declared by the current
3218 add_decl_to_level (b, decl);
3221 /* Check to see whether or not DECL is a variable that would have been
3222 in scope under the ARM, but is not in scope under the ANSI/ISO
3223 standard. If so, issue an error message. If name lookup would
3224 work in both cases, but return a different result, this function
3225 returns the result of ANSI/ISO lookup. Otherwise, it returns
3228 FIXME: Scheduled for removal after GCC-8 is done. */
3231 check_for_out_of_scope_variable (tree decl)
3235 /* We only care about out of scope variables. */
3236 if (!(VAR_P (decl) && DECL_DEAD_FOR_LOCAL (decl)))
3239 shadowed = DECL_HAS_SHADOWED_FOR_VAR_P (decl)
3240 ? DECL_SHADOWED_FOR_VAR (decl) : NULL_TREE ;
3241 while (shadowed != NULL_TREE && VAR_P (shadowed)
3242 && DECL_DEAD_FOR_LOCAL (shadowed))
3243 shadowed = DECL_HAS_SHADOWED_FOR_VAR_P (shadowed)
3244 ? DECL_SHADOWED_FOR_VAR (shadowed) : NULL_TREE;
3246 shadowed = find_namespace_value (current_namespace, DECL_NAME (decl));
3249 if (!DECL_ERROR_REPORTED (decl)
3251 && warning (0, "name lookup of %qD changed", DECL_NAME (decl)))
3253 inform (DECL_SOURCE_LOCATION (shadowed),
3254 "matches this %qD under ISO standard rules", shadowed);
3255 inform (DECL_SOURCE_LOCATION (decl),
3256 " matches this %qD under old rules", decl);
3258 DECL_ERROR_REPORTED (decl) = 1;
3262 /* If we have already complained about this declaration, there's no
3263 need to do it again. */
3264 if (DECL_ERROR_REPORTED (decl))
3267 DECL_ERROR_REPORTED (decl) = 1;
3269 if (TREE_TYPE (decl) == error_mark_node)
3272 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TREE_TYPE (decl)))
3274 error ("name lookup of %qD changed for ISO %<for%> scoping",
3276 inform (DECL_SOURCE_LOCATION (decl),
3277 "cannot use obsolete binding %qD because it has a destructor",
3279 return error_mark_node;
3283 permerror (input_location,
3284 "name lookup of %qD changed for ISO %<for%> scoping",
3286 if (flag_permissive)
3287 inform (DECL_SOURCE_LOCATION (decl),
3288 "using obsolete binding %qD", decl);
3291 inform (input_location, flag_permissive
3292 ? "this flexibility is deprecated and will be removed"
3293 : "if you use %<-fpermissive%> G++ will accept your code");
3300 /* true means unconditionally make a BLOCK for the next level pushed. */
3302 static bool keep_next_level_flag;
3304 static int binding_depth = 0;
3311 for (i = 0; i < depth * 2; i++)
3315 /* Return a string describing the kind of SCOPE we have. */
3317 cp_binding_level_descriptor (cp_binding_level *scope)
3319 /* The order of this table must match the "scope_kind"
3321 static const char* scope_kind_names[] = {
3327 "function-parameter-scope",
3330 "template-parameter-scope",
3331 "template-explicit-spec-scope"
3333 const scope_kind kind = scope->explicit_spec_p
3334 ? sk_template_spec : scope->kind;
3336 return scope_kind_names[kind];
3339 /* Output a debugging information about SCOPE when performing
3342 cp_binding_level_debug (cp_binding_level *scope, int line, const char *action)
3344 const char *desc = cp_binding_level_descriptor (scope);
3345 if (scope->this_entity)
3346 verbatim ("%s %<%s(%E)%> %p %d\n", action, desc,
3347 scope->this_entity, (void *) scope, line);
3349 verbatim ("%s %s %p %d\n", action, desc, (void *) scope, line);
3352 /* Return the estimated initial size of the hashtable of a NAMESPACE
3355 static inline size_t
3356 namespace_scope_ht_size (tree ns)
3358 tree name = DECL_NAME (ns);
3360 return name == std_identifier
3361 ? NAMESPACE_STD_HT_SIZE
3362 : (name == global_identifier
3363 ? GLOBAL_SCOPE_HT_SIZE
3364 : NAMESPACE_ORDINARY_HT_SIZE);
3367 /* A chain of binding_level structures awaiting reuse. */
3369 static GTY((deletable)) cp_binding_level *free_binding_level;
3371 /* Insert SCOPE as the innermost binding level. */
3374 push_binding_level (cp_binding_level *scope)
3376 /* Add it to the front of currently active scopes stack. */
3377 scope->level_chain = current_binding_level;
3378 current_binding_level = scope;
3379 keep_next_level_flag = false;
3381 if (ENABLE_SCOPE_CHECKING)
3383 scope->binding_depth = binding_depth;
3384 indent (binding_depth);
3385 cp_binding_level_debug (scope, LOCATION_LINE (input_location),
3391 /* Create a new KIND scope and make it the top of the active scopes stack.
3392 ENTITY is the scope of the associated C++ entity (namespace, class,
3393 function, C++0x enumeration); it is NULL otherwise. */
3396 begin_scope (scope_kind kind, tree entity)
3398 cp_binding_level *scope;
3400 /* Reuse or create a struct for this binding level. */
3401 if (!ENABLE_SCOPE_CHECKING && free_binding_level)
3403 scope = free_binding_level;
3404 free_binding_level = scope->level_chain;
3405 memset (scope, 0, sizeof (cp_binding_level));
3408 scope = ggc_cleared_alloc<cp_binding_level> ();
3410 scope->this_entity = entity;
3411 scope->more_cleanups_ok = true;
3418 case sk_template_spec:
3419 scope->explicit_spec_p = true;
3420 kind = sk_template_parms;
3422 case sk_template_parms:
3429 case sk_scoped_enum:
3430 case sk_function_parms:
3431 case sk_transaction:
3433 scope->keep = keep_next_level_flag;
3437 NAMESPACE_LEVEL (entity) = scope;
3441 /* Should not happen. */
3447 push_binding_level (scope);
3452 /* We're about to leave current scope. Pop the top of the stack of
3453 currently active scopes. Return the enclosing scope, now active. */
3458 cp_binding_level *scope = current_binding_level;
3460 if (scope->kind == sk_namespace && class_binding_level)
3461 current_binding_level = class_binding_level;
3463 /* We cannot leave a scope, if there are none left. */
3464 if (NAMESPACE_LEVEL (global_namespace))
3465 gcc_assert (!global_scope_p (scope));
3467 if (ENABLE_SCOPE_CHECKING)
3469 indent (--binding_depth);
3470 cp_binding_level_debug (scope, LOCATION_LINE (input_location),
3474 /* Move one nesting level up. */
3475 current_binding_level = scope->level_chain;
3477 /* Namespace-scopes are left most probably temporarily, not
3478 completely; they can be reopened later, e.g. in namespace-extension
3479 or any name binding activity that requires us to resume a
3480 namespace. For classes, we cache some binding levels. For other
3481 scopes, we just make the structure available for reuse. */
3482 if (scope->kind != sk_namespace
3483 && scope->kind != sk_class)
3485 scope->level_chain = free_binding_level;
3486 gcc_assert (!ENABLE_SCOPE_CHECKING
3487 || scope->binding_depth == binding_depth);
3488 free_binding_level = scope;
3491 if (scope->kind == sk_class)
3493 /* Reset DEFINING_CLASS_P to allow for reuse of a
3494 class-defining scope in a non-defining context. */
3495 scope->defining_class_p = 0;
3497 /* Find the innermost enclosing class scope, and reset
3498 CLASS_BINDING_LEVEL appropriately. */
3499 class_binding_level = NULL;
3500 for (scope = current_binding_level; scope; scope = scope->level_chain)
3501 if (scope->kind == sk_class)
3503 class_binding_level = scope;
3508 return current_binding_level;
3512 resume_scope (cp_binding_level* b)
3514 /* Resuming binding levels is meant only for namespaces,
3515 and those cannot nest into classes. */
3516 gcc_assert (!class_binding_level);
3517 /* Also, resuming a non-directly nested namespace is a no-no. */
3518 gcc_assert (b->level_chain == current_binding_level);
3519 current_binding_level = b;
3520 if (ENABLE_SCOPE_CHECKING)
3522 b->binding_depth = binding_depth;
3523 indent (binding_depth);
3524 cp_binding_level_debug (b, LOCATION_LINE (input_location), "resume");
3529 /* Return the innermost binding level that is not for a class scope. */
3531 static cp_binding_level *
3532 innermost_nonclass_level (void)
3534 cp_binding_level *b;
3536 b = current_binding_level;
3537 while (b->kind == sk_class)
3543 /* We're defining an object of type TYPE. If it needs a cleanup, but
3544 we're not allowed to add any more objects with cleanups to the current
3545 scope, create a new binding level. */
3548 maybe_push_cleanup_level (tree type)
3550 if (type != error_mark_node
3551 && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type)
3552 && current_binding_level->more_cleanups_ok == 0)
3554 begin_scope (sk_cleanup, NULL);
3555 current_binding_level->statement_list = push_stmt_list ();
3559 /* Return true if we are in the global binding level. */
3562 global_bindings_p (void)
3564 return global_scope_p (current_binding_level);
3567 /* True if we are currently in a toplevel binding level. This
3568 means either the global binding level or a namespace in a toplevel
3569 binding level. Since there are no non-toplevel namespace levels,
3570 this really means any namespace or template parameter level. We
3571 also include a class whose context is toplevel. */
3574 toplevel_bindings_p (void)
3576 cp_binding_level *b = innermost_nonclass_level ();
3578 return b->kind == sk_namespace || b->kind == sk_template_parms;
3581 /* True if this is a namespace scope, or if we are defining a class
3582 which is itself at namespace scope, or whose enclosing class is
3583 such a class, etc. */
3586 namespace_bindings_p (void)
3588 cp_binding_level *b = innermost_nonclass_level ();
3590 return b->kind == sk_namespace;
3593 /* True if the innermost non-class scope is a block scope. */
3596 local_bindings_p (void)
3598 cp_binding_level *b = innermost_nonclass_level ();
3599 return b->kind < sk_function_parms || b->kind == sk_omp;
3602 /* True if the current level needs to have a BLOCK made. */
3607 return (current_binding_level->blocks != NULL_TREE
3608 || current_binding_level->keep
3609 || current_binding_level->kind == sk_cleanup
3610 || current_binding_level->names != NULL_TREE
3611 || current_binding_level->using_directives);
3614 /* Returns the kind of the innermost scope. */
3617 innermost_scope_kind (void)
3619 return current_binding_level->kind;
3622 /* Returns true if this scope was created to store template parameters. */
3625 template_parm_scope_p (void)
3627 return innermost_scope_kind () == sk_template_parms;
3630 /* If KEEP is true, make a BLOCK node for the next binding level,
3631 unconditionally. Otherwise, use the normal logic to decide whether
3632 or not to create a BLOCK. */
3635 keep_next_level (bool keep)
3637 keep_next_level_flag = keep;
3640 /* Return the list of declarations of the current local scope. */
3643 get_local_decls (void)
3645 gcc_assert (current_binding_level->kind != sk_namespace
3646 && current_binding_level->kind != sk_class);
3647 return current_binding_level->names;
3650 /* Return how many function prototypes we are currently nested inside. */
3653 function_parm_depth (void)
3656 cp_binding_level *b;
3658 for (b = current_binding_level;
3659 b->kind == sk_function_parms;
3666 /* For debugging. */
3667 static int no_print_functions = 0;
3668 static int no_print_builtins = 0;
3671 print_binding_level (cp_binding_level* lvl)
3675 fprintf (stderr, " blocks=%p", (void *) lvl->blocks);
3676 if (lvl->more_cleanups_ok)
3677 fprintf (stderr, " more-cleanups-ok");
3678 if (lvl->have_cleanups)
3679 fprintf (stderr, " have-cleanups");
3680 fprintf (stderr, "\n");
3683 fprintf (stderr, " names:\t");
3684 /* We can probably fit 3 names to a line? */
3685 for (t = lvl->names; t; t = TREE_CHAIN (t))
3687 if (no_print_functions && (TREE_CODE (t) == FUNCTION_DECL))
3689 if (no_print_builtins
3690 && (TREE_CODE (t) == TYPE_DECL)
3691 && DECL_IS_BUILTIN (t))
3694 /* Function decls tend to have longer names. */
3695 if (TREE_CODE (t) == FUNCTION_DECL)
3702 fprintf (stderr, "\n\t");
3705 print_node_brief (stderr, "", t, 0);
3706 if (t == error_mark_node)
3710 fprintf (stderr, "\n");
3712 if (vec_safe_length (lvl->class_shadowed))
3715 cp_class_binding *b;
3716 fprintf (stderr, " class-shadowed:");
3717 FOR_EACH_VEC_ELT (*lvl->class_shadowed, i, b)
3718 fprintf (stderr, " %s ", IDENTIFIER_POINTER (b->identifier));
3719 fprintf (stderr, "\n");
3721 if (lvl->type_shadowed)
3723 fprintf (stderr, " type-shadowed:");
3724 for (t = lvl->type_shadowed; t; t = TREE_CHAIN (t))
3726 fprintf (stderr, " %s ", IDENTIFIER_POINTER (TREE_PURPOSE (t)));
3728 fprintf (stderr, "\n");
3733 debug (cp_binding_level &ref)
3735 print_binding_level (&ref);
3739 debug (cp_binding_level *ptr)
3744 fprintf (stderr, "<nil>\n");
3749 print_other_binding_stack (cp_binding_level *stack)
3751 cp_binding_level *level;
3752 for (level = stack; !global_scope_p (level); level = level->level_chain)
3754 fprintf (stderr, "binding level %p\n", (void *) level);
3755 print_binding_level (level);
3760 print_binding_stack (void)
3762 cp_binding_level *b;
3763 fprintf (stderr, "current_binding_level=%p\n"
3764 "class_binding_level=%p\n"
3765 "NAMESPACE_LEVEL (global_namespace)=%p\n",
3766 (void *) current_binding_level, (void *) class_binding_level,
3767 (void *) NAMESPACE_LEVEL (global_namespace));
3768 if (class_binding_level)
3770 for (b = class_binding_level; b; b = b->level_chain)
3771 if (b == current_binding_level)
3774 b = class_binding_level;
3776 b = current_binding_level;
3779 b = current_binding_level;
3780 print_other_binding_stack (b);
3781 fprintf (stderr, "global:\n");
3782 print_binding_level (NAMESPACE_LEVEL (global_namespace));
3785 /* Return the type associated with ID. */
3788 identifier_type_value_1 (tree id)
3790 /* There is no type with that name, anywhere. */
3791 if (REAL_IDENTIFIER_TYPE_VALUE (id) == NULL_TREE)
3793 /* This is not the type marker, but the real thing. */
3794 if (REAL_IDENTIFIER_TYPE_VALUE (id) != global_type_node)
3795 return REAL_IDENTIFIER_TYPE_VALUE (id);
3796 /* Have to search for it. It must be on the global level, now.
3797 Ask lookup_name not to return non-types. */
3798 id = lookup_name_real (id, 2, 1, /*block_p=*/true, 0, 0);
3800 return TREE_TYPE (id);
3804 /* Wrapper for identifier_type_value_1. */
3807 identifier_type_value (tree id)
3810 timevar_start (TV_NAME_LOOKUP);
3811 ret = identifier_type_value_1 (id);
3812 timevar_stop (TV_NAME_LOOKUP);
3816 /* Push a definition of struct, union or enum tag named ID. into
3817 binding_level B. DECL is a TYPE_DECL for the type. We assume that
3818 the tag ID is not already defined. */
3821 set_identifier_type_value_with_scope (tree id, tree decl, cp_binding_level *b)
3825 if (b->kind != sk_namespace)
3827 /* Shadow the marker, not the real thing, so that the marker
3828 gets restored later. */
3829 tree old_type_value = REAL_IDENTIFIER_TYPE_VALUE (id);
3831 = tree_cons (id, old_type_value, b->type_shadowed);
3832 type = decl ? TREE_TYPE (decl) : NULL_TREE;
3833 TREE_TYPE (b->type_shadowed) = type;
3837 tree *slot = find_namespace_slot (current_namespace, id, true);
3839 update_binding (b, NULL, slot, MAYBE_STAT_DECL (*slot), decl, false);
3841 /* Store marker instead of real type. */
3842 type = global_type_node;
3844 SET_IDENTIFIER_TYPE_VALUE (id, type);
3847 /* As set_identifier_type_value_with_scope, but using
3848 current_binding_level. */
3851 set_identifier_type_value (tree id, tree decl)
3853 set_identifier_type_value_with_scope (id, decl, current_binding_level);
3856 /* Return the name for the constructor (or destructor) for the
3860 constructor_name (tree type)
3862 tree decl = TYPE_NAME (TYPE_MAIN_VARIANT (type));
3864 return decl ? DECL_NAME (decl) : NULL_TREE;
3867 /* Returns TRUE if NAME is the name for the constructor for TYPE,
3868 which must be a class type. */
3871 constructor_name_p (tree name, tree type)
3873 gcc_assert (MAYBE_CLASS_TYPE_P (type));
3875 /* These don't have names. */
3876 if (TREE_CODE (type) == DECLTYPE_TYPE
3877 || TREE_CODE (type) == TYPEOF_TYPE)
3880 if (name && name == constructor_name (type))
3886 /* Counter used to create anonymous type names. */
3888 static GTY(()) int anon_cnt;
3890 /* Return an IDENTIFIER which can be used as a name for
3891 unnamed structs and unions. */
3894 make_anon_name (void)
3898 sprintf (buf, anon_aggrname_format (), anon_cnt++);
3899 return get_identifier (buf);
3902 /* This code is practically identical to that for creating
3903 anonymous names, but is just used for lambdas instead. This isn't really
3904 necessary, but it's convenient to avoid treating lambdas like other
3907 static GTY(()) int lambda_cnt = 0;
3910 make_lambda_name (void)
3914 sprintf (buf, LAMBDANAME_FORMAT, lambda_cnt++);
3915 return get_identifier (buf);
3918 /* Insert another USING_DECL into the current binding level, returning
3919 this declaration. If this is a redeclaration, do nothing, and
3920 return NULL_TREE if this not in namespace scope (in namespace
3921 scope, a using decl might extend any previous bindings). */
3924 push_using_decl_1 (tree scope, tree name)
3928 gcc_assert (TREE_CODE (scope) == NAMESPACE_DECL);
3929 gcc_assert (identifier_p (name));
3930 for (decl = current_binding_level->usings; decl; decl = DECL_CHAIN (decl))
3931 if (USING_DECL_SCOPE (decl) == scope && DECL_NAME (decl) == name)
3934 return namespace_bindings_p () ? decl : NULL_TREE;
3935 decl = build_lang_decl (USING_DECL, name, NULL_TREE);
3936 USING_DECL_SCOPE (decl) = scope;
3937 DECL_CHAIN (decl) = current_binding_level->usings;
3938 current_binding_level->usings = decl;
3942 /* Wrapper for push_using_decl_1. */
3945 push_using_decl (tree scope, tree name)
3948 timevar_start (TV_NAME_LOOKUP);
3949 ret = push_using_decl_1 (scope, name);
3950 timevar_stop (TV_NAME_LOOKUP);
3954 /* Same as pushdecl, but define X in binding-level LEVEL. We rely on the
3955 caller to set DECL_CONTEXT properly.
3957 Note that this must only be used when X will be the new innermost
3958 binding for its name, as we tack it onto the front of IDENTIFIER_BINDING
3959 without checking to see if the current IDENTIFIER_BINDING comes from a
3960 closer binding level than LEVEL. */
3963 do_pushdecl_with_scope (tree x, cp_binding_level *level, bool is_friend)
3965 cp_binding_level *b;
3967 if (level->kind == sk_class)
3969 b = class_binding_level;
3970 class_binding_level = level;
3971 pushdecl_class_level (x);
3972 class_binding_level = b;
3976 tree function_decl = current_function_decl;
3977 if (level->kind == sk_namespace)
3978 current_function_decl = NULL_TREE;
3979 b = current_binding_level;
3980 current_binding_level = level;
3981 x = pushdecl (x, is_friend);
3982 current_binding_level = b;
3983 current_function_decl = function_decl;
3988 /* Inject X into the local scope just before the function parms. */
3991 pushdecl_outermost_localscope (tree x)
3993 cp_binding_level *b = NULL;
3994 bool subtime = timevar_cond_start (TV_NAME_LOOKUP);
3996 /* Find the scope just inside the function parms. */
3997 for (cp_binding_level *n = current_binding_level;
3998 n->kind != sk_function_parms; n = b->level_chain)
4001 tree ret = b ? do_pushdecl_with_scope (x, b, false) : error_mark_node;
4002 timevar_cond_stop (TV_NAME_LOOKUP, subtime);
4007 /* Check a non-member using-declaration. Return the name and scope
4008 being used, and the USING_DECL, or NULL_TREE on failure. */
4011 validate_nonmember_using_decl (tree decl, tree scope, tree name)
4013 /* [namespace.udecl]
4014 A using-declaration for a class member shall be a
4015 member-declaration. */
4018 error ("%qT is not a namespace or unscoped enum", scope);
4021 else if (scope == error_mark_node)
4024 if (TREE_CODE (decl) == TEMPLATE_ID_EXPR)
4027 A using-declaration shall not name a template-id. */
4028 error ("a using-declaration cannot specify a template-id. "
4029 "Try %<using %D%>", name);
4033 if (TREE_CODE (decl) == NAMESPACE_DECL)
4035 error ("namespace %qD not allowed in using-declaration", decl);
4039 if (TREE_CODE (decl) == SCOPE_REF)
4041 /* It's a nested name with template parameter dependent scope.
4042 This can only be using-declaration for class member. */
4043 error ("%qT is not a namespace", TREE_OPERAND (decl, 0));
4047 decl = OVL_FIRST (decl);
4049 /* Make a USING_DECL. */
4050 tree using_decl = push_using_decl (scope, name);
4052 if (using_decl == NULL_TREE
4053 && at_function_scope_p ()
4055 /* C++11 7.3.3/10. */
4056 error ("%qD is already declared in this scope", name);
4061 /* Process a local-scope or namespace-scope using declaration. SCOPE
4062 is the nominated scope to search for NAME. VALUE_P and TYPE_P
4063 point to the binding for NAME in the current scope and are
4067 do_nonmember_using_decl (tree scope, tree name, tree *value_p, tree *type_p)
4069 name_lookup lookup (name, 0);
4071 if (!qualified_namespace_lookup (scope, &lookup))
4073 error ("%qD not declared", name);
4076 else if (TREE_CODE (lookup.value) == TREE_LIST)
4078 error ("reference to %qD is ambiguous", name);
4079 print_candidates (lookup.value);
4080 lookup.value = NULL_TREE;
4083 if (lookup.type && TREE_CODE (lookup.type) == TREE_LIST)
4085 error ("reference to %qD is ambiguous", name);
4086 print_candidates (lookup.type);
4087 lookup.type = NULL_TREE;
4090 tree value = *value_p;
4091 tree type = *type_p;
4093 /* Shift the old and new bindings around so we're comparing class and
4094 enumeration names to each other. */
4095 if (value && DECL_IMPLICIT_TYPEDEF_P (value))
4101 if (lookup.value && DECL_IMPLICIT_TYPEDEF_P (lookup.value))
4103 lookup.type = lookup.value;
4104 lookup.value = NULL_TREE;
4107 if (lookup.value && lookup.value != value)
4109 /* Check for using functions. */
4110 if (OVL_P (lookup.value) && (!value || OVL_P (value)))
4112 for (lkp_iterator usings (lookup.value); usings; ++usings)
4114 tree new_fn = *usings;
4116 /* [namespace.udecl]
4118 If a function declaration in namespace scope or block
4119 scope has the same name and the same parameter types as a
4120 function introduced by a using declaration the program is
4123 for (ovl_iterator old (value); !found && old; ++old)
4127 if (new_fn == old_fn)
4128 /* The function already exists in the current
4131 else if (old.using_p ())
4132 continue; /* This is a using decl. */
4133 else if (old.hidden_p () && !DECL_HIDDEN_FRIEND_P (old_fn))
4134 continue; /* This is an anticipated builtin. */
4135 else if (!matching_fn_p (new_fn, old_fn))
4136 continue; /* Parameters do not match. */
4137 else if (decls_match (new_fn, old_fn))
4141 diagnose_name_conflict (new_fn, old_fn);
4147 /* Unlike the overload case we don't drop anticipated
4148 builtins here. They don't cause a problem, and
4149 we'd like to match them with a future
4151 value = ovl_insert (new_fn, value, true);
4155 /* Ignore anticipated builtins. */
4156 && !anticipated_builtin_p (value)
4157 && !decls_match (lookup.value, value))
4158 diagnose_name_conflict (lookup.value, value);
4160 value = lookup.value;
4163 if (lookup.type && lookup.type != type)
4165 if (type && !decls_match (lookup.type, type))
4166 diagnose_name_conflict (lookup.type, type);
4171 /* If bind->value is empty, shift any class or enumeration name back. */
4182 /* Returns true if ANCESTOR encloses DESCENDANT, including matching.
4183 Both are namespaces. */
4186 is_nested_namespace (tree ancestor, tree descendant, bool inline_only)
4188 int depth = SCOPE_DEPTH (ancestor);
4190 if (!depth && !inline_only)
4191 /* The global namespace encloses everything. */
4194 while (SCOPE_DEPTH (descendant) > depth
4195 && (!inline_only || DECL_NAMESPACE_INLINE_P (descendant)))
4196 descendant = CP_DECL_CONTEXT (descendant);
4198 return ancestor == descendant;
4201 /* Returns true if ROOT (a namespace, class, or function) encloses
4202 CHILD. CHILD may be either a class type or a namespace. */
4205 is_ancestor (tree root, tree child)
4207 gcc_assert ((TREE_CODE (root) == NAMESPACE_DECL
4208 || TREE_CODE (root) == FUNCTION_DECL
4209 || CLASS_TYPE_P (root)));
4210 gcc_assert ((TREE_CODE (child) == NAMESPACE_DECL
4211 || CLASS_TYPE_P (child)));
4213 /* The global namespace encloses everything. */
4214 if (root == global_namespace)
4217 /* Search until we reach namespace scope. */
4218 while (TREE_CODE (child) != NAMESPACE_DECL)
4220 /* If we've reached the ROOT, it encloses CHILD. */
4223 /* Go out one level. */
4225 child = TYPE_NAME (child);
4226 child = CP_DECL_CONTEXT (child);
4229 if (TREE_CODE (root) == NAMESPACE_DECL)
4230 return is_nested_namespace (root, child);
4235 /* Enter the class or namespace scope indicated by T suitable for name
4236 lookup. T can be arbitrary scope, not necessary nested inside the
4237 current scope. Returns a non-null scope to pop iff pop_scope
4238 should be called later to exit this scope. */
4243 if (TREE_CODE (t) == NAMESPACE_DECL)
4244 push_decl_namespace (t);
4245 else if (CLASS_TYPE_P (t))
4247 if (!at_class_scope_p ()
4248 || !same_type_p (current_class_type, t))
4249 push_nested_class (t);
4251 /* T is the same as the current scope. There is therefore no
4252 need to re-enter the scope. Since we are not actually
4253 pushing a new scope, our caller should not call
4261 /* Leave scope pushed by push_scope. */
4268 if (TREE_CODE (t) == NAMESPACE_DECL)
4269 pop_decl_namespace ();
4270 else if CLASS_TYPE_P (t)
4271 pop_nested_class ();
4274 /* Subroutine of push_inner_scope. */
4277 push_inner_scope_r (tree outer, tree inner)
4282 || (TREE_CODE (inner) != NAMESPACE_DECL && !CLASS_TYPE_P (inner)))
4285 prev = CP_DECL_CONTEXT (TREE_CODE (inner) == NAMESPACE_DECL ? inner : TYPE_NAME (inner));
4287 push_inner_scope_r (outer, prev);
4288 if (TREE_CODE (inner) == NAMESPACE_DECL)
4290 cp_binding_level *save_template_parm = 0;
4291 /* Temporary take out template parameter scopes. They are saved
4292 in reversed order in save_template_parm. */
4293 while (current_binding_level->kind == sk_template_parms)
4295 cp_binding_level *b = current_binding_level;
4296 current_binding_level = b->level_chain;
4297 b->level_chain = save_template_parm;
4298 save_template_parm = b;
4301 resume_scope (NAMESPACE_LEVEL (inner));
4302 current_namespace = inner;
4304 /* Restore template parameter scopes. */
4305 while (save_template_parm)
4307 cp_binding_level *b = save_template_parm;
4308 save_template_parm = b->level_chain;
4309 b->level_chain = current_binding_level;
4310 current_binding_level = b;
4317 /* Enter the scope INNER from current scope. INNER must be a scope
4318 nested inside current scope. This works with both name lookup and
4319 pushing name into scope. In case a template parameter scope is present,
4320 namespace is pushed under the template parameter scope according to
4321 name lookup rule in 14.6.1/6.
4323 Return the former current scope suitable for pop_inner_scope. */
4326 push_inner_scope (tree inner)
4328 tree outer = current_scope ();
4330 outer = current_namespace;
4332 push_inner_scope_r (outer, inner);
4336 /* Exit the current scope INNER back to scope OUTER. */
4339 pop_inner_scope (tree outer, tree inner)
4342 || (TREE_CODE (inner) != NAMESPACE_DECL && !CLASS_TYPE_P (inner)))
4345 while (outer != inner)
4347 if (TREE_CODE (inner) == NAMESPACE_DECL)
4349 cp_binding_level *save_template_parm = 0;
4350 /* Temporary take out template parameter scopes. They are saved
4351 in reversed order in save_template_parm. */
4352 while (current_binding_level->kind == sk_template_parms)
4354 cp_binding_level *b = current_binding_level;
4355 current_binding_level = b->level_chain;
4356 b->level_chain = save_template_parm;
4357 save_template_parm = b;
4362 /* Restore template parameter scopes. */
4363 while (save_template_parm)
4365 cp_binding_level *b = save_template_parm;
4366 save_template_parm = b->level_chain;
4367 b->level_chain = current_binding_level;
4368 current_binding_level = b;
4374 inner = CP_DECL_CONTEXT (TREE_CODE (inner) == NAMESPACE_DECL ? inner : TYPE_NAME (inner));
4378 /* Do a pushlevel for class declarations. */
4381 pushlevel_class (void)
4383 class_binding_level = begin_scope (sk_class, current_class_type);
4386 /* ...and a poplevel for class declarations. */
4389 poplevel_class (void)
4391 cp_binding_level *level = class_binding_level;
4392 cp_class_binding *cb;
4396 bool subtime = timevar_cond_start (TV_NAME_LOOKUP);
4397 gcc_assert (level != 0);
4399 /* If we're leaving a toplevel class, cache its binding level. */
4400 if (current_class_depth == 1)
4401 previous_class_level = level;
4402 for (shadowed = level->type_shadowed;
4404 shadowed = TREE_CHAIN (shadowed))
4405 SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (shadowed), TREE_VALUE (shadowed));
4407 /* Remove the bindings for all of the class-level declarations. */
4408 if (level->class_shadowed)
4410 FOR_EACH_VEC_ELT (*level->class_shadowed, i, cb)
4412 IDENTIFIER_BINDING (cb->identifier) = cb->base->previous;
4413 cxx_binding_free (cb->base);
4415 ggc_free (level->class_shadowed);
4416 level->class_shadowed = NULL;
4419 /* Now, pop out of the binding level which we created up in the
4420 `pushlevel_class' routine. */
4421 gcc_assert (current_binding_level == level);
4423 timevar_cond_stop (TV_NAME_LOOKUP, subtime);
4426 /* Set INHERITED_VALUE_BINDING_P on BINDING to true or false, as
4427 appropriate. DECL is the value to which a name has just been
4428 bound. CLASS_TYPE is the class in which the lookup occurred. */
4431 set_inherited_value_binding_p (cxx_binding *binding, tree decl,
4434 if (binding->value == decl && TREE_CODE (decl) != TREE_LIST)
4438 if (TREE_CODE (decl) == OVERLOAD)
4439 context = ovl_scope (decl);
4442 gcc_assert (DECL_P (decl));
4443 context = context_for_name_lookup (decl);
4446 if (is_properly_derived_from (class_type, context))
4447 INHERITED_VALUE_BINDING_P (binding) = 1;
4449 INHERITED_VALUE_BINDING_P (binding) = 0;
4451 else if (binding->value == decl)
4452 /* We only encounter a TREE_LIST when there is an ambiguity in the
4453 base classes. Such an ambiguity can be overridden by a
4454 definition in this class. */
4455 INHERITED_VALUE_BINDING_P (binding) = 1;
4457 INHERITED_VALUE_BINDING_P (binding) = 0;
4460 /* Make the declaration of X appear in CLASS scope. */
4463 pushdecl_class_level (tree x)
4465 bool is_valid = true;
4468 /* Do nothing if we're adding to an outer lambda closure type,
4469 outer_binding will add it later if it's needed. */
4470 if (current_class_type != class_binding_level->this_entity)
4473 subtime = timevar_cond_start (TV_NAME_LOOKUP);
4474 /* Get the name of X. */
4475 tree name = OVL_NAME (x);
4479 is_valid = push_class_level_binding (name, x);
4480 if (TREE_CODE (x) == TYPE_DECL)
4481 set_identifier_type_value (name, x);
4483 else if (ANON_AGGR_TYPE_P (TREE_TYPE (x)))
4485 /* If X is an anonymous aggregate, all of its members are
4486 treated as if they were members of the class containing the
4487 aggregate, for naming purposes. */
4488 location_t save_location = input_location;
4489 tree anon = TREE_TYPE (x);
4490 if (vec<tree, va_gc> *member_vec = CLASSTYPE_MEMBER_VEC (anon))
4491 for (unsigned ix = member_vec->length (); ix--;)
4493 tree binding = (*member_vec)[ix];
4494 if (STAT_HACK_P (binding))
4496 if (!pushdecl_class_level (STAT_TYPE (binding)))
4498 binding = STAT_DECL (binding);
4500 if (!pushdecl_class_level (binding))
4504 for (tree f = TYPE_FIELDS (anon); f; f = DECL_CHAIN (f))
4505 if (TREE_CODE (f) == FIELD_DECL)
4507 input_location = DECL_SOURCE_LOCATION (f);
4508 if (!pushdecl_class_level (f))
4511 input_location = save_location;
4513 timevar_cond_stop (TV_NAME_LOOKUP, subtime);
4517 /* Return the BINDING (if any) for NAME in SCOPE, which is a class
4518 scope. If the value returned is non-NULL, and the PREVIOUS field
4519 is not set, callers must set the PREVIOUS field explicitly. */
4521 static cxx_binding *
4522 get_class_binding (tree name, cp_binding_level *scope)
4527 cxx_binding *binding;
4529 class_type = scope->this_entity;
4531 /* Get the type binding. */
4532 type_binding = lookup_member (class_type, name,
4533 /*protect=*/2, /*want_type=*/true,
4534 tf_warning_or_error);
4535 /* Get the value binding. */
4536 value_binding = lookup_member (class_type, name,
4537 /*protect=*/2, /*want_type=*/false,
4538 tf_warning_or_error);
4541 && (TREE_CODE (value_binding) == TYPE_DECL
4542 || DECL_CLASS_TEMPLATE_P (value_binding)
4543 || (TREE_CODE (value_binding) == TREE_LIST
4544 && TREE_TYPE (value_binding) == error_mark_node
4545 && (TREE_CODE (TREE_VALUE (value_binding))
4547 /* We found a type binding, even when looking for a non-type
4548 binding. This means that we already processed this binding
4551 else if (value_binding)
4553 if (TREE_CODE (value_binding) == TREE_LIST
4554 && TREE_TYPE (value_binding) == error_mark_node)
4555 /* NAME is ambiguous. */
4557 else if (BASELINK_P (value_binding))
4558 /* NAME is some overloaded functions. */
4559 value_binding = BASELINK_FUNCTIONS (value_binding);
4562 /* If we found either a type binding or a value binding, create a
4563 new binding object. */
4564 if (type_binding || value_binding)
4566 binding = new_class_binding (name,
4570 /* This is a class-scope binding, not a block-scope binding. */
4571 LOCAL_BINDING_P (binding) = 0;
4572 set_inherited_value_binding_p (binding, value_binding, class_type);
4580 /* Make the declaration(s) of X appear in CLASS scope under the name
4581 NAME. Returns true if the binding is valid. */
4584 push_class_level_binding_1 (tree name, tree x)
4586 cxx_binding *binding;
4590 /* The class_binding_level will be NULL if x is a template
4591 parameter name in a member template. */
4592 if (!class_binding_level)
4595 if (name == error_mark_node)
4598 /* Can happen for an erroneous declaration (c++/60384). */
4599 if (!identifier_p (name))
4601 gcc_assert (errorcount || sorrycount);
4605 /* Check for invalid member names. But don't worry about a default
4606 argument-scope lambda being pushed after the class is complete. */
4607 gcc_assert (TYPE_BEING_DEFINED (current_class_type)
4608 || LAMBDA_TYPE_P (TREE_TYPE (decl)));
4609 /* Check that we're pushing into the right binding level. */
4610 gcc_assert (current_class_type == class_binding_level->this_entity);
4612 /* We could have been passed a tree list if this is an ambiguous
4613 declaration. If so, pull the declaration out because
4614 check_template_shadow will not handle a TREE_LIST. */
4615 if (TREE_CODE (decl) == TREE_LIST
4616 && TREE_TYPE (decl) == error_mark_node)
4617 decl = TREE_VALUE (decl);
4619 if (!check_template_shadow (decl))
4624 If T is the name of a class, then each of the following shall
4625 have a name different from T:
4627 -- every static data member of class T;
4629 -- every member of class T that is itself a type;
4631 -- every enumerator of every member of class T that is an
4634 -- every member of every anonymous union that is a member of
4637 (Non-static data members were also forbidden to have the same
4638 name as T until TC1.) */
4640 || TREE_CODE (x) == CONST_DECL
4641 || (TREE_CODE (x) == TYPE_DECL
4642 && !DECL_SELF_REFERENCE_P (x))
4643 /* A data member of an anonymous union. */
4644 || (TREE_CODE (x) == FIELD_DECL
4645 && DECL_CONTEXT (x) != current_class_type))
4646 && DECL_NAME (x) == DECL_NAME (TYPE_NAME (current_class_type)))
4648 tree scope = context_for_name_lookup (x);
4649 if (TYPE_P (scope) && same_type_p (scope, current_class_type))
4651 error ("%qD has the same name as the class in which it is "
4658 /* Get the current binding for NAME in this class, if any. */
4659 binding = IDENTIFIER_BINDING (name);
4660 if (!binding || binding->scope != class_binding_level)
4662 binding = get_class_binding (name, class_binding_level);
4663 /* If a new binding was created, put it at the front of the
4664 IDENTIFIER_BINDING list. */
4667 binding->previous = IDENTIFIER_BINDING (name);
4668 IDENTIFIER_BINDING (name) = binding;
4672 /* If there is already a binding, then we may need to update the
4674 if (binding && binding->value)
4676 tree bval = binding->value;
4677 tree old_decl = NULL_TREE;
4678 tree target_decl = strip_using_decl (decl);
4679 tree target_bval = strip_using_decl (bval);
4681 if (INHERITED_VALUE_BINDING_P (binding))
4683 /* If the old binding was from a base class, and was for a
4684 tag name, slide it over to make room for the new binding.
4685 The old binding is still visible if explicitly qualified
4686 with a class-key. */
4687 if (TREE_CODE (target_bval) == TYPE_DECL
4688 && DECL_ARTIFICIAL (target_bval)
4689 && !(TREE_CODE (target_decl) == TYPE_DECL
4690 && DECL_ARTIFICIAL (target_decl)))
4692 old_decl = binding->type;
4693 binding->type = bval;
4694 binding->value = NULL_TREE;
4695 INHERITED_VALUE_BINDING_P (binding) = 0;
4700 /* Any inherited type declaration is hidden by the type
4701 declaration in the derived class. */
4702 if (TREE_CODE (target_decl) == TYPE_DECL
4703 && DECL_ARTIFICIAL (target_decl))
4704 binding->type = NULL_TREE;
4707 else if (TREE_CODE (target_decl) == OVERLOAD
4708 && OVL_P (target_bval))
4710 else if (TREE_CODE (decl) == USING_DECL
4711 && TREE_CODE (bval) == USING_DECL
4712 && same_type_p (USING_DECL_SCOPE (decl),
4713 USING_DECL_SCOPE (bval)))
4714 /* This is a using redeclaration that will be diagnosed later
4715 in supplement_binding */
4717 else if (TREE_CODE (decl) == USING_DECL
4718 && TREE_CODE (bval) == USING_DECL
4719 && DECL_DEPENDENT_P (decl)
4720 && DECL_DEPENDENT_P (bval))
4722 else if (TREE_CODE (decl) == USING_DECL
4723 && OVL_P (target_bval))
4725 else if (TREE_CODE (bval) == USING_DECL
4726 && OVL_P (target_decl))
4729 if (old_decl && binding->scope == class_binding_level)
4732 /* It is always safe to clear INHERITED_VALUE_BINDING_P
4733 here. This function is only used to register bindings
4734 from with the class definition itself. */
4735 INHERITED_VALUE_BINDING_P (binding) = 0;
4740 /* Note that we declared this value so that we can issue an error if
4741 this is an invalid redeclaration of a name already used for some
4743 note_name_declared_in_class (name, decl);
4745 /* If we didn't replace an existing binding, put the binding on the
4746 stack of bindings for the identifier, and update the shadowed
4748 if (binding && binding->scope == class_binding_level)
4749 /* Supplement the existing binding. */
4750 ok = supplement_binding (binding, decl);
4753 /* Create a new binding. */
4754 push_binding (name, decl, class_binding_level);
4761 /* Wrapper for push_class_level_binding_1. */
4764 push_class_level_binding (tree name, tree x)
4767 bool subtime = timevar_cond_start (TV_NAME_LOOKUP);
4768 ret = push_class_level_binding_1 (name, x);
4769 timevar_cond_stop (TV_NAME_LOOKUP, subtime);
4773 /* Process "using SCOPE::NAME" in a class scope. Return the
4774 USING_DECL created. */
4777 do_class_using_decl (tree scope, tree name)
4779 if (name == error_mark_node)
4782 if (!scope || !TYPE_P (scope))
4784 error ("using-declaration for non-member at class scope");
4788 /* Make sure the name is not invalid */
4789 if (TREE_CODE (name) == BIT_NOT_EXPR)
4791 error ("%<%T::%D%> names destructor", scope, name);
4795 /* Using T::T declares inheriting ctors, even if T is a typedef. */
4796 if (MAYBE_CLASS_TYPE_P (scope)
4797 && (name == TYPE_IDENTIFIER (scope)
4798 || constructor_name_p (name, scope)))
4800 maybe_warn_cpp0x (CPP0X_INHERITING_CTORS);
4801 name = ctor_identifier;
4802 CLASSTYPE_NON_AGGREGATE (current_class_type) = true;
4805 /* Cannot introduce a constructor name. */
4806 if (constructor_name_p (name, current_class_type))
4808 error ("%<%T::%D%> names constructor in %qT",
4809 scope, name, current_class_type);
4813 /* From [namespace.udecl]:
4815 A using-declaration used as a member-declaration shall refer to a
4816 member of a base class of the class being defined.
4818 In general, we cannot check this constraint in a template because
4819 we do not know the entire set of base classes of the current
4820 class type. Morover, if SCOPE is dependent, it might match a
4821 non-dependent base. */
4823 tree decl = NULL_TREE;
4824 if (!dependent_scope_p (scope))
4827 tree binfo = lookup_base (current_class_type, scope, ba_any, &b_kind,
4828 tf_warning_or_error);
4829 if (b_kind < bk_proper_base)
4831 /* If there are dependent bases, scope might resolve at
4832 instantiation time, even if it isn't exactly one of the
4834 if (b_kind == bk_same_type || !any_dependent_bases_p ())
4836 error_not_base_type (scope, current_class_type);
4840 else if (name == ctor_identifier && !binfo_direct_p (binfo))
4842 error ("cannot inherit constructors from indirect base %qT", scope);
4845 else if (!IDENTIFIER_CONV_OP_P (name)
4846 || !dependent_type_p (TREE_TYPE (name)))
4848 decl = lookup_member (binfo, name, 0, false, tf_warning_or_error);
4851 error ("no members matching %<%T::%D%> in %q#T", scope, name,
4856 /* The binfo from which the functions came does not matter. */
4857 if (BASELINK_P (decl))
4858 decl = BASELINK_FUNCTIONS (decl);
4862 tree value = build_lang_decl (USING_DECL, name, NULL_TREE);
4863 USING_DECL_DECLS (value) = decl;
4864 USING_DECL_SCOPE (value) = scope;
4865 DECL_DEPENDENT_P (value) = !decl;
4871 /* Return the binding for NAME in NS. If NS is NULL, look in
4872 global_namespace. */
4875 get_namespace_binding (tree ns, tree name)
4877 bool subtime = timevar_cond_start (TV_NAME_LOOKUP);
4879 ns = global_namespace;
4880 gcc_checking_assert (!DECL_NAMESPACE_ALIAS (ns));
4881 tree ret = find_namespace_value (ns, name);
4882 timevar_cond_stop (TV_NAME_LOOKUP, subtime);
4886 /* Push internal DECL into the global namespace. Does not do the
4887 full overload fn handling and does not add it to the list of things
4888 in the namespace. */
4891 set_global_binding (tree decl)
4893 bool subtime = timevar_cond_start (TV_NAME_LOOKUP);
4895 tree *slot = find_namespace_slot (global_namespace, DECL_NAME (decl), true);
4898 /* The user's placed something in the implementor's namespace. */
4899 diagnose_name_conflict (decl, MAYBE_STAT_DECL (*slot));
4901 /* Force the binding, so compiler internals continue to work. */
4904 timevar_cond_stop (TV_NAME_LOOKUP, subtime);
4907 /* Set the context of a declaration to scope. Complain if we are not
4911 set_decl_namespace (tree decl, tree scope, bool friendp)
4913 /* Get rid of namespace aliases. */
4914 scope = ORIGINAL_NAMESPACE (scope);
4916 /* It is ok for friends to be qualified in parallel space. */
4917 if (!friendp && !is_nested_namespace (current_namespace, scope))
4918 error ("declaration of %qD not in a namespace surrounding %qD",
4920 DECL_CONTEXT (decl) = FROB_CONTEXT (scope);
4922 /* See whether this has been declared in the namespace or inline
4924 tree old = NULL_TREE;
4926 name_lookup lookup (DECL_NAME (decl), LOOKUP_HIDDEN);
4927 if (!lookup.search_qualified (scope, /*usings=*/false))
4928 /* No old declaration at all. */
4933 /* If it's a TREE_LIST, the result of the lookup was ambiguous. */
4934 if (TREE_CODE (old) == TREE_LIST)
4937 DECL_CONTEXT (decl) = FROB_CONTEXT (scope);
4938 error ("reference to %qD is ambiguous", decl);
4939 print_candidates (old);
4943 if (!DECL_DECLARES_FUNCTION_P (decl))
4945 /* Don't compare non-function decls with decls_match here, since
4946 it can't check for the correct constness at this
4947 point. pushdecl will find those errors later. */
4949 /* We might have found it in an inline namespace child of SCOPE. */
4950 if (TREE_CODE (decl) == TREE_CODE (old))
4951 DECL_CONTEXT (decl) = DECL_CONTEXT (old);
4954 /* Writing "N::i" to declare something directly in "N" is invalid. */
4955 if (CP_DECL_CONTEXT (decl) == current_namespace
4956 && at_namespace_scope_p ())
4957 error ("explicit qualification in declaration of %qD", decl);
4961 /* Since decl is a function, old should contain a function decl. */
4965 /* We handle these in check_explicit_instantiation_namespace. */
4966 if (processing_explicit_instantiation)
4968 if (processing_template_decl || processing_specialization)
4969 /* We have not yet called push_template_decl to turn a
4970 FUNCTION_DECL into a TEMPLATE_DECL, so the declarations won't
4971 match. But, we'll check later, when we construct the
4974 /* Instantiations or specializations of templates may be declared as
4975 friends in any namespace. */
4976 if (friendp && DECL_USE_TEMPLATE (decl))
4982 for (lkp_iterator iter (old); iter; ++iter)
4984 if (iter.using_p ())
4989 /* Adjust DECL_CONTEXT first so decls_match will return true
4990 if DECL will match a declaration in an inline namespace. */
4991 DECL_CONTEXT (decl) = DECL_CONTEXT (ofn);
4992 if (decls_match (decl, ofn))
4996 /* We found more than one matching declaration. */
4997 DECL_CONTEXT (decl) = FROB_CONTEXT (scope);
5006 if (DECL_HIDDEN_FRIEND_P (found))
5008 pedwarn (DECL_SOURCE_LOCATION (decl), 0,
5009 "%qD has not been declared within %qD", decl, scope);
5010 inform (DECL_SOURCE_LOCATION (found),
5011 "only here as a %<friend%>");
5013 DECL_CONTEXT (decl) = DECL_CONTEXT (found);
5018 /* It didn't work, go back to the explicit scope. */
5019 DECL_CONTEXT (decl) = FROB_CONTEXT (scope);
5020 error ("%qD should have been declared inside %qD", decl, scope);
5023 /* Return the namespace where the current declaration is declared. */
5026 current_decl_namespace (void)
5029 /* If we have been pushed into a different namespace, use it. */
5030 if (!vec_safe_is_empty (decl_namespace_list))
5031 return decl_namespace_list->last ();
5033 if (current_class_type)
5034 result = decl_namespace_context (current_class_type);
5035 else if (current_function_decl)
5036 result = decl_namespace_context (current_function_decl);
5038 result = current_namespace;
5042 /* Process any ATTRIBUTES on a namespace definition. Returns true if
5043 attribute visibility is seen. */
5046 handle_namespace_attrs (tree ns, tree attributes)
5049 bool saw_vis = false;
5051 if (attributes == error_mark_node)
5054 for (d = attributes; d; d = TREE_CHAIN (d))
5056 tree name = get_attribute_name (d);
5057 tree args = TREE_VALUE (d);
5059 if (is_attribute_p ("visibility", name))
5061 /* attribute visibility is a property of the syntactic block
5062 rather than the namespace as a whole, so we don't touch the
5063 NAMESPACE_DECL at all. */
5064 tree x = args ? TREE_VALUE (args) : NULL_TREE;
5065 if (x == NULL_TREE || TREE_CODE (x) != STRING_CST || TREE_CHAIN (args))
5067 warning (OPT_Wattributes,
5068 "%qD attribute requires a single NTBS argument",
5073 if (!TREE_PUBLIC (ns))
5074 warning (OPT_Wattributes,
5075 "%qD attribute is meaningless since members of the "
5076 "anonymous namespace get local symbols", name);
5078 push_visibility (TREE_STRING_POINTER (x), 1);
5081 else if (is_attribute_p ("abi_tag", name))
5083 if (!DECL_NAME (ns))
5085 warning (OPT_Wattributes, "ignoring %qD attribute on anonymous "
5089 if (!DECL_NAMESPACE_INLINE_P (ns))
5091 warning (OPT_Wattributes, "ignoring %qD attribute on non-inline "
5097 tree dn = DECL_NAME (ns);
5098 args = build_string (IDENTIFIER_LENGTH (dn) + 1,
5099 IDENTIFIER_POINTER (dn));
5100 TREE_TYPE (args) = char_array_type_node;
5101 args = fix_string_type (args);
5102 args = build_tree_list (NULL_TREE, args);
5104 if (check_abi_tag_args (args, name))
5105 DECL_ATTRIBUTES (ns) = tree_cons (name, args,
5106 DECL_ATTRIBUTES (ns));
5110 warning (OPT_Wattributes, "%qD attribute directive ignored",
5119 /* Temporarily set the namespace for the current declaration. */
5122 push_decl_namespace (tree decl)
5124 if (TREE_CODE (decl) != NAMESPACE_DECL)
5125 decl = decl_namespace_context (decl);
5126 vec_safe_push (decl_namespace_list, ORIGINAL_NAMESPACE (decl));
5129 /* [namespace.memdef]/2 */
5132 pop_decl_namespace (void)
5134 decl_namespace_list->pop ();
5137 /* Process a namespace-alias declaration. */
5140 do_namespace_alias (tree alias, tree name_space)
5142 if (name_space == error_mark_node)
5145 gcc_assert (TREE_CODE (name_space) == NAMESPACE_DECL);
5147 name_space = ORIGINAL_NAMESPACE (name_space);
5149 /* Build the alias. */
5150 alias = build_lang_decl (NAMESPACE_DECL, alias, void_type_node);
5151 DECL_NAMESPACE_ALIAS (alias) = name_space;
5152 DECL_EXTERNAL (alias) = 1;
5153 DECL_CONTEXT (alias) = FROB_CONTEXT (current_scope ());
5156 /* Emit debug info for namespace alias. */
5157 if (!building_stmt_list_p ())
5158 (*debug_hooks->early_global_decl) (alias);
5161 /* Like pushdecl, only it places X in the current namespace,
5165 pushdecl_namespace_level (tree x, bool is_friend)
5167 cp_binding_level *b = current_binding_level;
5170 bool subtime = timevar_cond_start (TV_NAME_LOOKUP);
5171 t = do_pushdecl_with_scope
5172 (x, NAMESPACE_LEVEL (current_namespace), is_friend);
5174 /* Now, the type_shadowed stack may screw us. Munge it so it does
5176 if (TREE_CODE (t) == TYPE_DECL)
5178 tree name = DECL_NAME (t);
5180 tree *ptr = (tree *)0;
5181 for (; !global_scope_p (b); b = b->level_chain)
5183 tree shadowed = b->type_shadowed;
5184 for (; shadowed; shadowed = TREE_CHAIN (shadowed))
5185 if (TREE_PURPOSE (shadowed) == name)
5187 ptr = &TREE_VALUE (shadowed);
5188 /* Can't break out of the loop here because sometimes
5189 a binding level will have duplicate bindings for
5190 PT names. It's gross, but I haven't time to fix it. */
5193 newval = TREE_TYPE (t);
5194 if (ptr == (tree *)0)
5196 /* @@ This shouldn't be needed. My test case "zstring.cc" trips
5197 up here if this is changed to an assertion. --KR */
5198 SET_IDENTIFIER_TYPE_VALUE (name, t);
5205 timevar_cond_stop (TV_NAME_LOOKUP, subtime);
5209 /* Process a using-declaration appearing in namespace scope. */
5212 finish_namespace_using_decl (tree decl, tree scope, tree name)
5214 tree orig_decl = decl;
5216 gcc_checking_assert (current_binding_level->kind == sk_namespace
5217 && !processing_template_decl);
5218 decl = validate_nonmember_using_decl (decl, scope, name);
5219 if (decl == NULL_TREE)
5222 tree *slot = find_namespace_slot (current_namespace, name, true);
5223 tree val = slot ? MAYBE_STAT_DECL (*slot) : NULL_TREE;
5224 tree type = slot ? MAYBE_STAT_TYPE (*slot) : NULL_TREE;
5225 do_nonmember_using_decl (scope, name, &val, &type);
5226 if (STAT_HACK_P (*slot))
5228 STAT_DECL (*slot) = val;
5229 STAT_TYPE (*slot) = type;
5232 *slot = stat_hack (val, type);
5236 /* Emit debug info. */
5237 cp_emit_debug_info_for_using (orig_decl, current_namespace);
5240 /* Process a using-declaration at function scope. */
5243 finish_local_using_decl (tree decl, tree scope, tree name)
5245 tree orig_decl = decl;
5247 gcc_checking_assert (current_binding_level->kind != sk_class
5248 && current_binding_level->kind != sk_namespace);
5249 decl = validate_nonmember_using_decl (decl, scope, name);
5250 if (decl == NULL_TREE)
5253 add_decl_expr (decl);
5255 cxx_binding *binding = find_local_binding (current_binding_level, name);
5256 tree value = binding ? binding->value : NULL_TREE;
5257 tree type = binding ? binding->type : NULL_TREE;
5259 do_nonmember_using_decl (scope, name, &value, &type);
5263 else if (binding && value == binding->value)
5265 else if (binding && binding->value && TREE_CODE (value) == OVERLOAD)
5267 update_local_overload (IDENTIFIER_BINDING (name), value);
5268 IDENTIFIER_BINDING (name)->value = value;
5271 /* Install the new binding. */
5272 push_local_binding (name, value, true);
5276 else if (binding && type == binding->type)
5280 push_local_binding (name, type, true);
5281 set_identifier_type_value (name, type);
5284 /* Emit debug info. */
5285 if (!processing_template_decl)
5286 cp_emit_debug_info_for_using (orig_decl, current_scope ());
5289 /* Return the declarations that are members of the namespace NS. */
5292 cp_namespace_decls (tree ns)
5294 return NAMESPACE_LEVEL (ns)->names;
5297 /* Combine prefer_type and namespaces_only into flags. */
5300 lookup_flags (int prefer_type, int namespaces_only)
5302 if (namespaces_only)
5303 return LOOKUP_PREFER_NAMESPACES;
5304 if (prefer_type > 1)
5305 return LOOKUP_PREFER_TYPES;
5306 if (prefer_type > 0)
5307 return LOOKUP_PREFER_BOTH;
5311 /* Given a lookup that returned VAL, use FLAGS to decide if we want to
5312 ignore it or not. Subroutine of lookup_name_real and
5313 lookup_type_scope. */
5316 qualify_lookup (tree val, int flags)
5318 if (val == NULL_TREE)
5320 if ((flags & LOOKUP_PREFER_NAMESPACES) && TREE_CODE (val) == NAMESPACE_DECL)
5322 if (flags & LOOKUP_PREFER_TYPES)
5324 tree target_val = strip_using_decl (val);
5325 if (TREE_CODE (target_val) == TYPE_DECL
5326 || TREE_CODE (target_val) == TEMPLATE_DECL)
5329 if (flags & (LOOKUP_PREFER_NAMESPACES | LOOKUP_PREFER_TYPES))
5331 /* Look through lambda things that we shouldn't be able to see. */
5332 if (!(flags & LOOKUP_HIDDEN) && is_lambda_ignored_entity (val))
5337 /* Is there a "using namespace std;" directive within USINGS? */
5340 using_directives_contain_std_p (vec<tree, va_gc> *usings)
5345 for (unsigned ix = usings->length (); ix--;)
5346 if ((*usings)[ix] == std_node)
5352 /* Is there a "using namespace std;" directive within the current
5353 namespace (or its ancestors)?
5354 Compare with name_lookup::search_unqualified. */
5357 has_using_namespace_std_directive_p ()
5359 /* Look at local using-directives. */
5360 for (cp_binding_level *level = current_binding_level;
5361 level->kind != sk_namespace;
5362 level = level->level_chain)
5363 if (using_directives_contain_std_p (level->using_directives))
5366 /* Look at this namespace and its ancestors. */
5367 for (tree scope = current_namespace; scope; scope = CP_DECL_CONTEXT (scope))
5369 if (using_directives_contain_std_p (DECL_NAMESPACE_USING (scope)))
5372 if (scope == global_namespace)
5379 /* Suggest alternatives for NAME, an IDENTIFIER_NODE for which name
5380 lookup failed. Search through all available namespaces and print out
5381 possible candidates. If no exact matches are found, and
5382 SUGGEST_MISSPELLINGS is true, then also look for near-matches and
5383 suggest the best near-match, if there is one. */
5386 suggest_alternatives_for (location_t location, tree name,
5387 bool suggest_misspellings)
5389 vec<tree> candidates = vNULL;
5390 vec<tree> worklist = vNULL;
5391 unsigned limit = PARAM_VALUE (CXX_MAX_NAMESPACES_FOR_DIAGNOSTIC_HELP);
5392 bool limited = false;
5394 /* Breadth-first search of namespaces. Up to limit namespaces
5395 searched (limit zero == unlimited). */
5396 worklist.safe_push (global_namespace);
5397 for (unsigned ix = 0; ix != worklist.length (); ix++)
5399 tree ns = worklist[ix];
5400 name_lookup lookup (name);
5402 if (lookup.search_qualified (ns, false))
5403 candidates.safe_push (lookup.value);
5407 /* Look for child namespaces. We have to do this
5408 indirectly because they are chained in reverse order,
5409 which is confusing to the user. */
5410 vec<tree> children = vNULL;
5412 for (tree decl = NAMESPACE_LEVEL (ns)->names;
5413 decl; decl = TREE_CHAIN (decl))
5414 if (TREE_CODE (decl) == NAMESPACE_DECL
5415 && !DECL_NAMESPACE_ALIAS (decl)
5416 && !DECL_NAMESPACE_INLINE_P (decl))
5417 children.safe_push (decl);
5419 while (!limited && !children.is_empty ())
5421 if (worklist.length () == limit)
5423 /* Unconditionally warn that the search was truncated. */
5425 "maximum limit of %d namespaces searched for %qE",
5430 worklist.safe_push (children.pop ());
5432 children.release ();
5435 worklist.release ();
5437 if (candidates.length ())
5439 inform_n (location, candidates.length (),
5440 "suggested alternative:",
5441 "suggested alternatives:");
5442 for (unsigned ix = 0; ix != candidates.length (); ix++)
5444 tree val = candidates[ix];
5446 inform (location_of (val), " %qE", val);
5448 candidates.release ();
5452 /* No candidates were found in the available namespaces. */
5454 /* If there's a "using namespace std;" active, and this
5455 is one of the most common "std::" names, then it's probably a
5456 missing #include. */
5457 if (has_using_namespace_std_directive_p ())
5458 if (maybe_suggest_missing_std_header (location, name))
5461 /* Otherwise, consider misspellings. */
5462 if (!suggest_misspellings)
5464 if (name_hint hint = lookup_name_fuzzy (name, FUZZY_LOOKUP_NAME,
5467 /* Show a spelling correction. */
5468 gcc_rich_location richloc (location);
5470 richloc.add_fixit_replace (hint.suggestion ());
5471 inform (&richloc, "suggested alternative: %qs", hint.suggestion ());
5475 /* A well-known name within the C++ standard library, returned by
5476 get_std_name_hint. */
5478 struct std_name_hint
5480 /* A name within "std::". */
5483 /* The header name defining it within the C++ Standard Library
5484 (with '<' and '>'). */
5487 /* The dialect of C++ in which this was added. */
5488 enum cxx_dialect min_dialect;
5491 /* Subroutine of maybe_suggest_missing_header for handling unrecognized names
5492 for some of the most common names within "std::".
5493 Given non-NULL NAME, return the std_name_hint for it, or NULL. */
5495 static const std_name_hint *
5496 get_std_name_hint (const char *name)
5498 static const std_name_hint hints[] = {
5500 {"any", "<any>", cxx17},
5501 {"any_cast", "<any>", cxx17},
5502 {"make_any", "<any>", cxx17},
5504 {"array", "<array>", cxx11},
5506 {"atomic", "<atomic>", cxx11},
5507 {"atomic_flag", "<atomic>", cxx11},
5509 {"bitset", "<bitset>", cxx11},
5511 {"complex", "<complex>", cxx98},
5512 {"complex_literals", "<complex>", cxx98},
5513 /* <condition_variable>. */
5514 {"condition_variable", "<condition_variable>", cxx11},
5515 {"condition_variable_any", "<condition_variable>", cxx11},
5517 {"deque", "<deque>", cxx98},
5518 /* <forward_list>. */
5519 {"forward_list", "<forward_list>", cxx11},
5521 {"basic_filebuf", "<fstream>", cxx98},
5522 {"basic_ifstream", "<fstream>", cxx98},
5523 {"basic_ofstream", "<fstream>", cxx98},
5524 {"basic_fstream", "<fstream>", cxx98},
5525 {"fstream", "<fstream>", cxx98},
5526 {"ifstream", "<fstream>", cxx98},
5527 {"ofstream", "<fstream>", cxx98},
5529 {"bind", "<functional>", cxx11},
5530 {"function", "<functional>", cxx11},
5531 {"hash", "<functional>", cxx11},
5532 {"mem_fn", "<functional>", cxx11},
5534 {"async", "<future>", cxx11},
5535 {"future", "<future>", cxx11},
5536 {"packaged_task", "<future>", cxx11},
5537 {"promise", "<future>", cxx11},
5539 {"cin", "<iostream>", cxx98},
5540 {"cout", "<iostream>", cxx98},
5541 {"cerr", "<iostream>", cxx98},
5542 {"clog", "<iostream>", cxx98},
5543 {"wcin", "<iostream>", cxx98},
5544 {"wcout", "<iostream>", cxx98},
5545 {"wclog", "<iostream>", cxx98},
5547 {"istream", "<istream>", cxx98},
5549 {"advance", "<iterator>", cxx98},
5550 {"back_inserter", "<iterator>", cxx98},
5551 {"begin", "<iterator>", cxx11},
5552 {"distance", "<iterator>", cxx98},
5553 {"end", "<iterator>", cxx11},
5554 {"front_inserter", "<iterator>", cxx98},
5555 {"inserter", "<iterator>", cxx98},
5556 {"istream_iterator", "<iterator>", cxx98},
5557 {"istreambuf_iterator", "<iterator>", cxx98},
5558 {"iterator_traits", "<iterator>", cxx98},
5559 {"move_iterator", "<iterator>", cxx11},
5560 {"next", "<iterator>", cxx11},
5561 {"ostream_iterator", "<iterator>", cxx98},
5562 {"ostreambuf_iterator", "<iterator>", cxx98},
5563 {"prev", "<iterator>", cxx11},
5564 {"reverse_iterator", "<iterator>", cxx98},
5566 {"ostream", "<ostream>", cxx98},
5568 {"list", "<list>", cxx98},
5570 {"map", "<map>", cxx98},
5571 {"multimap", "<map>", cxx98},
5573 {"make_shared", "<memory>", cxx11},
5574 {"make_unique", "<memory>", cxx11},
5575 {"shared_ptr", "<memory>", cxx11},
5576 {"unique_ptr", "<memory>", cxx11},
5577 {"weak_ptr", "<memory>", cxx11},
5579 {"mutex", "<mutex>", cxx11},
5580 {"timed_mutex", "<mutex>", cxx11},
5581 {"recursive_mutex", "<mutex>", cxx11},
5582 {"recursive_timed_mutex", "<mutex>", cxx11},
5583 {"once_flag", "<mutex>", cxx11},
5584 {"call_once,", "<mutex>", cxx11},
5585 {"lock", "<mutex>", cxx11},
5586 {"scoped_lock", "<mutex>", cxx17},
5587 {"try_lock", "<mutex>", cxx11},
5588 {"lock_guard", "<mutex>", cxx11},
5589 {"unique_lock", "<mutex>", cxx11},
5591 {"optional", "<optional>", cxx17},
5592 {"make_optional", "<optional>", cxx17},
5594 {"ostream", "<ostream>", cxx98},
5595 {"wostream", "<ostream>", cxx98},
5596 {"ends", "<ostream>", cxx98},
5597 {"flush", "<ostream>", cxx98},
5598 {"endl", "<ostream>", cxx98},
5600 {"queue", "<queue>", cxx98},
5601 {"priority_queue", "<queue>", cxx98},
5603 {"set", "<set>", cxx98},
5604 {"multiset", "<set>", cxx98},
5605 /* <shared_mutex>. */
5606 {"shared_lock", "<shared_mutex>", cxx14},
5607 {"shared_mutex", "<shared_mutex>", cxx17},
5608 {"shared_timed_mutex", "<shared_mutex>", cxx14},
5610 {"basic_stringbuf", "<sstream>", cxx98},
5611 {"basic_istringstream", "<sstream>", cxx98},
5612 {"basic_ostringstream", "<sstream>", cxx98},
5613 {"basic_stringstream", "<sstream>", cxx98},
5614 {"istringstream", "<sstream>", cxx98},
5615 {"ostringstream", "<sstream>", cxx98},
5616 {"stringstream", "<sstream>", cxx98},
5618 {"stack", "<stack>", cxx98},
5620 {"basic_string", "<string>", cxx98},
5621 {"string", "<string>", cxx98},
5622 {"wstring", "<string>", cxx98},
5623 {"u16string", "<string>", cxx11},
5624 {"u32string", "<string>", cxx11},
5625 /* <string_view>. */
5626 {"string_view", "<string_view>", cxx17},
5628 {"thread", "<thread>", cxx11},
5630 {"make_tuple", "<tuple>", cxx11},
5631 {"tuple", "<tuple>", cxx11},
5632 {"tuple_element", "<tuple>", cxx11},
5633 {"tuple_size", "<tuple>", cxx11},
5634 /* <unordered_map>. */
5635 {"unordered_map", "<unordered_map>", cxx11},
5636 {"unordered_multimap", "<unordered_map>", cxx11},
5637 /* <unordered_set>. */
5638 {"unordered_set", "<unordered_set>", cxx11},
5639 {"unordered_multiset", "<unordered_set>", cxx11},
5641 {"declval", "<utility>", cxx11},
5642 {"forward", "<utility>", cxx11},
5643 {"make_pair", "<utility>", cxx98},
5644 {"move", "<utility>", cxx11},
5645 {"pair", "<utility>", cxx98},
5647 {"variant", "<variant>", cxx17},
5648 {"visit", "<variant>", cxx17},
5650 {"vector", "<vector>", cxx98},
5652 const size_t num_hints = sizeof (hints) / sizeof (hints[0]);
5653 for (size_t i = 0; i < num_hints; i++)
5655 if (strcmp (name, hints[i].name) == 0)
5661 /* Describe DIALECT. */
5664 get_cxx_dialect_name (enum cxx_dialect dialect)
5683 /* Suggest pertinent header files for NAME at LOCATION, for common
5684 names within the "std" namespace.
5685 Return true iff a suggestion was offered. */
5688 maybe_suggest_missing_std_header (location_t location, tree name)
5690 gcc_assert (TREE_CODE (name) == IDENTIFIER_NODE);
5692 const char *name_str = IDENTIFIER_POINTER (name);
5693 const std_name_hint *header_hint = get_std_name_hint (name_str);
5697 gcc_rich_location richloc (location);
5698 if (cxx_dialect >= header_hint->min_dialect)
5700 const char *header = header_hint->header;
5701 maybe_add_include_fixit (&richloc, header);
5703 "%<std::%s%> is defined in header %qs;"
5704 " did you forget to %<#include %s%>?",
5705 name_str, header, header);
5710 "%<std::%s%> is only available from %s onwards",
5711 name_str, get_cxx_dialect_name (header_hint->min_dialect));
5716 /* If SCOPE is the "std" namespace, then suggest pertinent header
5717 files for NAME at LOCATION.
5718 Return true iff a suggestion was offered. */
5721 maybe_suggest_missing_header (location_t location, tree name, tree scope)
5723 if (scope == NULL_TREE)
5725 if (TREE_CODE (scope) != NAMESPACE_DECL)
5727 /* We only offer suggestions for the "std" namespace. */
5728 if (scope != std_node)
5730 return maybe_suggest_missing_std_header (location, name);
5733 /* Look for alternatives for NAME, an IDENTIFIER_NODE for which name
5734 lookup failed within the explicitly provided SCOPE. Suggest the
5735 the best meaningful candidates (if any) as a fix-it hint.
5736 Return true iff a suggestion was provided. */
5739 suggest_alternative_in_explicit_scope (location_t location, tree name,
5742 /* Something went very wrong; don't suggest anything. */
5743 if (name == error_mark_node)
5746 /* Resolve any namespace aliases. */
5747 scope = ORIGINAL_NAMESPACE (scope);
5749 if (maybe_suggest_missing_header (location, name, scope))
5752 cp_binding_level *level = NAMESPACE_LEVEL (scope);
5754 best_match <tree, const char *> bm (name);
5755 consider_binding_level (name, bm, level, false, FUZZY_LOOKUP_NAME);
5757 /* See if we have a good suggesion for the user. */
5758 const char *fuzzy_name = bm.get_best_meaningful_candidate ();
5761 gcc_rich_location richloc (location);
5762 richloc.add_fixit_replace (fuzzy_name);
5763 inform (&richloc, "suggested alternative: %qs",
5771 /* Look up NAME (an IDENTIFIER_NODE) in SCOPE (either a NAMESPACE_DECL
5774 If PREFER_TYPE is > 0, we only return TYPE_DECLs or namespaces.
5775 If PREFER_TYPE is > 1, we only return TYPE_DECLs.
5777 Returns a DECL (or OVERLOAD, or BASELINK) representing the
5778 declaration found. If no suitable declaration can be found,
5779 ERROR_MARK_NODE is returned. If COMPLAIN is true and SCOPE is
5780 neither a class-type nor a namespace a diagnostic is issued. */
5783 lookup_qualified_name (tree scope, tree name, int prefer_type, bool complain,
5788 if (TREE_CODE (scope) == NAMESPACE_DECL)
5790 int flags = lookup_flags (prefer_type, /*namespaces_only*/false);
5792 flags |= LOOKUP_HIDDEN;
5793 name_lookup lookup (name, flags);
5795 if (qualified_namespace_lookup (scope, &lookup))
5798 else if (cxx_dialect != cxx98 && TREE_CODE (scope) == ENUMERAL_TYPE)
5799 t = lookup_enumerator (scope, name);
5800 else if (is_class_type (scope, complain))
5801 t = lookup_member (scope, name, 2, prefer_type, tf_warning_or_error);
5804 return error_mark_node;
5809 Accepts the NAME to lookup and its qualifying SCOPE.
5810 Returns the name/type pair found into the cxx_binding *RESULT,
5811 or false on error. */
5814 qualified_namespace_lookup (tree scope, name_lookup *lookup)
5816 timevar_start (TV_NAME_LOOKUP);
5817 query_oracle (lookup->name);
5818 bool found = lookup->search_qualified (ORIGINAL_NAMESPACE (scope));
5819 timevar_stop (TV_NAME_LOOKUP);
5823 /* Helper function for lookup_name_fuzzy.
5824 Traverse binding level LVL, looking for good name matches for NAME
5827 consider_binding_level (tree name, best_match <tree, const char *> &bm,
5828 cp_binding_level *lvl, bool look_within_fields,
5829 enum lookup_name_fuzzy_kind kind)
5831 if (look_within_fields)
5832 if (lvl->this_entity && TREE_CODE (lvl->this_entity) == RECORD_TYPE)
5834 tree type = lvl->this_entity;
5835 bool want_type_p = (kind == FUZZY_LOOKUP_TYPENAME);
5836 tree best_matching_field
5837 = lookup_member_fuzzy (type, name, want_type_p);
5838 if (best_matching_field)
5839 bm.consider (IDENTIFIER_POINTER (best_matching_field));
5842 /* Only suggest names reserved for the implementation if NAME begins
5843 with an underscore. */
5844 bool consider_implementation_names = (IDENTIFIER_POINTER (name)[0] == '_');
5846 for (tree t = lvl->names; t; t = TREE_CHAIN (t))
5850 /* OVERLOADs or decls from using declaration are wrapped into
5852 if (TREE_CODE (d) == TREE_LIST)
5853 d = OVL_FIRST (TREE_VALUE (d));
5855 /* Don't use bindings from implicitly declared functions,
5856 as they were likely misspellings themselves. */
5857 if (TREE_TYPE (d) == error_mark_node)
5860 /* Skip anticipated decls of builtin functions. */
5861 if (TREE_CODE (d) == FUNCTION_DECL
5862 && DECL_BUILT_IN (d)
5863 && DECL_ANTICIPATED (d))
5866 /* Skip compiler-generated variables (e.g. __for_begin/__for_end
5867 within range for). */
5868 if (TREE_CODE (d) == VAR_DECL
5869 && DECL_ARTIFICIAL (d))
5872 tree suggestion = DECL_NAME (d);
5876 /* Don't suggest names that are for anonymous aggregate types, as
5877 they are an implementation detail generated by the compiler. */
5878 if (anon_aggrname_p (suggestion))
5881 const char *suggestion_str = IDENTIFIER_POINTER (suggestion);
5883 /* Ignore internal names with spaces in them. */
5884 if (strchr (suggestion_str, ' '))
5887 /* Don't suggest names that are reserved for use by the
5888 implementation, unless NAME began with an underscore. */
5889 if (name_reserved_for_implementation_p (suggestion_str)
5890 && !consider_implementation_names)
5893 bm.consider (suggestion_str);
5897 /* Subclass of deferred_diagnostic. Notify the user that the
5898 given macro was used before it was defined.
5899 This can be done in the C++ frontend since tokenization happens
5902 class macro_use_before_def : public deferred_diagnostic
5905 /* Factory function. Return a new macro_use_before_def instance if
5906 appropriate, or return NULL. */
5907 static macro_use_before_def *
5908 maybe_make (location_t use_loc, cpp_hashnode *macro)
5910 source_location def_loc = cpp_macro_definition_location (macro);
5911 if (def_loc == UNKNOWN_LOCATION)
5914 /* We only want to issue a note if the macro was used *before* it was
5916 We don't want to issue a note for cases where a macro was incorrectly
5917 used, leaving it unexpanded (e.g. by using the wrong argument
5919 if (!linemap_location_before_p (line_table, use_loc, def_loc))
5922 return new macro_use_before_def (use_loc, macro);
5926 /* Ctor. LOC is the location of the usage. MACRO is the
5927 macro that was used. */
5928 macro_use_before_def (location_t loc, cpp_hashnode *macro)
5929 : deferred_diagnostic (loc), m_macro (macro)
5934 ~macro_use_before_def ()
5936 if (is_suppressed_p ())
5939 inform (get_location (), "the macro %qs had not yet been defined",
5940 (const char *)m_macro->ident.str);
5941 inform (cpp_macro_definition_location (m_macro),
5942 "it was later defined here");
5946 cpp_hashnode *m_macro;
5949 /* Determine if it can ever make sense to offer RID as a suggestion for
5952 Subroutine of lookup_name_fuzzy. */
5955 suggest_rid_p (enum rid rid)
5959 /* Support suggesting function-like keywords. */
5960 case RID_STATIC_ASSERT:
5964 /* Support suggesting the various decl-specifier words, to handle
5965 e.g. "singed" vs "signed" typos. */
5966 if (cp_keyword_starts_decl_specifier_p (rid))
5969 /* Otherwise, don't offer it. This avoids suggesting e.g. "if"
5970 and "do" for short misspellings, which are likely to lead to
5971 nonsensical results. */
5976 /* Search for near-matches for NAME within the current bindings, and within
5977 macro names, returning the best match as a const char *, or NULL if
5978 no reasonable match is found.
5980 Use LOC for any deferred diagnostics. */
5983 lookup_name_fuzzy (tree name, enum lookup_name_fuzzy_kind kind, location_t loc)
5985 gcc_assert (TREE_CODE (name) == IDENTIFIER_NODE);
5987 /* First, try some well-known names in the C++ standard library, in case
5988 the user forgot a #include. */
5989 const char *header_hint
5990 = get_cp_stdlib_header_for_name (IDENTIFIER_POINTER (name));
5992 return name_hint (NULL,
5993 new suggest_missing_header (loc,
5994 IDENTIFIER_POINTER (name),
5997 best_match <tree, const char *> bm (name);
5999 cp_binding_level *lvl;
6000 for (lvl = scope_chain->class_bindings; lvl; lvl = lvl->level_chain)
6001 consider_binding_level (name, bm, lvl, true, kind);
6003 for (lvl = current_binding_level; lvl; lvl = lvl->level_chain)
6004 consider_binding_level (name, bm, lvl, false, kind);
6006 /* Consider macros: if the user misspelled a macro name e.g. "SOME_MACRO"
6008 x = SOME_OTHER_MACRO (y);
6009 then "SOME_OTHER_MACRO" will survive to the frontend and show up
6010 as a misspelled identifier.
6012 Use the best distance so far so that a candidate is only set if
6013 a macro is better than anything so far. This allows early rejection
6014 (without calculating the edit distance) of macro names that must have
6015 distance >= bm.get_best_distance (), and means that we only get a
6016 non-NULL result for best_macro_match if it's better than any of
6017 the identifiers already checked. */
6018 best_macro_match bmm (name, bm.get_best_distance (), parse_in);
6019 cpp_hashnode *best_macro = bmm.get_best_meaningful_candidate ();
6020 /* If a macro is the closest so far to NAME, consider it. */
6022 bm.consider ((const char *)best_macro->ident.str);
6023 else if (bmm.get_best_distance () == 0)
6025 /* If we have an exact match for a macro name, then either the
6026 macro was used with the wrong argument count, or the macro
6027 has been used before it was defined. */
6028 cpp_hashnode *macro = bmm.blithely_get_best_candidate ();
6029 if (macro && (macro->flags & NODE_BUILTIN) == 0)
6030 return name_hint (NULL,
6031 macro_use_before_def::maybe_make (loc, macro));
6034 /* Try the "starts_decl_specifier_p" keywords to detect
6035 "singed" vs "signed" typos. */
6036 for (unsigned i = 0; i < num_c_common_reswords; i++)
6038 const c_common_resword *resword = &c_common_reswords[i];
6040 if (!suggest_rid_p (resword->rid))
6043 tree resword_identifier = ridpointers [resword->rid];
6044 if (!resword_identifier)
6046 gcc_assert (TREE_CODE (resword_identifier) == IDENTIFIER_NODE);
6048 /* Only consider reserved words that survived the
6049 filtering in init_reswords (e.g. for -std). */
6050 if (!IDENTIFIER_KEYWORD_P (resword_identifier))
6053 bm.consider (IDENTIFIER_POINTER (resword_identifier));
6056 return name_hint (bm.get_best_meaningful_candidate (), NULL);
6059 /* Subroutine of outer_binding.
6061 Returns TRUE if BINDING is a binding to a template parameter of
6062 SCOPE. In that case SCOPE is the scope of a primary template
6063 parameter -- in the sense of G++, i.e, a template that has its own
6066 Returns FALSE otherwise. */
6069 binding_to_template_parms_of_scope_p (cxx_binding *binding,
6070 cp_binding_level *scope)
6072 tree binding_value, tmpl, tinfo;
6075 if (!binding || !scope || !scope->this_entity)
6078 binding_value = binding->value ? binding->value : binding->type;
6079 tinfo = get_template_info (scope->this_entity);
6081 /* BINDING_VALUE must be a template parm. */
6082 if (binding_value == NULL_TREE
6083 || (!DECL_P (binding_value)
6084 || !DECL_TEMPLATE_PARM_P (binding_value)))
6087 /* The level of BINDING_VALUE. */
6089 template_type_parameter_p (binding_value)
6090 ? TEMPLATE_PARM_LEVEL (TEMPLATE_TYPE_PARM_INDEX
6091 (TREE_TYPE (binding_value)))
6092 : TEMPLATE_PARM_LEVEL (DECL_INITIAL (binding_value));
6094 /* The template of the current scope, iff said scope is a primary
6097 && PRIMARY_TEMPLATE_P (TI_TEMPLATE (tinfo))
6098 ? TI_TEMPLATE (tinfo)
6101 /* If the level of the parm BINDING_VALUE equals the depth of TMPL,
6102 then BINDING_VALUE is a parameter of TMPL. */
6103 return (tmpl && level == TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (tmpl)));
6106 /* Return the innermost non-namespace binding for NAME from a scope
6107 containing BINDING, or, if BINDING is NULL, the current scope.
6108 Please note that for a given template, the template parameters are
6109 considered to be in the scope containing the current scope.
6110 If CLASS_P is false, then class bindings are ignored. */
6113 outer_binding (tree name,
6114 cxx_binding *binding,
6118 cp_binding_level *scope;
6119 cp_binding_level *outer_scope;
6123 scope = binding->scope->level_chain;
6124 outer = binding->previous;
6128 scope = current_binding_level;
6129 outer = IDENTIFIER_BINDING (name);
6131 outer_scope = outer ? outer->scope : NULL;
6133 /* Because we create class bindings lazily, we might be missing a
6134 class binding for NAME. If there are any class binding levels
6135 between the LAST_BINDING_LEVEL and the scope in which OUTER was
6136 declared, we must lookup NAME in those class scopes. */
6138 while (scope && scope != outer_scope && scope->kind != sk_namespace)
6140 if (scope->kind == sk_class)
6142 cxx_binding *class_binding;
6144 class_binding = get_class_binding (name, scope);
6147 /* Thread this new class-scope binding onto the
6148 IDENTIFIER_BINDING list so that future lookups
6150 class_binding->previous = outer;
6152 binding->previous = class_binding;
6154 IDENTIFIER_BINDING (name) = class_binding;
6155 return class_binding;
6158 /* If we are in a member template, the template parms of the member
6159 template are considered to be inside the scope of the containing
6160 class, but within G++ the class bindings are all pushed between the
6161 template parms and the function body. So if the outer binding is
6162 a template parm for the current scope, return it now rather than
6163 look for a class binding. */
6164 if (outer_scope && outer_scope->kind == sk_template_parms
6165 && binding_to_template_parms_of_scope_p (outer, scope))
6168 scope = scope->level_chain;
6174 /* Return the innermost block-scope or class-scope value binding for
6175 NAME, or NULL_TREE if there is no such binding. */
6178 innermost_non_namespace_value (tree name)
6180 cxx_binding *binding;
6181 binding = outer_binding (name, /*binding=*/NULL, /*class_p=*/true);
6182 return binding ? binding->value : NULL_TREE;
6185 /* Look up NAME in the current binding level and its superiors in the
6186 namespace of variables, functions and typedefs. Return a ..._DECL
6187 node of some kind representing its definition if there is only one
6188 such declaration, or return a TREE_LIST with all the overloaded
6189 definitions if there are many, or return 0 if it is undefined.
6190 Hidden name, either friend declaration or built-in function, are
6193 If PREFER_TYPE is > 0, we prefer TYPE_DECLs or namespaces.
6194 If PREFER_TYPE is > 1, we reject non-type decls (e.g. namespaces).
6195 Otherwise we prefer non-TYPE_DECLs.
6197 If NONCLASS is nonzero, bindings in class scopes are ignored. If
6198 BLOCK_P is false, bindings in block scopes are ignored. */
6201 lookup_name_real_1 (tree name, int prefer_type, int nonclass, bool block_p,
6202 int namespaces_only, int flags)
6205 tree val = NULL_TREE;
6207 query_oracle (name);
6209 /* Conversion operators are handled specially because ordinary
6210 unqualified name lookup will not find template conversion
6212 if (IDENTIFIER_CONV_OP_P (name))
6214 cp_binding_level *level;
6216 for (level = current_binding_level;
6217 level && level->kind != sk_namespace;
6218 level = level->level_chain)
6223 /* A conversion operator can only be declared in a class
6225 if (level->kind != sk_class)
6228 /* Lookup the conversion operator in the class. */
6229 class_type = level->this_entity;
6230 operators = lookup_fnfields (class_type, name, /*protect=*/0);
6238 flags |= lookup_flags (prefer_type, namespaces_only);
6240 /* First, look in non-namespace scopes. */
6242 if (current_class_type == NULL_TREE)
6245 if (block_p || !nonclass)
6246 for (iter = outer_binding (name, NULL, !nonclass);
6248 iter = outer_binding (name, iter, !nonclass))
6252 /* Skip entities we don't want. */
6253 if (LOCAL_BINDING_P (iter) ? !block_p : nonclass)
6256 /* If this is the kind of thing we're looking for, we're done. */
6257 if (qualify_lookup (iter->value, flags))
6258 binding = iter->value;
6259 else if ((flags & LOOKUP_PREFER_TYPES)
6260 && qualify_lookup (iter->type, flags))
6261 binding = iter->type;
6263 binding = NULL_TREE;
6267 if (TREE_CODE (binding) == TYPE_DECL && DECL_HIDDEN_P (binding))
6269 /* A non namespace-scope binding can only be hidden in the
6270 presence of a local class, due to friend declarations.
6272 In particular, consider:
6280 B* b; // error: B is hidden
6281 C* c; // OK, finds ::C
6284 B *b; // error: B is hidden
6285 C *c; // OK, finds ::C
6290 The standard says that "B" is a local class in "f"
6291 (but not nested within "A") -- but that name lookup
6292 for "B" does not find this declaration until it is
6293 declared directly with "f".
6299 If a friend declaration appears in a local class and
6300 the name specified is an unqualified name, a prior
6301 declaration is looked up without considering scopes
6302 that are outside the innermost enclosing non-class
6303 scope. For a friend function declaration, if there is
6304 no prior declaration, the program is ill-formed. For a
6305 friend class declaration, if there is no prior
6306 declaration, the class that is specified belongs to the
6307 innermost enclosing non-class scope, but if it is
6308 subsequently referenced, its name is not found by name
6309 lookup until a matching declaration is provided in the
6310 innermost enclosing nonclass scope.
6312 So just keep looking for a non-hidden binding.
6314 gcc_assert (TREE_CODE (binding) == TYPE_DECL);
6322 /* Now lookup in namespace scopes. */
6325 name_lookup lookup (name, flags);
6326 if (lookup.search_unqualified
6327 (current_decl_namespace (), current_binding_level))
6331 /* If we have a single function from a using decl, pull it out. */
6332 if (val && TREE_CODE (val) == OVERLOAD && !really_overloaded_fn (val))
6333 val = OVL_FUNCTION (val);
6338 /* Wrapper for lookup_name_real_1. */
6341 lookup_name_real (tree name, int prefer_type, int nonclass, bool block_p,
6342 int namespaces_only, int flags)
6345 bool subtime = timevar_cond_start (TV_NAME_LOOKUP);
6346 ret = lookup_name_real_1 (name, prefer_type, nonclass, block_p,
6347 namespaces_only, flags);
6348 timevar_cond_stop (TV_NAME_LOOKUP, subtime);
6353 lookup_name_nonclass (tree name)
6355 return lookup_name_real (name, 0, 1, /*block_p=*/true, 0, 0);
6359 lookup_name (tree name)
6361 return lookup_name_real (name, 0, 0, /*block_p=*/true, 0, 0);
6365 lookup_name_prefer_type (tree name, int prefer_type)
6367 return lookup_name_real (name, prefer_type, 0, /*block_p=*/true, 0, 0);
6370 /* Look up NAME for type used in elaborated name specifier in
6371 the scopes given by SCOPE. SCOPE can be either TS_CURRENT or
6372 TS_WITHIN_ENCLOSING_NON_CLASS. Although not implied by the
6373 name, more scopes are checked if cleanup or template parameter
6374 scope is encountered.
6376 Unlike lookup_name_real, we make sure that NAME is actually
6377 declared in the desired scope, not from inheritance, nor using
6378 directive. For using declaration, there is DR138 still waiting
6379 to be resolved. Hidden name coming from an earlier friend
6380 declaration is also returned.
6382 A TYPE_DECL best matching the NAME is returned. Catching error
6383 and issuing diagnostics are caller's responsibility. */
6386 lookup_type_scope_1 (tree name, tag_scope scope)
6388 cxx_binding *iter = NULL;
6389 tree val = NULL_TREE;
6390 cp_binding_level *level = NULL;
6392 /* Look in non-namespace scope first. */
6393 if (current_binding_level->kind != sk_namespace)
6394 iter = outer_binding (name, NULL, /*class_p=*/ true);
6395 for (; iter; iter = outer_binding (name, iter, /*class_p=*/ true))
6397 /* Check if this is the kind of thing we're looking for.
6398 If SCOPE is TS_CURRENT, also make sure it doesn't come from
6399 base class. For ITER->VALUE, we can simply use
6400 INHERITED_VALUE_BINDING_P. For ITER->TYPE, we have to use
6403 We check ITER->TYPE before ITER->VALUE in order to handle
6404 typedef struct C {} C;
6407 if (qualify_lookup (iter->type, LOOKUP_PREFER_TYPES)
6408 && (scope != ts_current
6409 || LOCAL_BINDING_P (iter)
6410 || DECL_CONTEXT (iter->type) == iter->scope->this_entity))
6412 else if ((scope != ts_current
6413 || !INHERITED_VALUE_BINDING_P (iter))
6414 && qualify_lookup (iter->value, LOOKUP_PREFER_TYPES))
6421 /* Look in namespace scope. */
6423 level = iter->scope;
6426 tree ns = current_decl_namespace ();
6428 if (tree *slot = find_namespace_slot (ns, name))
6430 /* If this is the kind of thing we're looking for, we're done. */
6431 if (tree type = MAYBE_STAT_TYPE (*slot))
6432 if (qualify_lookup (type, LOOKUP_PREFER_TYPES))
6436 if (tree decl = MAYBE_STAT_DECL (*slot))
6437 if (qualify_lookup (decl, LOOKUP_PREFER_TYPES))
6440 level = NAMESPACE_LEVEL (ns);
6444 /* Type found, check if it is in the allowed scopes, ignoring cleanup
6445 and template parameter scopes. */
6448 cp_binding_level *b = current_binding_level;
6454 if (b->kind == sk_cleanup || b->kind == sk_template_parms
6455 || b->kind == sk_function_parms)
6457 else if (b->kind == sk_class
6458 && scope == ts_within_enclosing_non_class)
6468 /* Wrapper for lookup_type_scope_1. */
6471 lookup_type_scope (tree name, tag_scope scope)
6474 bool subtime = timevar_cond_start (TV_NAME_LOOKUP);
6475 ret = lookup_type_scope_1 (name, scope);
6476 timevar_cond_stop (TV_NAME_LOOKUP, subtime);
6480 /* Returns true iff DECL is a block-scope extern declaration of a function
6484 is_local_extern (tree decl)
6486 cxx_binding *binding;
6488 /* For functions, this is easy. */
6489 if (TREE_CODE (decl) == FUNCTION_DECL)
6490 return DECL_LOCAL_FUNCTION_P (decl);
6494 if (!current_function_decl)
6497 /* For variables, this is not easy. We need to look at the binding stack
6498 for the identifier to see whether the decl we have is a local. */
6499 for (binding = IDENTIFIER_BINDING (DECL_NAME (decl));
6500 binding && binding->scope->kind != sk_namespace;
6501 binding = binding->previous)
6502 if (binding->value == decl)
6503 return LOCAL_BINDING_P (binding);
6508 /* The type TYPE is being declared. If it is a class template, or a
6509 specialization of a class template, do any processing required and
6510 perform error-checking. If IS_FRIEND is nonzero, this TYPE is
6511 being declared a friend. B is the binding level at which this TYPE
6514 Returns the TYPE_DECL for TYPE, which may have been altered by this
6518 maybe_process_template_type_declaration (tree type, int is_friend,
6519 cp_binding_level *b)
6521 tree decl = TYPE_NAME (type);
6523 if (processing_template_parmlist)
6524 /* You can't declare a new template type in a template parameter
6525 list. But, you can declare a non-template type:
6527 template <class A*> struct S;
6529 is a forward-declaration of `A'. */
6531 else if (b->kind == sk_namespace
6532 && current_binding_level->kind != sk_namespace)
6533 /* If this new type is being injected into a containing scope,
6534 then it's not a template type. */
6538 gcc_assert (MAYBE_CLASS_TYPE_P (type)
6539 || TREE_CODE (type) == ENUMERAL_TYPE);
6541 if (processing_template_decl)
6543 /* This may change after the call to
6544 push_template_decl_real, but we want the original value. */
6545 tree name = DECL_NAME (decl);
6547 decl = push_template_decl_real (decl, is_friend);
6548 if (decl == error_mark_node)
6549 return error_mark_node;
6551 /* If the current binding level is the binding level for the
6552 template parameters (see the comment in
6553 begin_template_parm_list) and the enclosing level is a class
6554 scope, and we're not looking at a friend, push the
6555 declaration of the member class into the class scope. In the
6556 friend case, push_template_decl will already have put the
6557 friend into global scope, if appropriate. */
6558 if (TREE_CODE (type) != ENUMERAL_TYPE
6559 && !is_friend && b->kind == sk_template_parms
6560 && b->level_chain->kind == sk_class)
6562 finish_member_declaration (CLASSTYPE_TI_TEMPLATE (type));
6564 if (!COMPLETE_TYPE_P (current_class_type))
6566 maybe_add_class_template_decl_list (current_class_type,
6567 type, /*friend_p=*/0);
6568 /* Put this UTD in the table of UTDs for the class. */
6569 if (CLASSTYPE_NESTED_UTDS (current_class_type) == NULL)
6570 CLASSTYPE_NESTED_UTDS (current_class_type) =
6571 binding_table_new (SCOPE_DEFAULT_HT_SIZE);
6573 binding_table_insert
6574 (CLASSTYPE_NESTED_UTDS (current_class_type), name, type);
6583 /* Push a tag name NAME for struct/class/union/enum type TYPE. In case
6584 that the NAME is a class template, the tag is processed but not pushed.
6586 The pushed scope depend on the SCOPE parameter:
6587 - When SCOPE is TS_CURRENT, put it into the inner-most non-sk_cleanup
6589 - When SCOPE is TS_GLOBAL, put it in the inner-most non-class and
6590 non-template-parameter scope. This case is needed for forward
6592 - When SCOPE is TS_WITHIN_ENCLOSING_NON_CLASS, this is similar to
6593 TS_GLOBAL case except that names within template-parameter scopes
6594 are not pushed at all.
6596 Returns TYPE upon success and ERROR_MARK_NODE otherwise. */
6599 do_pushtag (tree name, tree type, tag_scope scope)
6603 cp_binding_level *b = current_binding_level;
6604 while (/* Cleanup scopes are not scopes from the point of view of
6606 b->kind == sk_cleanup
6607 /* Neither are function parameter scopes. */
6608 || b->kind == sk_function_parms
6609 /* Neither are the scopes used to hold template parameters
6610 for an explicit specialization. For an ordinary template
6611 declaration, these scopes are not scopes from the point of
6612 view of the language. */
6613 || (b->kind == sk_template_parms
6614 && (b->explicit_spec_p || scope == ts_global))
6615 || (b->kind == sk_class
6616 && (scope != ts_current
6617 /* We may be defining a new type in the initializer
6618 of a static member variable. We allow this when
6619 not pedantic, and it is particularly useful for
6620 type punning via an anonymous union. */
6621 || COMPLETE_TYPE_P (b->this_entity))))
6624 gcc_assert (identifier_p (name));
6626 /* Do C++ gratuitous typedefing. */
6627 if (identifier_type_value_1 (name) != type)
6631 tree context = TYPE_CONTEXT (type);
6635 tree cs = current_scope ();
6637 /* Avoid setting the lambda context to a current_function_decl that
6638 we aren't actually inside, e.g. one set by push_access_scope
6639 during tsubst_default_argument. */
6640 if (cs && TREE_CODE (cs) == FUNCTION_DECL
6641 && LAMBDA_TYPE_P (type)
6642 && !at_function_scope_p ())
6643 cs = DECL_CONTEXT (cs);
6645 if (scope == ts_current
6646 || (cs && TREE_CODE (cs) == FUNCTION_DECL))
6648 else if (cs && TYPE_P (cs))
6649 /* When declaring a friend class of a local class, we want
6650 to inject the newly named class into the scope
6651 containing the local class, not the namespace
6653 context = decl_function_context (get_type_decl (cs));
6656 context = current_namespace;
6658 if (b->kind == sk_class
6659 || (b->kind == sk_template_parms
6660 && b->level_chain->kind == sk_class))
6663 tdef = create_implicit_typedef (name, type);
6664 DECL_CONTEXT (tdef) = FROB_CONTEXT (context);
6665 if (scope == ts_within_enclosing_non_class)
6667 /* This is a friend. Make this TYPE_DECL node hidden from
6668 ordinary name lookup. Its corresponding TEMPLATE_DECL
6669 will be marked in push_template_decl_real. */
6670 retrofit_lang_decl (tdef);
6671 DECL_ANTICIPATED (tdef) = 1;
6672 DECL_FRIEND_P (tdef) = 1;
6675 decl = maybe_process_template_type_declaration
6676 (type, scope == ts_within_enclosing_non_class, b);
6677 if (decl == error_mark_node)
6680 if (b->kind == sk_class)
6682 if (!TYPE_BEING_DEFINED (current_class_type)
6683 && !LAMBDA_TYPE_P (type))
6684 return error_mark_node;
6686 if (!PROCESSING_REAL_TEMPLATE_DECL_P ())
6687 /* Put this TYPE_DECL on the TYPE_FIELDS list for the
6688 class. But if it's a member template class, we want
6689 the TEMPLATE_DECL, not the TYPE_DECL, so this is done
6691 finish_member_declaration (decl);
6693 pushdecl_class_level (decl);
6695 else if (b->kind != sk_template_parms)
6697 decl = do_pushdecl_with_scope (decl, b, /*is_friend=*/false);
6698 if (decl == error_mark_node)
6701 if (DECL_CONTEXT (decl) == std_node
6702 && init_list_identifier == DECL_NAME (TYPE_NAME (type))
6703 && !CLASSTYPE_TEMPLATE_INFO (type))
6705 error ("declaration of %<std::initializer_list%> does not match "
6706 "%<#include <initializer_list>%>, isn't a template");
6707 return error_mark_node;
6712 set_identifier_type_value_with_scope (name, tdef, b);
6714 TYPE_CONTEXT (type) = DECL_CONTEXT (decl);
6716 /* If this is a local class, keep track of it. We need this
6717 information for name-mangling, and so that it is possible to
6718 find all function definitions in a translation unit in a
6719 convenient way. (It's otherwise tricky to find a member
6720 function definition it's only pointed to from within a local
6722 if (TYPE_FUNCTION_SCOPE_P (type))
6724 if (processing_template_decl)
6726 /* Push a DECL_EXPR so we call pushtag at the right time in
6727 template instantiation rather than in some nested context. */
6728 add_decl_expr (decl);
6730 /* Lambdas use LAMBDA_EXPR_DISCRIMINATOR instead. */
6731 else if (!LAMBDA_TYPE_P (type))
6732 vec_safe_push (local_classes, type);
6736 if (b->kind == sk_class
6737 && !COMPLETE_TYPE_P (current_class_type))
6739 maybe_add_class_template_decl_list (current_class_type,
6740 type, /*friend_p=*/0);
6742 if (CLASSTYPE_NESTED_UTDS (current_class_type) == NULL)
6743 CLASSTYPE_NESTED_UTDS (current_class_type)
6744 = binding_table_new (SCOPE_DEFAULT_HT_SIZE);
6746 binding_table_insert
6747 (CLASSTYPE_NESTED_UTDS (current_class_type), name, type);
6750 decl = TYPE_NAME (type);
6751 gcc_assert (TREE_CODE (decl) == TYPE_DECL);
6753 /* Set type visibility now if this is a forward declaration. */
6754 TREE_PUBLIC (decl) = 1;
6755 determine_visibility (decl);
6760 /* Wrapper for do_pushtag. */
6763 pushtag (tree name, tree type, tag_scope scope)
6766 bool subtime = timevar_cond_start (TV_NAME_LOOKUP);
6767 ret = do_pushtag (name, type, scope);
6768 timevar_cond_stop (TV_NAME_LOOKUP, subtime);
6773 /* Subroutines for reverting temporarily to top-level for instantiation
6774 of templates and such. We actually need to clear out the class- and
6775 local-value slots of all identifiers, so that only the global values
6776 are at all visible. Simply setting current_binding_level to the global
6777 scope isn't enough, because more binding levels may be pushed. */
6778 struct saved_scope *scope_chain;
6780 /* Return true if ID has not already been marked. */
6783 store_binding_p (tree id)
6785 if (!id || !IDENTIFIER_BINDING (id))
6788 if (IDENTIFIER_MARKED (id))
6794 /* Add an appropriate binding to *OLD_BINDINGS which needs to already
6795 have enough space reserved. */
6798 store_binding (tree id, vec<cxx_saved_binding, va_gc> **old_bindings)
6800 cxx_saved_binding saved;
6802 gcc_checking_assert (store_binding_p (id));
6804 IDENTIFIER_MARKED (id) = 1;
6806 saved.identifier = id;
6807 saved.binding = IDENTIFIER_BINDING (id);
6808 saved.real_type_value = REAL_IDENTIFIER_TYPE_VALUE (id);
6809 (*old_bindings)->quick_push (saved);
6810 IDENTIFIER_BINDING (id) = NULL;
6814 store_bindings (tree names, vec<cxx_saved_binding, va_gc> **old_bindings)
6816 static vec<tree> bindings_need_stored;
6820 bool subtime = timevar_cond_start (TV_NAME_LOOKUP);
6821 for (t = names; t; t = TREE_CHAIN (t))
6823 if (TREE_CODE (t) == TREE_LIST)
6824 id = TREE_PURPOSE (t);
6828 if (store_binding_p (id))
6829 bindings_need_stored.safe_push (id);
6831 if (!bindings_need_stored.is_empty ())
6833 vec_safe_reserve_exact (*old_bindings, bindings_need_stored.length ());
6834 for (i = 0; bindings_need_stored.iterate (i, &id); ++i)
6836 /* We can apparently have duplicates in NAMES. */
6837 if (store_binding_p (id))
6838 store_binding (id, old_bindings);
6840 bindings_need_stored.truncate (0);
6842 timevar_cond_stop (TV_NAME_LOOKUP, subtime);
6845 /* Like store_bindings, but NAMES is a vector of cp_class_binding
6846 objects, rather than a TREE_LIST. */
6849 store_class_bindings (vec<cp_class_binding, va_gc> *names,
6850 vec<cxx_saved_binding, va_gc> **old_bindings)
6852 static vec<tree> bindings_need_stored;
6854 cp_class_binding *cb;
6856 for (i = 0; vec_safe_iterate (names, i, &cb); ++i)
6857 if (store_binding_p (cb->identifier))
6858 bindings_need_stored.safe_push (cb->identifier);
6859 if (!bindings_need_stored.is_empty ())
6862 vec_safe_reserve_exact (*old_bindings, bindings_need_stored.length ());
6863 for (i = 0; bindings_need_stored.iterate (i, &id); ++i)
6864 store_binding (id, old_bindings);
6865 bindings_need_stored.truncate (0);
6869 /* A chain of saved_scope structures awaiting reuse. */
6871 static GTY((deletable)) struct saved_scope *free_saved_scope;
6874 do_push_to_top_level (void)
6876 struct saved_scope *s;
6877 cp_binding_level *b;
6878 cxx_saved_binding *sb;
6882 /* Reuse or create a new structure for this saved scope. */
6883 if (free_saved_scope != NULL)
6885 s = free_saved_scope;
6886 free_saved_scope = s->prev;
6888 vec<cxx_saved_binding, va_gc> *old_bindings = s->old_bindings;
6889 memset (s, 0, sizeof (*s));
6890 /* Also reuse the structure's old_bindings vector. */
6891 vec_safe_truncate (old_bindings, 0);
6892 s->old_bindings = old_bindings;
6895 s = ggc_cleared_alloc<saved_scope> ();
6897 b = scope_chain ? current_binding_level : 0;
6899 /* If we're in the middle of some function, save our state. */
6903 push_function_context ();
6908 if (scope_chain && previous_class_level)
6909 store_class_bindings (previous_class_level->class_shadowed,
6912 /* Have to include the global scope, because class-scope decls
6913 aren't listed anywhere useful. */
6914 for (; b; b = b->level_chain)
6918 /* Template IDs are inserted into the global level. If they were
6919 inserted into namespace level, finish_file wouldn't find them
6920 when doing pending instantiations. Therefore, don't stop at
6921 namespace level, but continue until :: . */
6922 if (global_scope_p (b))
6925 store_bindings (b->names, &s->old_bindings);
6926 /* We also need to check class_shadowed to save class-level type
6927 bindings, since pushclass doesn't fill in b->names. */
6928 if (b->kind == sk_class)
6929 store_class_bindings (b->class_shadowed, &s->old_bindings);
6931 /* Unwind type-value slots back to top level. */
6932 for (t = b->type_shadowed; t; t = TREE_CHAIN (t))
6933 SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (t), TREE_VALUE (t));
6936 FOR_EACH_VEC_SAFE_ELT (s->old_bindings, i, sb)
6937 IDENTIFIER_MARKED (sb->identifier) = 0;
6939 s->prev = scope_chain;
6941 s->need_pop_function_context = need_pop;
6942 s->function_decl = current_function_decl;
6943 s->unevaluated_operand = cp_unevaluated_operand;
6944 s->inhibit_evaluation_warnings = c_inhibit_evaluation_warnings;
6945 s->x_stmt_tree.stmts_are_full_exprs_p = true;
6948 current_function_decl = NULL_TREE;
6949 current_lang_base = NULL;
6950 current_lang_name = lang_name_cplusplus;
6951 current_namespace = global_namespace;
6952 push_class_stack ();
6953 cp_unevaluated_operand = 0;
6954 c_inhibit_evaluation_warnings = 0;
6958 do_pop_from_top_level (void)
6960 struct saved_scope *s = scope_chain;
6961 cxx_saved_binding *saved;
6964 /* Clear out class-level bindings cache. */
6965 if (previous_class_level)
6966 invalidate_class_lookup_cache ();
6969 release_tree_vector (current_lang_base);
6971 scope_chain = s->prev;
6972 FOR_EACH_VEC_SAFE_ELT (s->old_bindings, i, saved)
6974 tree id = saved->identifier;
6976 IDENTIFIER_BINDING (id) = saved->binding;
6977 SET_IDENTIFIER_TYPE_VALUE (id, saved->real_type_value);
6980 /* If we were in the middle of compiling a function, restore our
6982 if (s->need_pop_function_context)
6983 pop_function_context ();
6984 current_function_decl = s->function_decl;
6985 cp_unevaluated_operand = s->unevaluated_operand;
6986 c_inhibit_evaluation_warnings = s->inhibit_evaluation_warnings;
6988 /* Make this saved_scope structure available for reuse by
6989 push_to_top_level. */
6990 s->prev = free_saved_scope;
6991 free_saved_scope = s;
6994 /* Push into the scope of the namespace NS, even if it is deeply
6995 nested within another namespace. */
6998 do_push_nested_namespace (tree ns)
7000 if (ns == global_namespace)
7001 do_push_to_top_level ();
7004 do_push_nested_namespace (CP_DECL_CONTEXT (ns));
7006 (find_namespace_value (current_namespace, DECL_NAME (ns)) == ns);
7007 resume_scope (NAMESPACE_LEVEL (ns));
7008 current_namespace = ns;
7012 /* Pop back from the scope of the namespace NS, which was previously
7013 entered with push_nested_namespace. */
7016 do_pop_nested_namespace (tree ns)
7018 while (ns != global_namespace)
7020 ns = CP_DECL_CONTEXT (ns);
7021 current_namespace = ns;
7025 do_pop_from_top_level ();
7028 /* Add TARGET to USINGS, if it does not already exist there.
7029 We used to build the complete graph of usings at this point, from
7030 the POV of the source namespaces. Now we build that as we perform
7031 the unqualified search. */
7034 add_using_namespace (vec<tree, va_gc> *&usings, tree target)
7037 for (unsigned ix = usings->length (); ix--;)
7038 if ((*usings)[ix] == target)
7041 vec_safe_push (usings, target);
7044 /* Tell the debug system of a using directive. */
7047 emit_debug_info_using_namespace (tree from, tree target, bool implicit)
7049 /* Emit debugging info. */
7050 tree context = from != global_namespace ? from : NULL_TREE;
7051 debug_hooks->imported_module_or_decl (target, NULL_TREE, context, false,
7055 /* Process a namespace-scope using directive. */
7058 finish_namespace_using_directive (tree target, tree attribs)
7060 gcc_checking_assert (namespace_bindings_p ());
7061 if (target == error_mark_node)
7064 add_using_namespace (DECL_NAMESPACE_USING (current_namespace),
7065 ORIGINAL_NAMESPACE (target));
7066 emit_debug_info_using_namespace (current_namespace,
7067 ORIGINAL_NAMESPACE (target), false);
7069 if (attribs == error_mark_node)
7072 for (tree a = attribs; a; a = TREE_CHAIN (a))
7074 tree name = get_attribute_name (a);
7075 if (is_attribute_p ("strong", name))
7077 warning (0, "strong using directive no longer supported");
7078 if (CP_DECL_CONTEXT (target) == current_namespace)
7079 inform (DECL_SOURCE_LOCATION (target),
7080 "you may use an inline namespace instead");
7083 warning (OPT_Wattributes, "%qD attribute directive ignored", name);
7087 /* Process a function-scope using-directive. */
7090 finish_local_using_directive (tree target, tree attribs)
7092 gcc_checking_assert (local_bindings_p ());
7093 if (target == error_mark_node)
7097 warning (OPT_Wattributes, "attributes ignored on local using directive");
7099 add_stmt (build_stmt (input_location, USING_STMT, target));
7101 add_using_namespace (current_binding_level->using_directives,
7102 ORIGINAL_NAMESPACE (target));
7105 /* Pushes X into the global namespace. */
7108 pushdecl_top_level (tree x, bool is_friend)
7110 bool subtime = timevar_cond_start (TV_NAME_LOOKUP);
7111 do_push_to_top_level ();
7112 x = pushdecl_namespace_level (x, is_friend);
7113 do_pop_from_top_level ();
7114 timevar_cond_stop (TV_NAME_LOOKUP, subtime);
7118 /* Pushes X into the global namespace and calls cp_finish_decl to
7119 register the variable, initializing it with INIT. */
7122 pushdecl_top_level_and_finish (tree x, tree init)
7124 bool subtime = timevar_cond_start (TV_NAME_LOOKUP);
7125 do_push_to_top_level ();
7126 x = pushdecl_namespace_level (x, false);
7127 cp_finish_decl (x, init, false, NULL_TREE, 0);
7128 do_pop_from_top_level ();
7129 timevar_cond_stop (TV_NAME_LOOKUP, subtime);
7133 /* Enter the namespaces from current_namerspace to NS. */
7136 push_inline_namespaces (tree ns)
7139 if (ns != current_namespace)
7141 gcc_assert (ns != global_namespace);
7142 count += push_inline_namespaces (CP_DECL_CONTEXT (ns));
7143 resume_scope (NAMESPACE_LEVEL (ns));
7144 current_namespace = ns;
7150 /* Push into the scope of the NAME namespace. If NAME is NULL_TREE,
7151 then we enter an anonymous namespace. If MAKE_INLINE is true, then
7152 we create an inline namespace (it is up to the caller to check upon
7153 redefinition). Return the number of namespaces entered. */
7156 push_namespace (tree name, bool make_inline)
7158 bool subtime = timevar_cond_start (TV_NAME_LOOKUP);
7161 /* We should not get here if the global_namespace is not yet constructed
7162 nor if NAME designates the global namespace: The global scope is
7163 constructed elsewhere. */
7164 gcc_checking_assert (global_namespace != NULL && name != global_identifier);
7166 tree ns = NULL_TREE;
7168 name_lookup lookup (name, 0);
7169 if (!lookup.search_qualified (current_namespace, /*usings=*/false))
7171 else if (TREE_CODE (lookup.value) != NAMESPACE_DECL)
7173 else if (tree dna = DECL_NAMESPACE_ALIAS (lookup.value))
7175 /* A namespace alias is not allowed here, but if the alias
7176 is for a namespace also inside the current scope,
7177 accept it with a diagnostic. That's better than dying
7179 if (is_nested_namespace (current_namespace, CP_DECL_CONTEXT (dna)))
7181 error ("namespace alias %qD not allowed here, "
7182 "assuming %qD", lookup.value, dna);
7190 bool new_ns = false;
7192 /* DR2061. NS might be a member of an inline namespace. We
7193 need to push into those namespaces. */
7194 count += push_inline_namespaces (CP_DECL_CONTEXT (ns));
7197 ns = build_lang_decl (NAMESPACE_DECL, name, void_type_node);
7198 SCOPE_DEPTH (ns) = SCOPE_DEPTH (current_namespace) + 1;
7199 if (!SCOPE_DEPTH (ns))
7200 /* We only allow depth 255. */
7201 sorry ("cannot nest more than %d namespaces",
7202 SCOPE_DEPTH (current_namespace));
7203 DECL_CONTEXT (ns) = FROB_CONTEXT (current_namespace);
7206 if (pushdecl (ns) == error_mark_node)
7212 SET_DECL_ASSEMBLER_NAME (ns, anon_identifier);
7215 add_using_namespace (DECL_NAMESPACE_USING (current_namespace),
7218 else if (TREE_PUBLIC (current_namespace))
7219 TREE_PUBLIC (ns) = 1;
7223 DECL_NAMESPACE_INLINE_P (ns) = true;
7224 vec_safe_push (DECL_NAMESPACE_INLINEES (current_namespace), ns);
7227 if (!name || make_inline)
7228 emit_debug_info_using_namespace (current_namespace, ns, true);
7234 if (make_inline && !DECL_NAMESPACE_INLINE_P (ns))
7236 error ("inline namespace must be specified at initial definition");
7237 inform (DECL_SOURCE_LOCATION (ns), "%qD defined here", ns);
7240 begin_scope (sk_namespace, ns);
7242 resume_scope (NAMESPACE_LEVEL (ns));
7243 current_namespace = ns;
7247 timevar_cond_stop (TV_NAME_LOOKUP, subtime);
7251 /* Pop from the scope of the current namespace. */
7254 pop_namespace (void)
7256 bool subtime = timevar_cond_start (TV_NAME_LOOKUP);
7258 gcc_assert (current_namespace != global_namespace);
7259 current_namespace = CP_DECL_CONTEXT (current_namespace);
7260 /* The binding level is not popped, as it might be re-opened later. */
7263 timevar_cond_stop (TV_NAME_LOOKUP, subtime);
7266 /* External entry points for do_{push_to/pop_from}_top_level. */
7269 push_to_top_level (void)
7271 bool subtime = timevar_cond_start (TV_NAME_LOOKUP);
7272 do_push_to_top_level ();
7273 timevar_cond_stop (TV_NAME_LOOKUP, subtime);
7277 pop_from_top_level (void)
7279 bool subtime = timevar_cond_start (TV_NAME_LOOKUP);
7280 do_pop_from_top_level ();
7281 timevar_cond_stop (TV_NAME_LOOKUP, subtime);
7284 /* External entry points for do_{push,pop}_nested_namespace. */
7287 push_nested_namespace (tree ns)
7289 bool subtime = timevar_cond_start (TV_NAME_LOOKUP);
7290 do_push_nested_namespace (ns);
7291 timevar_cond_stop (TV_NAME_LOOKUP, subtime);
7295 pop_nested_namespace (tree ns)
7297 bool subtime = timevar_cond_start (TV_NAME_LOOKUP);
7298 gcc_assert (current_namespace == ns);
7299 do_pop_nested_namespace (ns);
7300 timevar_cond_stop (TV_NAME_LOOKUP, subtime);
7303 /* Pop off extraneous binding levels left over due to syntax errors.
7304 We don't pop past namespaces, as they might be valid. */
7307 pop_everything (void)
7309 if (ENABLE_SCOPE_CHECKING)
7310 verbatim ("XXX entering pop_everything ()\n");
7311 while (!namespace_bindings_p ())
7313 if (current_binding_level->kind == sk_class)
7314 pop_nested_class ();
7318 if (ENABLE_SCOPE_CHECKING)
7319 verbatim ("XXX leaving pop_everything ()\n");
7322 /* Emit debugging information for using declarations and directives.
7323 If input tree is overloaded fn then emit debug info for all
7327 cp_emit_debug_info_for_using (tree t, tree context)
7329 /* Don't try to emit any debug information if we have errors. */
7333 /* Ignore this FUNCTION_DECL if it refers to a builtin declaration
7334 of a builtin function. */
7335 if (TREE_CODE (t) == FUNCTION_DECL
7336 && DECL_EXTERNAL (t)
7337 && DECL_BUILT_IN (t))
7340 /* Do not supply context to imported_module_or_decl, if
7341 it is a global namespace. */
7342 if (context == global_namespace)
7343 context = NULL_TREE;
7345 t = MAYBE_BASELINK_FUNCTIONS (t);
7347 /* FIXME: Handle TEMPLATE_DECLs. */
7348 for (lkp_iterator iter (t); iter; ++iter)
7351 if (TREE_CODE (fn) != TEMPLATE_DECL)
7353 if (building_stmt_list_p ())
7354 add_stmt (build_stmt (input_location, USING_STMT, fn));
7356 debug_hooks->imported_module_or_decl (fn, NULL_TREE, context,
7362 #include "gt-cp-name-lookup.h"