1 /* Definitions for C++ name lookup routines.
2 Copyright (C) 2003-2020 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"
32 #include "gcc-rich-location.h"
33 #include "spellcheck-tree.h"
35 #include "c-family/name-hint.h"
36 #include "c-family/known-headers.h"
37 #include "c-family/c-spellcheck.h"
39 static cxx_binding
*cxx_binding_make (tree value
, tree type
);
40 static cp_binding_level
*innermost_nonclass_level (void);
41 static void set_identifier_type_value_with_scope (tree id
, tree decl
,
43 static name_hint
maybe_suggest_missing_std_header (location_t location
,
45 static name_hint
suggest_alternatives_for_1 (location_t location
, tree name
,
46 bool suggest_misspellings
);
48 /* Create an overload suitable for recording an artificial TYPE_DECL
49 and another decl. We use this machanism to implement the struct
50 stat hack within a namespace. It'd be nice to use it everywhere. */
52 #define STAT_HACK_P(N) ((N) && TREE_CODE (N) == OVERLOAD && OVL_LOOKUP_P (N))
53 #define STAT_TYPE(N) TREE_TYPE (N)
54 #define STAT_DECL(N) OVL_FUNCTION (N)
55 #define MAYBE_STAT_DECL(N) (STAT_HACK_P (N) ? STAT_DECL (N) : N)
56 #define MAYBE_STAT_TYPE(N) (STAT_HACK_P (N) ? STAT_TYPE (N) : NULL_TREE)
58 /* Create a STAT_HACK node with DECL as the value binding and TYPE as
62 stat_hack (tree decl
= NULL_TREE
, tree type
= NULL_TREE
)
64 tree result
= make_node (OVERLOAD
);
66 /* Mark this as a lookup, so we can tell this is a stat hack. */
67 OVL_LOOKUP_P (result
) = true;
68 STAT_DECL (result
) = decl
;
69 STAT_TYPE (result
) = type
;
73 /* Create a local binding level for NAME. */
76 create_local_binding (cp_binding_level
*level
, tree name
)
78 cxx_binding
*binding
= cxx_binding_make (NULL
, NULL
);
80 INHERITED_VALUE_BINDING_P (binding
) = false;
81 LOCAL_BINDING_P (binding
) = true;
82 binding
->scope
= level
;
83 binding
->previous
= IDENTIFIER_BINDING (name
);
85 IDENTIFIER_BINDING (name
) = binding
;
90 /* Find the binding for NAME in namespace NS. If CREATE_P is true,
91 make an empty binding if there wasn't one. */
94 find_namespace_slot (tree ns
, tree name
, bool create_p
= false)
96 tree
*slot
= DECL_NAMESPACE_BINDINGS (ns
)
97 ->find_slot_with_hash (name
, name
? IDENTIFIER_HASH_VALUE (name
) : 0,
98 create_p
? INSERT
: NO_INSERT
);
103 find_namespace_value (tree ns
, tree name
)
105 tree
*b
= find_namespace_slot (ns
, name
);
107 return b
? MAYBE_STAT_DECL (*b
) : NULL_TREE
;
110 /* Add DECL to the list of things declared in B. */
113 add_decl_to_level (cp_binding_level
*b
, tree decl
)
115 gcc_assert (b
->kind
!= sk_class
);
117 /* Make sure we don't create a circular list. xref_tag can end
118 up pushing the same artificial decl more than once. We
119 should have already detected that in update_binding. */
120 gcc_assert (b
->names
!= decl
);
122 /* We build up the list in reverse order, and reverse it later if
124 TREE_CHAIN (decl
) = b
->names
;
127 /* If appropriate, add decl to separate list of statics. We
128 include extern variables because they might turn out to be
129 static later. It's OK for this list to contain a few false
131 if (b
->kind
== sk_namespace
133 && (TREE_STATIC (decl
) || DECL_EXTERNAL (decl
)))
134 || (TREE_CODE (decl
) == FUNCTION_DECL
135 && (!TREE_PUBLIC (decl
)
136 || decl_anon_ns_mem_p (decl
)
137 || DECL_DECLARED_INLINE_P (decl
)))))
138 vec_safe_push (static_decls
, decl
);
141 /* Find the binding for NAME in the local binding level B. */
144 find_local_binding (cp_binding_level
*b
, tree name
)
146 if (cxx_binding
*binding
= IDENTIFIER_BINDING (name
))
147 for (;; b
= b
->level_chain
)
149 if (binding
->scope
== b
)
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
425 && OVL_DEDUP_P (probe
))
427 /* We're about to add something found by a using
428 declaration, so need to engage deduping mode. */
429 lookup_mark (value
, true);
434 value
= lookup_maybe_add (fns
, value
, deduping
);
437 /* Add a NEW_VAL, a found value binding into the current value binding. */
440 name_lookup::add_value (tree new_val
)
442 if (OVL_P (new_val
) && (!value
|| OVL_P (value
)))
443 add_overload (new_val
);
446 else if (value
== new_val
)
448 else if ((TREE_CODE (value
) == TYPE_DECL
449 && TREE_CODE (new_val
) == TYPE_DECL
450 && same_type_p (TREE_TYPE (value
), TREE_TYPE (new_val
))))
451 /* Typedefs to the same type. */;
452 else if (TREE_CODE (value
) == NAMESPACE_DECL
453 && TREE_CODE (new_val
) == NAMESPACE_DECL
454 && ORIGINAL_NAMESPACE (value
) == ORIGINAL_NAMESPACE (new_val
))
455 /* Namespace (possibly aliased) to the same namespace. Locate
457 value
= ORIGINAL_NAMESPACE (value
);
462 /* Disengage deduping mode. */
463 lookup_mark (value
, false);
466 value
= ambiguous (new_val
, value
);
470 /* Add a NEW_TYPE, a found type binding into the current type binding. */
473 name_lookup::add_type (tree new_type
)
477 else if (TREE_CODE (type
) == TREE_LIST
478 || !same_type_p (TREE_TYPE (type
), TREE_TYPE (new_type
)))
479 type
= ambiguous (new_type
, type
);
482 /* Process a found binding containing NEW_VAL and NEW_TYPE. Returns
483 true if we actually found something noteworthy. */
486 name_lookup::process_binding (tree new_val
, tree new_type
)
488 /* Did we really see a type? */
490 && (LOOKUP_NAMESPACES_ONLY (flags
)
491 || (!(flags
& LOOKUP_HIDDEN
)
492 && DECL_LANG_SPECIFIC (new_type
)
493 && DECL_ANTICIPATED (new_type
))))
494 new_type
= NULL_TREE
;
496 if (new_val
&& !(flags
& LOOKUP_HIDDEN
))
497 new_val
= ovl_skip_hidden (new_val
);
499 /* Do we really see a value? */
501 switch (TREE_CODE (new_val
))
504 /* If we expect types or namespaces, and not templates,
505 or this is not a template class. */
506 if ((LOOKUP_QUALIFIERS_ONLY (flags
)
507 && !DECL_TYPE_TEMPLATE_P (new_val
)))
511 if (LOOKUP_NAMESPACES_ONLY (flags
)
512 || (new_type
&& (flags
& LOOKUP_PREFER_TYPES
)))
516 if (LOOKUP_TYPES_ONLY (flags
))
520 if (LOOKUP_QUALIFIERS_ONLY (flags
))
527 new_type
= NULL_TREE
;
530 /* Merge into the lookup */
536 return new_val
!= NULL_TREE
;
539 /* Look in exactly namespace SCOPE. */
542 name_lookup::search_namespace_only (tree scope
)
546 if (tree
*binding
= find_namespace_slot (scope
, name
))
547 found
|= process_binding (MAYBE_STAT_DECL (*binding
),
548 MAYBE_STAT_TYPE (*binding
));
553 /* Conditionally look in namespace SCOPE and inline children. */
556 name_lookup::search_namespace (tree scope
)
558 if (see_and_mark (scope
))
559 /* We've visited this scope before. Return what we found then. */
560 return found_p (scope
);
562 /* Look in exactly namespace. */
563 bool found
= search_namespace_only (scope
);
565 /* Don't look into inline children, if we're looking for an
566 anonymous name -- it must be in the current scope, if anywhere. */
568 /* Recursively look in its inline children. */
569 if (vec
<tree
, va_gc
> *inlinees
= DECL_NAMESPACE_INLINEES (scope
))
570 for (unsigned ix
= inlinees
->length (); ix
--;)
571 found
|= search_namespace ((*inlinees
)[ix
]);
579 /* Recursively follow using directives of SCOPE & its inline children.
580 Such following is essentially a flood-fill algorithm. */
583 name_lookup::search_usings (tree scope
)
585 /* We do not check seen_p here, as that was already set during the
586 namespace_only walk. */
591 if (vec
<tree
, va_gc
> *usings
= NAMESPACE_LEVEL (scope
)->using_directives
)
592 for (unsigned ix
= usings
->length (); ix
--;)
593 found
|= search_qualified ((*usings
)[ix
], true);
595 /* Look in its inline children. */
596 if (vec
<tree
, va_gc
> *inlinees
= DECL_NAMESPACE_INLINEES (scope
))
597 for (unsigned ix
= inlinees
->length (); ix
--;)
598 found
|= search_usings ((*inlinees
)[ix
]);
606 /* Qualified namespace lookup in SCOPE.
607 1) Look in SCOPE (+inlines). If found, we're done.
608 2) Otherwise, if USINGS is true,
609 recurse for every using directive of SCOPE (+inlines).
611 Trickiness is (a) loops and (b) multiple paths to same namespace.
612 In both cases we want to not repeat any lookups, and know whether
613 to stop the caller's step #2. Do this via the FOUND_P marker. */
616 name_lookup::search_qualified (tree scope
, bool usings
)
621 found
= found_p (scope
);
624 found
= search_namespace (scope
);
625 if (!found
&& usings
)
626 found
= search_usings (scope
);
632 /* Add SCOPE to the unqualified search queue, recursively add its
633 inlines and those via using directives. */
635 name_lookup::using_queue
*
636 name_lookup::queue_namespace (using_queue
*queue
, int depth
, tree scope
)
638 if (see_and_mark (scope
))
643 while (SCOPE_DEPTH (common
) > depth
)
644 common
= CP_DECL_CONTEXT (common
);
645 vec_safe_push (queue
, using_pair (common
, scope
));
647 /* Queue its inline children. */
648 if (vec
<tree
, va_gc
> *inlinees
= DECL_NAMESPACE_INLINEES (scope
))
649 for (unsigned ix
= inlinees
->length (); ix
--;)
650 queue
= queue_namespace (queue
, depth
, (*inlinees
)[ix
]);
652 /* Queue its using targets. */
653 queue
= queue_usings (queue
, depth
, NAMESPACE_LEVEL (scope
)->using_directives
);
658 /* Add the namespaces in USINGS to the unqualified search queue. */
660 name_lookup::using_queue
*
661 name_lookup::do_queue_usings (using_queue
*queue
, int depth
,
662 vec
<tree
, va_gc
> *usings
)
664 for (unsigned ix
= usings
->length (); ix
--;)
665 queue
= queue_namespace (queue
, depth
, (*usings
)[ix
]);
670 /* Unqualified namespace lookup in SCOPE.
671 1) add scope+inlins to worklist.
672 2) recursively add target of every using directive
673 3) for each worklist item where SCOPE is common ancestor, search it
674 4) if nothing find, scope=parent, goto 1. */
677 name_lookup::search_unqualified (tree scope
, cp_binding_level
*level
)
679 /* Make static to avoid continual reallocation. We're not
681 static using_queue
*queue
= NULL
;
683 int length
= vec_safe_length (queue
);
685 /* Queue local using-directives. */
686 for (; level
->kind
!= sk_namespace
; level
= level
->level_chain
)
687 queue
= queue_usings (queue
, SCOPE_DEPTH (scope
), level
->using_directives
);
689 for (; !found
; scope
= CP_DECL_CONTEXT (scope
))
691 gcc_assert (!DECL_NAMESPACE_ALIAS (scope
));
692 int depth
= SCOPE_DEPTH (scope
);
694 /* Queue namespaces reachable from SCOPE. */
695 queue
= queue_namespace (queue
, depth
, scope
);
697 /* Search every queued namespace where SCOPE is the common
698 ancestor. Adjust the others. */
699 unsigned ix
= length
;
702 using_pair
&pair
= (*queue
)[ix
];
703 while (pair
.first
== scope
)
705 found
|= search_namespace_only (pair
.second
);
706 pair
= queue
->pop ();
707 if (ix
== queue
->length ())
710 /* The depth is the same as SCOPE, find the parent scope. */
711 if (SCOPE_DEPTH (pair
.first
) == depth
)
712 pair
.first
= CP_DECL_CONTEXT (pair
.first
);
715 while (ix
< queue
->length ());
717 if (scope
== global_namespace
)
720 /* If looking for hidden names, we only look in the innermost
721 namespace scope. [namespace.memdef]/3 If a friend
722 declaration in a non-local class first declares a class,
723 function, class template or function template the friend is a
724 member of the innermost enclosing namespace. See also
725 [basic.lookup.unqual]/7 */
726 if (flags
& LOOKUP_HIDDEN
)
730 vec_safe_truncate (queue
, length
);
735 /* FNS is a value binding. If it is a (set of overloaded) functions,
736 add them into the current value. */
739 name_lookup::add_fns (tree fns
)
743 else if (TREE_CODE (fns
) == OVERLOAD
)
745 if (TREE_TYPE (fns
) != unknown_type_node
)
746 fns
= OVL_FUNCTION (fns
);
748 else if (!DECL_DECLARES_FUNCTION_P (fns
))
754 /* Add functions of a namespace to the lookup structure. */
757 name_lookup::adl_namespace_only (tree scope
)
761 /* Look down into inline namespaces. */
762 if (vec
<tree
, va_gc
> *inlinees
= DECL_NAMESPACE_INLINEES (scope
))
763 for (unsigned ix
= inlinees
->length (); ix
--;)
764 adl_namespace_only ((*inlinees
)[ix
]);
766 if (tree fns
= find_namespace_value (scope
, name
))
767 add_fns (ovl_skip_hidden (fns
));
770 /* Find the containing non-inlined namespace, add it and all its
774 name_lookup::adl_namespace (tree scope
)
779 /* Find the containing non-inline namespace. */
780 while (DECL_NAMESPACE_INLINE_P (scope
))
781 scope
= CP_DECL_CONTEXT (scope
);
783 adl_namespace_only (scope
);
786 /* Adds the class and its friends to the lookup structure. */
789 name_lookup::adl_class_only (tree type
)
791 /* Backend-built structures, such as __builtin_va_list, aren't
792 affected by all this. */
793 if (!CLASS_TYPE_P (type
))
796 type
= TYPE_MAIN_VARIANT (type
);
798 if (see_and_mark (type
))
801 tree context
= decl_namespace_context (type
);
802 adl_namespace (context
);
804 complete_type (type
);
807 for (tree list
= DECL_FRIENDLIST (TYPE_MAIN_DECL (type
)); list
;
808 list
= TREE_CHAIN (list
))
809 if (name
== FRIEND_NAME (list
))
810 for (tree friends
= FRIEND_DECLS (list
); friends
;
811 friends
= TREE_CHAIN (friends
))
813 tree fn
= TREE_VALUE (friends
);
815 /* Only interested in global functions with potentially hidden
816 (i.e. unqualified) declarations. */
817 if (CP_DECL_CONTEXT (fn
) != context
)
820 /* Only interested in anticipated friends. (Non-anticipated
821 ones will have been inserted during the namespace
823 if (!DECL_ANTICIPATED (fn
))
826 /* Template specializations are never found by name lookup.
827 (Templates themselves can be found, but not template
829 if (TREE_CODE (fn
) == FUNCTION_DECL
&& DECL_USE_TEMPLATE (fn
))
836 /* Adds the class and its bases to the lookup structure.
837 Returns true on error. */
840 name_lookup::adl_bases (tree type
)
842 adl_class_only (type
);
844 /* Process baseclasses. */
845 if (tree binfo
= TYPE_BINFO (type
))
850 for (i
= 0; BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); i
++)
851 adl_bases (BINFO_TYPE (base_binfo
));
855 /* Adds everything associated with a class argument type to the lookup
856 structure. Returns true on error.
858 If T is a class type (including unions), its associated classes are: the
859 class itself; the class of which it is a member, if any; and its direct
860 and indirect base classes. Its associated namespaces are the namespaces
861 of which its associated classes are members. Furthermore, if T is a
862 class template specialization, its associated namespaces and classes
863 also include: the namespaces and classes associated with the types of
864 the template arguments provided for template type parameters (excluding
865 template template parameters); the namespaces of which any template
866 template arguments are members; and the classes of which any member
867 templates used as template template arguments are members. [ Note:
868 non-type template arguments do not contribute to the set of associated
869 namespaces. --end note] */
872 name_lookup::adl_class (tree type
)
874 /* Backend build structures, such as __builtin_va_list, aren't
875 affected by all this. */
876 if (!CLASS_TYPE_P (type
))
879 type
= TYPE_MAIN_VARIANT (type
);
880 /* We don't set found here because we have to have set seen first,
881 which is done in the adl_bases walk. */
888 if (TYPE_CLASS_SCOPE_P (type
))
889 adl_class_only (TYPE_CONTEXT (type
));
891 /* Process template arguments. */
892 if (CLASSTYPE_TEMPLATE_INFO (type
)
893 && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (type
)))
895 tree list
= INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (type
));
896 for (int i
= 0; i
< TREE_VEC_LENGTH (list
); ++i
)
897 adl_template_arg (TREE_VEC_ELT (list
, i
));
902 name_lookup::adl_expr (tree expr
)
907 gcc_assert (!TYPE_P (expr
));
909 if (TREE_TYPE (expr
) != unknown_type_node
)
911 adl_type (unlowered_expr_type (expr
));
915 if (TREE_CODE (expr
) == ADDR_EXPR
)
916 expr
= TREE_OPERAND (expr
, 0);
917 if (TREE_CODE (expr
) == COMPONENT_REF
918 || TREE_CODE (expr
) == OFFSET_REF
)
919 expr
= TREE_OPERAND (expr
, 1);
920 expr
= MAYBE_BASELINK_FUNCTIONS (expr
);
923 for (lkp_iterator
iter (expr
); iter
; ++iter
)
924 adl_type (TREE_TYPE (*iter
));
925 else if (TREE_CODE (expr
) == TEMPLATE_ID_EXPR
)
927 /* The working paper doesn't currently say how to handle
928 template-id arguments. The sensible thing would seem to be
929 to handle the list of template candidates like a normal
930 overload set, and handle the template arguments like we do
931 for class template specializations. */
933 /* First the templates. */
934 adl_expr (TREE_OPERAND (expr
, 0));
936 /* Now the arguments. */
937 if (tree args
= TREE_OPERAND (expr
, 1))
938 for (int ix
= TREE_VEC_LENGTH (args
); ix
--;)
939 adl_template_arg (TREE_VEC_ELT (args
, ix
));
944 name_lookup::adl_type (tree type
)
949 if (TYPE_PTRDATAMEM_P (type
))
951 /* Pointer to member: associate class type and value type. */
952 adl_type (TYPE_PTRMEM_CLASS_TYPE (type
));
953 adl_type (TYPE_PTRMEM_POINTED_TO_TYPE (type
));
957 switch (TREE_CODE (type
))
960 if (TYPE_PTRMEMFUNC_P (type
))
962 adl_type (TYPE_PTRMEMFUNC_FN_TYPE (type
));
971 /* The basetype is referenced in the first arg type, so just
974 /* Associate the parameter types. */
975 for (tree args
= TYPE_ARG_TYPES (type
); args
; args
= TREE_CHAIN (args
))
976 adl_type (TREE_VALUE (args
));
982 adl_type (TREE_TYPE (type
));
986 if (TYPE_CLASS_SCOPE_P (type
))
987 adl_class_only (TYPE_CONTEXT (type
));
988 adl_namespace (decl_namespace_context (type
));
992 gcc_assert (type
== unknown_type_node
993 || type
== init_list_type_node
);
996 case TYPE_PACK_EXPANSION
:
997 adl_type (PACK_EXPANSION_PATTERN (type
));
1005 /* Adds everything associated with a template argument to the lookup
1009 name_lookup::adl_template_arg (tree arg
)
1011 /* [basic.lookup.koenig]
1013 If T is a template-id, its associated namespaces and classes are
1014 ... the namespaces and classes associated with the types of the
1015 template arguments provided for template type parameters
1016 (excluding template template parameters); the namespaces in which
1017 any template template arguments are defined; and the classes in
1018 which any member templates used as template template arguments
1019 are defined. [Note: non-type template arguments do not
1020 contribute to the set of associated namespaces. ] */
1022 /* Consider first template template arguments. */
1023 if (TREE_CODE (arg
) == TEMPLATE_TEMPLATE_PARM
1024 || TREE_CODE (arg
) == UNBOUND_CLASS_TEMPLATE
)
1026 else if (TREE_CODE (arg
) == TEMPLATE_DECL
)
1028 tree ctx
= CP_DECL_CONTEXT (arg
);
1030 /* It's not a member template. */
1031 if (TREE_CODE (ctx
) == NAMESPACE_DECL
)
1032 adl_namespace (ctx
);
1033 /* Otherwise, it must be member template. */
1035 adl_class_only (ctx
);
1037 /* It's an argument pack; handle it recursively. */
1038 else if (ARGUMENT_PACK_P (arg
))
1040 tree args
= ARGUMENT_PACK_ARGS (arg
);
1041 int i
, len
= TREE_VEC_LENGTH (args
);
1042 for (i
= 0; i
< len
; ++i
)
1043 adl_template_arg (TREE_VEC_ELT (args
, i
));
1045 /* It's not a template template argument, but it is a type template
1047 else if (TYPE_P (arg
))
1051 /* Perform ADL lookup. FNS is the existing lookup result and ARGS are
1052 the call arguments. */
1055 name_lookup::search_adl (tree fns
, vec
<tree
, va_gc
> *args
)
1060 lookup_mark (fns
, true);
1067 FOR_EACH_VEC_ELT_REVERSE (*args
, ix
, arg
)
1068 /* OMP reduction operators put an ADL-significant type as the
1080 static bool qualified_namespace_lookup (tree
, name_lookup
*);
1081 static void consider_binding_level (tree name
,
1082 best_match
<tree
, const char *> &bm
,
1083 cp_binding_level
*lvl
,
1084 bool look_within_fields
,
1085 enum lookup_name_fuzzy_kind kind
);
1086 static void diagnose_name_conflict (tree
, tree
);
1088 /* ADL lookup of NAME. FNS is the result of regular lookup, and we
1089 don't add duplicates to it. ARGS is the vector of call
1090 arguments (which will not be empty). */
1093 lookup_arg_dependent (tree name
, tree fns
, vec
<tree
, va_gc
> *args
)
1095 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
1096 name_lookup
lookup (name
);
1097 fns
= lookup
.search_adl (fns
, args
);
1098 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
1102 /* FNS is an overload set of conversion functions. Return the
1103 overloads converting to TYPE. */
1106 extract_conversion_operator (tree fns
, tree type
)
1108 tree convs
= NULL_TREE
;
1109 tree tpls
= NULL_TREE
;
1111 for (ovl_iterator
iter (fns
); iter
; ++iter
)
1113 if (same_type_p (DECL_CONV_FN_TYPE (*iter
), type
))
1114 convs
= lookup_add (*iter
, convs
);
1116 if (TREE_CODE (*iter
) == TEMPLATE_DECL
)
1117 tpls
= lookup_add (*iter
, tpls
);
1126 /* Binary search of (ordered) MEMBER_VEC for NAME. */
1129 member_vec_binary_search (vec
<tree
, va_gc
> *member_vec
, tree name
)
1131 for (unsigned lo
= 0, hi
= member_vec
->length (); lo
< hi
;)
1133 unsigned mid
= (lo
+ hi
) / 2;
1134 tree binding
= (*member_vec
)[mid
];
1135 tree binding_name
= OVL_NAME (binding
);
1137 if (binding_name
> name
)
1139 else if (binding_name
< name
)
1148 /* Linear search of (unordered) MEMBER_VEC for NAME. */
1151 member_vec_linear_search (vec
<tree
, va_gc
> *member_vec
, tree name
)
1153 for (int ix
= member_vec
->length (); ix
--;)
1154 if (tree binding
= (*member_vec
)[ix
])
1155 if (OVL_NAME (binding
) == name
)
1161 /* Linear search of (partially ordered) fields of KLASS for NAME. */
1164 fields_linear_search (tree klass
, tree name
, bool want_type
)
1166 for (tree fields
= TYPE_FIELDS (klass
); fields
; fields
= DECL_CHAIN (fields
))
1170 if (TREE_CODE (decl
) == FIELD_DECL
1171 && ANON_AGGR_TYPE_P (TREE_TYPE (decl
)))
1173 if (tree temp
= search_anon_aggr (TREE_TYPE (decl
), name
, want_type
))
1177 if (DECL_NAME (decl
) != name
)
1180 if (TREE_CODE (decl
) == USING_DECL
)
1182 decl
= strip_using_decl (decl
);
1183 if (is_overloaded_fn (decl
))
1187 if (DECL_DECLARES_FUNCTION_P (decl
))
1188 /* Functions are found separately. */
1191 if (!want_type
|| DECL_DECLARES_TYPE_P (decl
))
1198 /* Look for NAME member inside of anonymous aggregate ANON. Although
1199 such things should only contain FIELD_DECLs, we check that too
1200 late, and would give very confusing errors if we weren't
1204 search_anon_aggr (tree anon
, tree name
, bool want_type
)
1206 gcc_assert (COMPLETE_TYPE_P (anon
));
1207 tree ret
= get_class_binding_direct (anon
, name
, want_type
);
1211 /* Look for NAME as an immediate member of KLASS (including
1212 anon-members or unscoped enum member). TYPE_OR_FNS is zero for
1213 regular search. >0 to get a type binding (if there is one) and <0
1214 if you want (just) the member function binding.
1216 Use this if you do not want lazy member creation. */
1219 get_class_binding_direct (tree klass
, tree name
, bool want_type
)
1221 gcc_checking_assert (RECORD_OR_UNION_TYPE_P (klass
));
1223 /* Conversion operators can only be found by the marker conversion
1225 bool conv_op
= IDENTIFIER_CONV_OP_P (name
);
1226 tree lookup
= conv_op
? conv_op_identifier
: name
;
1227 tree val
= NULL_TREE
;
1228 vec
<tree
, va_gc
> *member_vec
= CLASSTYPE_MEMBER_VEC (klass
);
1230 if (COMPLETE_TYPE_P (klass
) && member_vec
)
1232 val
= member_vec_binary_search (member_vec
, lookup
);
1235 else if (STAT_HACK_P (val
))
1236 val
= want_type
? STAT_TYPE (val
) : STAT_DECL (val
);
1237 else if (want_type
&& !DECL_DECLARES_TYPE_P (val
))
1242 if (member_vec
&& !want_type
)
1243 val
= member_vec_linear_search (member_vec
, lookup
);
1245 if (!val
|| (TREE_CODE (val
) == OVERLOAD
&& OVL_DEDUP_P (val
)))
1246 /* Dependent using declarations are a 'field', make sure we
1247 return that even if we saw an overload already. */
1248 if (tree field_val
= fields_linear_search (klass
, lookup
, want_type
))
1252 else if (TREE_CODE (field_val
) == USING_DECL
)
1253 val
= ovl_make (field_val
, val
);
1257 /* Extract the conversion operators asked for, unless the general
1258 conversion operator was requested. */
1261 gcc_checking_assert (OVL_FUNCTION (val
) == conv_op_marker
);
1262 val
= OVL_CHAIN (val
);
1263 if (tree type
= TREE_TYPE (name
))
1264 val
= extract_conversion_operator (val
, type
);
1270 /* Look for NAME's binding in exactly KLASS. See
1271 get_class_binding_direct for argument description. Does lazy
1272 special function creation as necessary. */
1275 get_class_binding (tree klass
, tree name
, bool want_type
/*=false*/)
1277 klass
= complete_type (klass
);
1279 if (COMPLETE_TYPE_P (klass
))
1281 /* Lazily declare functions, if we're going to search these. */
1282 if (IDENTIFIER_CTOR_P (name
))
1284 if (CLASSTYPE_LAZY_DEFAULT_CTOR (klass
))
1285 lazily_declare_fn (sfk_constructor
, klass
);
1286 if (CLASSTYPE_LAZY_COPY_CTOR (klass
))
1287 lazily_declare_fn (sfk_copy_constructor
, klass
);
1288 if (CLASSTYPE_LAZY_MOVE_CTOR (klass
))
1289 lazily_declare_fn (sfk_move_constructor
, klass
);
1291 else if (IDENTIFIER_DTOR_P (name
))
1293 if (CLASSTYPE_LAZY_DESTRUCTOR (klass
))
1294 lazily_declare_fn (sfk_destructor
, klass
);
1296 else if (name
== assign_op_identifier
)
1298 if (CLASSTYPE_LAZY_COPY_ASSIGN (klass
))
1299 lazily_declare_fn (sfk_copy_assignment
, klass
);
1300 if (CLASSTYPE_LAZY_MOVE_ASSIGN (klass
))
1301 lazily_declare_fn (sfk_move_assignment
, klass
);
1305 return get_class_binding_direct (klass
, name
, want_type
);
1308 /* Find the slot containing overloads called 'NAME'. If there is no
1309 such slot and the class is complete, create an empty one, at the
1310 correct point in the sorted member vector. Otherwise return NULL.
1311 Deals with conv_op marker handling. */
1314 find_member_slot (tree klass
, tree name
)
1316 bool complete_p
= COMPLETE_TYPE_P (klass
);
1318 vec
<tree
, va_gc
> *member_vec
= CLASSTYPE_MEMBER_VEC (klass
);
1321 vec_alloc (member_vec
, 8);
1322 CLASSTYPE_MEMBER_VEC (klass
) = member_vec
;
1325 /* If the class is complete but had no member_vec, we need
1326 to add the TYPE_FIELDS into it. We're also most likely
1327 to be adding ctors & dtors, so ask for 6 spare slots (the
1328 abstract cdtors and their clones). */
1329 set_class_bindings (klass
, 6);
1330 member_vec
= CLASSTYPE_MEMBER_VEC (klass
);
1334 if (IDENTIFIER_CONV_OP_P (name
))
1335 name
= conv_op_identifier
;
1337 unsigned ix
, length
= member_vec
->length ();
1338 for (ix
= 0; ix
< length
; ix
++)
1340 tree
*slot
= &(*member_vec
)[ix
];
1341 tree fn_name
= OVL_NAME (*slot
);
1343 if (fn_name
== name
)
1345 /* If we found an existing slot, it must be a function set.
1346 Even with insertion after completion, because those only
1347 happen with artificial fns that have unspellable names.
1348 This means we do not have to deal with the stat hack
1350 gcc_checking_assert (OVL_P (*slot
));
1351 if (name
== conv_op_identifier
)
1353 gcc_checking_assert (OVL_FUNCTION (*slot
) == conv_op_marker
);
1354 /* Skip the conv-op marker. */
1355 slot
= &OVL_CHAIN (*slot
);
1360 if (complete_p
&& fn_name
> name
)
1364 /* No slot found, add one if the class is complete. */
1367 /* Do exact allocation, as we don't expect to add many. */
1368 gcc_assert (name
!= conv_op_identifier
);
1369 vec_safe_reserve_exact (member_vec
, 1);
1370 CLASSTYPE_MEMBER_VEC (klass
) = member_vec
;
1371 member_vec
->quick_insert (ix
, NULL_TREE
);
1372 return &(*member_vec
)[ix
];
1378 /* KLASS is an incomplete class to which we're adding a method NAME.
1379 Add a slot and deal with conv_op marker handling. */
1382 add_member_slot (tree klass
, tree name
)
1384 gcc_assert (!COMPLETE_TYPE_P (klass
));
1386 vec
<tree
, va_gc
> *member_vec
= CLASSTYPE_MEMBER_VEC (klass
);
1387 vec_safe_push (member_vec
, NULL_TREE
);
1388 CLASSTYPE_MEMBER_VEC (klass
) = member_vec
;
1390 tree
*slot
= &member_vec
->last ();
1391 if (IDENTIFIER_CONV_OP_P (name
))
1393 /* Install the marker prefix. */
1394 *slot
= ovl_make (conv_op_marker
, NULL_TREE
);
1395 slot
= &OVL_CHAIN (*slot
);
1401 /* Comparison function to compare two MEMBER_VEC entries by name.
1402 Because we can have duplicates during insertion of TYPE_FIELDS, we
1403 do extra checking so deduping doesn't have to deal with so many
1407 member_name_cmp (const void *a_p
, const void *b_p
)
1409 tree a
= *(const tree
*)a_p
;
1410 tree b
= *(const tree
*)b_p
;
1411 tree name_a
= DECL_NAME (TREE_CODE (a
) == OVERLOAD
? OVL_FUNCTION (a
) : a
);
1412 tree name_b
= DECL_NAME (TREE_CODE (b
) == OVERLOAD
? OVL_FUNCTION (b
) : b
);
1414 gcc_checking_assert (name_a
&& name_b
);
1415 if (name_a
!= name_b
)
1416 return name_a
< name_b
? -1 : +1;
1418 if (name_a
== conv_op_identifier
)
1420 /* Strip the conv-op markers. */
1421 gcc_checking_assert (OVL_FUNCTION (a
) == conv_op_marker
1422 && OVL_FUNCTION (b
) == conv_op_marker
);
1427 if (TREE_CODE (a
) == OVERLOAD
)
1428 a
= OVL_FUNCTION (a
);
1429 if (TREE_CODE (b
) == OVERLOAD
)
1430 b
= OVL_FUNCTION (b
);
1432 /* We're in STAT_HACK or USING_DECL territory (or possibly error-land). */
1433 if (TREE_CODE (a
) != TREE_CODE (b
))
1435 /* If one of them is a TYPE_DECL, it loses. */
1436 if (TREE_CODE (a
) == TYPE_DECL
)
1438 else if (TREE_CODE (b
) == TYPE_DECL
)
1441 /* If one of them is a USING_DECL, it loses. */
1442 if (TREE_CODE (a
) == USING_DECL
)
1444 else if (TREE_CODE (b
) == USING_DECL
)
1447 /* There are no other cases with different kinds of decls, as
1448 duplicate detection should have kicked in earlier. However,
1449 some erroneous cases get though. */
1450 gcc_assert (errorcount
);
1453 /* Using source location would be the best thing here, but we can
1454 get identically-located decls in the following circumstances:
1456 1) duplicate artificial type-decls for the same type.
1458 2) pack expansions of using-decls.
1460 We should not be doing #1, but in either case it doesn't matter
1461 how we order these. Use UID as a proxy for source ordering, so
1462 that identically-located decls still have a well-defined stable
1464 if (DECL_UID (a
) != DECL_UID (b
))
1465 return DECL_UID (a
) < DECL_UID (b
) ? -1 : +1;
1466 gcc_assert (a
== b
);
1471 gt_pointer_operator new_value
;
1475 /* This routine compares two fields like member_name_cmp but using the
1476 pointer operator in resort_field_decl_data. We don't have to deal
1477 with duplicates here. */
1480 resort_member_name_cmp (const void *a_p
, const void *b_p
)
1482 tree a
= *(const tree
*)a_p
;
1483 tree b
= *(const tree
*)b_p
;
1484 tree name_a
= OVL_NAME (a
);
1485 tree name_b
= OVL_NAME (b
);
1487 resort_data
.new_value (&name_a
, resort_data
.cookie
);
1488 resort_data
.new_value (&name_b
, resort_data
.cookie
);
1490 gcc_checking_assert (name_a
!= name_b
);
1492 return name_a
< name_b
? -1 : +1;
1495 /* Resort CLASSTYPE_MEMBER_VEC because pointers have been reordered. */
1498 resort_type_member_vec (void *obj
, void */
*orig_obj*/
,
1499 gt_pointer_operator new_value
, void* cookie
)
1501 if (vec
<tree
, va_gc
> *member_vec
= (vec
<tree
, va_gc
> *) obj
)
1503 resort_data
.new_value
= new_value
;
1504 resort_data
.cookie
= cookie
;
1505 member_vec
->qsort (resort_member_name_cmp
);
1509 /* Recursively count the number of fields in KLASS, including anonymous
1513 count_class_fields (tree klass
)
1515 unsigned n_fields
= 0;
1517 for (tree fields
= TYPE_FIELDS (klass
); fields
; fields
= DECL_CHAIN (fields
))
1518 if (DECL_DECLARES_FUNCTION_P (fields
))
1519 /* Functions are dealt with separately. */;
1520 else if (TREE_CODE (fields
) == FIELD_DECL
1521 && ANON_AGGR_TYPE_P (TREE_TYPE (fields
)))
1522 n_fields
+= count_class_fields (TREE_TYPE (fields
));
1523 else if (DECL_NAME (fields
))
1529 /* Append all the nonfunction members fields of KLASS to MEMBER_VEC.
1530 Recurse for anonymous members. MEMBER_VEC must have space. */
1533 member_vec_append_class_fields (vec
<tree
, va_gc
> *member_vec
, tree klass
)
1535 for (tree fields
= TYPE_FIELDS (klass
); fields
; fields
= DECL_CHAIN (fields
))
1536 if (DECL_DECLARES_FUNCTION_P (fields
))
1537 /* Functions are handled separately. */;
1538 else if (TREE_CODE (fields
) == FIELD_DECL
1539 && ANON_AGGR_TYPE_P (TREE_TYPE (fields
)))
1540 member_vec_append_class_fields (member_vec
, TREE_TYPE (fields
));
1541 else if (DECL_NAME (fields
))
1543 tree field
= fields
;
1544 /* Mark a conv-op USING_DECL with the conv-op-marker. */
1545 if (TREE_CODE (field
) == USING_DECL
1546 && IDENTIFIER_CONV_OP_P (DECL_NAME (field
)))
1547 field
= ovl_make (conv_op_marker
, field
);
1548 member_vec
->quick_push (field
);
1552 /* Append all of the enum values of ENUMTYPE to MEMBER_VEC.
1553 MEMBER_VEC must have space. */
1556 member_vec_append_enum_values (vec
<tree
, va_gc
> *member_vec
, tree enumtype
)
1558 for (tree values
= TYPE_VALUES (enumtype
);
1559 values
; values
= TREE_CHAIN (values
))
1560 member_vec
->quick_push (TREE_VALUE (values
));
1563 /* MEMBER_VEC has just had new DECLs added to it, but is sorted.
1564 DeDup adjacent DECLS of the same name. We already dealt with
1565 conflict resolution when adding the fields or methods themselves.
1566 There are three cases (which could all be combined):
1567 1) a TYPE_DECL and non TYPE_DECL. Deploy STAT_HACK as appropriate.
1568 2) a USING_DECL and an overload. If the USING_DECL is dependent,
1569 it wins. Otherwise the OVERLOAD does.
1570 3) two USING_DECLS. ...
1572 member_name_cmp will have ordered duplicates as
1573 <fns><using><type> */
1576 member_vec_dedup (vec
<tree
, va_gc
> *member_vec
)
1578 unsigned len
= member_vec
->length ();
1584 tree name
= OVL_NAME ((*member_vec
)[0]);
1585 for (unsigned jx
, ix
= 0; ix
< len
; ix
= jx
)
1587 tree current
= NULL_TREE
;
1588 tree to_type
= NULL_TREE
;
1589 tree to_using
= NULL_TREE
;
1590 tree marker
= NULL_TREE
;
1592 for (jx
= ix
; jx
< len
; jx
++)
1594 tree next
= (*member_vec
)[jx
];
1597 tree next_name
= OVL_NAME (next
);
1598 if (next_name
!= name
)
1605 if (IDENTIFIER_CONV_OP_P (name
))
1608 next
= OVL_CHAIN (next
);
1611 if (TREE_CODE (next
) == USING_DECL
)
1613 if (IDENTIFIER_CTOR_P (name
))
1614 /* Dependent inherited ctor. */
1617 next
= strip_using_decl (next
);
1618 if (TREE_CODE (next
) == USING_DECL
)
1624 if (is_overloaded_fn (next
))
1628 if (DECL_DECLARES_TYPE_P (next
))
1643 current
= ovl_make (to_using
, current
);
1651 current
= stat_hack (current
, to_type
);
1658 OVL_CHAIN (marker
) = current
;
1661 (*member_vec
)[store
++] = current
;
1665 while (store
++ < len
)
1669 /* Add the non-function members to CLASSTYPE_MEMBER_VEC. If there is
1670 no existing MEMBER_VEC and fewer than 8 fields, do nothing. We
1671 know there must be at least 1 field -- the self-reference
1672 TYPE_DECL, except for anon aggregates, which will have at least
1676 set_class_bindings (tree klass
, unsigned extra
)
1678 unsigned n_fields
= count_class_fields (klass
);
1679 vec
<tree
, va_gc
> *member_vec
= CLASSTYPE_MEMBER_VEC (klass
);
1681 if (member_vec
|| n_fields
>= 8)
1683 /* Append the new fields. */
1684 vec_safe_reserve_exact (member_vec
, extra
+ n_fields
);
1685 member_vec_append_class_fields (member_vec
, klass
);
1690 CLASSTYPE_MEMBER_VEC (klass
) = member_vec
;
1691 member_vec
->qsort (member_name_cmp
);
1692 member_vec_dedup (member_vec
);
1696 /* Insert lately defined enum ENUMTYPE into KLASS for the sorted case. */
1699 insert_late_enum_def_bindings (tree klass
, tree enumtype
)
1702 vec
<tree
, va_gc
> *member_vec
= CLASSTYPE_MEMBER_VEC (klass
);
1704 /* The enum bindings will already be on the TYPE_FIELDS, so don't
1705 count them twice. */
1707 n_fields
= count_class_fields (klass
);
1709 n_fields
= list_length (TYPE_VALUES (enumtype
));
1711 if (member_vec
|| n_fields
>= 8)
1713 vec_safe_reserve_exact (member_vec
, n_fields
);
1714 if (CLASSTYPE_MEMBER_VEC (klass
))
1715 member_vec_append_enum_values (member_vec
, enumtype
);
1717 member_vec_append_class_fields (member_vec
, klass
);
1718 CLASSTYPE_MEMBER_VEC (klass
) = member_vec
;
1719 member_vec
->qsort (member_name_cmp
);
1720 member_vec_dedup (member_vec
);
1724 /* Compute the chain index of a binding_entry given the HASH value of its
1725 name and the total COUNT of chains. COUNT is assumed to be a power
1728 #define ENTRY_INDEX(HASH, COUNT) (((HASH) >> 3) & ((COUNT) - 1))
1730 /* A free list of "binding_entry"s awaiting for re-use. */
1732 static GTY((deletable
)) binding_entry free_binding_entry
= NULL
;
1734 /* The binding oracle; see cp-tree.h. */
1736 cp_binding_oracle_function
*cp_binding_oracle
;
1738 /* If we have a binding oracle, ask it for all namespace-scoped
1739 definitions of NAME. */
1742 query_oracle (tree name
)
1744 if (!cp_binding_oracle
)
1747 /* LOOKED_UP holds the set of identifiers that we have already
1748 looked up with the oracle. */
1749 static hash_set
<tree
> looked_up
;
1750 if (looked_up
.add (name
))
1753 cp_binding_oracle (CP_ORACLE_IDENTIFIER
, name
);
1756 /* Create a binding_entry object for (NAME, TYPE). */
1758 static inline binding_entry
1759 binding_entry_make (tree name
, tree type
)
1761 binding_entry entry
;
1763 if (free_binding_entry
)
1765 entry
= free_binding_entry
;
1766 free_binding_entry
= entry
->chain
;
1769 entry
= ggc_alloc
<binding_entry_s
> ();
1773 entry
->chain
= NULL
;
1778 /* Put ENTRY back on the free list. */
1781 binding_entry_free (binding_entry entry
)
1785 entry
->chain
= free_binding_entry
;
1786 free_binding_entry
= entry
;
1790 /* The datatype used to implement the mapping from names to types at
1792 struct GTY(()) binding_table_s
{
1793 /* Array of chains of "binding_entry"s */
1794 binding_entry
* GTY((length ("%h.chain_count"))) chain
;
1796 /* The number of chains in this table. This is the length of the
1797 member "chain" considered as an array. */
1800 /* Number of "binding_entry"s in this table. */
1804 /* Construct TABLE with an initial CHAIN_COUNT. */
1807 binding_table_construct (binding_table table
, size_t chain_count
)
1809 table
->chain_count
= chain_count
;
1810 table
->entry_count
= 0;
1811 table
->chain
= ggc_cleared_vec_alloc
<binding_entry
> (table
->chain_count
);
1814 /* Make TABLE's entries ready for reuse. */
1817 binding_table_free (binding_table table
)
1825 for (i
= 0, count
= table
->chain_count
; i
< count
; ++i
)
1827 binding_entry temp
= table
->chain
[i
];
1828 while (temp
!= NULL
)
1830 binding_entry entry
= temp
;
1831 temp
= entry
->chain
;
1832 binding_entry_free (entry
);
1834 table
->chain
[i
] = NULL
;
1836 table
->entry_count
= 0;
1840 /* Allocate a table with CHAIN_COUNT, assumed to be a power of two. */
1842 static inline binding_table
1843 binding_table_new (size_t chain_count
)
1845 binding_table table
= ggc_alloc
<binding_table_s
> ();
1846 table
->chain
= NULL
;
1847 binding_table_construct (table
, chain_count
);
1851 /* Expand TABLE to twice its current chain_count. */
1854 binding_table_expand (binding_table table
)
1856 const size_t old_chain_count
= table
->chain_count
;
1857 const size_t old_entry_count
= table
->entry_count
;
1858 const size_t new_chain_count
= 2 * old_chain_count
;
1859 binding_entry
*old_chains
= table
->chain
;
1862 binding_table_construct (table
, new_chain_count
);
1863 for (i
= 0; i
< old_chain_count
; ++i
)
1865 binding_entry entry
= old_chains
[i
];
1866 for (; entry
!= NULL
; entry
= old_chains
[i
])
1868 const unsigned int hash
= IDENTIFIER_HASH_VALUE (entry
->name
);
1869 const size_t j
= ENTRY_INDEX (hash
, new_chain_count
);
1871 old_chains
[i
] = entry
->chain
;
1872 entry
->chain
= table
->chain
[j
];
1873 table
->chain
[j
] = entry
;
1876 table
->entry_count
= old_entry_count
;
1879 /* Insert a binding for NAME to TYPE into TABLE. */
1882 binding_table_insert (binding_table table
, tree name
, tree type
)
1884 const unsigned int hash
= IDENTIFIER_HASH_VALUE (name
);
1885 const size_t i
= ENTRY_INDEX (hash
, table
->chain_count
);
1886 binding_entry entry
= binding_entry_make (name
, type
);
1888 entry
->chain
= table
->chain
[i
];
1889 table
->chain
[i
] = entry
;
1890 ++table
->entry_count
;
1892 if (3 * table
->chain_count
< 5 * table
->entry_count
)
1893 binding_table_expand (table
);
1896 /* Return the binding_entry, if any, that maps NAME. */
1899 binding_table_find (binding_table table
, tree name
)
1901 const unsigned int hash
= IDENTIFIER_HASH_VALUE (name
);
1902 binding_entry entry
= table
->chain
[ENTRY_INDEX (hash
, table
->chain_count
)];
1904 while (entry
!= NULL
&& entry
->name
!= name
)
1905 entry
= entry
->chain
;
1910 /* Apply PROC -- with DATA -- to all entries in TABLE. */
1913 binding_table_foreach (binding_table table
, bt_foreach_proc proc
, void *data
)
1921 chain_count
= table
->chain_count
;
1922 for (i
= 0; i
< chain_count
; ++i
)
1924 binding_entry entry
= table
->chain
[i
];
1925 for (; entry
!= NULL
; entry
= entry
->chain
)
1930 #ifndef ENABLE_SCOPE_CHECKING
1931 # define ENABLE_SCOPE_CHECKING 0
1933 # define ENABLE_SCOPE_CHECKING 1
1936 /* A free list of "cxx_binding"s, connected by their PREVIOUS. */
1938 static GTY((deletable
)) cxx_binding
*free_bindings
;
1940 /* Initialize VALUE and TYPE field for BINDING, and set the PREVIOUS
1944 cxx_binding_init (cxx_binding
*binding
, tree value
, tree type
)
1946 binding
->value
= value
;
1947 binding
->type
= type
;
1948 binding
->previous
= NULL
;
1951 /* (GC)-allocate a binding object with VALUE and TYPE member initialized. */
1953 static cxx_binding
*
1954 cxx_binding_make (tree value
, tree type
)
1956 cxx_binding
*binding
;
1959 binding
= free_bindings
;
1960 free_bindings
= binding
->previous
;
1963 binding
= ggc_alloc
<cxx_binding
> ();
1965 cxx_binding_init (binding
, value
, type
);
1970 /* Put BINDING back on the free list. */
1973 cxx_binding_free (cxx_binding
*binding
)
1975 binding
->scope
= NULL
;
1976 binding
->previous
= free_bindings
;
1977 free_bindings
= binding
;
1980 /* Create a new binding for NAME (with the indicated VALUE and TYPE
1981 bindings) in the class scope indicated by SCOPE. */
1983 static cxx_binding
*
1984 new_class_binding (tree name
, tree value
, tree type
, cp_binding_level
*scope
)
1986 cp_class_binding cb
= {cxx_binding_make (value
, type
), name
};
1987 cxx_binding
*binding
= cb
.base
;
1988 vec_safe_push (scope
->class_shadowed
, cb
);
1989 binding
->scope
= scope
;
1993 /* Make DECL the innermost binding for ID. The LEVEL is the binding
1994 level at which this declaration is being bound. */
1997 push_binding (tree id
, tree decl
, cp_binding_level
* level
)
1999 cxx_binding
*binding
;
2001 if (level
!= class_binding_level
)
2003 binding
= cxx_binding_make (decl
, NULL_TREE
);
2004 binding
->scope
= level
;
2007 binding
= new_class_binding (id
, decl
, /*type=*/NULL_TREE
, level
);
2009 /* Now, fill in the binding information. */
2010 binding
->previous
= IDENTIFIER_BINDING (id
);
2011 INHERITED_VALUE_BINDING_P (binding
) = 0;
2012 LOCAL_BINDING_P (binding
) = (level
!= class_binding_level
);
2014 /* And put it on the front of the list of bindings for ID. */
2015 IDENTIFIER_BINDING (id
) = binding
;
2018 /* Remove the binding for DECL which should be the innermost binding
2022 pop_local_binding (tree id
, tree decl
)
2024 cxx_binding
*binding
;
2026 if (id
== NULL_TREE
)
2027 /* It's easiest to write the loops that call this function without
2028 checking whether or not the entities involved have names. We
2029 get here for such an entity. */
2032 /* Get the innermost binding for ID. */
2033 binding
= IDENTIFIER_BINDING (id
);
2035 /* The name should be bound. */
2036 gcc_assert (binding
!= NULL
);
2038 /* The DECL will be either the ordinary binding or the type
2039 binding for this identifier. Remove that binding. */
2040 if (binding
->value
== decl
)
2041 binding
->value
= NULL_TREE
;
2044 gcc_assert (binding
->type
== decl
);
2045 binding
->type
= NULL_TREE
;
2048 if (!binding
->value
&& !binding
->type
)
2050 /* We're completely done with the innermost binding for this
2051 identifier. Unhook it from the list of bindings. */
2052 IDENTIFIER_BINDING (id
) = binding
->previous
;
2054 /* Add it to the free list. */
2055 cxx_binding_free (binding
);
2059 /* Remove the bindings for the decls of the current level and leave
2060 the current scope. */
2063 pop_bindings_and_leave_scope (void)
2065 for (tree t
= get_local_decls (); t
; t
= DECL_CHAIN (t
))
2067 tree decl
= TREE_CODE (t
) == TREE_LIST
? TREE_VALUE (t
) : t
;
2068 tree name
= OVL_NAME (decl
);
2070 pop_local_binding (name
, decl
);
2076 /* Strip non dependent using declarations. If DECL is dependent,
2077 surreptitiously create a typename_type and return it. */
2080 strip_using_decl (tree decl
)
2082 if (decl
== NULL_TREE
)
2085 while (TREE_CODE (decl
) == USING_DECL
&& !DECL_DEPENDENT_P (decl
))
2086 decl
= USING_DECL_DECLS (decl
);
2088 if (TREE_CODE (decl
) == USING_DECL
&& DECL_DEPENDENT_P (decl
)
2089 && USING_DECL_TYPENAME_P (decl
))
2091 /* We have found a type introduced by a using
2092 declaration at class scope that refers to a dependent
2095 using typename :: [opt] nested-name-specifier unqualified-id ;
2097 decl
= make_typename_type (USING_DECL_SCOPE (decl
),
2099 typename_type
, tf_error
);
2100 if (decl
!= error_mark_node
)
2101 decl
= TYPE_NAME (decl
);
2107 /* Return true if OVL is an overload for an anticipated builtin. */
2110 anticipated_builtin_p (tree ovl
)
2112 if (TREE_CODE (ovl
) != OVERLOAD
)
2115 if (!OVL_HIDDEN_P (ovl
))
2118 tree fn
= OVL_FUNCTION (ovl
);
2119 gcc_checking_assert (DECL_ANTICIPATED (fn
));
2121 if (DECL_HIDDEN_FRIEND_P (fn
))
2127 /* BINDING records an existing declaration for a name in the current scope.
2128 But, DECL is another declaration for that same identifier in the
2129 same scope. This is the `struct stat' hack whereby a non-typedef
2130 class name or enum-name can be bound at the same level as some other
2134 A class name (9.1) or enumeration name (7.2) can be hidden by the
2135 name of an object, function, or enumerator declared in the same scope.
2136 If a class or enumeration name and an object, function, or enumerator
2137 are declared in the same scope (in any order) with the same name, the
2138 class or enumeration name is hidden wherever the object, function, or
2139 enumerator name is visible.
2141 It's the responsibility of the caller to check that
2142 inserting this name is valid here. Returns nonzero if the new binding
2146 supplement_binding_1 (cxx_binding
*binding
, tree decl
)
2148 tree bval
= binding
->value
;
2150 tree target_bval
= strip_using_decl (bval
);
2151 tree target_decl
= strip_using_decl (decl
);
2153 if (TREE_CODE (target_decl
) == TYPE_DECL
&& DECL_ARTIFICIAL (target_decl
)
2154 && target_decl
!= target_bval
2155 && (TREE_CODE (target_bval
) != TYPE_DECL
2156 /* We allow pushing an enum multiple times in a class
2157 template in order to handle late matching of underlying
2158 type on an opaque-enum-declaration followed by an
2160 || (processing_template_decl
2161 && TREE_CODE (TREE_TYPE (target_decl
)) == ENUMERAL_TYPE
2162 && TREE_CODE (TREE_TYPE (target_bval
)) == ENUMERAL_TYPE
2163 && (dependent_type_p (ENUM_UNDERLYING_TYPE
2164 (TREE_TYPE (target_decl
)))
2165 || dependent_type_p (ENUM_UNDERLYING_TYPE
2166 (TREE_TYPE (target_bval
)))))))
2167 /* The new name is the type name. */
2168 binding
->type
= decl
;
2169 else if (/* TARGET_BVAL is null when push_class_level_binding moves
2170 an inherited type-binding out of the way to make room
2171 for a new value binding. */
2173 /* TARGET_BVAL is error_mark_node when TARGET_DECL's name
2174 has been used in a non-class scope prior declaration.
2175 In that case, we should have already issued a
2176 diagnostic; for graceful error recovery purpose, pretend
2177 this was the intended declaration for that name. */
2178 || target_bval
== error_mark_node
2179 /* If TARGET_BVAL is anticipated but has not yet been
2180 declared, pretend it is not there at all. */
2181 || anticipated_builtin_p (target_bval
))
2182 binding
->value
= decl
;
2183 else if (TREE_CODE (target_bval
) == TYPE_DECL
2184 && DECL_ARTIFICIAL (target_bval
)
2185 && target_decl
!= target_bval
2186 && (TREE_CODE (target_decl
) != TYPE_DECL
2187 || same_type_p (TREE_TYPE (target_decl
),
2188 TREE_TYPE (target_bval
))))
2190 /* The old binding was a type name. It was placed in
2191 VALUE field because it was thought, at the point it was
2192 declared, to be the only entity with such a name. Move the
2193 type name into the type slot; it is now hidden by the new
2195 binding
->type
= bval
;
2196 binding
->value
= decl
;
2197 binding
->value_is_inherited
= false;
2199 else if (TREE_CODE (target_bval
) == TYPE_DECL
2200 && TREE_CODE (target_decl
) == TYPE_DECL
2201 && DECL_NAME (target_decl
) == DECL_NAME (target_bval
)
2202 && binding
->scope
->kind
!= sk_class
2203 && (same_type_p (TREE_TYPE (target_decl
), TREE_TYPE (target_bval
))
2204 /* If either type involves template parameters, we must
2205 wait until instantiation. */
2206 || uses_template_parms (TREE_TYPE (target_decl
))
2207 || uses_template_parms (TREE_TYPE (target_bval
))))
2208 /* We have two typedef-names, both naming the same type to have
2209 the same name. In general, this is OK because of:
2213 In a given scope, a typedef specifier can be used to redefine
2214 the name of any type declared in that scope to refer to the
2215 type to which it already refers.
2217 However, in class scopes, this rule does not apply due to the
2218 stricter language in [class.mem] prohibiting redeclarations of
2221 /* There can be two block-scope declarations of the same variable,
2222 so long as they are `extern' declarations. However, there cannot
2223 be two declarations of the same static data member:
2227 A member shall not be declared twice in the
2228 member-specification. */
2229 else if (VAR_P (target_decl
)
2230 && VAR_P (target_bval
)
2231 && DECL_EXTERNAL (target_decl
) && DECL_EXTERNAL (target_bval
)
2232 && !DECL_CLASS_SCOPE_P (target_decl
))
2234 duplicate_decls (decl
, binding
->value
, /*newdecl_is_friend=*/false);
2237 else if (TREE_CODE (decl
) == NAMESPACE_DECL
2238 && TREE_CODE (bval
) == NAMESPACE_DECL
2239 && DECL_NAMESPACE_ALIAS (decl
)
2240 && DECL_NAMESPACE_ALIAS (bval
)
2241 && ORIGINAL_NAMESPACE (bval
) == ORIGINAL_NAMESPACE (decl
))
2242 /* [namespace.alias]
2244 In a declarative region, a namespace-alias-definition can be
2245 used to redefine a namespace-alias declared in that declarative
2246 region to refer only to the namespace to which it already
2251 if (!error_operand_p (bval
))
2252 diagnose_name_conflict (decl
, bval
);
2259 /* Diagnose a name conflict between DECL and BVAL. */
2262 diagnose_name_conflict (tree decl
, tree bval
)
2264 if (TREE_CODE (decl
) == TREE_CODE (bval
)
2265 && TREE_CODE (decl
) != NAMESPACE_DECL
2266 && !DECL_DECLARES_FUNCTION_P (decl
)
2267 && (TREE_CODE (decl
) != TYPE_DECL
2268 || DECL_ARTIFICIAL (decl
) == DECL_ARTIFICIAL (bval
))
2269 && CP_DECL_CONTEXT (decl
) == CP_DECL_CONTEXT (bval
))
2271 if (concept_definition_p (decl
))
2272 error ("redeclaration of %q#D with different template parameters",
2275 error ("redeclaration of %q#D", decl
);
2278 error ("%q#D conflicts with a previous declaration", decl
);
2280 inform (location_of (bval
), "previous declaration %q#D", bval
);
2283 /* Wrapper for supplement_binding_1. */
2286 supplement_binding (cxx_binding
*binding
, tree decl
)
2289 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
2290 ret
= supplement_binding_1 (binding
, decl
);
2291 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
2295 /* Replace BINDING's current value on its scope's name list with
2299 update_local_overload (cxx_binding
*binding
, tree newval
)
2303 for (d
= &binding
->scope
->names
; ; d
= &TREE_CHAIN (*d
))
2304 if (*d
== binding
->value
)
2306 /* Stitch new list node in. */
2307 *d
= tree_cons (NULL_TREE
, NULL_TREE
, TREE_CHAIN (*d
));
2310 else if (TREE_CODE (*d
) == TREE_LIST
&& TREE_VALUE (*d
) == binding
->value
)
2313 TREE_VALUE (*d
) = newval
;
2316 /* Compares the parameter-type-lists of ONE and TWO and
2317 returns false if they are different. If the DECLs are template
2318 functions, the return types and the template parameter lists are
2319 compared too (DR 565). */
2322 matching_fn_p (tree one
, tree two
)
2324 if (!compparms (TYPE_ARG_TYPES (TREE_TYPE (one
)),
2325 TYPE_ARG_TYPES (TREE_TYPE (two
))))
2328 if (TREE_CODE (one
) == TEMPLATE_DECL
2329 && TREE_CODE (two
) == TEMPLATE_DECL
)
2331 /* Compare template parms. */
2332 if (!comp_template_parms (DECL_TEMPLATE_PARMS (one
),
2333 DECL_TEMPLATE_PARMS (two
)))
2336 /* And return type. */
2337 if (!same_type_p (TREE_TYPE (TREE_TYPE (one
)),
2338 TREE_TYPE (TREE_TYPE (two
))))
2342 if (!equivalently_constrained (one
, two
))
2348 /* Push DECL into nonclass LEVEL BINDING or SLOT. OLD is the current
2349 binding value (possibly with anticipated builtins stripped).
2350 Diagnose conflicts and return updated decl. */
2353 update_binding (cp_binding_level
*level
, cxx_binding
*binding
, tree
*slot
,
2354 tree old
, tree decl
, bool is_friend
)
2357 tree old_type
= slot
? MAYBE_STAT_TYPE (*slot
) : binding
->type
;
2358 tree to_type
= old_type
;
2360 gcc_assert (level
->kind
== sk_namespace
? !binding
2361 : level
->kind
!= sk_class
&& !slot
);
2362 if (old
== error_mark_node
)
2365 if (TREE_CODE (decl
) == TYPE_DECL
&& DECL_ARTIFICIAL (decl
))
2367 tree other
= to_type
;
2369 if (old
&& TREE_CODE (old
) == TYPE_DECL
&& DECL_ARTIFICIAL (old
))
2372 /* Pushing an artificial typedef. See if this matches either
2373 the type slot or the old value slot. */
2376 else if (same_type_p (TREE_TYPE (other
), TREE_TYPE (decl
)))
2377 /* Two artificial decls to same type. Do nothing. */
2384 /* Slide decl into the type slot, keep old unaltered */
2391 if (old
&& TREE_CODE (old
) == TYPE_DECL
&& DECL_ARTIFICIAL (old
))
2393 /* Slide old into the type slot. */
2398 if (DECL_DECLARES_FUNCTION_P (decl
))
2402 else if (OVL_P (old
))
2404 for (ovl_iterator
iter (old
); iter
; ++iter
)
2408 if (iter
.using_p () && matching_fn_p (fn
, decl
))
2410 /* If a function declaration in namespace scope or
2411 block scope has the same name and the same
2412 parameter-type- list (8.3.5) as a function
2413 introduced by a using-declaration, and the
2414 declarations do not declare the same function,
2415 the program is ill-formed. [namespace.udecl]/14 */
2416 if (tree match
= duplicate_decls (decl
, fn
, is_friend
))
2419 /* FIXME: To preserve existing error behavior, we
2420 still push the decl. This might change. */
2421 diagnose_name_conflict (decl
, fn
);
2428 if (to_type
!= old_type
2430 && MAYBE_CLASS_TYPE_P (TREE_TYPE (to_type
))
2431 && !(DECL_IN_SYSTEM_HEADER (decl
)
2432 && DECL_IN_SYSTEM_HEADER (to_type
)))
2433 warning (OPT_Wshadow
, "%q#D hides constructor for %q#D",
2436 to_val
= ovl_insert (decl
, old
);
2440 else if (TREE_CODE (old
) != TREE_CODE (decl
))
2441 /* Different kinds of decls conflict. */
2443 else if (TREE_CODE (old
) == TYPE_DECL
)
2445 if (same_type_p (TREE_TYPE (old
), TREE_TYPE (decl
)))
2446 /* Two type decls to the same type. Do nothing. */
2451 else if (TREE_CODE (old
) == NAMESPACE_DECL
)
2453 /* Two maybe-aliased namespaces. If they're to the same target
2454 namespace, that's ok. */
2455 if (ORIGINAL_NAMESPACE (old
) != ORIGINAL_NAMESPACE (decl
))
2458 /* The new one must be an alias at this point. */
2459 gcc_assert (DECL_NAMESPACE_ALIAS (decl
));
2462 else if (TREE_CODE (old
) == VAR_DECL
)
2464 /* There can be two block-scope declarations of the same
2465 variable, so long as they are `extern' declarations. */
2466 if (!DECL_EXTERNAL (old
) || !DECL_EXTERNAL (decl
))
2468 else if (tree match
= duplicate_decls (decl
, old
, false))
2476 diagnose_name_conflict (decl
, old
);
2483 if (level
->kind
== sk_namespace
|| to_type
== decl
|| to_val
== decl
)
2484 add_decl_to_level (level
, decl
);
2487 gcc_checking_assert (binding
->value
&& OVL_P (binding
->value
));
2488 update_local_overload (binding
, to_val
);
2493 if (STAT_HACK_P (*slot
))
2495 STAT_TYPE (*slot
) = to_type
;
2496 STAT_DECL (*slot
) = to_val
;
2499 *slot
= stat_hack (to_val
, to_type
);
2505 binding
->type
= to_type
;
2506 binding
->value
= to_val
;
2513 /* Table of identifiers to extern C declarations (or LISTS thereof). */
2515 static GTY(()) hash_table
<named_decl_hash
> *extern_c_decls
;
2517 /* DECL has C linkage. If we have an existing instance, make sure the
2518 new one is compatible. Make sure it has the same exception
2519 specification [7.5, 7.6]. Add DECL to the map. */
2522 check_extern_c_conflict (tree decl
)
2524 /* Ignore artificial or system header decls. */
2525 if (DECL_ARTIFICIAL (decl
) || DECL_IN_SYSTEM_HEADER (decl
))
2528 /* This only applies to decls at namespace scope. */
2529 if (!DECL_NAMESPACE_SCOPE_P (decl
))
2532 if (!extern_c_decls
)
2533 extern_c_decls
= hash_table
<named_decl_hash
>::create_ggc (127);
2535 tree
*slot
= extern_c_decls
2536 ->find_slot_with_hash (DECL_NAME (decl
),
2537 IDENTIFIER_HASH_VALUE (DECL_NAME (decl
)), INSERT
);
2538 if (tree old
= *slot
)
2540 if (TREE_CODE (old
) == OVERLOAD
)
2541 old
= OVL_FUNCTION (old
);
2544 if (DECL_CONTEXT (old
) == DECL_CONTEXT (decl
))
2545 ; /* If they're in the same context, we'll have already complained
2546 about a (possible) mismatch, when inserting the decl. */
2547 else if (!decls_match (decl
, old
))
2549 else if (TREE_CODE (decl
) == FUNCTION_DECL
2550 && !comp_except_specs (TYPE_RAISES_EXCEPTIONS (TREE_TYPE (old
)),
2551 TYPE_RAISES_EXCEPTIONS (TREE_TYPE (decl
)),
2554 else if (DECL_ASSEMBLER_NAME_SET_P (old
))
2555 SET_DECL_ASSEMBLER_NAME (decl
, DECL_ASSEMBLER_NAME (old
));
2559 auto_diagnostic_group d
;
2560 pedwarn (DECL_SOURCE_LOCATION (decl
), 0,
2561 "conflicting C language linkage declaration %q#D", decl
);
2562 inform (DECL_SOURCE_LOCATION (old
),
2563 "previous declaration %q#D", old
);
2565 inform (DECL_SOURCE_LOCATION (decl
),
2566 "due to different exception specifications");
2571 /* The hash table expects OVERLOADS, so construct one with
2572 OLD as both the function and the chain. This allocate
2573 an excess OVERLOAD node, but it's rare to have multiple
2574 extern "C" decls of the same name. And we save
2575 complicating the hash table logic (which is used
2577 *slot
= ovl_make (old
, old
);
2579 slot
= &OVL_CHAIN (*slot
);
2581 /* Chain it on for c_linkage_binding's use. */
2582 *slot
= tree_cons (NULL_TREE
, decl
, *slot
);
2589 /* Returns a list of C-linkage decls with the name NAME. Used in
2590 c-family/c-pragma.c to implement redefine_extname pragma. */
2593 c_linkage_bindings (tree name
)
2596 if (tree
*slot
= extern_c_decls
2597 ->find_slot_with_hash (name
, IDENTIFIER_HASH_VALUE (name
), NO_INSERT
))
2599 tree result
= *slot
;
2600 if (TREE_CODE (result
) == OVERLOAD
)
2601 result
= OVL_CHAIN (result
);
2608 /* Subroutine of check_local_shadow. */
2611 inform_shadowed (tree shadowed
)
2613 inform (DECL_SOURCE_LOCATION (shadowed
),
2614 "shadowed declaration is here");
2617 /* DECL is being declared at a local scope. Emit suitable shadow
2621 check_local_shadow (tree decl
)
2623 /* Don't complain about the parms we push and then pop
2624 while tentatively parsing a function declarator. */
2625 if (TREE_CODE (decl
) == PARM_DECL
&& !DECL_CONTEXT (decl
))
2628 /* External decls are something else. */
2629 if (DECL_EXTERNAL (decl
))
2632 tree old
= NULL_TREE
;
2633 cp_binding_level
*old_scope
= NULL
;
2634 if (cxx_binding
*binding
= outer_binding (DECL_NAME (decl
), NULL
, true))
2636 old
= binding
->value
;
2637 old_scope
= binding
->scope
;
2641 && (TREE_CODE (old
) == PARM_DECL
2643 || (TREE_CODE (old
) == TYPE_DECL
2644 && (!DECL_ARTIFICIAL (old
)
2645 || TREE_CODE (decl
) == TYPE_DECL
)))
2646 && DECL_FUNCTION_SCOPE_P (old
)
2647 && (!DECL_ARTIFICIAL (decl
)
2648 || is_capture_proxy (decl
)
2649 || DECL_IMPLICIT_TYPEDEF_P (decl
)
2650 || (VAR_P (decl
) && DECL_ANON_UNION_VAR_P (decl
))))
2652 /* DECL shadows a local thing possibly of interest. */
2654 /* DR 2211: check that captures and parameters
2655 do not have the same name. */
2656 if (is_capture_proxy (decl
))
2658 if (current_lambda_expr ()
2659 && DECL_CONTEXT (old
) == lambda_function (current_lambda_expr ())
2660 && TREE_CODE (old
) == PARM_DECL
2661 && DECL_NAME (decl
) != this_identifier
)
2663 error_at (DECL_SOURCE_LOCATION (old
),
2664 "lambda parameter %qD "
2665 "previously declared as a capture", old
);
2669 /* Don't complain if it's from an enclosing function. */
2670 else if (DECL_CONTEXT (old
) == current_function_decl
2671 && TREE_CODE (decl
) != PARM_DECL
2672 && TREE_CODE (old
) == PARM_DECL
)
2674 /* Go to where the parms should be and see if we find
2676 cp_binding_level
*b
= current_binding_level
->level_chain
;
2678 if (FUNCTION_NEEDS_BODY_BLOCK (current_function_decl
))
2679 /* Skip the ctor/dtor cleanup level. */
2683 if (b
->kind
== sk_function_parms
)
2685 error_at (DECL_SOURCE_LOCATION (decl
),
2686 "declaration of %q#D shadows a parameter", decl
);
2691 /* The local structure or class can't use parameters of
2692 the containing function anyway. */
2693 if (DECL_CONTEXT (old
) != current_function_decl
)
2695 for (cp_binding_level
*scope
= current_binding_level
;
2696 scope
!= old_scope
; scope
= scope
->level_chain
)
2697 if (scope
->kind
== sk_class
2698 && !LAMBDA_TYPE_P (scope
->this_entity
))
2701 /* Error if redeclaring a local declared in a
2702 init-statement or in the condition of an if or
2703 switch statement when the new declaration is in the
2704 outermost block of the controlled statement.
2705 Redeclaring a variable from a for or while condition is
2706 detected elsewhere. */
2707 else if (VAR_P (old
)
2708 && old_scope
== current_binding_level
->level_chain
2709 && (old_scope
->kind
== sk_cond
|| old_scope
->kind
== sk_for
))
2711 auto_diagnostic_group d
;
2712 error_at (DECL_SOURCE_LOCATION (decl
),
2713 "redeclaration of %q#D", decl
);
2714 inform (DECL_SOURCE_LOCATION (old
),
2715 "%q#D previously declared here", old
);
2719 3.3.3/3: The name declared in an exception-declaration (...)
2720 shall not be redeclared in the outermost block of the handler.
2721 3.3.3/2: A parameter name shall not be redeclared (...) in
2722 the outermost block of any handler associated with a
2724 3.4.1/15: The function parameter names shall not be redeclared
2725 in the exception-declaration nor in the outermost block of a
2726 handler for the function-try-block. */
2727 else if ((TREE_CODE (old
) == VAR_DECL
2728 && old_scope
== current_binding_level
->level_chain
2729 && old_scope
->kind
== sk_catch
)
2730 || (TREE_CODE (old
) == PARM_DECL
2731 && (current_binding_level
->kind
== sk_catch
2732 || current_binding_level
->level_chain
->kind
== sk_catch
)
2733 && in_function_try_handler
))
2735 auto_diagnostic_group d
;
2736 if (permerror (DECL_SOURCE_LOCATION (decl
),
2737 "redeclaration of %q#D", decl
))
2738 inform (DECL_SOURCE_LOCATION (old
),
2739 "%q#D previously declared here", old
);
2743 /* If '-Wshadow=compatible-local' is specified without other
2744 -Wshadow= flags, we will warn only when the type of the
2745 shadowing variable (DECL) can be converted to that of the
2746 shadowed parameter (OLD_LOCAL). The reason why we only check
2747 if DECL's type can be converted to OLD_LOCAL's type (but not the
2748 other way around) is because when users accidentally shadow a
2749 parameter, more than often they would use the variable
2750 thinking (mistakenly) it's still the parameter. It would be
2751 rare that users would use the variable in the place that
2752 expects the parameter but thinking it's a new decl.
2753 If either object is a TYPE_DECL, '-Wshadow=compatible-local'
2754 warns regardless of whether one of the types involved
2755 is a subclass of the other, since that is never okay. */
2757 enum opt_code warning_code
;
2759 warning_code
= OPT_Wshadow
;
2760 else if (same_type_p (TREE_TYPE (old
), TREE_TYPE (decl
))
2761 || TREE_CODE (decl
) == TYPE_DECL
2762 || TREE_CODE (old
) == TYPE_DECL
2763 || (!dependent_type_p (TREE_TYPE (decl
))
2764 && !dependent_type_p (TREE_TYPE (old
))
2765 /* If the new decl uses auto, we don't yet know
2766 its type (the old type cannot be using auto
2767 at this point, without also being
2768 dependent). This is an indication we're
2769 (now) doing the shadow checking too
2771 && !type_uses_auto (TREE_TYPE (decl
))
2772 && can_convert_arg (TREE_TYPE (old
), TREE_TYPE (decl
),
2773 decl
, LOOKUP_IMPLICIT
, tf_none
)))
2774 warning_code
= OPT_Wshadow_compatible_local
;
2776 warning_code
= OPT_Wshadow_local
;
2779 if (TREE_CODE (old
) == PARM_DECL
)
2780 msg
= "declaration of %q#D shadows a parameter";
2781 else if (is_capture_proxy (old
))
2782 msg
= "declaration of %qD shadows a lambda capture";
2784 msg
= "declaration of %qD shadows a previous local";
2786 auto_diagnostic_group d
;
2787 if (warning_at (DECL_SOURCE_LOCATION (decl
), warning_code
, msg
, decl
))
2788 inform_shadowed (old
);
2795 /* Don't warn for artificial things that are not implicit typedefs. */
2796 if (DECL_ARTIFICIAL (decl
) && !DECL_IMPLICIT_TYPEDEF_P (decl
))
2799 if (nonlambda_method_basetype ())
2800 if (tree member
= lookup_member (current_nonlambda_class_type (),
2801 DECL_NAME (decl
), /*protect=*/0,
2802 /*want_type=*/false, tf_warning_or_error
))
2804 member
= MAYBE_BASELINK_FUNCTIONS (member
);
2806 /* Warn if a variable shadows a non-function, or the variable
2807 is a function or a pointer-to-function. */
2809 || TREE_CODE (decl
) == FUNCTION_DECL
2810 || TYPE_PTRFN_P (TREE_TYPE (decl
))
2811 || TYPE_PTRMEMFUNC_P (TREE_TYPE (decl
)))
2813 auto_diagnostic_group d
;
2814 if (warning_at (DECL_SOURCE_LOCATION (decl
), OPT_Wshadow
,
2815 "declaration of %qD shadows a member of %qT",
2816 decl
, current_nonlambda_class_type ())
2818 inform_shadowed (member
);
2823 /* Now look for a namespace shadow. */
2824 old
= find_namespace_value (current_namespace
, DECL_NAME (decl
));
2827 || (TREE_CODE (old
) == TYPE_DECL
2828 && (!DECL_ARTIFICIAL (old
)
2829 || TREE_CODE (decl
) == TYPE_DECL
)))
2830 && !instantiating_current_function_p ())
2831 /* XXX shadow warnings in outer-more namespaces */
2833 auto_diagnostic_group d
;
2834 if (warning_at (DECL_SOURCE_LOCATION (decl
), OPT_Wshadow
,
2835 "declaration of %qD shadows a global declaration",
2837 inform_shadowed (old
);
2844 /* DECL is being pushed inside function CTX. Set its context, if
2848 set_decl_context_in_fn (tree ctx
, tree decl
)
2850 if (!DECL_CONTEXT (decl
)
2851 /* A local declaration for a function doesn't constitute
2853 && TREE_CODE (decl
) != FUNCTION_DECL
2854 /* A local declaration for an `extern' variable is in the
2855 scope of the current namespace, not the current
2857 && !(VAR_P (decl
) && DECL_EXTERNAL (decl
))
2858 /* When parsing the parameter list of a function declarator,
2859 don't set DECL_CONTEXT to an enclosing function. When we
2860 push the PARM_DECLs in order to process the function body,
2861 current_binding_level->this_entity will be set. */
2862 && !(TREE_CODE (decl
) == PARM_DECL
2863 && current_binding_level
->kind
== sk_function_parms
2864 && current_binding_level
->this_entity
== NULL
))
2865 DECL_CONTEXT (decl
) = ctx
;
2867 /* If this is the declaration for a namespace-scope function,
2868 but the declaration itself is in a local scope, mark the
2870 if (TREE_CODE (decl
) == FUNCTION_DECL
&& DECL_NAMESPACE_SCOPE_P (decl
))
2871 DECL_LOCAL_FUNCTION_P (decl
) = 1;
2874 /* DECL is a local-scope decl with linkage. SHADOWED is true if the
2875 name is already bound at the current level.
2877 [basic.link] If there is a visible declaration of an entity with
2878 linkage having the same name and type, ignoring entities declared
2879 outside the innermost enclosing namespace scope, the block scope
2880 declaration declares that same entity and receives the linkage of
2881 the previous declaration.
2883 Also, make sure that this decl matches any existing external decl
2884 in the enclosing namespace. */
2887 set_local_extern_decl_linkage (tree decl
, bool shadowed
)
2889 tree ns_value
= decl
; /* Unique marker. */
2893 tree loc_value
= innermost_non_namespace_value (DECL_NAME (decl
));
2897 = find_namespace_value (current_namespace
, DECL_NAME (decl
));
2898 loc_value
= ns_value
;
2900 if (loc_value
== error_mark_node
2901 /* An ambiguous lookup. */
2902 || (loc_value
&& TREE_CODE (loc_value
) == TREE_LIST
))
2903 loc_value
= NULL_TREE
;
2905 for (ovl_iterator
iter (loc_value
); iter
; ++iter
)
2906 if (!iter
.hidden_p ()
2907 && (TREE_STATIC (*iter
) || DECL_EXTERNAL (*iter
))
2908 && decls_match (*iter
, decl
))
2910 /* The standard only says that the local extern inherits
2911 linkage from the previous decl; in particular, default
2912 args are not shared. Add the decl into a hash table to
2913 make sure only the previous decl in this case is seen
2914 by the middle end. */
2915 struct cxx_int_tree_map
*h
;
2917 /* We inherit the outer decl's linkage. But we're a
2919 TREE_PUBLIC (decl
) = TREE_PUBLIC (*iter
);
2921 if (cp_function_chain
->extern_decl_map
== NULL
)
2922 cp_function_chain
->extern_decl_map
2923 = hash_table
<cxx_int_tree_map_hasher
>::create_ggc (20);
2925 h
= ggc_alloc
<cxx_int_tree_map
> ();
2926 h
->uid
= DECL_UID (decl
);
2928 cxx_int_tree_map
**loc
= cp_function_chain
->extern_decl_map
2929 ->find_slot (h
, INSERT
);
2935 if (TREE_PUBLIC (decl
))
2937 /* DECL is externally visible. Make sure it matches a matching
2938 decl in the namespace scope. We only really need to check
2939 this when inserting the decl, not when we find an existing
2940 match in the current scope. However, in practice we're
2941 going to be inserting a new decl in the majority of cases --
2942 who writes multiple extern decls for the same thing in the
2943 same local scope? Doing it here often avoids a duplicate
2944 namespace lookup. */
2946 /* Avoid repeating a lookup. */
2947 if (ns_value
== decl
)
2948 ns_value
= find_namespace_value (current_namespace
, DECL_NAME (decl
));
2950 if (ns_value
== error_mark_node
2951 || (ns_value
&& TREE_CODE (ns_value
) == TREE_LIST
))
2952 ns_value
= NULL_TREE
;
2954 for (ovl_iterator
iter (ns_value
); iter
; ++iter
)
2958 if (!(TREE_PUBLIC (other
) || DECL_EXTERNAL (other
)))
2959 ; /* Not externally visible. */
2960 else if (DECL_EXTERN_C_P (decl
) && DECL_EXTERN_C_P (other
))
2961 ; /* Both are extern "C", we'll check via that mechanism. */
2962 else if (TREE_CODE (other
) != TREE_CODE (decl
)
2963 || ((VAR_P (decl
) || matching_fn_p (other
, decl
))
2964 && !comptypes (TREE_TYPE (decl
), TREE_TYPE (other
),
2965 COMPARE_REDECLARATION
)))
2967 auto_diagnostic_group d
;
2968 if (permerror (DECL_SOURCE_LOCATION (decl
),
2969 "local external declaration %q#D", decl
))
2970 inform (DECL_SOURCE_LOCATION (other
),
2971 "does not match previous declaration %q#D", other
);
2978 /* Record DECL as belonging to the current lexical scope. Check for
2979 errors (such as an incompatible declaration for the same name
2980 already seen in the same scope). IS_FRIEND is true if DECL is
2981 declared as a friend.
2983 Returns either DECL or an old decl for the same name. If an old
2984 decl is returned, it may have been smashed to agree with what DECL
2988 do_pushdecl (tree decl
, bool is_friend
)
2990 if (decl
== error_mark_node
)
2991 return error_mark_node
;
2993 if (!DECL_TEMPLATE_PARM_P (decl
) && current_function_decl
)
2994 set_decl_context_in_fn (current_function_decl
, decl
);
2996 /* The binding level we will be pushing into. During local class
2997 pushing, we want to push to the containing scope. */
2998 cp_binding_level
*level
= current_binding_level
;
2999 while (level
->kind
== sk_class
)
3000 level
= level
->level_chain
;
3002 /* An anonymous namespace has a NULL DECL_NAME, but we still want to
3003 insert it. Other NULL-named decls, not so much. */
3004 tree name
= DECL_NAME (decl
);
3005 if (name
|| TREE_CODE (decl
) == NAMESPACE_DECL
)
3007 cxx_binding
*binding
= NULL
; /* Local scope binding. */
3008 tree ns
= NULL_TREE
; /* Searched namespace. */
3009 tree
*slot
= NULL
; /* Binding slot in namespace. */
3010 tree old
= NULL_TREE
;
3012 if (level
->kind
== sk_namespace
)
3014 /* We look in the decl's namespace for an existing
3015 declaration, even though we push into the current
3017 ns
= (DECL_NAMESPACE_SCOPE_P (decl
)
3018 ? CP_DECL_CONTEXT (decl
) : current_namespace
);
3019 /* Create the binding, if this is current namespace, because
3020 that's where we'll be pushing anyway. */
3021 slot
= find_namespace_slot (ns
, name
, ns
== current_namespace
);
3023 old
= MAYBE_STAT_DECL (*slot
);
3027 binding
= find_local_binding (level
, name
);
3029 old
= binding
->value
;
3032 if (current_function_decl
&& VAR_OR_FUNCTION_DECL_P (decl
)
3033 && DECL_EXTERNAL (decl
))
3034 set_local_extern_decl_linkage (decl
, old
!= NULL_TREE
);
3036 if (old
== error_mark_node
)
3039 for (ovl_iterator
iter (old
); iter
; ++iter
)
3040 if (iter
.using_p ())
3041 ; /* Ignore using decls here. */
3042 else if (tree match
= duplicate_decls (decl
, *iter
, is_friend
))
3044 if (match
== error_mark_node
)
3046 else if (TREE_CODE (match
) == TYPE_DECL
)
3047 /* The IDENTIFIER will have the type referring to the
3048 now-smashed TYPE_DECL, because ...? Reset it. */
3049 SET_IDENTIFIER_TYPE_VALUE (name
, TREE_TYPE (match
));
3050 else if (iter
.hidden_p () && !DECL_HIDDEN_P (match
))
3052 /* Unhiding a previously hidden decl. */
3053 tree head
= iter
.reveal_node (old
);
3058 update_local_overload (binding
, head
);
3059 binding
->value
= head
;
3061 else if (STAT_HACK_P (*slot
))
3062 STAT_DECL (*slot
) = head
;
3066 if (DECL_EXTERN_C_P (match
))
3067 /* We need to check and register the decl now. */
3068 check_extern_c_conflict (match
);
3073 /* We are pushing a new decl. */
3075 /* Skip a hidden builtin we failed to match already. There can
3077 if (old
&& anticipated_builtin_p (old
))
3078 old
= OVL_CHAIN (old
);
3080 check_template_shadow (decl
);
3082 if (DECL_DECLARES_FUNCTION_P (decl
))
3084 check_default_args (decl
);
3088 if (level
->kind
!= sk_namespace
)
3090 /* In a local class, a friend function declaration must
3091 find a matching decl in the innermost non-class scope.
3092 [class.friend/11] */
3093 error_at (DECL_SOURCE_LOCATION (decl
),
3094 "friend declaration %qD in local class without "
3095 "prior local declaration", decl
);
3096 /* Don't attempt to push it. */
3097 return error_mark_node
;
3099 /* Hide it from ordinary lookup. */
3100 DECL_ANTICIPATED (decl
) = DECL_HIDDEN_FRIEND_P (decl
) = true;
3104 if (level
->kind
!= sk_namespace
)
3106 check_local_shadow (decl
);
3108 if (TREE_CODE (decl
) == NAMESPACE_DECL
)
3109 /* A local namespace alias. */
3110 set_identifier_type_value (name
, NULL_TREE
);
3113 binding
= create_local_binding (level
, name
);
3117 ns
= current_namespace
;
3118 slot
= find_namespace_slot (ns
, name
, true);
3119 /* Update OLD to reflect the namespace we're going to be
3121 old
= MAYBE_STAT_DECL (*slot
);
3124 old
= update_binding (level
, binding
, slot
, old
, decl
, is_friend
);
3127 /* An existing decl matched, use it. */
3129 else if (TREE_CODE (decl
) == TYPE_DECL
)
3131 tree type
= TREE_TYPE (decl
);
3133 if (type
!= error_mark_node
)
3135 if (TYPE_NAME (type
) != decl
)
3136 set_underlying_type (decl
);
3139 set_identifier_type_value_with_scope (name
, decl
, level
);
3141 SET_IDENTIFIER_TYPE_VALUE (name
, global_type_node
);
3144 /* If this is a locally defined typedef in a function that
3145 is not a template instantation, record it to implement
3146 -Wunused-local-typedefs. */
3147 if (!instantiating_current_function_p ())
3148 record_locally_defined_typedef (decl
);
3150 else if (VAR_P (decl
))
3151 maybe_register_incomplete_var (decl
);
3153 if ((VAR_P (decl
) || TREE_CODE (decl
) == FUNCTION_DECL
)
3154 && DECL_EXTERN_C_P (decl
))
3155 check_extern_c_conflict (decl
);
3158 add_decl_to_level (level
, decl
);
3163 /* Record a decl-node X as belonging to the current lexical scope.
3164 It's a friend if IS_FRIEND is true -- which affects exactly where
3168 pushdecl (tree x
, bool is_friend
)
3170 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
3171 tree ret
= do_pushdecl (x
, is_friend
);
3172 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
3176 /* Enter DECL into the symbol table, if that's appropriate. Returns
3177 DECL, or a modified version thereof. */
3180 maybe_push_decl (tree decl
)
3182 tree type
= TREE_TYPE (decl
);
3184 /* Add this decl to the current binding level, but not if it comes
3185 from another scope, e.g. a static member variable. TEM may equal
3186 DECL or it may be a previous decl of the same name. */
3187 if (decl
== error_mark_node
3188 || (TREE_CODE (decl
) != PARM_DECL
3189 && DECL_CONTEXT (decl
) != NULL_TREE
3190 /* Definitions of namespace members outside their namespace are
3192 && !DECL_NAMESPACE_SCOPE_P (decl
))
3193 || (TREE_CODE (decl
) == TEMPLATE_DECL
&& !namespace_bindings_p ())
3194 || type
== unknown_type_node
3195 /* The declaration of a template specialization does not affect
3196 the functions available for overload resolution, so we do not
3198 || (TREE_CODE (decl
) == FUNCTION_DECL
3199 && DECL_TEMPLATE_SPECIALIZATION (decl
)))
3202 return pushdecl (decl
);
3205 /* Bind DECL to ID in the current_binding_level, assumed to be a local
3206 binding level. If IS_USING is true, DECL got here through a
3207 using-declaration. */
3210 push_local_binding (tree id
, tree decl
, bool is_using
)
3212 /* Skip over any local classes. This makes sense if we call
3213 push_local_binding with a friend decl of a local class. */
3214 cp_binding_level
*b
= innermost_nonclass_level ();
3216 gcc_assert (b
->kind
!= sk_namespace
);
3217 if (find_local_binding (b
, id
))
3219 /* Supplement the existing binding. */
3220 if (!supplement_binding (IDENTIFIER_BINDING (id
), decl
))
3221 /* It didn't work. Something else must be bound at this
3222 level. Do not add DECL to the list of things to pop
3227 /* Create a new binding. */
3228 push_binding (id
, decl
, b
);
3230 if (TREE_CODE (decl
) == OVERLOAD
|| is_using
)
3231 /* We must put the OVERLOAD or using into a TREE_LIST since we
3232 cannot use the decl's chain itself. */
3233 decl
= build_tree_list (NULL_TREE
, decl
);
3235 /* And put DECL on the list of things declared by the current
3237 add_decl_to_level (b
, decl
);
3241 /* true means unconditionally make a BLOCK for the next level pushed. */
3243 static bool keep_next_level_flag
;
3245 static int binding_depth
= 0;
3252 for (i
= 0; i
< depth
* 2; i
++)
3256 /* Return a string describing the kind of SCOPE we have. */
3258 cp_binding_level_descriptor (cp_binding_level
*scope
)
3260 /* The order of this table must match the "scope_kind"
3262 static const char* scope_kind_names
[] = {
3268 "function-parameter-scope",
3271 "template-parameter-scope",
3272 "template-explicit-spec-scope"
3274 const scope_kind kind
= scope
->explicit_spec_p
3275 ? sk_template_spec
: scope
->kind
;
3277 return scope_kind_names
[kind
];
3280 /* Output a debugging information about SCOPE when performing
3283 cp_binding_level_debug (cp_binding_level
*scope
, int line
, const char *action
)
3285 const char *desc
= cp_binding_level_descriptor (scope
);
3286 if (scope
->this_entity
)
3287 verbatim ("%s %<%s(%E)%> %p %d", action
, desc
,
3288 scope
->this_entity
, (void *) scope
, line
);
3290 verbatim ("%s %s %p %d", action
, desc
, (void *) scope
, line
);
3293 /* A chain of binding_level structures awaiting reuse. */
3295 static GTY((deletable
)) cp_binding_level
*free_binding_level
;
3297 /* Insert SCOPE as the innermost binding level. */
3300 push_binding_level (cp_binding_level
*scope
)
3302 /* Add it to the front of currently active scopes stack. */
3303 scope
->level_chain
= current_binding_level
;
3304 current_binding_level
= scope
;
3305 keep_next_level_flag
= false;
3307 if (ENABLE_SCOPE_CHECKING
)
3309 scope
->binding_depth
= binding_depth
;
3310 indent (binding_depth
);
3311 cp_binding_level_debug (scope
, LOCATION_LINE (input_location
),
3317 /* Create a new KIND scope and make it the top of the active scopes stack.
3318 ENTITY is the scope of the associated C++ entity (namespace, class,
3319 function, C++0x enumeration); it is NULL otherwise. */
3322 begin_scope (scope_kind kind
, tree entity
)
3324 cp_binding_level
*scope
;
3326 /* Reuse or create a struct for this binding level. */
3327 if (!ENABLE_SCOPE_CHECKING
&& free_binding_level
)
3329 scope
= free_binding_level
;
3330 free_binding_level
= scope
->level_chain
;
3331 memset (scope
, 0, sizeof (cp_binding_level
));
3334 scope
= ggc_cleared_alloc
<cp_binding_level
> ();
3336 scope
->this_entity
= entity
;
3337 scope
->more_cleanups_ok
= true;
3344 case sk_template_spec
:
3345 scope
->explicit_spec_p
= true;
3346 kind
= sk_template_parms
;
3348 case sk_template_parms
:
3355 case sk_scoped_enum
:
3356 case sk_function_parms
:
3357 case sk_transaction
:
3359 scope
->keep
= keep_next_level_flag
;
3363 NAMESPACE_LEVEL (entity
) = scope
;
3367 /* Should not happen. */
3373 push_binding_level (scope
);
3378 /* We're about to leave current scope. Pop the top of the stack of
3379 currently active scopes. Return the enclosing scope, now active. */
3384 cp_binding_level
*scope
= current_binding_level
;
3386 if (scope
->kind
== sk_namespace
&& class_binding_level
)
3387 current_binding_level
= class_binding_level
;
3389 /* We cannot leave a scope, if there are none left. */
3390 if (NAMESPACE_LEVEL (global_namespace
))
3391 gcc_assert (!global_scope_p (scope
));
3393 if (ENABLE_SCOPE_CHECKING
)
3395 indent (--binding_depth
);
3396 cp_binding_level_debug (scope
, LOCATION_LINE (input_location
),
3400 /* Move one nesting level up. */
3401 current_binding_level
= scope
->level_chain
;
3403 /* Namespace-scopes are left most probably temporarily, not
3404 completely; they can be reopened later, e.g. in namespace-extension
3405 or any name binding activity that requires us to resume a
3406 namespace. For classes, we cache some binding levels. For other
3407 scopes, we just make the structure available for reuse. */
3408 if (scope
->kind
!= sk_namespace
3409 && scope
!= previous_class_level
)
3411 scope
->level_chain
= free_binding_level
;
3412 gcc_assert (!ENABLE_SCOPE_CHECKING
3413 || scope
->binding_depth
== binding_depth
);
3414 free_binding_level
= scope
;
3417 if (scope
->kind
== sk_class
)
3419 /* Reset DEFINING_CLASS_P to allow for reuse of a
3420 class-defining scope in a non-defining context. */
3421 scope
->defining_class_p
= 0;
3423 /* Find the innermost enclosing class scope, and reset
3424 CLASS_BINDING_LEVEL appropriately. */
3425 class_binding_level
= NULL
;
3426 for (scope
= current_binding_level
; scope
; scope
= scope
->level_chain
)
3427 if (scope
->kind
== sk_class
)
3429 class_binding_level
= scope
;
3434 return current_binding_level
;
3437 /* When we exit a toplevel class scope, we save its binding level so
3438 that we can restore it quickly. Here, we've entered some other
3439 class, so we must invalidate our cache. */
3442 invalidate_class_lookup_cache (void)
3444 previous_class_level
->level_chain
= free_binding_level
;
3445 free_binding_level
= previous_class_level
;
3446 previous_class_level
= NULL
;
3450 resume_scope (cp_binding_level
* b
)
3452 /* Resuming binding levels is meant only for namespaces,
3453 and those cannot nest into classes. */
3454 gcc_assert (!class_binding_level
);
3455 /* Also, resuming a non-directly nested namespace is a no-no. */
3456 gcc_assert (b
->level_chain
== current_binding_level
);
3457 current_binding_level
= b
;
3458 if (ENABLE_SCOPE_CHECKING
)
3460 b
->binding_depth
= binding_depth
;
3461 indent (binding_depth
);
3462 cp_binding_level_debug (b
, LOCATION_LINE (input_location
), "resume");
3467 /* Return the innermost binding level that is not for a class scope. */
3469 static cp_binding_level
*
3470 innermost_nonclass_level (void)
3472 cp_binding_level
*b
;
3474 b
= current_binding_level
;
3475 while (b
->kind
== sk_class
)
3481 /* We're defining an object of type TYPE. If it needs a cleanup, but
3482 we're not allowed to add any more objects with cleanups to the current
3483 scope, create a new binding level. */
3486 maybe_push_cleanup_level (tree type
)
3488 if (type
!= error_mark_node
3489 && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
)
3490 && current_binding_level
->more_cleanups_ok
== 0)
3492 begin_scope (sk_cleanup
, NULL
);
3493 current_binding_level
->statement_list
= push_stmt_list ();
3497 /* Return true if we are in the global binding level. */
3500 global_bindings_p (void)
3502 return global_scope_p (current_binding_level
);
3505 /* True if we are currently in a toplevel binding level. This
3506 means either the global binding level or a namespace in a toplevel
3507 binding level. Since there are no non-toplevel namespace levels,
3508 this really means any namespace or template parameter level. We
3509 also include a class whose context is toplevel. */
3512 toplevel_bindings_p (void)
3514 cp_binding_level
*b
= innermost_nonclass_level ();
3516 return b
->kind
== sk_namespace
|| b
->kind
== sk_template_parms
;
3519 /* True if this is a namespace scope, or if we are defining a class
3520 which is itself at namespace scope, or whose enclosing class is
3521 such a class, etc. */
3524 namespace_bindings_p (void)
3526 cp_binding_level
*b
= innermost_nonclass_level ();
3528 return b
->kind
== sk_namespace
;
3531 /* True if the innermost non-class scope is a block scope. */
3534 local_bindings_p (void)
3536 cp_binding_level
*b
= innermost_nonclass_level ();
3537 return b
->kind
< sk_function_parms
|| b
->kind
== sk_omp
;
3540 /* True if the current level needs to have a BLOCK made. */
3545 return (current_binding_level
->blocks
!= NULL_TREE
3546 || current_binding_level
->keep
3547 || current_binding_level
->kind
== sk_cleanup
3548 || current_binding_level
->names
!= NULL_TREE
3549 || current_binding_level
->using_directives
);
3552 /* Returns the kind of the innermost scope. */
3555 innermost_scope_kind (void)
3557 return current_binding_level
->kind
;
3560 /* Returns true if this scope was created to store template parameters. */
3563 template_parm_scope_p (void)
3565 return innermost_scope_kind () == sk_template_parms
;
3568 /* If KEEP is true, make a BLOCK node for the next binding level,
3569 unconditionally. Otherwise, use the normal logic to decide whether
3570 or not to create a BLOCK. */
3573 keep_next_level (bool keep
)
3575 keep_next_level_flag
= keep
;
3578 /* Return the list of declarations of the current local scope. */
3581 get_local_decls (void)
3583 gcc_assert (current_binding_level
->kind
!= sk_namespace
3584 && current_binding_level
->kind
!= sk_class
);
3585 return current_binding_level
->names
;
3588 /* Return how many function prototypes we are currently nested inside. */
3591 function_parm_depth (void)
3594 cp_binding_level
*b
;
3596 for (b
= current_binding_level
;
3597 b
->kind
== sk_function_parms
;
3604 /* For debugging. */
3605 static int no_print_functions
= 0;
3606 static int no_print_builtins
= 0;
3609 print_binding_level (cp_binding_level
* lvl
)
3613 if (lvl
->this_entity
)
3614 print_node_brief (stderr
, "entity=", lvl
->this_entity
, 1);
3615 fprintf (stderr
, " blocks=%p", (void *) lvl
->blocks
);
3616 if (lvl
->more_cleanups_ok
)
3617 fprintf (stderr
, " more-cleanups-ok");
3618 if (lvl
->have_cleanups
)
3619 fprintf (stderr
, " have-cleanups");
3620 fprintf (stderr
, "\n");
3623 fprintf (stderr
, " names:\t");
3624 /* We can probably fit 3 names to a line? */
3625 for (t
= lvl
->names
; t
; t
= TREE_CHAIN (t
))
3627 if (no_print_functions
&& (TREE_CODE (t
) == FUNCTION_DECL
))
3629 if (no_print_builtins
3630 && (TREE_CODE (t
) == TYPE_DECL
)
3631 && DECL_IS_BUILTIN (t
))
3634 /* Function decls tend to have longer names. */
3635 if (TREE_CODE (t
) == FUNCTION_DECL
)
3642 fprintf (stderr
, "\n\t");
3645 print_node_brief (stderr
, "", t
, 0);
3646 if (t
== error_mark_node
)
3650 fprintf (stderr
, "\n");
3652 if (vec_safe_length (lvl
->class_shadowed
))
3655 cp_class_binding
*b
;
3656 fprintf (stderr
, " class-shadowed:");
3657 FOR_EACH_VEC_ELT (*lvl
->class_shadowed
, i
, b
)
3658 fprintf (stderr
, " %s ", IDENTIFIER_POINTER (b
->identifier
));
3659 fprintf (stderr
, "\n");
3661 if (lvl
->type_shadowed
)
3663 fprintf (stderr
, " type-shadowed:");
3664 for (t
= lvl
->type_shadowed
; t
; t
= TREE_CHAIN (t
))
3666 fprintf (stderr
, " %s ", IDENTIFIER_POINTER (TREE_PURPOSE (t
)));
3668 fprintf (stderr
, "\n");
3673 debug (cp_binding_level
&ref
)
3675 print_binding_level (&ref
);
3679 debug (cp_binding_level
*ptr
)
3684 fprintf (stderr
, "<nil>\n");
3689 print_other_binding_stack (cp_binding_level
*stack
)
3691 cp_binding_level
*level
;
3692 for (level
= stack
; !global_scope_p (level
); level
= level
->level_chain
)
3694 fprintf (stderr
, "binding level %p\n", (void *) level
);
3695 print_binding_level (level
);
3700 print_binding_stack (void)
3702 cp_binding_level
*b
;
3703 fprintf (stderr
, "current_binding_level=%p\n"
3704 "class_binding_level=%p\n"
3705 "NAMESPACE_LEVEL (global_namespace)=%p\n",
3706 (void *) current_binding_level
, (void *) class_binding_level
,
3707 (void *) NAMESPACE_LEVEL (global_namespace
));
3708 if (class_binding_level
)
3710 for (b
= class_binding_level
; b
; b
= b
->level_chain
)
3711 if (b
== current_binding_level
)
3714 b
= class_binding_level
;
3716 b
= current_binding_level
;
3719 b
= current_binding_level
;
3720 print_other_binding_stack (b
);
3721 fprintf (stderr
, "global:\n");
3722 print_binding_level (NAMESPACE_LEVEL (global_namespace
));
3725 /* Return the type associated with ID. */
3728 identifier_type_value_1 (tree id
)
3730 /* There is no type with that name, anywhere. */
3731 if (REAL_IDENTIFIER_TYPE_VALUE (id
) == NULL_TREE
)
3733 /* This is not the type marker, but the real thing. */
3734 if (REAL_IDENTIFIER_TYPE_VALUE (id
) != global_type_node
)
3735 return REAL_IDENTIFIER_TYPE_VALUE (id
);
3736 /* Have to search for it. It must be on the global level, now.
3737 Ask lookup_name not to return non-types. */
3738 id
= lookup_name_real (id
, 2, 1, /*block_p=*/true, 0, 0);
3740 return TREE_TYPE (id
);
3744 /* Wrapper for identifier_type_value_1. */
3747 identifier_type_value (tree id
)
3750 timevar_start (TV_NAME_LOOKUP
);
3751 ret
= identifier_type_value_1 (id
);
3752 timevar_stop (TV_NAME_LOOKUP
);
3756 /* Push a definition of struct, union or enum tag named ID. into
3757 binding_level B. DECL is a TYPE_DECL for the type. We assume that
3758 the tag ID is not already defined. */
3761 set_identifier_type_value_with_scope (tree id
, tree decl
, cp_binding_level
*b
)
3765 if (b
->kind
!= sk_namespace
)
3767 /* Shadow the marker, not the real thing, so that the marker
3768 gets restored later. */
3769 tree old_type_value
= REAL_IDENTIFIER_TYPE_VALUE (id
);
3771 = tree_cons (id
, old_type_value
, b
->type_shadowed
);
3772 type
= decl
? TREE_TYPE (decl
) : NULL_TREE
;
3773 TREE_TYPE (b
->type_shadowed
) = type
;
3777 tree
*slot
= find_namespace_slot (current_namespace
, id
, true);
3779 update_binding (b
, NULL
, slot
, MAYBE_STAT_DECL (*slot
), decl
, false);
3781 /* Store marker instead of real type. */
3782 type
= global_type_node
;
3784 SET_IDENTIFIER_TYPE_VALUE (id
, type
);
3787 /* As set_identifier_type_value_with_scope, but using
3788 current_binding_level. */
3791 set_identifier_type_value (tree id
, tree decl
)
3793 set_identifier_type_value_with_scope (id
, decl
, current_binding_level
);
3796 /* Return the name for the constructor (or destructor) for the
3800 constructor_name (tree type
)
3802 tree decl
= TYPE_NAME (TYPE_MAIN_VARIANT (type
));
3804 return decl
? DECL_NAME (decl
) : NULL_TREE
;
3807 /* Returns TRUE if NAME is the name for the constructor for TYPE,
3808 which must be a class type. */
3811 constructor_name_p (tree name
, tree type
)
3813 gcc_assert (MAYBE_CLASS_TYPE_P (type
));
3815 /* These don't have names. */
3816 if (TREE_CODE (type
) == DECLTYPE_TYPE
3817 || TREE_CODE (type
) == TYPEOF_TYPE
)
3820 if (name
&& name
== constructor_name (type
))
3826 /* Same as pushdecl, but define X in binding-level LEVEL. We rely on the
3827 caller to set DECL_CONTEXT properly.
3829 Note that this must only be used when X will be the new innermost
3830 binding for its name, as we tack it onto the front of IDENTIFIER_BINDING
3831 without checking to see if the current IDENTIFIER_BINDING comes from a
3832 closer binding level than LEVEL. */
3835 do_pushdecl_with_scope (tree x
, cp_binding_level
*level
, bool is_friend
)
3837 cp_binding_level
*b
;
3839 if (level
->kind
== sk_class
)
3841 b
= class_binding_level
;
3842 class_binding_level
= level
;
3843 pushdecl_class_level (x
);
3844 class_binding_level
= b
;
3848 tree function_decl
= current_function_decl
;
3849 if (level
->kind
== sk_namespace
)
3850 current_function_decl
= NULL_TREE
;
3851 b
= current_binding_level
;
3852 current_binding_level
= level
;
3853 x
= pushdecl (x
, is_friend
);
3854 current_binding_level
= b
;
3855 current_function_decl
= function_decl
;
3860 /* Inject X into the local scope just before the function parms. */
3863 pushdecl_outermost_localscope (tree x
)
3865 cp_binding_level
*b
= NULL
;
3866 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
3868 /* Find the scope just inside the function parms. */
3869 for (cp_binding_level
*n
= current_binding_level
;
3870 n
->kind
!= sk_function_parms
; n
= b
->level_chain
)
3873 tree ret
= b
? do_pushdecl_with_scope (x
, b
, false) : error_mark_node
;
3874 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
3879 /* Process a local-scope or namespace-scope using declaration. LOOKUP
3880 is the result of qualified lookup (both value & type are
3881 significant). FN_SCOPE_P indicates if we're at function-scope (as
3882 opposed to namespace-scope). *VALUE_P and *TYPE_P are the current
3883 bindings, which are altered to reflect the newly brought in
3887 do_nonmember_using_decl (name_lookup
&lookup
, bool fn_scope_p
,
3888 tree
*value_p
, tree
*type_p
)
3890 tree value
= *value_p
;
3891 tree type
= *type_p
;
3892 bool failed
= false;
3894 /* Shift the old and new bindings around so we're comparing class and
3895 enumeration names to each other. */
3896 if (value
&& DECL_IMPLICIT_TYPEDEF_P (value
))
3902 if (lookup
.value
&& DECL_IMPLICIT_TYPEDEF_P (lookup
.value
))
3904 lookup
.type
= lookup
.value
;
3905 lookup
.value
= NULL_TREE
;
3910 else if (OVL_P (lookup
.value
) && (!value
|| OVL_P (value
)))
3912 for (lkp_iterator
usings (lookup
.value
); usings
; ++usings
)
3914 tree new_fn
= *usings
;
3916 /* [namespace.udecl]
3918 If a function declaration in namespace scope or block
3919 scope has the same name and the same parameter types as a
3920 function introduced by a using declaration the program is
3923 for (ovl_iterator
old (value
); !found
&& old
; ++old
)
3927 if (new_fn
== old_fn
)
3929 /* The function already exists in the current
3934 else if (old
.using_p ())
3935 continue; /* This is a using decl. */
3936 else if (old
.hidden_p () && !DECL_HIDDEN_FRIEND_P (old_fn
))
3937 continue; /* This is an anticipated builtin. */
3938 else if (!matching_fn_p (new_fn
, old_fn
))
3939 continue; /* Parameters do not match. */
3940 else if (decls_match (new_fn
, old_fn
))
3942 /* Extern "C" in different namespaces. */
3948 diagnose_name_conflict (new_fn
, old_fn
);
3956 /* Unlike the decl-pushing case we don't drop anticipated
3957 builtins here. They don't cause a problem, and we'd
3958 like to match them with a future declaration. */
3959 value
= ovl_insert (new_fn
, value
, true);
3963 /* Ignore anticipated builtins. */
3964 && !anticipated_builtin_p (value
)
3965 && (fn_scope_p
|| !decls_match (lookup
.value
, value
)))
3967 diagnose_name_conflict (lookup
.value
, value
);
3971 value
= lookup
.value
;
3973 if (lookup
.type
&& lookup
.type
!= type
)
3975 if (type
&& !decls_match (lookup
.type
, type
))
3977 diagnose_name_conflict (lookup
.type
, type
);
3984 /* If value is empty, shift any class or enumeration name back. */
3996 /* Returns true if ANCESTOR encloses DESCENDANT, including matching.
3997 Both are namespaces. */
4000 is_nested_namespace (tree ancestor
, tree descendant
, bool inline_only
)
4002 int depth
= SCOPE_DEPTH (ancestor
);
4004 if (!depth
&& !inline_only
)
4005 /* The global namespace encloses everything. */
4008 while (SCOPE_DEPTH (descendant
) > depth
4009 && (!inline_only
|| DECL_NAMESPACE_INLINE_P (descendant
)))
4010 descendant
= CP_DECL_CONTEXT (descendant
);
4012 return ancestor
== descendant
;
4015 /* Returns true if ROOT (a namespace, class, or function) encloses
4016 CHILD. CHILD may be either a class type or a namespace. */
4019 is_ancestor (tree root
, tree child
)
4021 gcc_assert ((TREE_CODE (root
) == NAMESPACE_DECL
4022 || TREE_CODE (root
) == FUNCTION_DECL
4023 || CLASS_TYPE_P (root
)));
4024 gcc_assert ((TREE_CODE (child
) == NAMESPACE_DECL
4025 || CLASS_TYPE_P (child
)));
4027 /* The global namespace encloses everything. */
4028 if (root
== global_namespace
)
4031 /* Search until we reach namespace scope. */
4032 while (TREE_CODE (child
) != NAMESPACE_DECL
)
4034 /* If we've reached the ROOT, it encloses CHILD. */
4037 /* Go out one level. */
4039 child
= TYPE_NAME (child
);
4040 child
= CP_DECL_CONTEXT (child
);
4043 if (TREE_CODE (root
) == NAMESPACE_DECL
)
4044 return is_nested_namespace (root
, child
);
4049 /* Enter the class or namespace scope indicated by T suitable for name
4050 lookup. T can be arbitrary scope, not necessary nested inside the
4051 current scope. Returns a non-null scope to pop iff pop_scope
4052 should be called later to exit this scope. */
4057 if (TREE_CODE (t
) == NAMESPACE_DECL
)
4058 push_decl_namespace (t
);
4059 else if (CLASS_TYPE_P (t
))
4061 if (!at_class_scope_p ()
4062 || !same_type_p (current_class_type
, t
))
4063 push_nested_class (t
);
4065 /* T is the same as the current scope. There is therefore no
4066 need to re-enter the scope. Since we are not actually
4067 pushing a new scope, our caller should not call
4075 /* Leave scope pushed by push_scope. */
4082 if (TREE_CODE (t
) == NAMESPACE_DECL
)
4083 pop_decl_namespace ();
4084 else if CLASS_TYPE_P (t
)
4085 pop_nested_class ();
4088 /* Subroutine of push_inner_scope. */
4091 push_inner_scope_r (tree outer
, tree inner
)
4096 || (TREE_CODE (inner
) != NAMESPACE_DECL
&& !CLASS_TYPE_P (inner
)))
4099 prev
= CP_DECL_CONTEXT (TREE_CODE (inner
) == NAMESPACE_DECL
? inner
: TYPE_NAME (inner
));
4101 push_inner_scope_r (outer
, prev
);
4102 if (TREE_CODE (inner
) == NAMESPACE_DECL
)
4104 cp_binding_level
*save_template_parm
= 0;
4105 /* Temporary take out template parameter scopes. They are saved
4106 in reversed order in save_template_parm. */
4107 while (current_binding_level
->kind
== sk_template_parms
)
4109 cp_binding_level
*b
= current_binding_level
;
4110 current_binding_level
= b
->level_chain
;
4111 b
->level_chain
= save_template_parm
;
4112 save_template_parm
= b
;
4115 resume_scope (NAMESPACE_LEVEL (inner
));
4116 current_namespace
= inner
;
4118 /* Restore template parameter scopes. */
4119 while (save_template_parm
)
4121 cp_binding_level
*b
= save_template_parm
;
4122 save_template_parm
= b
->level_chain
;
4123 b
->level_chain
= current_binding_level
;
4124 current_binding_level
= b
;
4131 /* Enter the scope INNER from current scope. INNER must be a scope
4132 nested inside current scope. This works with both name lookup and
4133 pushing name into scope. In case a template parameter scope is present,
4134 namespace is pushed under the template parameter scope according to
4135 name lookup rule in 14.6.1/6.
4137 Return the former current scope suitable for pop_inner_scope. */
4140 push_inner_scope (tree inner
)
4142 tree outer
= current_scope ();
4144 outer
= current_namespace
;
4146 push_inner_scope_r (outer
, inner
);
4150 /* Exit the current scope INNER back to scope OUTER. */
4153 pop_inner_scope (tree outer
, tree inner
)
4156 || (TREE_CODE (inner
) != NAMESPACE_DECL
&& !CLASS_TYPE_P (inner
)))
4159 while (outer
!= inner
)
4161 if (TREE_CODE (inner
) == NAMESPACE_DECL
)
4163 cp_binding_level
*save_template_parm
= 0;
4164 /* Temporary take out template parameter scopes. They are saved
4165 in reversed order in save_template_parm. */
4166 while (current_binding_level
->kind
== sk_template_parms
)
4168 cp_binding_level
*b
= current_binding_level
;
4169 current_binding_level
= b
->level_chain
;
4170 b
->level_chain
= save_template_parm
;
4171 save_template_parm
= b
;
4176 /* Restore template parameter scopes. */
4177 while (save_template_parm
)
4179 cp_binding_level
*b
= save_template_parm
;
4180 save_template_parm
= b
->level_chain
;
4181 b
->level_chain
= current_binding_level
;
4182 current_binding_level
= b
;
4188 inner
= CP_DECL_CONTEXT (TREE_CODE (inner
) == NAMESPACE_DECL
? inner
: TYPE_NAME (inner
));
4192 /* Do a pushlevel for class declarations. */
4195 pushlevel_class (void)
4197 class_binding_level
= begin_scope (sk_class
, current_class_type
);
4200 /* ...and a poplevel for class declarations. */
4203 poplevel_class (void)
4205 cp_binding_level
*level
= class_binding_level
;
4206 cp_class_binding
*cb
;
4210 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
4211 gcc_assert (level
!= 0);
4213 /* If we're leaving a toplevel class, cache its binding level. */
4214 if (current_class_depth
== 1)
4215 previous_class_level
= level
;
4216 for (shadowed
= level
->type_shadowed
;
4218 shadowed
= TREE_CHAIN (shadowed
))
4219 SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (shadowed
), TREE_VALUE (shadowed
));
4221 /* Remove the bindings for all of the class-level declarations. */
4222 if (level
->class_shadowed
)
4224 FOR_EACH_VEC_ELT (*level
->class_shadowed
, i
, cb
)
4226 IDENTIFIER_BINDING (cb
->identifier
) = cb
->base
->previous
;
4227 cxx_binding_free (cb
->base
);
4229 ggc_free (level
->class_shadowed
);
4230 level
->class_shadowed
= NULL
;
4233 /* Now, pop out of the binding level which we created up in the
4234 `pushlevel_class' routine. */
4235 gcc_assert (current_binding_level
== level
);
4237 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
4240 /* Set INHERITED_VALUE_BINDING_P on BINDING to true or false, as
4241 appropriate. DECL is the value to which a name has just been
4242 bound. CLASS_TYPE is the class in which the lookup occurred. */
4245 set_inherited_value_binding_p (cxx_binding
*binding
, tree decl
,
4248 if (binding
->value
== decl
&& TREE_CODE (decl
) != TREE_LIST
)
4252 if (TREE_CODE (decl
) == OVERLOAD
)
4253 context
= ovl_scope (decl
);
4256 gcc_assert (DECL_P (decl
));
4257 context
= context_for_name_lookup (decl
);
4260 if (is_properly_derived_from (class_type
, context
))
4261 INHERITED_VALUE_BINDING_P (binding
) = 1;
4263 INHERITED_VALUE_BINDING_P (binding
) = 0;
4265 else if (binding
->value
== decl
)
4266 /* We only encounter a TREE_LIST when there is an ambiguity in the
4267 base classes. Such an ambiguity can be overridden by a
4268 definition in this class. */
4269 INHERITED_VALUE_BINDING_P (binding
) = 1;
4271 INHERITED_VALUE_BINDING_P (binding
) = 0;
4274 /* Make the declaration of X appear in CLASS scope. */
4277 pushdecl_class_level (tree x
)
4279 bool is_valid
= true;
4282 /* Do nothing if we're adding to an outer lambda closure type,
4283 outer_binding will add it later if it's needed. */
4284 if (current_class_type
!= class_binding_level
->this_entity
)
4287 subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
4288 /* Get the name of X. */
4289 tree name
= OVL_NAME (x
);
4293 is_valid
= push_class_level_binding (name
, x
);
4294 if (TREE_CODE (x
) == TYPE_DECL
)
4295 set_identifier_type_value (name
, x
);
4297 else if (ANON_AGGR_TYPE_P (TREE_TYPE (x
)))
4299 /* If X is an anonymous aggregate, all of its members are
4300 treated as if they were members of the class containing the
4301 aggregate, for naming purposes. */
4302 location_t save_location
= input_location
;
4303 tree anon
= TREE_TYPE (x
);
4304 if (vec
<tree
, va_gc
> *member_vec
= CLASSTYPE_MEMBER_VEC (anon
))
4305 for (unsigned ix
= member_vec
->length (); ix
--;)
4307 tree binding
= (*member_vec
)[ix
];
4308 if (STAT_HACK_P (binding
))
4310 if (!pushdecl_class_level (STAT_TYPE (binding
)))
4312 binding
= STAT_DECL (binding
);
4314 if (!pushdecl_class_level (binding
))
4318 for (tree f
= TYPE_FIELDS (anon
); f
; f
= DECL_CHAIN (f
))
4319 if (TREE_CODE (f
) == FIELD_DECL
)
4321 input_location
= DECL_SOURCE_LOCATION (f
);
4322 if (!pushdecl_class_level (f
))
4325 input_location
= save_location
;
4327 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
4331 /* Return the BINDING (if any) for NAME in SCOPE, which is a class
4332 scope. If the value returned is non-NULL, and the PREVIOUS field
4333 is not set, callers must set the PREVIOUS field explicitly. */
4335 static cxx_binding
*
4336 get_class_binding (tree name
, cp_binding_level
*scope
)
4341 cxx_binding
*binding
;
4343 class_type
= scope
->this_entity
;
4345 /* Get the type binding. */
4346 type_binding
= lookup_member (class_type
, name
,
4347 /*protect=*/2, /*want_type=*/true,
4348 tf_warning_or_error
);
4349 /* Get the value binding. */
4350 value_binding
= lookup_member (class_type
, name
,
4351 /*protect=*/2, /*want_type=*/false,
4352 tf_warning_or_error
);
4355 && (TREE_CODE (value_binding
) == TYPE_DECL
4356 || DECL_CLASS_TEMPLATE_P (value_binding
)
4357 || (TREE_CODE (value_binding
) == TREE_LIST
4358 && TREE_TYPE (value_binding
) == error_mark_node
4359 && (TREE_CODE (TREE_VALUE (value_binding
))
4361 /* We found a type binding, even when looking for a non-type
4362 binding. This means that we already processed this binding
4365 else if (value_binding
)
4367 if (TREE_CODE (value_binding
) == TREE_LIST
4368 && TREE_TYPE (value_binding
) == error_mark_node
)
4369 /* NAME is ambiguous. */
4371 else if (BASELINK_P (value_binding
))
4372 /* NAME is some overloaded functions. */
4373 value_binding
= BASELINK_FUNCTIONS (value_binding
);
4376 /* If we found either a type binding or a value binding, create a
4377 new binding object. */
4378 if (type_binding
|| value_binding
)
4380 binding
= new_class_binding (name
,
4384 /* This is a class-scope binding, not a block-scope binding. */
4385 LOCAL_BINDING_P (binding
) = 0;
4386 set_inherited_value_binding_p (binding
, value_binding
, class_type
);
4394 /* Make the declaration(s) of X appear in CLASS scope under the name
4395 NAME. Returns true if the binding is valid. */
4398 push_class_level_binding_1 (tree name
, tree x
)
4400 cxx_binding
*binding
;
4404 /* The class_binding_level will be NULL if x is a template
4405 parameter name in a member template. */
4406 if (!class_binding_level
)
4409 if (name
== error_mark_node
)
4412 /* Can happen for an erroneous declaration (c++/60384). */
4413 if (!identifier_p (name
))
4415 gcc_assert (errorcount
|| sorrycount
);
4419 /* Check for invalid member names. But don't worry about a default
4420 argument-scope lambda being pushed after the class is complete. */
4421 gcc_assert (TYPE_BEING_DEFINED (current_class_type
)
4422 || LAMBDA_TYPE_P (TREE_TYPE (decl
)));
4423 /* Check that we're pushing into the right binding level. */
4424 gcc_assert (current_class_type
== class_binding_level
->this_entity
);
4426 /* We could have been passed a tree list if this is an ambiguous
4427 declaration. If so, pull the declaration out because
4428 check_template_shadow will not handle a TREE_LIST. */
4429 if (TREE_CODE (decl
) == TREE_LIST
4430 && TREE_TYPE (decl
) == error_mark_node
)
4431 decl
= TREE_VALUE (decl
);
4433 if (!check_template_shadow (decl
))
4438 If T is the name of a class, then each of the following shall
4439 have a name different from T:
4441 -- every static data member of class T;
4443 -- every member of class T that is itself a type;
4445 -- every enumerator of every member of class T that is an
4448 -- every member of every anonymous union that is a member of
4451 (Non-static data members were also forbidden to have the same
4452 name as T until TC1.) */
4454 || TREE_CODE (x
) == CONST_DECL
4455 || (TREE_CODE (x
) == TYPE_DECL
4456 && !DECL_SELF_REFERENCE_P (x
))
4457 /* A data member of an anonymous union. */
4458 || (TREE_CODE (x
) == FIELD_DECL
4459 && DECL_CONTEXT (x
) != current_class_type
))
4460 && DECL_NAME (x
) == DECL_NAME (TYPE_NAME (current_class_type
)))
4462 tree scope
= context_for_name_lookup (x
);
4463 if (TYPE_P (scope
) && same_type_p (scope
, current_class_type
))
4465 error_at (DECL_SOURCE_LOCATION (x
),
4466 "%qD has the same name as the class in which it is "
4472 /* Get the current binding for NAME in this class, if any. */
4473 binding
= IDENTIFIER_BINDING (name
);
4474 if (!binding
|| binding
->scope
!= class_binding_level
)
4476 binding
= get_class_binding (name
, class_binding_level
);
4477 /* If a new binding was created, put it at the front of the
4478 IDENTIFIER_BINDING list. */
4481 binding
->previous
= IDENTIFIER_BINDING (name
);
4482 IDENTIFIER_BINDING (name
) = binding
;
4486 /* If there is already a binding, then we may need to update the
4488 if (binding
&& binding
->value
)
4490 tree bval
= binding
->value
;
4491 tree old_decl
= NULL_TREE
;
4492 tree target_decl
= strip_using_decl (decl
);
4493 tree target_bval
= strip_using_decl (bval
);
4495 if (INHERITED_VALUE_BINDING_P (binding
))
4497 /* If the old binding was from a base class, and was for a
4498 tag name, slide it over to make room for the new binding.
4499 The old binding is still visible if explicitly qualified
4500 with a class-key. */
4501 if (TREE_CODE (target_bval
) == TYPE_DECL
4502 && DECL_ARTIFICIAL (target_bval
)
4503 && !(TREE_CODE (target_decl
) == TYPE_DECL
4504 && DECL_ARTIFICIAL (target_decl
)))
4506 old_decl
= binding
->type
;
4507 binding
->type
= bval
;
4508 binding
->value
= NULL_TREE
;
4509 INHERITED_VALUE_BINDING_P (binding
) = 0;
4514 /* Any inherited type declaration is hidden by the type
4515 declaration in the derived class. */
4516 if (TREE_CODE (target_decl
) == TYPE_DECL
4517 && DECL_ARTIFICIAL (target_decl
))
4518 binding
->type
= NULL_TREE
;
4521 else if (TREE_CODE (decl
) == USING_DECL
4522 && TREE_CODE (bval
) == USING_DECL
4523 && same_type_p (USING_DECL_SCOPE (decl
),
4524 USING_DECL_SCOPE (bval
)))
4525 /* This is a using redeclaration that will be diagnosed later
4526 in supplement_binding */
4528 else if (TREE_CODE (decl
) == USING_DECL
4529 && TREE_CODE (bval
) == USING_DECL
4530 && DECL_DEPENDENT_P (decl
)
4531 && DECL_DEPENDENT_P (bval
))
4533 else if (TREE_CODE (decl
) == USING_DECL
4534 && OVL_P (target_bval
))
4536 else if (TREE_CODE (bval
) == USING_DECL
4537 && OVL_P (target_decl
))
4539 else if (OVL_P (target_decl
)
4540 && OVL_P (target_bval
))
4543 if (old_decl
&& binding
->scope
== class_binding_level
)
4546 /* It is always safe to clear INHERITED_VALUE_BINDING_P
4547 here. This function is only used to register bindings
4548 from with the class definition itself. */
4549 INHERITED_VALUE_BINDING_P (binding
) = 0;
4554 /* Note that we declared this value so that we can issue an error if
4555 this is an invalid redeclaration of a name already used for some
4557 note_name_declared_in_class (name
, decl
);
4559 /* If we didn't replace an existing binding, put the binding on the
4560 stack of bindings for the identifier, and update the shadowed
4562 if (binding
&& binding
->scope
== class_binding_level
)
4563 /* Supplement the existing binding. */
4564 ok
= supplement_binding (binding
, decl
);
4567 /* Create a new binding. */
4568 push_binding (name
, decl
, class_binding_level
);
4575 /* Wrapper for push_class_level_binding_1. */
4578 push_class_level_binding (tree name
, tree x
)
4581 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
4582 ret
= push_class_level_binding_1 (name
, x
);
4583 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
4587 /* Process and lookup a using decl SCOPE::lookup.name, filling in
4588 lookup.values & lookup.type. Return true if ok. */
4591 lookup_using_decl (tree scope
, name_lookup
&lookup
)
4593 tree current
= current_scope ();
4594 bool dependent_p
= false;
4596 if (TREE_CODE (scope
) == NAMESPACE_DECL
)
4598 /* Naming a namespace member. */
4599 if (TYPE_P (current
))
4601 error ("using-declaration for non-member at class scope");
4605 qualified_namespace_lookup (scope
, &lookup
);
4607 else if (TREE_CODE (scope
) == ENUMERAL_TYPE
)
4609 error ("using-declaration may not name enumerator %<%E::%D%>",
4610 scope
, lookup
.name
);
4615 /* Naming a class member. */
4616 if (!TYPE_P (current
))
4618 error ("using-declaration for member at non-class scope");
4622 /* Make sure the name is not invalid */
4623 if (TREE_CODE (lookup
.name
) == BIT_NOT_EXPR
)
4625 error ("%<%T::%D%> names destructor", scope
, lookup
.name
);
4629 /* Using T::T declares inheriting ctors, even if T is a typedef. */
4630 if (MAYBE_CLASS_TYPE_P (scope
)
4631 && (lookup
.name
== TYPE_IDENTIFIER (scope
)
4632 || constructor_name_p (lookup
.name
, scope
)))
4634 maybe_warn_cpp0x (CPP0X_INHERITING_CTORS
);
4635 lookup
.name
= ctor_identifier
;
4636 CLASSTYPE_NON_AGGREGATE (current
) = true;
4637 TYPE_HAS_USER_CONSTRUCTOR (current
) = true;
4640 /* Cannot introduce a constructor name. */
4641 if (constructor_name_p (lookup
.name
, current
))
4643 error ("%<%T::%D%> names constructor in %qT",
4644 scope
, lookup
.name
, current
);
4648 /* Member using decls finish processing when completing the
4650 /* From [namespace.udecl]:
4652 A using-declaration used as a member-declaration shall refer
4653 to a member of a base class of the class being defined.
4655 In general, we cannot check this constraint in a template
4656 because we do not know the entire set of base classes of the
4657 current class type. Morover, if SCOPE is dependent, it might
4658 match a non-dependent base. */
4660 dependent_p
= dependent_scope_p (scope
);
4664 tree binfo
= lookup_base (current
, scope
, ba_any
, &b_kind
,
4665 tf_warning_or_error
);
4666 if (b_kind
< bk_proper_base
)
4668 /* If there are dependent bases, scope might resolve at
4669 instantiation time, even if it isn't exactly one of
4670 the dependent bases. */
4671 if (b_kind
== bk_same_type
|| !any_dependent_bases_p ())
4673 error_not_base_type (scope
, current
);
4676 /* Treat as-if dependent. */
4679 else if (lookup
.name
== ctor_identifier
&& !binfo_direct_p (binfo
))
4681 error ("cannot inherit constructors from indirect base %qT",
4685 else if (IDENTIFIER_CONV_OP_P (lookup
.name
)
4686 && dependent_type_p (TREE_TYPE (lookup
.name
)))
4689 lookup
.value
= lookup_member (binfo
, lookup
.name
, 0,
4690 false, tf_warning_or_error
);
4698 error ("%qD has not been declared in %qE", lookup
.name
, scope
);
4702 if (TREE_CODE (lookup
.value
) == TREE_LIST
4703 /* We can (independently) have ambiguous implicit typedefs. */
4704 || (lookup
.type
&& TREE_CODE (lookup
.type
) == TREE_LIST
))
4706 error ("reference to %qD is ambiguous", lookup
.name
);
4707 print_candidates (TREE_CODE (lookup
.value
) == TREE_LIST
4708 ? lookup
.value
: lookup
.type
);
4712 if (TREE_CODE (lookup
.value
) == NAMESPACE_DECL
)
4714 error ("using-declaration may not name namespace %qD", lookup
.value
);
4722 /* Process "using SCOPE::NAME" in a class scope. Return the
4723 USING_DECL created. */
4726 do_class_using_decl (tree scope
, tree name
)
4728 if (name
== error_mark_node
4729 || scope
== error_mark_node
)
4732 name_lookup
lookup (name
, 0);
4733 if (!lookup_using_decl (scope
, lookup
))
4736 tree found
= lookup
.value
;
4737 if (found
&& BASELINK_P (found
))
4738 /* The binfo from which the functions came does not matter. */
4739 found
= BASELINK_FUNCTIONS (found
);
4741 tree using_decl
= build_lang_decl (USING_DECL
, lookup
.name
, NULL_TREE
);
4742 USING_DECL_SCOPE (using_decl
) = scope
;
4743 USING_DECL_DECLS (using_decl
) = found
;
4744 DECL_DEPENDENT_P (using_decl
) = !found
;
4750 /* Return the binding for NAME in NS. If NS is NULL, look in
4751 global_namespace. */
4754 get_namespace_binding (tree ns
, tree name
)
4756 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
4758 ns
= global_namespace
;
4759 gcc_checking_assert (!DECL_NAMESPACE_ALIAS (ns
));
4760 tree ret
= find_namespace_value (ns
, name
);
4761 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
4765 /* Push internal DECL into the global namespace. Does not do the
4766 full overload fn handling and does not add it to the list of things
4767 in the namespace. */
4770 set_global_binding (tree decl
)
4772 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
4774 tree
*slot
= find_namespace_slot (global_namespace
, DECL_NAME (decl
), true);
4777 /* The user's placed something in the implementor's namespace. */
4778 diagnose_name_conflict (decl
, MAYBE_STAT_DECL (*slot
));
4780 /* Force the binding, so compiler internals continue to work. */
4783 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
4786 /* Set the context of a declaration to scope. Complain if we are not
4790 set_decl_namespace (tree decl
, tree scope
, bool friendp
)
4792 /* Get rid of namespace aliases. */
4793 scope
= ORIGINAL_NAMESPACE (scope
);
4795 /* It is ok for friends to be qualified in parallel space. */
4796 if (!friendp
&& !is_nested_namespace (current_namespace
, scope
))
4797 error ("declaration of %qD not in a namespace surrounding %qD",
4799 DECL_CONTEXT (decl
) = FROB_CONTEXT (scope
);
4801 /* See whether this has been declared in the namespace or inline
4803 tree old
= NULL_TREE
;
4805 name_lookup
lookup (DECL_NAME (decl
), LOOKUP_HIDDEN
);
4806 if (!lookup
.search_qualified (scope
, /*usings=*/false))
4807 /* No old declaration at all. */
4812 /* If it's a TREE_LIST, the result of the lookup was ambiguous. */
4813 if (TREE_CODE (old
) == TREE_LIST
)
4816 DECL_CONTEXT (decl
) = FROB_CONTEXT (scope
);
4817 error ("reference to %qD is ambiguous", decl
);
4818 print_candidates (old
);
4822 if (!DECL_DECLARES_FUNCTION_P (decl
))
4824 /* Don't compare non-function decls with decls_match here, since
4825 it can't check for the correct constness at this
4826 point. pushdecl will find those errors later. */
4828 /* We might have found it in an inline namespace child of SCOPE. */
4829 if (TREE_CODE (decl
) == TREE_CODE (old
))
4830 DECL_CONTEXT (decl
) = DECL_CONTEXT (old
);
4833 /* Writing "N::i" to declare something directly in "N" is invalid. */
4834 if (CP_DECL_CONTEXT (decl
) == current_namespace
4835 && at_namespace_scope_p ())
4836 error_at (DECL_SOURCE_LOCATION (decl
),
4837 "explicit qualification in declaration of %qD", decl
);
4841 /* Since decl is a function, old should contain a function decl. */
4845 /* We handle these in check_explicit_instantiation_namespace. */
4846 if (processing_explicit_instantiation
)
4848 if (processing_template_decl
|| processing_specialization
)
4849 /* We have not yet called push_template_decl to turn a
4850 FUNCTION_DECL into a TEMPLATE_DECL, so the declarations won't
4851 match. But, we'll check later, when we construct the
4854 /* Instantiations or specializations of templates may be declared as
4855 friends in any namespace. */
4856 if (friendp
&& DECL_USE_TEMPLATE (decl
))
4862 for (lkp_iterator
iter (old
); iter
; ++iter
)
4864 if (iter
.using_p ())
4869 /* Adjust DECL_CONTEXT first so decls_match will return true
4870 if DECL will match a declaration in an inline namespace. */
4871 DECL_CONTEXT (decl
) = DECL_CONTEXT (ofn
);
4872 if (decls_match (decl
, ofn
))
4876 /* We found more than one matching declaration. */
4877 DECL_CONTEXT (decl
) = FROB_CONTEXT (scope
);
4886 if (DECL_HIDDEN_FRIEND_P (found
))
4888 pedwarn (DECL_SOURCE_LOCATION (decl
), 0,
4889 "%qD has not been declared within %qD", decl
, scope
);
4890 inform (DECL_SOURCE_LOCATION (found
),
4891 "only here as a %<friend%>");
4893 DECL_CONTEXT (decl
) = DECL_CONTEXT (found
);
4898 /* It didn't work, go back to the explicit scope. */
4899 DECL_CONTEXT (decl
) = FROB_CONTEXT (scope
);
4900 error ("%qD should have been declared inside %qD", decl
, scope
);
4903 /* Return the namespace where the current declaration is declared. */
4906 current_decl_namespace (void)
4909 /* If we have been pushed into a different namespace, use it. */
4910 if (!vec_safe_is_empty (decl_namespace_list
))
4911 return decl_namespace_list
->last ();
4913 if (current_class_type
)
4914 result
= decl_namespace_context (current_class_type
);
4915 else if (current_function_decl
)
4916 result
= decl_namespace_context (current_function_decl
);
4918 result
= current_namespace
;
4922 /* Process any ATTRIBUTES on a namespace definition. Returns true if
4923 attribute visibility is seen. */
4926 handle_namespace_attrs (tree ns
, tree attributes
)
4929 bool saw_vis
= false;
4931 if (attributes
== error_mark_node
)
4934 for (d
= attributes
; d
; d
= TREE_CHAIN (d
))
4936 tree name
= get_attribute_name (d
);
4937 tree args
= TREE_VALUE (d
);
4939 if (is_attribute_p ("visibility", name
))
4941 /* attribute visibility is a property of the syntactic block
4942 rather than the namespace as a whole, so we don't touch the
4943 NAMESPACE_DECL at all. */
4944 tree x
= args
? TREE_VALUE (args
) : NULL_TREE
;
4945 if (x
== NULL_TREE
|| TREE_CODE (x
) != STRING_CST
|| TREE_CHAIN (args
))
4947 warning (OPT_Wattributes
,
4948 "%qD attribute requires a single NTBS argument",
4953 if (!TREE_PUBLIC (ns
))
4954 warning (OPT_Wattributes
,
4955 "%qD attribute is meaningless since members of the "
4956 "anonymous namespace get local symbols", name
);
4958 push_visibility (TREE_STRING_POINTER (x
), 1);
4961 else if (is_attribute_p ("abi_tag", name
))
4963 if (!DECL_NAME (ns
))
4965 warning (OPT_Wattributes
, "ignoring %qD attribute on anonymous "
4969 if (!DECL_NAMESPACE_INLINE_P (ns
))
4971 warning (OPT_Wattributes
, "ignoring %qD attribute on non-inline "
4977 tree dn
= DECL_NAME (ns
);
4978 args
= build_string (IDENTIFIER_LENGTH (dn
) + 1,
4979 IDENTIFIER_POINTER (dn
));
4980 TREE_TYPE (args
) = char_array_type_node
;
4981 args
= fix_string_type (args
);
4982 args
= build_tree_list (NULL_TREE
, args
);
4984 if (check_abi_tag_args (args
, name
))
4985 DECL_ATTRIBUTES (ns
) = tree_cons (name
, args
,
4986 DECL_ATTRIBUTES (ns
));
4988 else if (is_attribute_p ("deprecated", name
))
4990 if (!DECL_NAME (ns
))
4992 warning (OPT_Wattributes
, "ignoring %qD attribute on anonymous "
4996 if (args
&& TREE_CODE (TREE_VALUE (args
)) != STRING_CST
)
4998 error ("deprecated message is not a string");
5001 TREE_DEPRECATED (ns
) = 1;
5003 DECL_ATTRIBUTES (ns
) = tree_cons (name
, args
,
5004 DECL_ATTRIBUTES (ns
));
5008 warning (OPT_Wattributes
, "%qD attribute directive ignored",
5017 /* Temporarily set the namespace for the current declaration. */
5020 push_decl_namespace (tree decl
)
5022 if (TREE_CODE (decl
) != NAMESPACE_DECL
)
5023 decl
= decl_namespace_context (decl
);
5024 vec_safe_push (decl_namespace_list
, ORIGINAL_NAMESPACE (decl
));
5027 /* [namespace.memdef]/2 */
5030 pop_decl_namespace (void)
5032 decl_namespace_list
->pop ();
5035 /* Process a namespace-alias declaration. */
5038 do_namespace_alias (tree alias
, tree name_space
)
5040 if (name_space
== error_mark_node
)
5043 gcc_assert (TREE_CODE (name_space
) == NAMESPACE_DECL
);
5045 name_space
= ORIGINAL_NAMESPACE (name_space
);
5047 /* Build the alias. */
5048 alias
= build_lang_decl (NAMESPACE_DECL
, alias
, void_type_node
);
5049 DECL_NAMESPACE_ALIAS (alias
) = name_space
;
5050 DECL_EXTERNAL (alias
) = 1;
5051 DECL_CONTEXT (alias
) = FROB_CONTEXT (current_scope ());
5054 /* Emit debug info for namespace alias. */
5055 if (!building_stmt_list_p ())
5056 (*debug_hooks
->early_global_decl
) (alias
);
5059 /* Like pushdecl, only it places X in the current namespace,
5063 pushdecl_namespace_level (tree x
, bool is_friend
)
5065 cp_binding_level
*b
= current_binding_level
;
5068 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
5069 t
= do_pushdecl_with_scope
5070 (x
, NAMESPACE_LEVEL (current_namespace
), is_friend
);
5072 /* Now, the type_shadowed stack may screw us. Munge it so it does
5074 if (TREE_CODE (t
) == TYPE_DECL
)
5076 tree name
= DECL_NAME (t
);
5078 tree
*ptr
= (tree
*)0;
5079 for (; !global_scope_p (b
); b
= b
->level_chain
)
5081 tree shadowed
= b
->type_shadowed
;
5082 for (; shadowed
; shadowed
= TREE_CHAIN (shadowed
))
5083 if (TREE_PURPOSE (shadowed
) == name
)
5085 ptr
= &TREE_VALUE (shadowed
);
5086 /* Can't break out of the loop here because sometimes
5087 a binding level will have duplicate bindings for
5088 PT names. It's gross, but I haven't time to fix it. */
5091 newval
= TREE_TYPE (t
);
5092 if (ptr
== (tree
*)0)
5094 /* @@ This shouldn't be needed. My test case "zstring.cc" trips
5095 up here if this is changed to an assertion. --KR */
5096 SET_IDENTIFIER_TYPE_VALUE (name
, t
);
5103 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
5107 /* Process a using declaration in non-class scope. */
5110 finish_nonmember_using_decl (tree scope
, tree name
)
5112 gcc_checking_assert (current_binding_level
->kind
!= sk_class
);
5114 if (scope
== error_mark_node
|| name
== error_mark_node
)
5117 name_lookup
lookup (name
, 0);
5119 if (!lookup_using_decl (scope
, lookup
))
5122 /* Emit debug info. */
5123 if (!processing_template_decl
)
5124 cp_emit_debug_info_for_using (lookup
.value
,
5125 current_binding_level
->this_entity
);
5127 if (current_binding_level
->kind
== sk_namespace
)
5129 tree
*slot
= find_namespace_slot (current_namespace
, name
, true);
5131 tree value
= MAYBE_STAT_DECL (*slot
);
5132 tree type
= MAYBE_STAT_TYPE (*slot
);
5134 do_nonmember_using_decl (lookup
, false, &value
, &type
);
5136 if (STAT_HACK_P (*slot
))
5138 STAT_DECL (*slot
) = value
;
5139 STAT_TYPE (*slot
) = type
;
5142 *slot
= stat_hack (value
, type
);
5148 tree using_decl
= build_lang_decl (USING_DECL
, lookup
.name
, NULL_TREE
);
5149 USING_DECL_SCOPE (using_decl
) = scope
;
5150 add_decl_expr (using_decl
);
5152 cxx_binding
*binding
= find_local_binding (current_binding_level
, name
);
5157 value
= binding
->value
;
5158 type
= binding
->type
;
5161 /* DR 36 questions why using-decls at function scope may not be
5162 duplicates. Disallow it, as C++11 claimed and PR 20420
5164 do_nonmember_using_decl (lookup
, true, &value
, &type
);
5168 else if (binding
&& value
== binding
->value
)
5170 else if (binding
&& binding
->value
&& TREE_CODE (value
) == OVERLOAD
)
5172 update_local_overload (IDENTIFIER_BINDING (name
), value
);
5173 IDENTIFIER_BINDING (name
)->value
= value
;
5176 /* Install the new binding. */
5177 push_local_binding (name
, value
, true);
5181 else if (binding
&& type
== binding
->type
)
5185 push_local_binding (name
, type
, true);
5186 set_identifier_type_value (name
, type
);
5191 /* Return the declarations that are members of the namespace NS. */
5194 cp_namespace_decls (tree ns
)
5196 return NAMESPACE_LEVEL (ns
)->names
;
5199 /* Combine prefer_type and namespaces_only into flags. */
5202 lookup_flags (int prefer_type
, int namespaces_only
)
5204 if (namespaces_only
)
5205 return LOOKUP_PREFER_NAMESPACES
;
5206 if (prefer_type
> 1)
5207 return LOOKUP_PREFER_TYPES
;
5208 if (prefer_type
> 0)
5209 return LOOKUP_PREFER_BOTH
;
5213 /* Given a lookup that returned VAL, use FLAGS to decide if we want to
5214 ignore it or not. Subroutine of lookup_name_real and
5215 lookup_type_scope. */
5218 qualify_lookup (tree val
, int flags
)
5220 if (val
== NULL_TREE
)
5222 if ((flags
& LOOKUP_PREFER_NAMESPACES
) && TREE_CODE (val
) == NAMESPACE_DECL
)
5224 if (flags
& LOOKUP_PREFER_TYPES
)
5226 tree target_val
= strip_using_decl (val
);
5227 if (TREE_CODE (target_val
) == TYPE_DECL
5228 || TREE_CODE (target_val
) == TEMPLATE_DECL
)
5231 if (flags
& (LOOKUP_PREFER_NAMESPACES
| LOOKUP_PREFER_TYPES
))
5233 /* Look through lambda things that we shouldn't be able to see. */
5234 if (!(flags
& LOOKUP_HIDDEN
) && is_lambda_ignored_entity (val
))
5239 /* Is there a "using namespace std;" directive within USINGS? */
5242 using_directives_contain_std_p (vec
<tree
, va_gc
> *usings
)
5247 for (unsigned ix
= usings
->length (); ix
--;)
5248 if ((*usings
)[ix
] == std_node
)
5254 /* Is there a "using namespace std;" directive within the current
5255 namespace (or its ancestors)?
5256 Compare with name_lookup::search_unqualified. */
5259 has_using_namespace_std_directive_p ()
5261 /* Look at local using-directives. */
5262 for (cp_binding_level
*level
= current_binding_level
;
5264 level
= level
->level_chain
)
5265 if (using_directives_contain_std_p (level
->using_directives
))
5271 /* Subclass of deferred_diagnostic, for issuing a note when
5272 --param cxx-max-namespaces-for-diagnostic-help is reached.
5274 The note should be issued after the error, but before any other
5275 deferred diagnostics. This is handled by decorating a wrapped
5276 deferred_diagnostic, and emitting a note before that wrapped note is
5279 class namespace_limit_reached
: public deferred_diagnostic
5282 namespace_limit_reached (location_t loc
, unsigned limit
, tree name
,
5283 gnu::unique_ptr
<deferred_diagnostic
> wrapped
)
5284 : deferred_diagnostic (loc
),
5285 m_limit (limit
), m_name (name
),
5286 m_wrapped (move (wrapped
))
5290 ~namespace_limit_reached ()
5292 /* Unconditionally warn that the search was truncated. */
5293 inform (get_location (),
5294 "maximum limit of %d namespaces searched for %qE",
5296 /* m_wrapped will be implicitly deleted after this, emitting any followup
5297 diagnostic after the above note. */
5303 gnu::unique_ptr
<deferred_diagnostic
> m_wrapped
;
5306 /* Subclass of deferred_diagnostic, for use when issuing a single suggestion.
5307 Emit a note showing the location of the declaration of the suggestion. */
5309 class show_candidate_location
: public deferred_diagnostic
5312 show_candidate_location (location_t loc
, tree candidate
)
5313 : deferred_diagnostic (loc
),
5314 m_candidate (candidate
)
5318 ~show_candidate_location ()
5320 inform (location_of (m_candidate
), "%qE declared here", m_candidate
);
5327 /* Subclass of deferred_diagnostic, for use when there are multiple candidates
5328 to be suggested by suggest_alternatives_for.
5330 Emit a series of notes showing the various suggestions. */
5332 class suggest_alternatives
: public deferred_diagnostic
5335 suggest_alternatives (location_t loc
, vec
<tree
> candidates
)
5336 : deferred_diagnostic (loc
),
5337 m_candidates (candidates
)
5341 ~suggest_alternatives ()
5343 if (m_candidates
.length ())
5345 inform_n (get_location (), m_candidates
.length (),
5346 "suggested alternative:",
5347 "suggested alternatives:");
5348 for (unsigned ix
= 0; ix
!= m_candidates
.length (); ix
++)
5350 tree val
= m_candidates
[ix
];
5352 inform (location_of (val
), " %qE", val
);
5355 m_candidates
.release ();
5359 vec
<tree
> m_candidates
;
5362 /* A class for encapsulating the result of a search across
5363 multiple namespaces (and scoped enums within them) for an
5364 unrecognized name seen at a given source location. */
5366 class namespace_hints
5369 namespace_hints (location_t loc
, tree name
);
5371 name_hint
convert_candidates_to_name_hint ();
5372 name_hint
maybe_decorate_with_limit (name_hint
);
5375 void maybe_add_candidate_for_scoped_enum (tree scoped_enum
, tree name
);
5379 vec
<tree
> m_candidates
;
5381 /* Value of "--param cxx-max-namespaces-for-diagnostic-help". */
5384 /* Was the limit reached? */
5388 /* Constructor for namespace_hints. Search namespaces and scoped enums,
5389 looking for an exact match for unrecognized NAME seen at LOC. */
5391 namespace_hints::namespace_hints (location_t loc
, tree name
)
5392 : m_loc(loc
), m_name (name
)
5394 auto_vec
<tree
> worklist
;
5396 m_candidates
= vNULL
;
5398 m_limit
= param_cxx_max_namespaces_for_diagnostic_help
;
5400 /* Breadth-first search of namespaces. Up to limit namespaces
5401 searched (limit zero == unlimited). */
5402 worklist
.safe_push (global_namespace
);
5403 for (unsigned ix
= 0; ix
!= worklist
.length (); ix
++)
5405 tree ns
= worklist
[ix
];
5406 name_lookup
lookup (name
);
5408 if (lookup
.search_qualified (ns
, false))
5409 m_candidates
.safe_push (lookup
.value
);
5413 /* Look for child namespaces. We have to do this
5414 indirectly because they are chained in reverse order,
5415 which is confusing to the user. */
5416 auto_vec
<tree
> children
;
5418 for (tree decl
= NAMESPACE_LEVEL (ns
)->names
;
5419 decl
; decl
= TREE_CHAIN (decl
))
5421 if (TREE_CODE (decl
) == NAMESPACE_DECL
5422 && !DECL_NAMESPACE_ALIAS (decl
)
5423 && !DECL_NAMESPACE_INLINE_P (decl
))
5424 children
.safe_push (decl
);
5426 /* Look for exact matches for NAME within scoped enums.
5427 These aren't added to the worklist, and so don't count
5428 against the search limit. */
5429 if (TREE_CODE (decl
) == TYPE_DECL
)
5431 tree type
= TREE_TYPE (decl
);
5432 if (SCOPED_ENUM_P (type
))
5433 maybe_add_candidate_for_scoped_enum (type
, name
);
5437 while (!m_limited
&& !children
.is_empty ())
5439 if (worklist
.length () == m_limit
)
5442 worklist
.safe_push (children
.pop ());
5448 /* Drop ownership of m_candidates, using it to generate a name_hint at m_loc
5449 for m_name, an IDENTIFIER_NODE for which name lookup failed.
5451 If m_candidates is non-empty, use it to generate a suggestion and/or
5452 a deferred diagnostic that lists the possible candidate(s).
5456 namespace_hints::convert_candidates_to_name_hint ()
5458 /* How many candidates do we have? */
5460 /* If we have just one candidate, issue a name_hint with it as a suggestion
5461 (so that consumers are able to suggest it within the error message and emit
5462 it as a fix-it hint), and with a note showing the candidate's location. */
5463 if (m_candidates
.length () == 1)
5465 tree candidate
= m_candidates
[0];
5466 /* Clean up CANDIDATES. */
5467 m_candidates
.release ();
5468 return name_hint (expr_to_string (candidate
),
5469 new show_candidate_location (m_loc
, candidate
));
5471 else if (m_candidates
.length () > 1)
5472 /* If we have more than one candidate, issue a name_hint without a single
5473 "suggestion", but with a deferred diagnostic that lists the
5474 various candidates. This takes ownership of m_candidates. */
5475 return name_hint (NULL
, new suggest_alternatives (m_loc
, m_candidates
));
5477 /* Otherwise, m_candidates ought to be empty, so no cleanup is necessary. */
5478 gcc_assert (m_candidates
.length () == 0);
5479 gcc_assert (m_candidates
== vNULL
);
5481 return name_hint ();
5484 /* If --param cxx-max-namespaces-for-diagnostic-help was reached,
5485 then we want to emit a note about after the error, but before
5486 any other deferred diagnostics.
5488 Handle this by figuring out what hint is needed, then optionally
5489 decorating HINT with a namespace_limit_reached wrapper. */
5492 namespace_hints::maybe_decorate_with_limit (name_hint hint
)
5495 return name_hint (hint
.suggestion (),
5496 new namespace_limit_reached (m_loc
, m_limit
,
5498 hint
.take_deferred ()));
5503 /* Look inside SCOPED_ENUM for exact matches for NAME.
5504 If one is found, add its CONST_DECL to m_candidates. */
5507 namespace_hints::maybe_add_candidate_for_scoped_enum (tree scoped_enum
,
5510 gcc_assert (SCOPED_ENUM_P (scoped_enum
));
5512 for (tree iter
= TYPE_VALUES (scoped_enum
); iter
; iter
= TREE_CHAIN (iter
))
5514 tree id
= TREE_PURPOSE (iter
);
5517 m_candidates
.safe_push (TREE_VALUE (iter
));
5523 /* Generate a name_hint at LOCATION for NAME, an IDENTIFIER_NODE for which
5526 Search through all available namespaces and any scoped enums within them
5527 and generate a suggestion and/or a deferred diagnostic that lists possible
5530 If no exact matches are found, and SUGGEST_MISSPELLINGS is true, then also
5531 look for near-matches and suggest the best near-match, if there is one.
5533 If nothing is found, then an empty name_hint is returned. */
5536 suggest_alternatives_for (location_t location
, tree name
,
5537 bool suggest_misspellings
)
5539 /* First, search for exact matches in other namespaces. */
5540 namespace_hints
ns_hints (location
, name
);
5541 name_hint result
= ns_hints
.convert_candidates_to_name_hint ();
5543 /* Otherwise, try other approaches. */
5545 result
= suggest_alternatives_for_1 (location
, name
, suggest_misspellings
);
5547 return ns_hints
.maybe_decorate_with_limit (gnu::move (result
));
5550 /* The second half of suggest_alternatives_for, for when no exact matches
5551 were found in other namespaces. */
5554 suggest_alternatives_for_1 (location_t location
, tree name
,
5555 bool suggest_misspellings
)
5557 /* No candidates were found in the available namespaces. */
5559 /* If there's a "using namespace std;" active, and this
5560 is one of the most common "std::" names, then it's probably a
5561 missing #include. */
5562 if (has_using_namespace_std_directive_p ())
5564 name_hint hint
= maybe_suggest_missing_std_header (location
, name
);
5569 /* Otherwise, consider misspellings. */
5570 if (!suggest_misspellings
)
5571 return name_hint ();
5573 return lookup_name_fuzzy (name
, FUZZY_LOOKUP_NAME
, location
);
5576 /* Generate a name_hint at LOCATION for NAME, an IDENTIFIER_NODE for which
5579 Search through all available namespaces and generate a suggestion and/or
5580 a deferred diagnostic that lists possible candidate(s).
5582 This is similiar to suggest_alternatives_for, but doesn't fallback to
5583 the other approaches used by that function. */
5586 suggest_alternatives_in_other_namespaces (location_t location
, tree name
)
5588 namespace_hints
ns_hints (location
, name
);
5590 name_hint result
= ns_hints
.convert_candidates_to_name_hint ();
5592 return ns_hints
.maybe_decorate_with_limit (gnu::move (result
));
5595 /* A well-known name within the C++ standard library, returned by
5596 get_std_name_hint. */
5598 struct std_name_hint
5600 /* A name within "std::". */
5603 /* The header name defining it within the C++ Standard Library
5604 (with '<' and '>'). */
5607 /* The dialect of C++ in which this was added. */
5608 enum cxx_dialect min_dialect
;
5611 /* Subroutine of maybe_suggest_missing_header for handling unrecognized names
5612 for some of the most common names within "std::".
5613 Given non-NULL NAME, return the std_name_hint for it, or NULL. */
5615 static const std_name_hint
*
5616 get_std_name_hint (const char *name
)
5618 static const std_name_hint hints
[] = {
5620 {"any", "<any>", cxx17
},
5621 {"any_cast", "<any>", cxx17
},
5622 {"make_any", "<any>", cxx17
},
5624 {"array", "<array>", cxx11
},
5625 {"to_array", "<array>", cxx2a
},
5627 {"atomic", "<atomic>", cxx11
},
5628 {"atomic_flag", "<atomic>", cxx11
},
5629 {"atomic_ref", "<atomic>", cxx2a
},
5631 {"bitset", "<bitset>", cxx11
},
5633 {"weak_equality", "<compare>", cxx2a
},
5634 {"strong_equality", "<compare>", cxx2a
},
5635 {"partial_ordering", "<compare>", cxx2a
},
5636 {"weak_ordering", "<compare>", cxx2a
},
5637 {"strong_ordering", "<compare>", cxx2a
},
5639 {"complex", "<complex>", cxx98
},
5640 {"complex_literals", "<complex>", cxx14
},
5641 /* <condition_variable>. */
5642 {"condition_variable", "<condition_variable>", cxx11
},
5643 {"condition_variable_any", "<condition_variable>", cxx11
},
5645 {"byte", "<cstddef>", cxx17
},
5647 {"deque", "<deque>", cxx98
},
5648 /* <forward_list>. */
5649 {"forward_list", "<forward_list>", cxx11
},
5651 {"basic_filebuf", "<fstream>", cxx98
},
5652 {"basic_ifstream", "<fstream>", cxx98
},
5653 {"basic_ofstream", "<fstream>", cxx98
},
5654 {"basic_fstream", "<fstream>", cxx98
},
5655 {"fstream", "<fstream>", cxx98
},
5656 {"ifstream", "<fstream>", cxx98
},
5657 {"ofstream", "<fstream>", cxx98
},
5659 {"bind", "<functional>", cxx11
},
5660 {"bind_front", "<functional>", cxx2a
},
5661 {"function", "<functional>", cxx11
},
5662 {"hash", "<functional>", cxx11
},
5663 {"invoke", "<functional>", cxx17
},
5664 {"mem_fn", "<functional>", cxx11
},
5665 {"not_fn", "<functional>", cxx17
},
5666 {"reference_wrapper", "<functional>", cxx11
},
5667 {"unwrap_reference", "<functional>", cxx2a
},
5668 {"unwrap_reference_t", "<functional>", cxx2a
},
5669 {"unwrap_ref_decay", "<functional>", cxx2a
},
5670 {"unwrap_ref_decay_t", "<functional>", cxx2a
},
5672 {"async", "<future>", cxx11
},
5673 {"future", "<future>", cxx11
},
5674 {"packaged_task", "<future>", cxx11
},
5675 {"promise", "<future>", cxx11
},
5677 {"cin", "<iostream>", cxx98
},
5678 {"cout", "<iostream>", cxx98
},
5679 {"cerr", "<iostream>", cxx98
},
5680 {"clog", "<iostream>", cxx98
},
5681 {"wcin", "<iostream>", cxx98
},
5682 {"wcout", "<iostream>", cxx98
},
5683 {"wclog", "<iostream>", cxx98
},
5685 {"istream", "<istream>", cxx98
},
5687 {"advance", "<iterator>", cxx98
},
5688 {"back_inserter", "<iterator>", cxx98
},
5689 {"begin", "<iterator>", cxx11
},
5690 {"distance", "<iterator>", cxx98
},
5691 {"end", "<iterator>", cxx11
},
5692 {"front_inserter", "<iterator>", cxx98
},
5693 {"inserter", "<iterator>", cxx98
},
5694 {"istream_iterator", "<iterator>", cxx98
},
5695 {"istreambuf_iterator", "<iterator>", cxx98
},
5696 {"iterator_traits", "<iterator>", cxx98
},
5697 {"move_iterator", "<iterator>", cxx11
},
5698 {"next", "<iterator>", cxx11
},
5699 {"ostream_iterator", "<iterator>", cxx98
},
5700 {"ostreambuf_iterator", "<iterator>", cxx98
},
5701 {"prev", "<iterator>", cxx11
},
5702 {"reverse_iterator", "<iterator>", cxx98
},
5704 {"ostream", "<ostream>", cxx98
},
5706 {"list", "<list>", cxx98
},
5708 {"map", "<map>", cxx98
},
5709 {"multimap", "<map>", cxx98
},
5711 {"allocate_shared", "<memory>", cxx11
},
5712 {"allocator", "<memory>", cxx98
},
5713 {"allocator_traits", "<memory>", cxx11
},
5714 {"make_shared", "<memory>", cxx11
},
5715 {"make_unique", "<memory>", cxx14
},
5716 {"shared_ptr", "<memory>", cxx11
},
5717 {"unique_ptr", "<memory>", cxx11
},
5718 {"weak_ptr", "<memory>", cxx11
},
5719 /* <memory_resource>. */
5720 {"pmr", "<memory_resource>", cxx17
},
5722 {"mutex", "<mutex>", cxx11
},
5723 {"timed_mutex", "<mutex>", cxx11
},
5724 {"recursive_mutex", "<mutex>", cxx11
},
5725 {"recursive_timed_mutex", "<mutex>", cxx11
},
5726 {"once_flag", "<mutex>", cxx11
},
5727 {"call_once,", "<mutex>", cxx11
},
5728 {"lock", "<mutex>", cxx11
},
5729 {"scoped_lock", "<mutex>", cxx17
},
5730 {"try_lock", "<mutex>", cxx11
},
5731 {"lock_guard", "<mutex>", cxx11
},
5732 {"unique_lock", "<mutex>", cxx11
},
5734 {"optional", "<optional>", cxx17
},
5735 {"make_optional", "<optional>", cxx17
},
5737 {"ostream", "<ostream>", cxx98
},
5738 {"wostream", "<ostream>", cxx98
},
5739 {"ends", "<ostream>", cxx98
},
5740 {"flush", "<ostream>", cxx98
},
5741 {"endl", "<ostream>", cxx98
},
5743 {"queue", "<queue>", cxx98
},
5744 {"priority_queue", "<queue>", cxx98
},
5746 {"set", "<set>", cxx98
},
5747 {"multiset", "<set>", cxx98
},
5748 /* <shared_mutex>. */
5749 {"shared_lock", "<shared_mutex>", cxx14
},
5750 {"shared_mutex", "<shared_mutex>", cxx17
},
5751 {"shared_timed_mutex", "<shared_mutex>", cxx14
},
5752 /* <source_location>. */
5753 {"source_location", "<source_location>", cxx2a
},
5755 {"basic_stringbuf", "<sstream>", cxx98
},
5756 {"basic_istringstream", "<sstream>", cxx98
},
5757 {"basic_ostringstream", "<sstream>", cxx98
},
5758 {"basic_stringstream", "<sstream>", cxx98
},
5759 {"istringstream", "<sstream>", cxx98
},
5760 {"ostringstream", "<sstream>", cxx98
},
5761 {"stringstream", "<sstream>", cxx98
},
5763 {"stack", "<stack>", cxx98
},
5765 {"basic_string", "<string>", cxx98
},
5766 {"string", "<string>", cxx98
},
5767 {"wstring", "<string>", cxx98
},
5768 {"u8string", "<string>", cxx2a
},
5769 {"u16string", "<string>", cxx11
},
5770 {"u32string", "<string>", cxx11
},
5771 /* <string_view>. */
5772 {"basic_string_view", "<string_view>", cxx17
},
5773 {"string_view", "<string_view>", cxx17
},
5775 {"thread", "<thread>", cxx11
},
5776 {"this_thread", "<thread>", cxx11
},
5778 {"apply", "<tuple>", cxx17
},
5779 {"forward_as_tuple", "<tuple>", cxx11
},
5780 {"make_from_tuple", "<tuple>", cxx17
},
5781 {"make_tuple", "<tuple>", cxx11
},
5782 {"tie", "<tuple>", cxx11
},
5783 {"tuple", "<tuple>", cxx11
},
5784 {"tuple_cat", "<tuple>", cxx11
},
5785 {"tuple_element", "<tuple>", cxx11
},
5786 {"tuple_element_t", "<tuple>", cxx14
},
5787 {"tuple_size", "<tuple>", cxx11
},
5788 {"tuple_size_v", "<tuple>", cxx17
},
5789 /* <type_traits>. */
5790 {"enable_if", "<type_traits>", cxx11
},
5791 {"enable_if_t", "<type_traits>", cxx14
},
5792 {"invoke_result", "<type_traits>", cxx17
},
5793 {"invoke_result_t", "<type_traits>", cxx17
},
5794 {"remove_cvref", "<type_traits>", cxx2a
},
5795 {"remove_cvref_t", "<type_traits>", cxx2a
},
5796 {"type_identity", "<type_traits>", cxx2a
},
5797 {"type_identity_t", "<type_traits>", cxx2a
},
5798 {"void_t", "<type_traits>", cxx17
},
5799 {"conjunction", "<type_traits>", cxx17
},
5800 {"conjunction_v", "<type_traits>", cxx17
},
5801 {"disjunction", "<type_traits>", cxx17
},
5802 {"disjunction_v", "<type_traits>", cxx17
},
5803 {"negation", "<type_traits>", cxx17
},
5804 {"negation_v", "<type_traits>", cxx17
},
5805 /* <unordered_map>. */
5806 {"unordered_map", "<unordered_map>", cxx11
},
5807 {"unordered_multimap", "<unordered_map>", cxx11
},
5808 /* <unordered_set>. */
5809 {"unordered_set", "<unordered_set>", cxx11
},
5810 {"unordered_multiset", "<unordered_set>", cxx11
},
5812 {"declval", "<utility>", cxx11
},
5813 {"forward", "<utility>", cxx11
},
5814 {"make_pair", "<utility>", cxx98
},
5815 {"move", "<utility>", cxx11
},
5816 {"pair", "<utility>", cxx98
},
5818 {"variant", "<variant>", cxx17
},
5819 {"visit", "<variant>", cxx17
},
5821 {"vector", "<vector>", cxx98
},
5823 const size_t num_hints
= sizeof (hints
) / sizeof (hints
[0]);
5824 for (size_t i
= 0; i
< num_hints
; i
++)
5826 if (strcmp (name
, hints
[i
].name
) == 0)
5832 /* Describe DIALECT. */
5835 get_cxx_dialect_name (enum cxx_dialect dialect
)
5854 /* Subclass of deferred_diagnostic for use for names in the "std" namespace
5855 that weren't recognized, but for which we know which header it ought to be
5858 Emit a note either suggesting the header to be included, or noting that
5859 the current dialect is too early for the given name. */
5861 class missing_std_header
: public deferred_diagnostic
5864 missing_std_header (location_t loc
,
5865 const char *name_str
,
5866 const std_name_hint
*header_hint
)
5867 : deferred_diagnostic (loc
),
5868 m_name_str (name_str
),
5869 m_header_hint (header_hint
)
5871 ~missing_std_header ()
5873 gcc_rich_location
richloc (get_location ());
5874 if (cxx_dialect
>= m_header_hint
->min_dialect
)
5876 const char *header
= m_header_hint
->header
;
5877 maybe_add_include_fixit (&richloc
, header
, true);
5879 "%<std::%s%> is defined in header %qs;"
5880 " did you forget to %<#include %s%>?",
5881 m_name_str
, header
, header
);
5885 "%<std::%s%> is only available from %s onwards",
5886 m_name_str
, get_cxx_dialect_name (m_header_hint
->min_dialect
));
5890 const char *m_name_str
;
5891 const std_name_hint
*m_header_hint
;
5894 /* Attempt to generate a name_hint that suggests pertinent header files
5895 for NAME at LOCATION, for common names within the "std" namespace,
5896 or an empty name_hint if this isn't applicable. */
5899 maybe_suggest_missing_std_header (location_t location
, tree name
)
5901 gcc_assert (TREE_CODE (name
) == IDENTIFIER_NODE
);
5903 const char *name_str
= IDENTIFIER_POINTER (name
);
5904 const std_name_hint
*header_hint
= get_std_name_hint (name_str
);
5906 return name_hint ();
5908 return name_hint (NULL
, new missing_std_header (location
, name_str
,
5912 /* Attempt to generate a name_hint that suggests a missing header file
5913 for NAME within SCOPE at LOCATION, or an empty name_hint if this isn't
5917 maybe_suggest_missing_header (location_t location
, tree name
, tree scope
)
5919 if (scope
== NULL_TREE
)
5920 return name_hint ();
5921 if (TREE_CODE (scope
) != NAMESPACE_DECL
)
5922 return name_hint ();
5923 /* We only offer suggestions for the "std" namespace. */
5924 if (scope
!= std_node
)
5925 return name_hint ();
5926 return maybe_suggest_missing_std_header (location
, name
);
5929 /* Generate a name_hint at LOCATION for NAME, an IDENTIFIER_NODE for which name
5930 lookup failed within the explicitly provided SCOPE.
5932 Suggest the the best meaningful candidates (if any), otherwise
5933 an empty name_hint is returned. */
5936 suggest_alternative_in_explicit_scope (location_t location
, tree name
,
5939 /* Something went very wrong; don't suggest anything. */
5940 if (name
== error_mark_node
)
5941 return name_hint ();
5943 /* Resolve any namespace aliases. */
5944 scope
= ORIGINAL_NAMESPACE (scope
);
5946 name_hint hint
= maybe_suggest_missing_header (location
, name
, scope
);
5950 cp_binding_level
*level
= NAMESPACE_LEVEL (scope
);
5952 best_match
<tree
, const char *> bm (name
);
5953 consider_binding_level (name
, bm
, level
, false, FUZZY_LOOKUP_NAME
);
5955 /* See if we have a good suggesion for the user. */
5956 const char *fuzzy_name
= bm
.get_best_meaningful_candidate ();
5958 return name_hint (fuzzy_name
, NULL
);
5960 return name_hint ();
5963 /* Given NAME, look within SCOPED_ENUM for possible spell-correction
5967 suggest_alternative_in_scoped_enum (tree name
, tree scoped_enum
)
5969 gcc_assert (SCOPED_ENUM_P (scoped_enum
));
5971 best_match
<tree
, const char *> bm (name
);
5972 for (tree iter
= TYPE_VALUES (scoped_enum
); iter
; iter
= TREE_CHAIN (iter
))
5974 tree id
= TREE_PURPOSE (iter
);
5975 bm
.consider (IDENTIFIER_POINTER (id
));
5977 return name_hint (bm
.get_best_meaningful_candidate (), NULL
);
5980 /* Look up NAME (an IDENTIFIER_NODE) in SCOPE (either a NAMESPACE_DECL
5983 If PREFER_TYPE is > 0, we only return TYPE_DECLs or namespaces.
5984 If PREFER_TYPE is > 1, we only return TYPE_DECLs.
5986 Returns a DECL (or OVERLOAD, or BASELINK) representing the
5987 declaration found. If no suitable declaration can be found,
5988 ERROR_MARK_NODE is returned. If COMPLAIN is true and SCOPE is
5989 neither a class-type nor a namespace a diagnostic is issued. */
5992 lookup_qualified_name (tree scope
, tree name
, int prefer_type
, bool complain
,
5993 bool find_hidden
/*=false*/)
5997 if (TREE_CODE (scope
) == NAMESPACE_DECL
)
5999 int flags
= lookup_flags (prefer_type
, /*namespaces_only*/false);
6001 flags
|= LOOKUP_HIDDEN
;
6002 name_lookup
lookup (name
, flags
);
6004 if (qualified_namespace_lookup (scope
, &lookup
))
6007 else if (cxx_dialect
!= cxx98
&& TREE_CODE (scope
) == ENUMERAL_TYPE
)
6008 t
= lookup_enumerator (scope
, name
);
6009 else if (is_class_type (scope
, complain
))
6010 t
= lookup_member (scope
, name
, 2, prefer_type
, tf_warning_or_error
);
6013 return error_mark_node
;
6017 /* Wrapper for the above that takes a string argument. The function name is
6018 not at the beginning of the line to keep this wrapper out of etags. */
6020 tree
lookup_qualified_name (tree t
, const char *p
, int wt
, bool c
, bool fh
)
6021 { return lookup_qualified_name (t
, get_identifier (p
), wt
, c
, fh
); }
6024 Accepts the NAME to lookup and its qualifying SCOPE.
6025 Returns the name/type pair found into the cxx_binding *RESULT,
6026 or false on error. */
6029 qualified_namespace_lookup (tree scope
, name_lookup
*lookup
)
6031 timevar_start (TV_NAME_LOOKUP
);
6032 query_oracle (lookup
->name
);
6033 bool found
= lookup
->search_qualified (ORIGINAL_NAMESPACE (scope
));
6034 timevar_stop (TV_NAME_LOOKUP
);
6038 /* Helper function for lookup_name_fuzzy.
6039 Traverse binding level LVL, looking for good name matches for NAME
6042 consider_binding_level (tree name
, best_match
<tree
, const char *> &bm
,
6043 cp_binding_level
*lvl
, bool look_within_fields
,
6044 enum lookup_name_fuzzy_kind kind
)
6046 if (look_within_fields
)
6047 if (lvl
->this_entity
&& TREE_CODE (lvl
->this_entity
) == RECORD_TYPE
)
6049 tree type
= lvl
->this_entity
;
6050 bool want_type_p
= (kind
== FUZZY_LOOKUP_TYPENAME
);
6051 tree best_matching_field
6052 = lookup_member_fuzzy (type
, name
, want_type_p
);
6053 if (best_matching_field
)
6054 bm
.consider (IDENTIFIER_POINTER (best_matching_field
));
6057 /* Only suggest names reserved for the implementation if NAME begins
6058 with an underscore. */
6059 bool consider_implementation_names
= (IDENTIFIER_POINTER (name
)[0] == '_');
6061 for (tree t
= lvl
->names
; t
; t
= TREE_CHAIN (t
))
6065 /* OVERLOADs or decls from using declaration are wrapped into
6067 if (TREE_CODE (d
) == TREE_LIST
)
6068 d
= OVL_FIRST (TREE_VALUE (d
));
6070 /* Don't use bindings from implicitly declared functions,
6071 as they were likely misspellings themselves. */
6072 if (TREE_TYPE (d
) == error_mark_node
)
6075 /* Skip anticipated decls of builtin functions. */
6076 if (TREE_CODE (d
) == FUNCTION_DECL
6077 && fndecl_built_in_p (d
)
6078 && DECL_ANTICIPATED (d
))
6081 /* Skip compiler-generated variables (e.g. __for_begin/__for_end
6082 within range for). */
6083 if (TREE_CODE (d
) == VAR_DECL
6084 && DECL_ARTIFICIAL (d
))
6087 tree suggestion
= DECL_NAME (d
);
6091 /* Don't suggest names that are for anonymous aggregate types, as
6092 they are an implementation detail generated by the compiler. */
6093 if (IDENTIFIER_ANON_P (suggestion
))
6096 const char *suggestion_str
= IDENTIFIER_POINTER (suggestion
);
6098 /* Ignore internal names with spaces in them. */
6099 if (strchr (suggestion_str
, ' '))
6102 /* Don't suggest names that are reserved for use by the
6103 implementation, unless NAME began with an underscore. */
6104 if (name_reserved_for_implementation_p (suggestion_str
)
6105 && !consider_implementation_names
)
6108 bm
.consider (suggestion_str
);
6112 /* Subclass of deferred_diagnostic. Notify the user that the
6113 given macro was used before it was defined.
6114 This can be done in the C++ frontend since tokenization happens
6117 class macro_use_before_def
: public deferred_diagnostic
6120 /* Factory function. Return a new macro_use_before_def instance if
6121 appropriate, or return NULL. */
6122 static macro_use_before_def
*
6123 maybe_make (location_t use_loc
, cpp_hashnode
*macro
)
6125 location_t def_loc
= cpp_macro_definition_location (macro
);
6126 if (def_loc
== UNKNOWN_LOCATION
)
6129 /* We only want to issue a note if the macro was used *before* it was
6131 We don't want to issue a note for cases where a macro was incorrectly
6132 used, leaving it unexpanded (e.g. by using the wrong argument
6134 if (!linemap_location_before_p (line_table
, use_loc
, def_loc
))
6137 return new macro_use_before_def (use_loc
, macro
);
6141 /* Ctor. LOC is the location of the usage. MACRO is the
6142 macro that was used. */
6143 macro_use_before_def (location_t loc
, cpp_hashnode
*macro
)
6144 : deferred_diagnostic (loc
), m_macro (macro
)
6149 ~macro_use_before_def ()
6151 if (is_suppressed_p ())
6154 inform (get_location (), "the macro %qs had not yet been defined",
6155 (const char *)m_macro
->ident
.str
);
6156 inform (cpp_macro_definition_location (m_macro
),
6157 "it was later defined here");
6161 cpp_hashnode
*m_macro
;
6164 /* Determine if it can ever make sense to offer RID as a suggestion for
6167 Subroutine of lookup_name_fuzzy. */
6170 suggest_rid_p (enum rid rid
)
6174 /* Support suggesting function-like keywords. */
6175 case RID_STATIC_ASSERT
:
6179 /* Support suggesting the various decl-specifier words, to handle
6180 e.g. "singed" vs "signed" typos. */
6181 if (cp_keyword_starts_decl_specifier_p (rid
))
6184 /* Otherwise, don't offer it. This avoids suggesting e.g. "if"
6185 and "do" for short misspellings, which are likely to lead to
6186 nonsensical results. */
6191 /* Search for near-matches for NAME within the current bindings, and within
6192 macro names, returning the best match as a const char *, or NULL if
6193 no reasonable match is found.
6195 Use LOC for any deferred diagnostics. */
6198 lookup_name_fuzzy (tree name
, enum lookup_name_fuzzy_kind kind
, location_t loc
)
6200 gcc_assert (TREE_CODE (name
) == IDENTIFIER_NODE
);
6202 /* First, try some well-known names in the C++ standard library, in case
6203 the user forgot a #include. */
6204 const char *header_hint
6205 = get_cp_stdlib_header_for_name (IDENTIFIER_POINTER (name
));
6207 return name_hint (NULL
,
6208 new suggest_missing_header (loc
,
6209 IDENTIFIER_POINTER (name
),
6212 best_match
<tree
, const char *> bm (name
);
6214 cp_binding_level
*lvl
;
6215 for (lvl
= scope_chain
->class_bindings
; lvl
; lvl
= lvl
->level_chain
)
6216 consider_binding_level (name
, bm
, lvl
, true, kind
);
6218 for (lvl
= current_binding_level
; lvl
; lvl
= lvl
->level_chain
)
6219 consider_binding_level (name
, bm
, lvl
, false, kind
);
6221 /* Consider macros: if the user misspelled a macro name e.g. "SOME_MACRO"
6223 x = SOME_OTHER_MACRO (y);
6224 then "SOME_OTHER_MACRO" will survive to the frontend and show up
6225 as a misspelled identifier.
6227 Use the best distance so far so that a candidate is only set if
6228 a macro is better than anything so far. This allows early rejection
6229 (without calculating the edit distance) of macro names that must have
6230 distance >= bm.get_best_distance (), and means that we only get a
6231 non-NULL result for best_macro_match if it's better than any of
6232 the identifiers already checked. */
6233 best_macro_match
bmm (name
, bm
.get_best_distance (), parse_in
);
6234 cpp_hashnode
*best_macro
= bmm
.get_best_meaningful_candidate ();
6235 /* If a macro is the closest so far to NAME, consider it. */
6237 bm
.consider ((const char *)best_macro
->ident
.str
);
6238 else if (bmm
.get_best_distance () == 0)
6240 /* If we have an exact match for a macro name, then either the
6241 macro was used with the wrong argument count, or the macro
6242 has been used before it was defined. */
6243 if (cpp_hashnode
*macro
= bmm
.blithely_get_best_candidate ())
6244 if (cpp_user_macro_p (macro
))
6245 return name_hint (NULL
,
6246 macro_use_before_def::maybe_make (loc
, macro
));
6249 /* Try the "starts_decl_specifier_p" keywords to detect
6250 "singed" vs "signed" typos. */
6251 for (unsigned i
= 0; i
< num_c_common_reswords
; i
++)
6253 const c_common_resword
*resword
= &c_common_reswords
[i
];
6255 if (!suggest_rid_p (resword
->rid
))
6258 tree resword_identifier
= ridpointers
[resword
->rid
];
6259 if (!resword_identifier
)
6261 gcc_assert (TREE_CODE (resword_identifier
) == IDENTIFIER_NODE
);
6263 /* Only consider reserved words that survived the
6264 filtering in init_reswords (e.g. for -std). */
6265 if (!IDENTIFIER_KEYWORD_P (resword_identifier
))
6268 bm
.consider (IDENTIFIER_POINTER (resword_identifier
));
6271 return name_hint (bm
.get_best_meaningful_candidate (), NULL
);
6274 /* Subroutine of outer_binding.
6276 Returns TRUE if BINDING is a binding to a template parameter of
6277 SCOPE. In that case SCOPE is the scope of a primary template
6278 parameter -- in the sense of G++, i.e, a template that has its own
6281 Returns FALSE otherwise. */
6284 binding_to_template_parms_of_scope_p (cxx_binding
*binding
,
6285 cp_binding_level
*scope
)
6287 tree binding_value
, tmpl
, tinfo
;
6290 if (!binding
|| !scope
|| !scope
->this_entity
)
6293 binding_value
= binding
->value
? binding
->value
: binding
->type
;
6294 tinfo
= get_template_info (scope
->this_entity
);
6296 /* BINDING_VALUE must be a template parm. */
6297 if (binding_value
== NULL_TREE
6298 || (!DECL_P (binding_value
)
6299 || !DECL_TEMPLATE_PARM_P (binding_value
)))
6302 /* The level of BINDING_VALUE. */
6304 template_type_parameter_p (binding_value
)
6305 ? TEMPLATE_PARM_LEVEL (TEMPLATE_TYPE_PARM_INDEX
6306 (TREE_TYPE (binding_value
)))
6307 : TEMPLATE_PARM_LEVEL (DECL_INITIAL (binding_value
));
6309 /* The template of the current scope, iff said scope is a primary
6312 && PRIMARY_TEMPLATE_P (TI_TEMPLATE (tinfo
))
6313 ? TI_TEMPLATE (tinfo
)
6316 /* If the level of the parm BINDING_VALUE equals the depth of TMPL,
6317 then BINDING_VALUE is a parameter of TMPL. */
6318 return (tmpl
&& level
== TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (tmpl
)));
6321 /* Return the innermost non-namespace binding for NAME from a scope
6322 containing BINDING, or, if BINDING is NULL, the current scope.
6323 Please note that for a given template, the template parameters are
6324 considered to be in the scope containing the current scope.
6325 If CLASS_P is false, then class bindings are ignored. */
6328 outer_binding (tree name
,
6329 cxx_binding
*binding
,
6333 cp_binding_level
*scope
;
6334 cp_binding_level
*outer_scope
;
6338 scope
= binding
->scope
->level_chain
;
6339 outer
= binding
->previous
;
6343 scope
= current_binding_level
;
6344 outer
= IDENTIFIER_BINDING (name
);
6346 outer_scope
= outer
? outer
->scope
: NULL
;
6348 /* Because we create class bindings lazily, we might be missing a
6349 class binding for NAME. If there are any class binding levels
6350 between the LAST_BINDING_LEVEL and the scope in which OUTER was
6351 declared, we must lookup NAME in those class scopes. */
6353 while (scope
&& scope
!= outer_scope
&& scope
->kind
!= sk_namespace
)
6355 if (scope
->kind
== sk_class
)
6357 cxx_binding
*class_binding
;
6359 class_binding
= get_class_binding (name
, scope
);
6362 /* Thread this new class-scope binding onto the
6363 IDENTIFIER_BINDING list so that future lookups
6365 class_binding
->previous
= outer
;
6367 binding
->previous
= class_binding
;
6369 IDENTIFIER_BINDING (name
) = class_binding
;
6370 return class_binding
;
6373 /* If we are in a member template, the template parms of the member
6374 template are considered to be inside the scope of the containing
6375 class, but within G++ the class bindings are all pushed between the
6376 template parms and the function body. So if the outer binding is
6377 a template parm for the current scope, return it now rather than
6378 look for a class binding. */
6379 if (outer_scope
&& outer_scope
->kind
== sk_template_parms
6380 && binding_to_template_parms_of_scope_p (outer
, scope
))
6383 scope
= scope
->level_chain
;
6389 /* Return the innermost block-scope or class-scope value binding for
6390 NAME, or NULL_TREE if there is no such binding. */
6393 innermost_non_namespace_value (tree name
)
6395 cxx_binding
*binding
;
6396 binding
= outer_binding (name
, /*binding=*/NULL
, /*class_p=*/true);
6397 return binding
? binding
->value
: NULL_TREE
;
6400 /* Look up NAME in the current binding level and its superiors in the
6401 namespace of variables, functions and typedefs. Return a ..._DECL
6402 node of some kind representing its definition if there is only one
6403 such declaration, or return a TREE_LIST with all the overloaded
6404 definitions if there are many, or return 0 if it is undefined.
6405 Hidden name, either friend declaration or built-in function, are
6408 If PREFER_TYPE is > 0, we prefer TYPE_DECLs or namespaces.
6409 If PREFER_TYPE is > 1, we reject non-type decls (e.g. namespaces).
6410 Otherwise we prefer non-TYPE_DECLs.
6412 If NONCLASS is nonzero, bindings in class scopes are ignored. If
6413 BLOCK_P is false, bindings in block scopes are ignored. */
6416 lookup_name_real_1 (tree name
, int prefer_type
, int nonclass
, bool block_p
,
6417 int namespaces_only
, int flags
)
6420 tree val
= NULL_TREE
;
6422 query_oracle (name
);
6424 /* Conversion operators are handled specially because ordinary
6425 unqualified name lookup will not find template conversion
6427 if (IDENTIFIER_CONV_OP_P (name
))
6429 cp_binding_level
*level
;
6431 for (level
= current_binding_level
;
6432 level
&& level
->kind
!= sk_namespace
;
6433 level
= level
->level_chain
)
6438 /* A conversion operator can only be declared in a class
6440 if (level
->kind
!= sk_class
)
6443 /* Lookup the conversion operator in the class. */
6444 class_type
= level
->this_entity
;
6445 operators
= lookup_fnfields (class_type
, name
, /*protect=*/0);
6453 flags
|= lookup_flags (prefer_type
, namespaces_only
);
6455 /* First, look in non-namespace scopes. */
6457 if (current_class_type
== NULL_TREE
)
6460 if (block_p
|| !nonclass
)
6461 for (iter
= outer_binding (name
, NULL
, !nonclass
);
6463 iter
= outer_binding (name
, iter
, !nonclass
))
6467 /* Skip entities we don't want. */
6468 if (LOCAL_BINDING_P (iter
) ? !block_p
: nonclass
)
6471 /* If this is the kind of thing we're looking for, we're done. */
6472 if (qualify_lookup (iter
->value
, flags
))
6473 binding
= iter
->value
;
6474 else if ((flags
& LOOKUP_PREFER_TYPES
)
6475 && qualify_lookup (iter
->type
, flags
))
6476 binding
= iter
->type
;
6478 binding
= NULL_TREE
;
6482 if (TREE_CODE (binding
) == TYPE_DECL
&& DECL_HIDDEN_P (binding
))
6484 /* A non namespace-scope binding can only be hidden in the
6485 presence of a local class, due to friend declarations.
6487 In particular, consider:
6495 B* b; // error: B is hidden
6496 C* c; // OK, finds ::C
6499 B *b; // error: B is hidden
6500 C *c; // OK, finds ::C
6505 The standard says that "B" is a local class in "f"
6506 (but not nested within "A") -- but that name lookup
6507 for "B" does not find this declaration until it is
6508 declared directly with "f".
6514 If a friend declaration appears in a local class and
6515 the name specified is an unqualified name, a prior
6516 declaration is looked up without considering scopes
6517 that are outside the innermost enclosing non-class
6518 scope. For a friend function declaration, if there is
6519 no prior declaration, the program is ill-formed. For a
6520 friend class declaration, if there is no prior
6521 declaration, the class that is specified belongs to the
6522 innermost enclosing non-class scope, but if it is
6523 subsequently referenced, its name is not found by name
6524 lookup until a matching declaration is provided in the
6525 innermost enclosing nonclass scope.
6527 So just keep looking for a non-hidden binding.
6529 gcc_assert (TREE_CODE (binding
) == TYPE_DECL
);
6537 /* Now lookup in namespace scopes. */
6540 name_lookup
lookup (name
, flags
);
6541 if (lookup
.search_unqualified
6542 (current_decl_namespace (), current_binding_level
))
6546 /* If we have a single function from a using decl, pull it out. */
6547 if (val
&& TREE_CODE (val
) == OVERLOAD
&& !really_overloaded_fn (val
))
6548 val
= OVL_FUNCTION (val
);
6553 /* Wrapper for lookup_name_real_1. */
6556 lookup_name_real (tree name
, int prefer_type
, int nonclass
, bool block_p
,
6557 int namespaces_only
, int flags
)
6560 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
6561 ret
= lookup_name_real_1 (name
, prefer_type
, nonclass
, block_p
,
6562 namespaces_only
, flags
);
6563 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
6568 lookup_name_nonclass (tree name
)
6570 return lookup_name_real (name
, 0, 1, /*block_p=*/true, 0, 0);
6574 lookup_name (tree name
)
6576 return lookup_name_real (name
, 0, 0, /*block_p=*/true, 0, 0);
6580 lookup_name_prefer_type (tree name
, int prefer_type
)
6582 return lookup_name_real (name
, prefer_type
, 0, /*block_p=*/true, 0, 0);
6585 /* Look up NAME for type used in elaborated name specifier in
6586 the scopes given by SCOPE. SCOPE can be either TS_CURRENT or
6587 TS_WITHIN_ENCLOSING_NON_CLASS. Although not implied by the
6588 name, more scopes are checked if cleanup or template parameter
6589 scope is encountered.
6591 Unlike lookup_name_real, we make sure that NAME is actually
6592 declared in the desired scope, not from inheritance, nor using
6593 directive. For using declaration, there is DR138 still waiting
6594 to be resolved. Hidden name coming from an earlier friend
6595 declaration is also returned.
6597 A TYPE_DECL best matching the NAME is returned. Catching error
6598 and issuing diagnostics are caller's responsibility. */
6601 lookup_type_scope_1 (tree name
, tag_scope scope
)
6603 cp_binding_level
*b
= current_binding_level
;
6605 if (b
->kind
!= sk_namespace
)
6606 /* Look in non-namespace scopes. */
6607 for (cxx_binding
*iter
= NULL
;
6608 (iter
= outer_binding (name
, iter
, /*class_p=*/ true)); )
6610 /* First check we're supposed to be looking in this scope --
6611 if we're not, we're done. */
6612 for (; b
!= iter
->scope
; b
= b
->level_chain
)
6613 if (!(b
->kind
== sk_cleanup
6614 || b
->kind
== sk_template_parms
6615 || b
->kind
== sk_function_parms
6616 || (b
->kind
== sk_class
6617 && scope
== ts_within_enclosing_non_class
)))
6620 /* Check if this is the kind of thing we're looking for. If
6621 SCOPE is TS_CURRENT, also make sure it doesn't come from
6622 base class. For ITER->VALUE, we can simply use
6623 INHERITED_VALUE_BINDING_P. For ITER->TYPE, we have to
6626 We check ITER->TYPE before ITER->VALUE in order to handle
6627 typedef struct C {} C;
6629 if (tree type
= iter
->type
)
6630 if (qualify_lookup (type
, LOOKUP_PREFER_TYPES
)
6631 && (scope
!= ts_current
6632 || LOCAL_BINDING_P (iter
)
6633 || DECL_CONTEXT (type
) == iter
->scope
->this_entity
))
6636 if (qualify_lookup (iter
->value
, LOOKUP_PREFER_TYPES
)
6637 && (scope
!= ts_current
6638 || !INHERITED_VALUE_BINDING_P (iter
)))
6642 /* Now check if we can look in namespace scope. */
6643 for (; b
->kind
!= sk_namespace
; b
= b
->level_chain
)
6644 if (!(b
->kind
== sk_cleanup
6645 || b
->kind
== sk_template_parms
6646 || b
->kind
== sk_function_parms
6647 || (b
->kind
== sk_class
6648 && scope
== ts_within_enclosing_non_class
)))
6651 /* Look in the innermost namespace. */
6652 tree ns
= b
->this_entity
;
6653 if (tree
*slot
= find_namespace_slot (ns
, name
))
6655 /* If this is the kind of thing we're looking for, we're done. */
6656 if (tree type
= MAYBE_STAT_TYPE (*slot
))
6657 if (qualify_lookup (type
, LOOKUP_PREFER_TYPES
))
6660 if (tree decl
= MAYBE_STAT_DECL (*slot
))
6661 if (qualify_lookup (decl
, LOOKUP_PREFER_TYPES
))
6668 /* Wrapper for lookup_type_scope_1. */
6671 lookup_type_scope (tree name
, tag_scope scope
)
6674 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
6675 ret
= lookup_type_scope_1 (name
, scope
);
6676 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
6680 /* Returns true iff DECL is a block-scope extern declaration of a function
6684 is_local_extern (tree decl
)
6686 cxx_binding
*binding
;
6688 /* For functions, this is easy. */
6689 if (TREE_CODE (decl
) == FUNCTION_DECL
)
6690 return DECL_LOCAL_FUNCTION_P (decl
);
6694 if (!current_function_decl
)
6697 /* For variables, this is not easy. We need to look at the binding stack
6698 for the identifier to see whether the decl we have is a local. */
6699 for (binding
= IDENTIFIER_BINDING (DECL_NAME (decl
));
6700 binding
&& binding
->scope
->kind
!= sk_namespace
;
6701 binding
= binding
->previous
)
6702 if (binding
->value
== decl
)
6703 return LOCAL_BINDING_P (binding
);
6708 /* The type TYPE is being declared. If it is a class template, or a
6709 specialization of a class template, do any processing required and
6710 perform error-checking. If IS_FRIEND is nonzero, this TYPE is
6711 being declared a friend. B is the binding level at which this TYPE
6714 Returns the TYPE_DECL for TYPE, which may have been altered by this
6718 maybe_process_template_type_declaration (tree type
, int is_friend
,
6719 cp_binding_level
*b
)
6721 tree decl
= TYPE_NAME (type
);
6723 if (processing_template_parmlist
)
6724 /* You can't declare a new template type in a template parameter
6725 list. But, you can declare a non-template type:
6727 template <class A*> struct S;
6729 is a forward-declaration of `A'. */
6731 else if (b
->kind
== sk_namespace
6732 && current_binding_level
->kind
!= sk_namespace
)
6733 /* If this new type is being injected into a containing scope,
6734 then it's not a template type. */
6738 gcc_assert (MAYBE_CLASS_TYPE_P (type
)
6739 || TREE_CODE (type
) == ENUMERAL_TYPE
);
6741 if (processing_template_decl
)
6743 /* This may change after the call to
6744 push_template_decl_real, but we want the original value. */
6745 tree name
= DECL_NAME (decl
);
6747 decl
= push_template_decl_real (decl
, is_friend
);
6748 if (decl
== error_mark_node
)
6749 return error_mark_node
;
6751 /* If the current binding level is the binding level for the
6752 template parameters (see the comment in
6753 begin_template_parm_list) and the enclosing level is a class
6754 scope, and we're not looking at a friend, push the
6755 declaration of the member class into the class scope. In the
6756 friend case, push_template_decl will already have put the
6757 friend into global scope, if appropriate. */
6758 if (TREE_CODE (type
) != ENUMERAL_TYPE
6759 && !is_friend
&& b
->kind
== sk_template_parms
6760 && b
->level_chain
->kind
== sk_class
)
6762 finish_member_declaration (CLASSTYPE_TI_TEMPLATE (type
));
6764 if (!COMPLETE_TYPE_P (current_class_type
))
6766 maybe_add_class_template_decl_list (current_class_type
,
6767 type
, /*friend_p=*/0);
6768 /* Put this UTD in the table of UTDs for the class. */
6769 if (CLASSTYPE_NESTED_UTDS (current_class_type
) == NULL
)
6770 CLASSTYPE_NESTED_UTDS (current_class_type
) =
6771 binding_table_new (SCOPE_DEFAULT_HT_SIZE
);
6773 binding_table_insert
6774 (CLASSTYPE_NESTED_UTDS (current_class_type
), name
, type
);
6783 /* Push a tag name NAME for struct/class/union/enum type TYPE. In case
6784 that the NAME is a class template, the tag is processed but not pushed.
6786 The pushed scope depend on the SCOPE parameter:
6787 - When SCOPE is TS_CURRENT, put it into the inner-most non-sk_cleanup
6789 - When SCOPE is TS_GLOBAL, put it in the inner-most non-class and
6790 non-template-parameter scope. This case is needed for forward
6792 - When SCOPE is TS_WITHIN_ENCLOSING_NON_CLASS, this is similar to
6793 TS_GLOBAL case except that names within template-parameter scopes
6794 are not pushed at all.
6796 Returns TYPE upon success and ERROR_MARK_NODE otherwise. */
6799 do_pushtag (tree name
, tree type
, tag_scope scope
)
6803 cp_binding_level
*b
= current_binding_level
;
6806 if (/* Cleanup scopes are not scopes from the point of view of
6808 b
->kind
== sk_cleanup
6809 /* Neither are function parameter scopes. */
6810 || b
->kind
== sk_function_parms
6811 /* Neither are the scopes used to hold template parameters
6812 for an explicit specialization. For an ordinary template
6813 declaration, these scopes are not scopes from the point of
6814 view of the language. */
6815 || (b
->kind
== sk_template_parms
6816 && (b
->explicit_spec_p
|| scope
== ts_global
)))
6818 else if (b
->kind
== sk_class
6819 && scope
!= ts_current
)
6822 if (b
->kind
== sk_template_parms
)
6829 gcc_assert (identifier_p (name
));
6831 /* Do C++ gratuitous typedefing. */
6832 if (identifier_type_value_1 (name
) != type
)
6836 tree context
= TYPE_CONTEXT (type
);
6840 cp_binding_level
*cb
= b
;
6841 while (cb
->kind
!= sk_namespace
6842 && cb
->kind
!= sk_class
6843 && (cb
->kind
!= sk_function_parms
6844 || !cb
->this_entity
))
6845 cb
= cb
->level_chain
;
6846 tree cs
= cb
->this_entity
;
6848 gcc_checking_assert (TREE_CODE (cs
) == FUNCTION_DECL
6849 ? cs
== current_function_decl
6850 : TYPE_P (cs
) ? cs
== current_class_type
6851 : cs
== current_namespace
);
6853 if (scope
== ts_current
6854 || (cs
&& TREE_CODE (cs
) == FUNCTION_DECL
))
6856 else if (cs
&& TYPE_P (cs
))
6857 /* When declaring a friend class of a local class, we want
6858 to inject the newly named class into the scope
6859 containing the local class, not the namespace
6861 context
= decl_function_context (get_type_decl (cs
));
6864 context
= current_namespace
;
6866 if (b
->kind
== sk_class
6867 || (b
->kind
== sk_template_parms
6868 && b
->level_chain
->kind
== sk_class
))
6871 tdef
= create_implicit_typedef (name
, type
);
6872 DECL_CONTEXT (tdef
) = FROB_CONTEXT (context
);
6873 if (scope
== ts_within_enclosing_non_class
)
6875 /* This is a friend. Make this TYPE_DECL node hidden from
6876 ordinary name lookup. Its corresponding TEMPLATE_DECL
6877 will be marked in push_template_decl_real. */
6878 retrofit_lang_decl (tdef
);
6879 DECL_ANTICIPATED (tdef
) = 1;
6880 DECL_FRIEND_P (tdef
) = 1;
6883 decl
= maybe_process_template_type_declaration
6884 (type
, scope
== ts_within_enclosing_non_class
, b
);
6885 if (decl
== error_mark_node
)
6888 if (b
->kind
== sk_class
)
6890 if (!TYPE_BEING_DEFINED (current_class_type
))
6891 /* Don't push anywhere if the class is complete; a lambda in an
6892 NSDMI is not a member of the class. */
6894 else if (!PROCESSING_REAL_TEMPLATE_DECL_P ())
6895 /* Put this TYPE_DECL on the TYPE_FIELDS list for the
6896 class. But if it's a member template class, we want
6897 the TEMPLATE_DECL, not the TYPE_DECL, so this is done
6899 finish_member_declaration (decl
);
6901 pushdecl_class_level (decl
);
6903 else if (b
->kind
!= sk_template_parms
)
6905 decl
= do_pushdecl_with_scope (decl
, b
, /*is_friend=*/false);
6906 if (decl
== error_mark_node
)
6909 if (DECL_CONTEXT (decl
) == std_node
6910 && init_list_identifier
== DECL_NAME (TYPE_NAME (type
))
6911 && !CLASSTYPE_TEMPLATE_INFO (type
))
6913 error ("declaration of %<std::initializer_list%> does not match "
6914 "%<#include <initializer_list>%>, isn%'t a template");
6915 return error_mark_node
;
6920 set_identifier_type_value_with_scope (name
, tdef
, b
);
6922 TYPE_CONTEXT (type
) = DECL_CONTEXT (decl
);
6924 /* If this is a local class, keep track of it. We need this
6925 information for name-mangling, and so that it is possible to
6926 find all function definitions in a translation unit in a
6927 convenient way. (It's otherwise tricky to find a member
6928 function definition it's only pointed to from within a local
6930 if (TYPE_FUNCTION_SCOPE_P (type
))
6932 if (processing_template_decl
)
6934 /* Push a DECL_EXPR so we call pushtag at the right time in
6935 template instantiation rather than in some nested context. */
6936 add_decl_expr (decl
);
6938 /* Lambdas use LAMBDA_EXPR_DISCRIMINATOR instead. */
6939 else if (!LAMBDA_TYPE_P (type
))
6940 determine_local_discriminator (TYPE_NAME (type
));
6944 if (b
->kind
== sk_class
6945 && !COMPLETE_TYPE_P (current_class_type
))
6947 maybe_add_class_template_decl_list (current_class_type
,
6948 type
, /*friend_p=*/0);
6950 if (CLASSTYPE_NESTED_UTDS (current_class_type
) == NULL
)
6951 CLASSTYPE_NESTED_UTDS (current_class_type
)
6952 = binding_table_new (SCOPE_DEFAULT_HT_SIZE
);
6954 binding_table_insert
6955 (CLASSTYPE_NESTED_UTDS (current_class_type
), name
, type
);
6958 decl
= TYPE_NAME (type
);
6959 gcc_assert (TREE_CODE (decl
) == TYPE_DECL
);
6961 /* Set type visibility now if this is a forward declaration. */
6962 TREE_PUBLIC (decl
) = 1;
6963 determine_visibility (decl
);
6968 /* Wrapper for do_pushtag. */
6971 pushtag (tree name
, tree type
, tag_scope scope
)
6974 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
6975 ret
= do_pushtag (name
, type
, scope
);
6976 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
6981 /* Subroutines for reverting temporarily to top-level for instantiation
6982 of templates and such. We actually need to clear out the class- and
6983 local-value slots of all identifiers, so that only the global values
6984 are at all visible. Simply setting current_binding_level to the global
6985 scope isn't enough, because more binding levels may be pushed. */
6986 struct saved_scope
*scope_chain
;
6988 /* Return true if ID has not already been marked. */
6991 store_binding_p (tree id
)
6993 if (!id
|| !IDENTIFIER_BINDING (id
))
6996 if (IDENTIFIER_MARKED (id
))
7002 /* Add an appropriate binding to *OLD_BINDINGS which needs to already
7003 have enough space reserved. */
7006 store_binding (tree id
, vec
<cxx_saved_binding
, va_gc
> **old_bindings
)
7008 cxx_saved_binding saved
;
7010 gcc_checking_assert (store_binding_p (id
));
7012 IDENTIFIER_MARKED (id
) = 1;
7014 saved
.identifier
= id
;
7015 saved
.binding
= IDENTIFIER_BINDING (id
);
7016 saved
.real_type_value
= REAL_IDENTIFIER_TYPE_VALUE (id
);
7017 (*old_bindings
)->quick_push (saved
);
7018 IDENTIFIER_BINDING (id
) = NULL
;
7022 store_bindings (tree names
, vec
<cxx_saved_binding
, va_gc
> **old_bindings
)
7024 static vec
<tree
> bindings_need_stored
;
7028 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
7029 for (t
= names
; t
; t
= TREE_CHAIN (t
))
7031 if (TREE_CODE (t
) == TREE_LIST
)
7032 id
= TREE_PURPOSE (t
);
7036 if (store_binding_p (id
))
7037 bindings_need_stored
.safe_push (id
);
7039 if (!bindings_need_stored
.is_empty ())
7041 vec_safe_reserve_exact (*old_bindings
, bindings_need_stored
.length ());
7042 for (i
= 0; bindings_need_stored
.iterate (i
, &id
); ++i
)
7044 /* We can apparently have duplicates in NAMES. */
7045 if (store_binding_p (id
))
7046 store_binding (id
, old_bindings
);
7048 bindings_need_stored
.truncate (0);
7050 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
7053 /* Like store_bindings, but NAMES is a vector of cp_class_binding
7054 objects, rather than a TREE_LIST. */
7057 store_class_bindings (vec
<cp_class_binding
, va_gc
> *names
,
7058 vec
<cxx_saved_binding
, va_gc
> **old_bindings
)
7060 static vec
<tree
> bindings_need_stored
;
7062 cp_class_binding
*cb
;
7064 for (i
= 0; vec_safe_iterate (names
, i
, &cb
); ++i
)
7065 if (store_binding_p (cb
->identifier
))
7066 bindings_need_stored
.safe_push (cb
->identifier
);
7067 if (!bindings_need_stored
.is_empty ())
7070 vec_safe_reserve_exact (*old_bindings
, bindings_need_stored
.length ());
7071 for (i
= 0; bindings_need_stored
.iterate (i
, &id
); ++i
)
7072 store_binding (id
, old_bindings
);
7073 bindings_need_stored
.truncate (0);
7077 /* A chain of saved_scope structures awaiting reuse. */
7079 static GTY((deletable
)) struct saved_scope
*free_saved_scope
;
7082 do_push_to_top_level (void)
7084 struct saved_scope
*s
;
7085 cp_binding_level
*b
;
7086 cxx_saved_binding
*sb
;
7090 /* Reuse or create a new structure for this saved scope. */
7091 if (free_saved_scope
!= NULL
)
7093 s
= free_saved_scope
;
7094 free_saved_scope
= s
->prev
;
7096 vec
<cxx_saved_binding
, va_gc
> *old_bindings
= s
->old_bindings
;
7097 memset (s
, 0, sizeof (*s
));
7098 /* Also reuse the structure's old_bindings vector. */
7099 vec_safe_truncate (old_bindings
, 0);
7100 s
->old_bindings
= old_bindings
;
7103 s
= ggc_cleared_alloc
<saved_scope
> ();
7105 b
= scope_chain
? current_binding_level
: 0;
7107 /* If we're in the middle of some function, save our state. */
7111 push_function_context ();
7116 if (scope_chain
&& previous_class_level
)
7117 store_class_bindings (previous_class_level
->class_shadowed
,
7120 /* Have to include the global scope, because class-scope decls
7121 aren't listed anywhere useful. */
7122 for (; b
; b
= b
->level_chain
)
7126 /* Template IDs are inserted into the global level. If they were
7127 inserted into namespace level, finish_file wouldn't find them
7128 when doing pending instantiations. Therefore, don't stop at
7129 namespace level, but continue until :: . */
7130 if (global_scope_p (b
))
7133 store_bindings (b
->names
, &s
->old_bindings
);
7134 /* We also need to check class_shadowed to save class-level type
7135 bindings, since pushclass doesn't fill in b->names. */
7136 if (b
->kind
== sk_class
)
7137 store_class_bindings (b
->class_shadowed
, &s
->old_bindings
);
7139 /* Unwind type-value slots back to top level. */
7140 for (t
= b
->type_shadowed
; t
; t
= TREE_CHAIN (t
))
7141 SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (t
), TREE_VALUE (t
));
7144 FOR_EACH_VEC_SAFE_ELT (s
->old_bindings
, i
, sb
)
7145 IDENTIFIER_MARKED (sb
->identifier
) = 0;
7147 s
->prev
= scope_chain
;
7149 s
->need_pop_function_context
= need_pop
;
7150 s
->function_decl
= current_function_decl
;
7151 s
->unevaluated_operand
= cp_unevaluated_operand
;
7152 s
->inhibit_evaluation_warnings
= c_inhibit_evaluation_warnings
;
7153 s
->suppress_location_wrappers
= suppress_location_wrappers
;
7154 s
->x_stmt_tree
.stmts_are_full_exprs_p
= true;
7157 current_function_decl
= NULL_TREE
;
7158 current_lang_base
= NULL
;
7159 current_lang_name
= lang_name_cplusplus
;
7160 current_namespace
= global_namespace
;
7161 push_class_stack ();
7162 cp_unevaluated_operand
= 0;
7163 c_inhibit_evaluation_warnings
= 0;
7164 suppress_location_wrappers
= 0;
7168 do_pop_from_top_level (void)
7170 struct saved_scope
*s
= scope_chain
;
7171 cxx_saved_binding
*saved
;
7174 /* Clear out class-level bindings cache. */
7175 if (previous_class_level
)
7176 invalidate_class_lookup_cache ();
7179 release_tree_vector (current_lang_base
);
7181 scope_chain
= s
->prev
;
7182 FOR_EACH_VEC_SAFE_ELT (s
->old_bindings
, i
, saved
)
7184 tree id
= saved
->identifier
;
7186 IDENTIFIER_BINDING (id
) = saved
->binding
;
7187 SET_IDENTIFIER_TYPE_VALUE (id
, saved
->real_type_value
);
7190 /* If we were in the middle of compiling a function, restore our
7192 if (s
->need_pop_function_context
)
7193 pop_function_context ();
7194 current_function_decl
= s
->function_decl
;
7195 cp_unevaluated_operand
= s
->unevaluated_operand
;
7196 c_inhibit_evaluation_warnings
= s
->inhibit_evaluation_warnings
;
7197 suppress_location_wrappers
= s
->suppress_location_wrappers
;
7199 /* Make this saved_scope structure available for reuse by
7200 push_to_top_level. */
7201 s
->prev
= free_saved_scope
;
7202 free_saved_scope
= s
;
7205 /* Push into the scope of the namespace NS, even if it is deeply
7206 nested within another namespace. */
7209 do_push_nested_namespace (tree ns
)
7211 if (ns
== global_namespace
)
7212 do_push_to_top_level ();
7215 do_push_nested_namespace (CP_DECL_CONTEXT (ns
));
7217 (find_namespace_value (current_namespace
, DECL_NAME (ns
)) == ns
);
7218 resume_scope (NAMESPACE_LEVEL (ns
));
7219 current_namespace
= ns
;
7223 /* Pop back from the scope of the namespace NS, which was previously
7224 entered with push_nested_namespace. */
7227 do_pop_nested_namespace (tree ns
)
7229 while (ns
!= global_namespace
)
7231 ns
= CP_DECL_CONTEXT (ns
);
7232 current_namespace
= ns
;
7236 do_pop_from_top_level ();
7239 /* Add TARGET to USINGS, if it does not already exist there.
7240 We used to build the complete graph of usings at this point, from
7241 the POV of the source namespaces. Now we build that as we perform
7242 the unqualified search. */
7245 add_using_namespace (vec
<tree
, va_gc
> *&usings
, tree target
)
7248 for (unsigned ix
= usings
->length (); ix
--;)
7249 if ((*usings
)[ix
] == target
)
7252 vec_safe_push (usings
, target
);
7255 /* Tell the debug system of a using directive. */
7258 emit_debug_info_using_namespace (tree from
, tree target
, bool implicit
)
7260 /* Emit debugging info. */
7261 tree context
= from
!= global_namespace
? from
: NULL_TREE
;
7262 debug_hooks
->imported_module_or_decl (target
, NULL_TREE
, context
, false,
7266 /* Process a using directive. */
7269 finish_using_directive (tree target
, tree attribs
)
7271 if (target
== error_mark_node
)
7274 if (current_binding_level
->kind
!= sk_namespace
)
7275 add_stmt (build_stmt (input_location
, USING_STMT
, target
));
7277 emit_debug_info_using_namespace (current_binding_level
->this_entity
,
7278 ORIGINAL_NAMESPACE (target
), false);
7280 add_using_namespace (current_binding_level
->using_directives
,
7281 ORIGINAL_NAMESPACE (target
));
7283 if (attribs
!= error_mark_node
)
7284 for (tree a
= attribs
; a
; a
= TREE_CHAIN (a
))
7286 tree name
= get_attribute_name (a
);
7287 if (current_binding_level
->kind
== sk_namespace
7288 && is_attribute_p ("strong", name
))
7290 if (warning (0, "%<strong%> using directive no longer supported")
7291 && CP_DECL_CONTEXT (target
) == current_namespace
)
7292 inform (DECL_SOURCE_LOCATION (target
),
7293 "you can use an inline namespace instead");
7296 warning (OPT_Wattributes
, "%qD attribute directive ignored", name
);
7300 /* Pushes X into the global namespace. */
7303 pushdecl_top_level (tree x
, bool is_friend
)
7305 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
7306 do_push_to_top_level ();
7307 x
= pushdecl_namespace_level (x
, is_friend
);
7308 do_pop_from_top_level ();
7309 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
7313 /* Pushes X into the global namespace and calls cp_finish_decl to
7314 register the variable, initializing it with INIT. */
7317 pushdecl_top_level_and_finish (tree x
, tree init
)
7319 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
7320 do_push_to_top_level ();
7321 x
= pushdecl_namespace_level (x
, false);
7322 cp_finish_decl (x
, init
, false, NULL_TREE
, 0);
7323 do_pop_from_top_level ();
7324 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
7328 /* Enter the namespaces from current_namerspace to NS. */
7331 push_inline_namespaces (tree ns
)
7334 if (ns
!= current_namespace
)
7336 gcc_assert (ns
!= global_namespace
);
7337 count
+= push_inline_namespaces (CP_DECL_CONTEXT (ns
));
7338 resume_scope (NAMESPACE_LEVEL (ns
));
7339 current_namespace
= ns
;
7345 /* Push into the scope of the NAME namespace. If NAME is NULL_TREE,
7346 then we enter an anonymous namespace. If MAKE_INLINE is true, then
7347 we create an inline namespace (it is up to the caller to check upon
7348 redefinition). Return the number of namespaces entered. */
7351 push_namespace (tree name
, bool make_inline
)
7353 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
7356 /* We should not get here if the global_namespace is not yet constructed
7357 nor if NAME designates the global namespace: The global scope is
7358 constructed elsewhere. */
7359 gcc_checking_assert (global_namespace
!= NULL
&& name
!= global_identifier
);
7361 tree ns
= NULL_TREE
;
7363 name_lookup
lookup (name
, 0);
7364 if (!lookup
.search_qualified (current_namespace
, /*usings=*/false))
7366 else if (TREE_CODE (lookup
.value
) != NAMESPACE_DECL
)
7368 else if (tree dna
= DECL_NAMESPACE_ALIAS (lookup
.value
))
7370 /* A namespace alias is not allowed here, but if the alias
7371 is for a namespace also inside the current scope,
7372 accept it with a diagnostic. That's better than dying
7374 if (is_nested_namespace (current_namespace
, CP_DECL_CONTEXT (dna
)))
7376 error ("namespace alias %qD not allowed here, "
7377 "assuming %qD", lookup
.value
, dna
);
7385 bool new_ns
= false;
7387 /* DR2061. NS might be a member of an inline namespace. We
7388 need to push into those namespaces. */
7389 count
+= push_inline_namespaces (CP_DECL_CONTEXT (ns
));
7392 ns
= build_lang_decl (NAMESPACE_DECL
, name
, void_type_node
);
7393 SCOPE_DEPTH (ns
) = SCOPE_DEPTH (current_namespace
) + 1;
7394 if (!SCOPE_DEPTH (ns
))
7395 /* We only allow depth 255. */
7396 sorry ("cannot nest more than %d namespaces",
7397 SCOPE_DEPTH (current_namespace
));
7398 DECL_CONTEXT (ns
) = FROB_CONTEXT (current_namespace
);
7401 if (pushdecl (ns
) == error_mark_node
)
7407 SET_DECL_ASSEMBLER_NAME (ns
, anon_identifier
);
7410 add_using_namespace (current_binding_level
->using_directives
,
7413 else if (TREE_PUBLIC (current_namespace
))
7414 TREE_PUBLIC (ns
) = 1;
7418 DECL_NAMESPACE_INLINE_P (ns
) = true;
7419 vec_safe_push (DECL_NAMESPACE_INLINEES (current_namespace
), ns
);
7422 if (!name
|| make_inline
)
7423 emit_debug_info_using_namespace (current_namespace
, ns
, true);
7429 if (make_inline
&& !DECL_NAMESPACE_INLINE_P (ns
))
7431 error ("inline namespace must be specified at initial definition");
7432 inform (DECL_SOURCE_LOCATION (ns
), "%qD defined here", ns
);
7435 begin_scope (sk_namespace
, ns
);
7437 resume_scope (NAMESPACE_LEVEL (ns
));
7438 current_namespace
= ns
;
7442 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
7446 /* Pop from the scope of the current namespace. */
7449 pop_namespace (void)
7451 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
7453 gcc_assert (current_namespace
!= global_namespace
);
7454 current_namespace
= CP_DECL_CONTEXT (current_namespace
);
7455 /* The binding level is not popped, as it might be re-opened later. */
7458 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
7461 /* External entry points for do_{push_to/pop_from}_top_level. */
7464 push_to_top_level (void)
7466 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
7467 do_push_to_top_level ();
7468 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
7472 pop_from_top_level (void)
7474 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
7475 do_pop_from_top_level ();
7476 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
7479 /* External entry points for do_{push,pop}_nested_namespace. */
7482 push_nested_namespace (tree ns
)
7484 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
7485 do_push_nested_namespace (ns
);
7486 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
7490 pop_nested_namespace (tree ns
)
7492 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
7493 gcc_assert (current_namespace
== ns
);
7494 do_pop_nested_namespace (ns
);
7495 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
7498 /* Pop off extraneous binding levels left over due to syntax errors.
7499 We don't pop past namespaces, as they might be valid. */
7502 pop_everything (void)
7504 if (ENABLE_SCOPE_CHECKING
)
7505 verbatim ("XXX entering %<pop_everything ()%>");
7506 while (!namespace_bindings_p ())
7508 if (current_binding_level
->kind
== sk_class
)
7509 pop_nested_class ();
7513 if (ENABLE_SCOPE_CHECKING
)
7514 verbatim ("XXX leaving %<pop_everything ()%>");
7517 /* Emit debugging information for using declarations and directives.
7518 If input tree is overloaded fn then emit debug info for all
7522 cp_emit_debug_info_for_using (tree t
, tree context
)
7524 /* Don't try to emit any debug information if we have errors. */
7528 /* Do not supply context to imported_module_or_decl, if
7529 it is a global namespace. */
7530 if (context
== global_namespace
)
7531 context
= NULL_TREE
;
7533 t
= MAYBE_BASELINK_FUNCTIONS (t
);
7535 for (lkp_iterator
iter (t
); iter
; ++iter
)
7539 if (TREE_CODE (fn
) == TEMPLATE_DECL
)
7540 /* FIXME: Handle TEMPLATE_DECLs. */
7543 /* Ignore this FUNCTION_DECL if it refers to a builtin declaration
7544 of a builtin function. */
7545 if (TREE_CODE (fn
) == FUNCTION_DECL
7546 && DECL_EXTERNAL (fn
)
7547 && fndecl_built_in_p (fn
))
7550 if (building_stmt_list_p ())
7551 add_stmt (build_stmt (input_location
, USING_STMT
, fn
));
7553 debug_hooks
->imported_module_or_decl (fn
, NULL_TREE
, context
,
7558 /* Return the result of unqualified lookup for the overloaded operator
7559 designated by CODE, if we are in a template and the binding we find is
7563 op_unqualified_lookup (tree fnname
)
7565 if (cxx_binding
*binding
= IDENTIFIER_BINDING (fnname
))
7567 cp_binding_level
*l
= binding
->scope
;
7568 while (l
&& !l
->this_entity
)
7570 if (l
&& uses_template_parms (l
->this_entity
))
7571 /* Don't preserve decls from an uninstantiated template,
7572 wait until that template is instantiated. */
7575 tree fns
= lookup_name (fnname
);
7576 if (fns
&& fns
== get_global_binding (fnname
))
7577 /* The instantiation can find these. */
7582 /* E is an expression representing an operation with dependent type, so we
7583 don't know yet whether it will use the built-in meaning of the operator or a
7584 function. Remember declarations of that operator in scope. */
7586 const char *const op_bind_attrname
= "operator bindings";
7589 maybe_save_operator_binding (tree e
)
7591 /* This is only useful in a generic lambda. */
7592 if (!processing_template_decl
)
7594 tree cfn
= current_function_decl
;
7598 /* Let's only do this for generic lambdas for now, we could do it for all
7599 function templates if we wanted to. */
7600 if (!current_lambda_expr())
7603 tree fnname
= ovl_op_identifier (false, TREE_CODE (e
));
7607 tree attributes
= DECL_ATTRIBUTES (cfn
);
7608 tree attr
= lookup_attribute (op_bind_attrname
, attributes
);
7609 tree bindings
= NULL_TREE
;
7610 tree fns
= NULL_TREE
;
7613 bindings
= TREE_VALUE (attr
);
7614 if (tree elt
= purpose_member (fnname
, bindings
))
7615 fns
= TREE_VALUE (elt
);
7618 if (!fns
&& (fns
= op_unqualified_lookup (fnname
)))
7620 bindings
= tree_cons (fnname
, fns
, bindings
);
7622 TREE_VALUE (attr
) = bindings
;
7624 DECL_ATTRIBUTES (cfn
)
7625 = tree_cons (get_identifier (op_bind_attrname
),
7631 /* Called from cp_free_lang_data so we don't put this into LTO. */
7634 discard_operator_bindings (tree decl
)
7636 DECL_ATTRIBUTES (decl
) = remove_attribute (op_bind_attrname
,
7637 DECL_ATTRIBUTES (decl
));
7640 /* Subroutine of start_preparsed_function: push the bindings we saved away in
7641 maybe_save_op_lookup into the function parameter binding level. */
7644 push_operator_bindings ()
7646 tree decl1
= current_function_decl
;
7647 if (tree attr
= lookup_attribute (op_bind_attrname
,
7648 DECL_ATTRIBUTES (decl1
)))
7649 for (tree binds
= TREE_VALUE (attr
); binds
; binds
= TREE_CHAIN (binds
))
7651 tree name
= TREE_PURPOSE (binds
);
7652 tree val
= TREE_VALUE (binds
);
7653 push_local_binding (name
, val
, /*using*/true);
7657 #include "gt-cp-name-lookup.h"