1 /* Definitions for C++ name lookup routines.
2 Copyright (C) 2003-2018 Free Software Foundation, Inc.
3 Contributed by Gabriel Dos Reis <gdr@integrable-solutions.net>
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3, or (at your option)
12 GCC is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING3. If not see
19 <http://www.gnu.org/licenses/>. */
22 #define INCLUDE_UNIQUE_PTR
24 #include "coretypes.h"
27 #include "stringpool.h"
28 #include "print-tree.h"
31 #include "c-family/c-pragma.h"
33 #include "gcc-rich-location.h"
34 #include "spellcheck-tree.h"
36 #include "c-family/name-hint.h"
37 #include "c-family/known-headers.h"
38 #include "c-family/c-spellcheck.h"
40 static cxx_binding
*cxx_binding_make (tree value
, tree type
);
41 static cp_binding_level
*innermost_nonclass_level (void);
42 static void set_identifier_type_value_with_scope (tree id
, tree decl
,
45 /* Create an overload suitable for recording an artificial TYPE_DECL
46 and another decl. We use this machanism to implement the struct
47 stat hack within a namespace. It'd be nice to use it everywhere. */
49 #define STAT_HACK_P(N) ((N) && TREE_CODE (N) == OVERLOAD && OVL_LOOKUP_P (N))
50 #define STAT_TYPE(N) TREE_TYPE (N)
51 #define STAT_DECL(N) OVL_FUNCTION (N)
52 #define MAYBE_STAT_DECL(N) (STAT_HACK_P (N) ? STAT_DECL (N) : N)
53 #define MAYBE_STAT_TYPE(N) (STAT_HACK_P (N) ? STAT_TYPE (N) : NULL_TREE)
55 /* Create a STAT_HACK node with DECL as the value binding and TYPE as
59 stat_hack (tree decl
= NULL_TREE
, tree type
= NULL_TREE
)
61 tree result
= make_node (OVERLOAD
);
63 /* Mark this as a lookup, so we can tell this is a stat hack. */
64 OVL_LOOKUP_P (result
) = true;
65 STAT_DECL (result
) = decl
;
66 STAT_TYPE (result
) = type
;
70 /* Create a local binding level for NAME. */
73 create_local_binding (cp_binding_level
*level
, tree name
)
75 cxx_binding
*binding
= cxx_binding_make (NULL
, NULL
);
77 INHERITED_VALUE_BINDING_P (binding
) = false;
78 LOCAL_BINDING_P (binding
) = true;
79 binding
->scope
= level
;
80 binding
->previous
= IDENTIFIER_BINDING (name
);
82 IDENTIFIER_BINDING (name
) = binding
;
87 /* Find the binding for NAME in namespace NS. If CREATE_P is true,
88 make an empty binding if there wasn't one. */
91 find_namespace_slot (tree ns
, tree name
, bool create_p
= false)
93 tree
*slot
= DECL_NAMESPACE_BINDINGS (ns
)
94 ->find_slot_with_hash (name
, name
? IDENTIFIER_HASH_VALUE (name
) : 0,
95 create_p
? INSERT
: NO_INSERT
);
100 find_namespace_value (tree ns
, tree name
)
102 tree
*b
= find_namespace_slot (ns
, name
);
104 return b
? MAYBE_STAT_DECL (*b
) : NULL_TREE
;
107 /* Add DECL to the list of things declared in B. */
110 add_decl_to_level (cp_binding_level
*b
, tree decl
)
112 gcc_assert (b
->kind
!= sk_class
);
114 /* Make sure we don't create a circular list. xref_tag can end
115 up pushing the same artificial decl more than once. We
116 should have already detected that in update_binding. */
117 gcc_assert (b
->names
!= decl
);
119 /* We build up the list in reverse order, and reverse it later if
121 TREE_CHAIN (decl
) = b
->names
;
124 /* If appropriate, add decl to separate list of statics. We
125 include extern variables because they might turn out to be
126 static later. It's OK for this list to contain a few false
128 if (b
->kind
== sk_namespace
130 && (TREE_STATIC (decl
) || DECL_EXTERNAL (decl
)))
131 || (TREE_CODE (decl
) == FUNCTION_DECL
132 && (!TREE_PUBLIC (decl
)
133 || decl_anon_ns_mem_p (decl
)
134 || DECL_DECLARED_INLINE_P (decl
)))))
135 vec_safe_push (static_decls
, decl
);
138 /* Find the binding for NAME in the local binding level B. */
141 find_local_binding (cp_binding_level
*b
, tree name
)
143 if (cxx_binding
*binding
= IDENTIFIER_BINDING (name
))
144 for (;; b
= b
->level_chain
)
146 if (binding
->scope
== b
147 && !(VAR_P (binding
->value
)
148 && DECL_DEAD_FOR_LOCAL (binding
->value
)))
151 /* Cleanup contours are transparent to the language. */
152 if (b
->kind
!= sk_cleanup
)
161 typedef std::pair
<tree
, tree
> using_pair
;
162 typedef vec
<using_pair
, va_heap
, vl_embed
> using_queue
;
165 tree name
; /* The identifier being looked for. */
166 tree value
; /* A (possibly ambiguous) set of things found. */
167 tree type
; /* A type that has been found. */
168 int flags
; /* Lookup flags. */
169 bool deduping
; /* Full deduping is needed because using declarations
171 vec
<tree
, va_heap
, vl_embed
> *scopes
;
172 name_lookup
*previous
; /* Previously active lookup. */
175 /* Marked scope stack for outermost name lookup. */
176 static vec
<tree
, va_heap
, vl_embed
> *shared_scopes
;
177 /* Currently active lookup. */
178 static name_lookup
*active
;
181 name_lookup (tree n
, int f
= 0)
182 : name (n
), value (NULL_TREE
), type (NULL_TREE
), flags (f
),
183 deduping (false), scopes (NULL
), previous (NULL
)
192 private: /* Uncopyable, unmovable, unassignable. I am a rock. */
193 name_lookup (const name_lookup
&);
194 name_lookup
&operator= (const name_lookup
&);
197 static bool seen_p (tree scope
)
199 return LOOKUP_SEEN_P (scope
);
201 static bool found_p (tree scope
)
203 return LOOKUP_FOUND_P (scope
);
206 void mark_seen (tree scope
); /* Mark and add to scope vector. */
207 static void mark_found (tree scope
)
209 gcc_checking_assert (seen_p (scope
));
210 LOOKUP_FOUND_P (scope
) = true;
212 bool see_and_mark (tree scope
)
214 bool ret
= seen_p (scope
);
219 bool find_and_mark (tree scope
);
222 void preserve_state ();
223 void restore_state ();
226 static tree
ambiguous (tree thing
, tree current
);
227 void add_overload (tree fns
);
228 void add_value (tree new_val
);
229 void add_type (tree new_type
);
230 bool process_binding (tree val_bind
, tree type_bind
);
232 /* Look in only namespace. */
233 bool search_namespace_only (tree scope
);
234 /* Look in namespace and its (recursive) inlines. Ignore using
235 directives. Return true if something found (inc dups). */
236 bool search_namespace (tree scope
);
237 /* Look in the using directives of namespace + inlines using
238 qualified lookup rules. */
239 bool search_usings (tree scope
);
242 using_queue
*queue_namespace (using_queue
*queue
, int depth
, tree scope
);
243 using_queue
*do_queue_usings (using_queue
*queue
, int depth
,
244 vec
<tree
, va_gc
> *usings
);
245 using_queue
*queue_usings (using_queue
*queue
, int depth
,
246 vec
<tree
, va_gc
> *usings
)
249 queue
= do_queue_usings (queue
, depth
, usings
);
256 void adl_expr (tree
);
257 void adl_type (tree
);
258 void adl_template_arg (tree
);
259 void adl_class (tree
);
260 void adl_bases (tree
);
261 void adl_class_only (tree
);
262 void adl_namespace (tree
);
263 void adl_namespace_only (tree
);
266 /* Search namespace + inlines + maybe usings as qualified lookup. */
267 bool search_qualified (tree scope
, bool usings
= true);
269 /* Search namespace + inlines + usings as unqualified lookup. */
270 bool search_unqualified (tree scope
, cp_binding_level
*);
272 /* ADL lookup of ARGS. */
273 tree
search_adl (tree fns
, vec
<tree
, va_gc
> *args
);
276 /* Scope stack shared by all outermost lookups. This avoids us
277 allocating and freeing on every single lookup. */
278 vec
<tree
, va_heap
, vl_embed
> *name_lookup::shared_scopes
;
280 /* Currently active lookup. */
281 name_lookup
*name_lookup::active
;
283 /* Name lookup is recursive, becase ADL can cause template
284 instatiation. This is of course a rare event, so we optimize for
285 it not happening. When we discover an active name-lookup, which
286 must be an ADL lookup, we need to unmark the marked scopes and also
287 unmark the lookup we might have been accumulating. */
290 name_lookup::preserve_state ()
295 unsigned length
= vec_safe_length (previous
->scopes
);
296 vec_safe_reserve (previous
->scopes
, length
* 2);
297 for (unsigned ix
= length
; ix
--;)
299 tree decl
= (*previous
->scopes
)[ix
];
301 gcc_checking_assert (LOOKUP_SEEN_P (decl
));
302 LOOKUP_SEEN_P (decl
) = false;
304 /* Preserve the FOUND_P state on the interrupted lookup's
306 if (LOOKUP_FOUND_P (decl
))
308 LOOKUP_FOUND_P (decl
) = false;
309 previous
->scopes
->quick_push (decl
);
313 /* Unmark the outer partial lookup. */
314 if (previous
->deduping
)
315 lookup_mark (previous
->value
, false);
318 scopes
= shared_scopes
;
322 /* Restore the marking state of a lookup we interrupted. */
325 name_lookup::restore_state ()
328 lookup_mark (value
, false);
330 /* Unmark and empty this lookup's scope stack. */
331 for (unsigned ix
= vec_safe_length (scopes
); ix
--;)
333 tree decl
= scopes
->pop ();
334 gcc_checking_assert (LOOKUP_SEEN_P (decl
));
335 LOOKUP_SEEN_P (decl
) = false;
336 LOOKUP_FOUND_P (decl
) = false;
344 unsigned length
= vec_safe_length (previous
->scopes
);
345 for (unsigned ix
= 0; ix
!= length
; ix
++)
347 tree decl
= (*previous
->scopes
)[ix
];
348 if (LOOKUP_SEEN_P (decl
))
350 /* The remainder of the scope stack must be recording
351 FOUND_P decls, which we want to pop off. */
354 tree decl
= previous
->scopes
->pop ();
355 gcc_checking_assert (LOOKUP_SEEN_P (decl
)
356 && !LOOKUP_FOUND_P (decl
));
357 LOOKUP_FOUND_P (decl
) = true;
359 while (++ix
!= length
);
363 gcc_checking_assert (!LOOKUP_FOUND_P (decl
));
364 LOOKUP_SEEN_P (decl
) = true;
367 /* Remark the outer partial lookup. */
368 if (previous
->deduping
)
369 lookup_mark (previous
->value
, true);
372 shared_scopes
= scopes
;
376 name_lookup::mark_seen (tree scope
)
378 gcc_checking_assert (!seen_p (scope
));
379 LOOKUP_SEEN_P (scope
) = true;
380 vec_safe_push (scopes
, scope
);
384 name_lookup::find_and_mark (tree scope
)
386 bool result
= LOOKUP_FOUND_P (scope
);
389 LOOKUP_FOUND_P (scope
) = true;
390 if (!LOOKUP_SEEN_P (scope
))
391 vec_safe_push (scopes
, scope
);
397 /* THING and CURRENT are ambiguous, concatenate them. */
400 name_lookup::ambiguous (tree thing
, tree current
)
402 if (TREE_CODE (current
) != TREE_LIST
)
404 current
= build_tree_list (NULL_TREE
, current
);
405 TREE_TYPE (current
) = error_mark_node
;
407 current
= tree_cons (NULL_TREE
, thing
, current
);
408 TREE_TYPE (current
) = error_mark_node
;
413 /* FNS is a new overload set to add to the exising set. */
416 name_lookup::add_overload (tree fns
)
418 if (!deduping
&& TREE_CODE (fns
) == OVERLOAD
)
421 if (flags
& LOOKUP_HIDDEN
)
422 probe
= ovl_skip_hidden (probe
);
423 if (probe
&& TREE_CODE (probe
) == OVERLOAD
&& OVL_USING_P (probe
))
425 /* We're about to add something found by a using
426 declaration, so need to engage deduping mode. */
427 lookup_mark (value
, true);
432 value
= lookup_maybe_add (fns
, value
, deduping
);
435 /* Add a NEW_VAL, a found value binding into the current value binding. */
438 name_lookup::add_value (tree new_val
)
440 if (OVL_P (new_val
) && (!value
|| OVL_P (value
)))
441 add_overload (new_val
);
444 else if (value
== new_val
)
446 else if ((TREE_CODE (value
) == TYPE_DECL
447 && TREE_CODE (new_val
) == TYPE_DECL
448 && same_type_p (TREE_TYPE (value
), TREE_TYPE (new_val
))))
449 /* Typedefs to the same type. */;
450 else if (TREE_CODE (value
) == NAMESPACE_DECL
451 && TREE_CODE (new_val
) == NAMESPACE_DECL
452 && ORIGINAL_NAMESPACE (value
) == ORIGINAL_NAMESPACE (new_val
))
453 /* Namespace (possibly aliased) to the same namespace. Locate
455 value
= ORIGINAL_NAMESPACE (value
);
460 /* Disengage deduping mode. */
461 lookup_mark (value
, false);
464 value
= ambiguous (new_val
, value
);
468 /* Add a NEW_TYPE, a found type binding into the current type binding. */
471 name_lookup::add_type (tree new_type
)
475 else if (TREE_CODE (type
) == TREE_LIST
476 || !same_type_p (TREE_TYPE (type
), TREE_TYPE (new_type
)))
477 type
= ambiguous (new_type
, type
);
480 /* Process a found binding containing NEW_VAL and NEW_TYPE. Returns
481 true if we actually found something noteworthy. */
484 name_lookup::process_binding (tree new_val
, tree new_type
)
486 /* Did we really see a type? */
488 && (LOOKUP_NAMESPACES_ONLY (flags
)
489 || (!(flags
& LOOKUP_HIDDEN
)
490 && DECL_LANG_SPECIFIC (new_type
)
491 && DECL_ANTICIPATED (new_type
))))
492 new_type
= NULL_TREE
;
494 if (new_val
&& !(flags
& LOOKUP_HIDDEN
))
495 new_val
= ovl_skip_hidden (new_val
);
497 /* Do we really see a value? */
499 switch (TREE_CODE (new_val
))
502 /* If we expect types or namespaces, and not templates,
503 or this is not a template class. */
504 if ((LOOKUP_QUALIFIERS_ONLY (flags
)
505 && !DECL_TYPE_TEMPLATE_P (new_val
)))
509 if (LOOKUP_NAMESPACES_ONLY (flags
)
510 || (new_type
&& (flags
& LOOKUP_PREFER_TYPES
)))
514 if (LOOKUP_TYPES_ONLY (flags
))
518 if (LOOKUP_QUALIFIERS_ONLY (flags
))
525 new_type
= NULL_TREE
;
528 /* Merge into the lookup */
534 return new_val
!= NULL_TREE
;
537 /* Look in exactly namespace SCOPE. */
540 name_lookup::search_namespace_only (tree scope
)
544 if (tree
*binding
= find_namespace_slot (scope
, name
))
545 found
|= process_binding (MAYBE_STAT_DECL (*binding
),
546 MAYBE_STAT_TYPE (*binding
));
551 /* Conditionally look in namespace SCOPE and inline children. */
554 name_lookup::search_namespace (tree scope
)
556 if (see_and_mark (scope
))
557 /* We've visited this scope before. Return what we found then. */
558 return found_p (scope
);
560 /* Look in exactly namespace. */
561 bool found
= search_namespace_only (scope
);
563 /* Recursively look in its inline children. */
564 if (vec
<tree
, va_gc
> *inlinees
= DECL_NAMESPACE_INLINEES (scope
))
565 for (unsigned ix
= inlinees
->length (); ix
--;)
566 found
|= search_namespace ((*inlinees
)[ix
]);
574 /* Recursively follow using directives of SCOPE & its inline children.
575 Such following is essentially a flood-fill algorithm. */
578 name_lookup::search_usings (tree scope
)
580 /* We do not check seen_p here, as that was already set during the
581 namespace_only walk. */
586 if (vec
<tree
, va_gc
> *usings
= DECL_NAMESPACE_USING (scope
))
587 for (unsigned ix
= usings
->length (); ix
--;)
588 found
|= search_qualified ((*usings
)[ix
], true);
590 /* Look in its inline children. */
591 if (vec
<tree
, va_gc
> *inlinees
= DECL_NAMESPACE_INLINEES (scope
))
592 for (unsigned ix
= inlinees
->length (); ix
--;)
593 found
|= search_usings ((*inlinees
)[ix
]);
601 /* Qualified namespace lookup in SCOPE.
602 1) Look in SCOPE (+inlines). If found, we're done.
603 2) Otherwise, if USINGS is true,
604 recurse for every using directive of SCOPE (+inlines).
606 Trickiness is (a) loops and (b) multiple paths to same namespace.
607 In both cases we want to not repeat any lookups, and know whether
608 to stop the caller's step #2. Do this via the FOUND_P marker. */
611 name_lookup::search_qualified (tree scope
, bool usings
)
616 found
= found_p (scope
);
619 found
= search_namespace (scope
);
620 if (!found
&& usings
)
621 found
= search_usings (scope
);
627 /* Add SCOPE to the unqualified search queue, recursively add its
628 inlines and those via using directives. */
630 name_lookup::using_queue
*
631 name_lookup::queue_namespace (using_queue
*queue
, int depth
, tree scope
)
633 if (see_and_mark (scope
))
638 while (SCOPE_DEPTH (common
) > depth
)
639 common
= CP_DECL_CONTEXT (common
);
640 vec_safe_push (queue
, using_pair (common
, scope
));
642 /* Queue its inline children. */
643 if (vec
<tree
, va_gc
> *inlinees
= DECL_NAMESPACE_INLINEES (scope
))
644 for (unsigned ix
= inlinees
->length (); ix
--;)
645 queue
= queue_namespace (queue
, depth
, (*inlinees
)[ix
]);
647 /* Queue its using targets. */
648 queue
= queue_usings (queue
, depth
, DECL_NAMESPACE_USING (scope
));
653 /* Add the namespaces in USINGS to the unqualified search queue. */
655 name_lookup::using_queue
*
656 name_lookup::do_queue_usings (using_queue
*queue
, int depth
,
657 vec
<tree
, va_gc
> *usings
)
659 for (unsigned ix
= usings
->length (); ix
--;)
660 queue
= queue_namespace (queue
, depth
, (*usings
)[ix
]);
665 /* Unqualified namespace lookup in SCOPE.
666 1) add scope+inlins to worklist.
667 2) recursively add target of every using directive
668 3) for each worklist item where SCOPE is common ancestor, search it
669 4) if nothing find, scope=parent, goto 1. */
672 name_lookup::search_unqualified (tree scope
, cp_binding_level
*level
)
674 /* Make static to avoid continual reallocation. We're not
676 static using_queue
*queue
= NULL
;
678 int length
= vec_safe_length (queue
);
680 /* Queue local using-directives. */
681 for (; level
->kind
!= sk_namespace
; level
= level
->level_chain
)
682 queue
= queue_usings (queue
, SCOPE_DEPTH (scope
), level
->using_directives
);
684 for (; !found
; scope
= CP_DECL_CONTEXT (scope
))
686 gcc_assert (!DECL_NAMESPACE_ALIAS (scope
));
687 int depth
= SCOPE_DEPTH (scope
);
689 /* Queue namespaces reachable from SCOPE. */
690 queue
= queue_namespace (queue
, depth
, scope
);
692 /* Search every queued namespace where SCOPE is the common
693 ancestor. Adjust the others. */
694 unsigned ix
= length
;
697 using_pair
&pair
= (*queue
)[ix
];
698 while (pair
.first
== scope
)
700 found
|= search_namespace_only (pair
.second
);
701 pair
= queue
->pop ();
702 if (ix
== queue
->length ())
705 /* The depth is the same as SCOPE, find the parent scope. */
706 if (SCOPE_DEPTH (pair
.first
) == depth
)
707 pair
.first
= CP_DECL_CONTEXT (pair
.first
);
710 while (ix
< queue
->length ());
712 if (scope
== global_namespace
)
715 /* If looking for hidden names, we only look in the innermost
716 namespace scope. [namespace.memdef]/3 If a friend
717 declaration in a non-local class first declares a class,
718 function, class template or function template the friend is a
719 member of the innermost enclosing namespace. See also
720 [basic.lookup.unqual]/7 */
721 if (flags
& LOOKUP_HIDDEN
)
725 vec_safe_truncate (queue
, length
);
730 /* FNS is a value binding. If it is a (set of overloaded) functions,
731 add them into the current value. */
734 name_lookup::add_fns (tree fns
)
738 else if (TREE_CODE (fns
) == OVERLOAD
)
740 if (TREE_TYPE (fns
) != unknown_type_node
)
741 fns
= OVL_FUNCTION (fns
);
743 else if (!DECL_DECLARES_FUNCTION_P (fns
))
749 /* Add functions of a namespace to the lookup structure. */
752 name_lookup::adl_namespace_only (tree scope
)
756 /* Look down into inline namespaces. */
757 if (vec
<tree
, va_gc
> *inlinees
= DECL_NAMESPACE_INLINEES (scope
))
758 for (unsigned ix
= inlinees
->length (); ix
--;)
759 adl_namespace_only ((*inlinees
)[ix
]);
761 if (tree fns
= find_namespace_value (scope
, name
))
762 add_fns (ovl_skip_hidden (fns
));
765 /* Find the containing non-inlined namespace, add it and all its
769 name_lookup::adl_namespace (tree scope
)
774 /* Find the containing non-inline namespace. */
775 while (DECL_NAMESPACE_INLINE_P (scope
))
776 scope
= CP_DECL_CONTEXT (scope
);
778 adl_namespace_only (scope
);
781 /* Adds the class and its friends to the lookup structure. */
784 name_lookup::adl_class_only (tree type
)
786 /* Backend-built structures, such as __builtin_va_list, aren't
787 affected by all this. */
788 if (!CLASS_TYPE_P (type
))
791 type
= TYPE_MAIN_VARIANT (type
);
793 if (see_and_mark (type
))
796 tree context
= decl_namespace_context (type
);
797 adl_namespace (context
);
799 complete_type (type
);
802 for (tree list
= DECL_FRIENDLIST (TYPE_MAIN_DECL (type
)); list
;
803 list
= TREE_CHAIN (list
))
804 if (name
== FRIEND_NAME (list
))
805 for (tree friends
= FRIEND_DECLS (list
); friends
;
806 friends
= TREE_CHAIN (friends
))
808 tree fn
= TREE_VALUE (friends
);
810 /* Only interested in global functions with potentially hidden
811 (i.e. unqualified) declarations. */
812 if (CP_DECL_CONTEXT (fn
) != context
)
815 /* Only interested in anticipated friends. (Non-anticipated
816 ones will have been inserted during the namespace
818 if (!DECL_ANTICIPATED (fn
))
821 /* Template specializations are never found by name lookup.
822 (Templates themselves can be found, but not template
824 if (TREE_CODE (fn
) == FUNCTION_DECL
&& DECL_USE_TEMPLATE (fn
))
831 /* Adds the class and its bases to the lookup structure.
832 Returns true on error. */
835 name_lookup::adl_bases (tree type
)
837 adl_class_only (type
);
839 /* Process baseclasses. */
840 if (tree binfo
= TYPE_BINFO (type
))
845 for (i
= 0; BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); i
++)
846 adl_bases (BINFO_TYPE (base_binfo
));
850 /* Adds everything associated with a class argument type to the lookup
851 structure. Returns true on error.
853 If T is a class type (including unions), its associated classes are: the
854 class itself; the class of which it is a member, if any; and its direct
855 and indirect base classes. Its associated namespaces are the namespaces
856 of which its associated classes are members. Furthermore, if T is a
857 class template specialization, its associated namespaces and classes
858 also include: the namespaces and classes associated with the types of
859 the template arguments provided for template type parameters (excluding
860 template template parameters); the namespaces of which any template
861 template arguments are members; and the classes of which any member
862 templates used as template template arguments are members. [ Note:
863 non-type template arguments do not contribute to the set of associated
864 namespaces. --end note] */
867 name_lookup::adl_class (tree type
)
869 /* Backend build structures, such as __builtin_va_list, aren't
870 affected by all this. */
871 if (!CLASS_TYPE_P (type
))
874 type
= TYPE_MAIN_VARIANT (type
);
875 /* We don't set found here because we have to have set seen first,
876 which is done in the adl_bases walk. */
883 if (TYPE_CLASS_SCOPE_P (type
))
884 adl_class_only (TYPE_CONTEXT (type
));
886 /* Process template arguments. */
887 if (CLASSTYPE_TEMPLATE_INFO (type
)
888 && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (type
)))
890 tree list
= INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (type
));
891 for (int i
= 0; i
< TREE_VEC_LENGTH (list
); ++i
)
892 adl_template_arg (TREE_VEC_ELT (list
, i
));
897 name_lookup::adl_expr (tree expr
)
902 gcc_assert (!TYPE_P (expr
));
904 if (TREE_TYPE (expr
) != unknown_type_node
)
906 adl_type (TREE_TYPE (expr
));
910 if (TREE_CODE (expr
) == ADDR_EXPR
)
911 expr
= TREE_OPERAND (expr
, 0);
912 if (TREE_CODE (expr
) == COMPONENT_REF
913 || TREE_CODE (expr
) == OFFSET_REF
)
914 expr
= TREE_OPERAND (expr
, 1);
915 expr
= MAYBE_BASELINK_FUNCTIONS (expr
);
918 for (lkp_iterator
iter (expr
); iter
; ++iter
)
919 adl_type (TREE_TYPE (*iter
));
920 else if (TREE_CODE (expr
) == TEMPLATE_ID_EXPR
)
922 /* The working paper doesn't currently say how to handle
923 template-id arguments. The sensible thing would seem to be
924 to handle the list of template candidates like a normal
925 overload set, and handle the template arguments like we do
926 for class template specializations. */
928 /* First the templates. */
929 adl_expr (TREE_OPERAND (expr
, 0));
931 /* Now the arguments. */
932 if (tree args
= TREE_OPERAND (expr
, 1))
933 for (int ix
= TREE_VEC_LENGTH (args
); ix
--;)
934 adl_template_arg (TREE_VEC_ELT (args
, ix
));
939 name_lookup::adl_type (tree type
)
944 if (TYPE_PTRDATAMEM_P (type
))
946 /* Pointer to member: associate class type and value type. */
947 adl_type (TYPE_PTRMEM_CLASS_TYPE (type
));
948 adl_type (TYPE_PTRMEM_POINTED_TO_TYPE (type
));
952 switch (TREE_CODE (type
))
955 if (TYPE_PTRMEMFUNC_P (type
))
957 adl_type (TYPE_PTRMEMFUNC_FN_TYPE (type
));
966 /* The basetype is referenced in the first arg type, so just
969 /* Associate the parameter types. */
970 for (tree args
= TYPE_ARG_TYPES (type
); args
; args
= TREE_CHAIN (args
))
971 adl_type (TREE_VALUE (args
));
977 adl_type (TREE_TYPE (type
));
981 if (TYPE_CLASS_SCOPE_P (type
))
982 adl_class_only (TYPE_CONTEXT (type
));
983 adl_namespace (decl_namespace_context (type
));
987 gcc_assert (type
== unknown_type_node
988 || type
== init_list_type_node
);
991 case TYPE_PACK_EXPANSION
:
992 adl_type (PACK_EXPANSION_PATTERN (type
));
1000 /* Adds everything associated with a template argument to the lookup
1004 name_lookup::adl_template_arg (tree arg
)
1006 /* [basic.lookup.koenig]
1008 If T is a template-id, its associated namespaces and classes are
1009 ... the namespaces and classes associated with the types of the
1010 template arguments provided for template type parameters
1011 (excluding template template parameters); the namespaces in which
1012 any template template arguments are defined; and the classes in
1013 which any member templates used as template template arguments
1014 are defined. [Note: non-type template arguments do not
1015 contribute to the set of associated namespaces. ] */
1017 /* Consider first template template arguments. */
1018 if (TREE_CODE (arg
) == TEMPLATE_TEMPLATE_PARM
1019 || TREE_CODE (arg
) == UNBOUND_CLASS_TEMPLATE
)
1021 else if (TREE_CODE (arg
) == TEMPLATE_DECL
)
1023 tree ctx
= CP_DECL_CONTEXT (arg
);
1025 /* It's not a member template. */
1026 if (TREE_CODE (ctx
) == NAMESPACE_DECL
)
1027 adl_namespace (ctx
);
1028 /* Otherwise, it must be member template. */
1030 adl_class_only (ctx
);
1032 /* It's an argument pack; handle it recursively. */
1033 else if (ARGUMENT_PACK_P (arg
))
1035 tree args
= ARGUMENT_PACK_ARGS (arg
);
1036 int i
, len
= TREE_VEC_LENGTH (args
);
1037 for (i
= 0; i
< len
; ++i
)
1038 adl_template_arg (TREE_VEC_ELT (args
, i
));
1040 /* It's not a template template argument, but it is a type template
1042 else if (TYPE_P (arg
))
1046 /* Perform ADL lookup. FNS is the existing lookup result and ARGS are
1047 the call arguments. */
1050 name_lookup::search_adl (tree fns
, vec
<tree
, va_gc
> *args
)
1055 lookup_mark (fns
, true);
1062 FOR_EACH_VEC_ELT_REVERSE (*args
, ix
, arg
)
1063 /* OMP reduction operators put an ADL-significant type as the
1075 static bool qualified_namespace_lookup (tree
, name_lookup
*);
1076 static void consider_binding_level (tree name
,
1077 best_match
<tree
, const char *> &bm
,
1078 cp_binding_level
*lvl
,
1079 bool look_within_fields
,
1080 enum lookup_name_fuzzy_kind kind
);
1081 static void diagnose_name_conflict (tree
, tree
);
1083 /* ADL lookup of NAME. FNS is the result of regular lookup, and we
1084 don't add duplicates to it. ARGS is the vector of call
1085 arguments (which will not be empty). */
1088 lookup_arg_dependent (tree name
, tree fns
, vec
<tree
, va_gc
> *args
)
1090 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
1091 name_lookup
lookup (name
);
1092 fns
= lookup
.search_adl (fns
, args
);
1093 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
1097 /* FNS is an overload set of conversion functions. Return the
1098 overloads converting to TYPE. */
1101 extract_conversion_operator (tree fns
, tree type
)
1103 tree convs
= NULL_TREE
;
1104 tree tpls
= NULL_TREE
;
1106 for (ovl_iterator
iter (fns
); iter
; ++iter
)
1108 if (same_type_p (DECL_CONV_FN_TYPE (*iter
), type
))
1109 convs
= lookup_add (*iter
, convs
);
1111 if (TREE_CODE (*iter
) == TEMPLATE_DECL
)
1112 tpls
= lookup_add (*iter
, tpls
);
1121 /* Binary search of (ordered) MEMBER_VEC for NAME. */
1124 member_vec_binary_search (vec
<tree
, va_gc
> *member_vec
, tree name
)
1126 for (unsigned lo
= 0, hi
= member_vec
->length (); lo
< hi
;)
1128 unsigned mid
= (lo
+ hi
) / 2;
1129 tree binding
= (*member_vec
)[mid
];
1130 tree binding_name
= OVL_NAME (binding
);
1132 if (binding_name
> name
)
1134 else if (binding_name
< name
)
1143 /* Linear search of (unordered) MEMBER_VEC for NAME. */
1146 member_vec_linear_search (vec
<tree
, va_gc
> *member_vec
, tree name
)
1148 for (int ix
= member_vec
->length (); ix
--;)
1149 if (tree binding
= (*member_vec
)[ix
])
1150 if (OVL_NAME (binding
) == name
)
1156 /* Linear search of (partially ordered) fields of KLASS for NAME. */
1159 fields_linear_search (tree klass
, tree name
, bool want_type
)
1161 for (tree fields
= TYPE_FIELDS (klass
); fields
; fields
= DECL_CHAIN (fields
))
1165 if (TREE_CODE (decl
) == FIELD_DECL
1166 && ANON_AGGR_TYPE_P (TREE_TYPE (decl
)))
1168 if (tree temp
= search_anon_aggr (TREE_TYPE (decl
), name
, want_type
))
1172 if (DECL_NAME (decl
) != name
)
1175 if (TREE_CODE (decl
) == USING_DECL
)
1177 decl
= strip_using_decl (decl
);
1178 if (is_overloaded_fn (decl
))
1182 if (DECL_DECLARES_FUNCTION_P (decl
))
1183 /* Functions are found separately. */
1186 if (!want_type
|| DECL_DECLARES_TYPE_P (decl
))
1193 /* Look for NAME member inside of anonymous aggregate ANON. Although
1194 such things should only contain FIELD_DECLs, we check that too
1195 late, and would give very confusing errors if we weren't
1199 search_anon_aggr (tree anon
, tree name
, bool want_type
)
1201 gcc_assert (COMPLETE_TYPE_P (anon
));
1202 tree ret
= get_class_binding_direct (anon
, name
, want_type
);
1206 /* Look for NAME as an immediate member of KLASS (including
1207 anon-members or unscoped enum member). TYPE_OR_FNS is zero for
1208 regular search. >0 to get a type binding (if there is one) and <0
1209 if you want (just) the member function binding.
1211 Use this if you do not want lazy member creation. */
1214 get_class_binding_direct (tree klass
, tree name
, int type_or_fns
)
1216 gcc_checking_assert (RECORD_OR_UNION_TYPE_P (klass
));
1218 /* Conversion operators can only be found by the marker conversion
1220 bool conv_op
= IDENTIFIER_CONV_OP_P (name
);
1221 tree lookup
= conv_op
? conv_op_identifier
: name
;
1222 tree val
= NULL_TREE
;
1223 vec
<tree
, va_gc
> *member_vec
= CLASSTYPE_MEMBER_VEC (klass
);
1225 if (COMPLETE_TYPE_P (klass
) && member_vec
)
1227 val
= member_vec_binary_search (member_vec
, lookup
);
1230 else if (type_or_fns
> 0)
1232 if (STAT_HACK_P (val
))
1233 val
= STAT_TYPE (val
);
1234 else if (!DECL_DECLARES_TYPE_P (val
))
1237 else if (STAT_HACK_P (val
))
1238 val
= STAT_DECL (val
);
1240 if (val
&& TREE_CODE (val
) == OVERLOAD
1241 && TREE_CODE (OVL_FUNCTION (val
)) == USING_DECL
)
1243 /* An overload with a dependent USING_DECL. Does the caller
1244 want the USING_DECL or the functions? */
1245 if (type_or_fns
< 0)
1246 val
= OVL_CHAIN (val
);
1248 val
= OVL_FUNCTION (val
);
1253 if (member_vec
&& type_or_fns
<= 0)
1254 val
= member_vec_linear_search (member_vec
, lookup
);
1256 if (type_or_fns
< 0)
1257 /* Don't bother looking for field. We don't want it. */;
1258 else if (!val
|| (TREE_CODE (val
) == OVERLOAD
&& OVL_USING_P (val
)))
1259 /* Dependent using declarations are a 'field', make sure we
1260 return that even if we saw an overload already. */
1261 if (tree field_val
= fields_linear_search (klass
, lookup
,
1263 if (!val
|| TREE_CODE (field_val
) == USING_DECL
)
1267 /* Extract the conversion operators asked for, unless the general
1268 conversion operator was requested. */
1271 gcc_checking_assert (OVL_FUNCTION (val
) == conv_op_marker
);
1272 val
= OVL_CHAIN (val
);
1273 if (tree type
= TREE_TYPE (name
))
1274 val
= extract_conversion_operator (val
, type
);
1280 /* Look for NAME's binding in exactly KLASS. See
1281 get_class_binding_direct for argument description. Does lazy
1282 special function creation as necessary. */
1285 get_class_binding (tree klass
, tree name
, int type_or_fns
)
1287 klass
= complete_type (klass
);
1289 if (COMPLETE_TYPE_P (klass
))
1291 /* Lazily declare functions, if we're going to search these. */
1292 if (IDENTIFIER_CTOR_P (name
))
1294 if (CLASSTYPE_LAZY_DEFAULT_CTOR (klass
))
1295 lazily_declare_fn (sfk_constructor
, klass
);
1296 if (CLASSTYPE_LAZY_COPY_CTOR (klass
))
1297 lazily_declare_fn (sfk_copy_constructor
, klass
);
1298 if (CLASSTYPE_LAZY_MOVE_CTOR (klass
))
1299 lazily_declare_fn (sfk_move_constructor
, klass
);
1301 else if (IDENTIFIER_DTOR_P (name
))
1303 if (CLASSTYPE_LAZY_DESTRUCTOR (klass
))
1304 lazily_declare_fn (sfk_destructor
, klass
);
1306 else if (name
== assign_op_identifier
)
1308 if (CLASSTYPE_LAZY_COPY_ASSIGN (klass
))
1309 lazily_declare_fn (sfk_copy_assignment
, klass
);
1310 if (CLASSTYPE_LAZY_MOVE_ASSIGN (klass
))
1311 lazily_declare_fn (sfk_move_assignment
, klass
);
1315 return get_class_binding_direct (klass
, name
, type_or_fns
);
1318 /* Find the slot containing overloads called 'NAME'. If there is no
1319 such slot and the class is complete, create an empty one, at the
1320 correct point in the sorted member vector. Otherwise return NULL.
1321 Deals with conv_op marker handling. */
1324 find_member_slot (tree klass
, tree name
)
1326 bool complete_p
= COMPLETE_TYPE_P (klass
);
1328 vec
<tree
, va_gc
> *member_vec
= CLASSTYPE_MEMBER_VEC (klass
);
1331 vec_alloc (member_vec
, 8);
1332 CLASSTYPE_MEMBER_VEC (klass
) = member_vec
;
1335 /* If the class is complete but had no member_vec, we need
1336 to add the TYPE_FIELDS into it. We're also most likely
1337 to be adding ctors & dtors, so ask for 6 spare slots (the
1338 abstract cdtors and their clones). */
1339 set_class_bindings (klass
, 6);
1340 member_vec
= CLASSTYPE_MEMBER_VEC (klass
);
1344 if (IDENTIFIER_CONV_OP_P (name
))
1345 name
= conv_op_identifier
;
1347 unsigned ix
, length
= member_vec
->length ();
1348 for (ix
= 0; ix
< length
; ix
++)
1350 tree
*slot
= &(*member_vec
)[ix
];
1351 tree fn_name
= OVL_NAME (*slot
);
1353 if (fn_name
== name
)
1355 /* If we found an existing slot, it must be a function set.
1356 Even with insertion after completion, because those only
1357 happen with artificial fns that have unspellable names.
1358 This means we do not have to deal with the stat hack
1360 gcc_checking_assert (OVL_P (*slot
));
1361 if (name
== conv_op_identifier
)
1363 gcc_checking_assert (OVL_FUNCTION (*slot
) == conv_op_marker
);
1364 /* Skip the conv-op marker. */
1365 slot
= &OVL_CHAIN (*slot
);
1370 if (complete_p
&& fn_name
> name
)
1374 /* No slot found, add one if the class is complete. */
1377 /* Do exact allocation, as we don't expect to add many. */
1378 gcc_assert (name
!= conv_op_identifier
);
1379 vec_safe_reserve_exact (member_vec
, 1);
1380 CLASSTYPE_MEMBER_VEC (klass
) = member_vec
;
1381 member_vec
->quick_insert (ix
, NULL_TREE
);
1382 return &(*member_vec
)[ix
];
1388 /* KLASS is an incomplete class to which we're adding a method NAME.
1389 Add a slot and deal with conv_op marker handling. */
1392 add_member_slot (tree klass
, tree name
)
1394 gcc_assert (!COMPLETE_TYPE_P (klass
));
1396 vec
<tree
, va_gc
> *member_vec
= CLASSTYPE_MEMBER_VEC (klass
);
1397 vec_safe_push (member_vec
, NULL_TREE
);
1398 CLASSTYPE_MEMBER_VEC (klass
) = member_vec
;
1400 tree
*slot
= &member_vec
->last ();
1401 if (IDENTIFIER_CONV_OP_P (name
))
1403 /* Install the marker prefix. */
1404 *slot
= ovl_make (conv_op_marker
, NULL_TREE
);
1405 slot
= &OVL_CHAIN (*slot
);
1411 /* Comparison function to compare two MEMBER_VEC entries by name.
1412 Because we can have duplicates during insertion of TYPE_FIELDS, we
1413 do extra checking so deduping doesn't have to deal with so many
1417 member_name_cmp (const void *a_p
, const void *b_p
)
1419 tree a
= *(const tree
*)a_p
;
1420 tree b
= *(const tree
*)b_p
;
1421 tree name_a
= DECL_NAME (TREE_CODE (a
) == OVERLOAD
? OVL_FUNCTION (a
) : a
);
1422 tree name_b
= DECL_NAME (TREE_CODE (b
) == OVERLOAD
? OVL_FUNCTION (b
) : b
);
1424 gcc_checking_assert (name_a
&& name_b
);
1425 if (name_a
!= name_b
)
1426 return name_a
< name_b
? -1 : +1;
1428 if (name_a
== conv_op_identifier
)
1430 /* Strip the conv-op markers. */
1431 gcc_checking_assert (OVL_FUNCTION (a
) == conv_op_marker
1432 && OVL_FUNCTION (b
) == conv_op_marker
);
1437 if (TREE_CODE (a
) == OVERLOAD
)
1438 a
= OVL_FUNCTION (a
);
1439 if (TREE_CODE (b
) == OVERLOAD
)
1440 b
= OVL_FUNCTION (b
);
1442 /* We're in STAT_HACK or USING_DECL territory (or possibly error-land). */
1443 if (TREE_CODE (a
) != TREE_CODE (b
))
1445 /* If one of them is a TYPE_DECL, it loses. */
1446 if (TREE_CODE (a
) == TYPE_DECL
)
1448 else if (TREE_CODE (b
) == TYPE_DECL
)
1451 /* If one of them is a USING_DECL, it loses. */
1452 if (TREE_CODE (a
) == USING_DECL
)
1454 else if (TREE_CODE (b
) == USING_DECL
)
1457 /* There are no other cases with different kinds of decls, as
1458 duplicate detection should have kicked in earlier. However,
1459 some erroneous cases get though. */
1460 gcc_assert (errorcount
);
1463 /* Using source location would be the best thing here, but we can
1464 get identically-located decls in the following circumstances:
1466 1) duplicate artificial type-decls for the same type.
1468 2) pack expansions of using-decls.
1470 We should not be doing #1, but in either case it doesn't matter
1471 how we order these. Use UID as a proxy for source ordering, so
1472 that identically-located decls still have a well-defined stable
1474 if (DECL_UID (a
) != DECL_UID (b
))
1475 return DECL_UID (a
) < DECL_UID (b
) ? -1 : +1;
1476 gcc_assert (a
== b
);
1481 gt_pointer_operator new_value
;
1485 /* This routine compares two fields like member_name_cmp but using the
1486 pointer operator in resort_field_decl_data. We don't have to deal
1487 with duplicates here. */
1490 resort_member_name_cmp (const void *a_p
, const void *b_p
)
1492 tree a
= *(const tree
*)a_p
;
1493 tree b
= *(const tree
*)b_p
;
1494 tree name_a
= OVL_NAME (a
);
1495 tree name_b
= OVL_NAME (b
);
1497 resort_data
.new_value (&name_a
, resort_data
.cookie
);
1498 resort_data
.new_value (&name_b
, resort_data
.cookie
);
1500 gcc_checking_assert (name_a
!= name_b
);
1502 return name_a
< name_b
? -1 : +1;
1505 /* Resort CLASSTYPE_MEMBER_VEC because pointers have been reordered. */
1508 resort_type_member_vec (void *obj
, void */
*orig_obj*/
,
1509 gt_pointer_operator new_value
, void* cookie
)
1511 if (vec
<tree
, va_gc
> *member_vec
= (vec
<tree
, va_gc
> *) obj
)
1513 resort_data
.new_value
= new_value
;
1514 resort_data
.cookie
= cookie
;
1515 member_vec
->qsort (resort_member_name_cmp
);
1519 /* Recursively count the number of fields in KLASS, including anonymous
1523 count_class_fields (tree klass
)
1525 unsigned n_fields
= 0;
1527 for (tree fields
= TYPE_FIELDS (klass
); fields
; fields
= DECL_CHAIN (fields
))
1528 if (DECL_DECLARES_FUNCTION_P (fields
))
1529 /* Functions are dealt with separately. */;
1530 else if (TREE_CODE (fields
) == FIELD_DECL
1531 && ANON_AGGR_TYPE_P (TREE_TYPE (fields
)))
1532 n_fields
+= count_class_fields (TREE_TYPE (fields
));
1533 else if (DECL_NAME (fields
))
1539 /* Append all the nonfunction members fields of KLASS to MEMBER_VEC.
1540 Recurse for anonymous members. MEMBER_VEC must have space. */
1543 member_vec_append_class_fields (vec
<tree
, va_gc
> *member_vec
, tree klass
)
1545 for (tree fields
= TYPE_FIELDS (klass
); fields
; fields
= DECL_CHAIN (fields
))
1546 if (DECL_DECLARES_FUNCTION_P (fields
))
1547 /* Functions are handled separately. */;
1548 else if (TREE_CODE (fields
) == FIELD_DECL
1549 && ANON_AGGR_TYPE_P (TREE_TYPE (fields
)))
1550 member_vec_append_class_fields (member_vec
, TREE_TYPE (fields
));
1551 else if (DECL_NAME (fields
))
1553 tree field
= fields
;
1554 /* Mark a conv-op USING_DECL with the conv-op-marker. */
1555 if (TREE_CODE (field
) == USING_DECL
1556 && IDENTIFIER_CONV_OP_P (DECL_NAME (field
)))
1557 field
= ovl_make (conv_op_marker
, field
);
1558 member_vec
->quick_push (field
);
1562 /* Append all of the enum values of ENUMTYPE to MEMBER_VEC.
1563 MEMBER_VEC must have space. */
1566 member_vec_append_enum_values (vec
<tree
, va_gc
> *member_vec
, tree enumtype
)
1568 for (tree values
= TYPE_VALUES (enumtype
);
1569 values
; values
= TREE_CHAIN (values
))
1570 member_vec
->quick_push (TREE_VALUE (values
));
1573 /* MEMBER_VEC has just had new DECLs added to it, but is sorted.
1574 DeDup adjacent DECLS of the same name. We already dealt with
1575 conflict resolution when adding the fields or methods themselves.
1576 There are three cases (which could all be combined):
1577 1) a TYPE_DECL and non TYPE_DECL. Deploy STAT_HACK as appropriate.
1578 2) a USING_DECL and an overload. If the USING_DECL is dependent,
1579 it wins. Otherwise the OVERLOAD does.
1580 3) two USING_DECLS. ...
1582 member_name_cmp will have ordered duplicates as
1583 <fns><using><type> */
1586 member_vec_dedup (vec
<tree
, va_gc
> *member_vec
)
1588 unsigned len
= member_vec
->length ();
1594 tree name
= OVL_NAME ((*member_vec
)[0]);
1595 for (unsigned jx
, ix
= 0; ix
< len
; ix
= jx
)
1597 tree current
= NULL_TREE
;
1598 tree to_type
= NULL_TREE
;
1599 tree to_using
= NULL_TREE
;
1600 tree marker
= NULL_TREE
;
1602 for (jx
= ix
; jx
< len
; jx
++)
1604 tree next
= (*member_vec
)[jx
];
1607 tree next_name
= OVL_NAME (next
);
1608 if (next_name
!= name
)
1615 if (IDENTIFIER_CONV_OP_P (name
))
1618 next
= OVL_CHAIN (next
);
1621 if (TREE_CODE (next
) == USING_DECL
)
1623 if (IDENTIFIER_CTOR_P (name
))
1624 /* Dependent inherited ctor. */
1627 next
= strip_using_decl (next
);
1628 if (TREE_CODE (next
) == USING_DECL
)
1634 if (is_overloaded_fn (next
))
1638 if (DECL_DECLARES_TYPE_P (next
))
1653 current
= ovl_make (to_using
, current
);
1661 current
= stat_hack (current
, to_type
);
1668 OVL_CHAIN (marker
) = current
;
1671 (*member_vec
)[store
++] = current
;
1675 while (store
++ < len
)
1679 /* Add the non-function members to CLASSTYPE_MEMBER_VEC. If there is
1680 no existing MEMBER_VEC and fewer than 8 fields, do nothing. We
1681 know there must be at least 1 field -- the self-reference
1682 TYPE_DECL, except for anon aggregates, which will have at least
1686 set_class_bindings (tree klass
, unsigned extra
)
1688 unsigned n_fields
= count_class_fields (klass
);
1689 vec
<tree
, va_gc
> *member_vec
= CLASSTYPE_MEMBER_VEC (klass
);
1691 if (member_vec
|| n_fields
>= 8)
1693 /* Append the new fields. */
1694 vec_safe_reserve_exact (member_vec
, extra
+ n_fields
);
1695 member_vec_append_class_fields (member_vec
, klass
);
1700 CLASSTYPE_MEMBER_VEC (klass
) = member_vec
;
1701 member_vec
->qsort (member_name_cmp
);
1702 member_vec_dedup (member_vec
);
1706 /* Insert lately defined enum ENUMTYPE into KLASS for the sorted case. */
1709 insert_late_enum_def_bindings (tree klass
, tree enumtype
)
1712 vec
<tree
, va_gc
> *member_vec
= CLASSTYPE_MEMBER_VEC (klass
);
1714 /* The enum bindings will already be on the TYPE_FIELDS, so don't
1715 count them twice. */
1717 n_fields
= count_class_fields (klass
);
1719 n_fields
= list_length (TYPE_VALUES (enumtype
));
1721 if (member_vec
|| n_fields
>= 8)
1723 vec_safe_reserve_exact (member_vec
, n_fields
);
1724 if (CLASSTYPE_MEMBER_VEC (klass
))
1725 member_vec_append_enum_values (member_vec
, enumtype
);
1727 member_vec_append_class_fields (member_vec
, klass
);
1728 CLASSTYPE_MEMBER_VEC (klass
) = member_vec
;
1729 member_vec
->qsort (member_name_cmp
);
1730 member_vec_dedup (member_vec
);
1734 /* Compute the chain index of a binding_entry given the HASH value of its
1735 name and the total COUNT of chains. COUNT is assumed to be a power
1738 #define ENTRY_INDEX(HASH, COUNT) (((HASH) >> 3) & ((COUNT) - 1))
1740 /* A free list of "binding_entry"s awaiting for re-use. */
1742 static GTY((deletable
)) binding_entry free_binding_entry
= NULL
;
1744 /* The binding oracle; see cp-tree.h. */
1746 cp_binding_oracle_function
*cp_binding_oracle
;
1748 /* If we have a binding oracle, ask it for all namespace-scoped
1749 definitions of NAME. */
1752 query_oracle (tree name
)
1754 if (!cp_binding_oracle
)
1757 /* LOOKED_UP holds the set of identifiers that we have already
1758 looked up with the oracle. */
1759 static hash_set
<tree
> looked_up
;
1760 if (looked_up
.add (name
))
1763 cp_binding_oracle (CP_ORACLE_IDENTIFIER
, name
);
1766 /* Create a binding_entry object for (NAME, TYPE). */
1768 static inline binding_entry
1769 binding_entry_make (tree name
, tree type
)
1771 binding_entry entry
;
1773 if (free_binding_entry
)
1775 entry
= free_binding_entry
;
1776 free_binding_entry
= entry
->chain
;
1779 entry
= ggc_alloc
<binding_entry_s
> ();
1783 entry
->chain
= NULL
;
1788 /* Put ENTRY back on the free list. */
1791 binding_entry_free (binding_entry entry
)
1795 entry
->chain
= free_binding_entry
;
1796 free_binding_entry
= entry
;
1800 /* The datatype used to implement the mapping from names to types at
1802 struct GTY(()) binding_table_s
{
1803 /* Array of chains of "binding_entry"s */
1804 binding_entry
* GTY((length ("%h.chain_count"))) chain
;
1806 /* The number of chains in this table. This is the length of the
1807 member "chain" considered as an array. */
1810 /* Number of "binding_entry"s in this table. */
1814 /* Construct TABLE with an initial CHAIN_COUNT. */
1817 binding_table_construct (binding_table table
, size_t chain_count
)
1819 table
->chain_count
= chain_count
;
1820 table
->entry_count
= 0;
1821 table
->chain
= ggc_cleared_vec_alloc
<binding_entry
> (table
->chain_count
);
1824 /* Make TABLE's entries ready for reuse. */
1827 binding_table_free (binding_table table
)
1835 for (i
= 0, count
= table
->chain_count
; i
< count
; ++i
)
1837 binding_entry temp
= table
->chain
[i
];
1838 while (temp
!= NULL
)
1840 binding_entry entry
= temp
;
1841 temp
= entry
->chain
;
1842 binding_entry_free (entry
);
1844 table
->chain
[i
] = NULL
;
1846 table
->entry_count
= 0;
1850 /* Allocate a table with CHAIN_COUNT, assumed to be a power of two. */
1852 static inline binding_table
1853 binding_table_new (size_t chain_count
)
1855 binding_table table
= ggc_alloc
<binding_table_s
> ();
1856 table
->chain
= NULL
;
1857 binding_table_construct (table
, chain_count
);
1861 /* Expand TABLE to twice its current chain_count. */
1864 binding_table_expand (binding_table table
)
1866 const size_t old_chain_count
= table
->chain_count
;
1867 const size_t old_entry_count
= table
->entry_count
;
1868 const size_t new_chain_count
= 2 * old_chain_count
;
1869 binding_entry
*old_chains
= table
->chain
;
1872 binding_table_construct (table
, new_chain_count
);
1873 for (i
= 0; i
< old_chain_count
; ++i
)
1875 binding_entry entry
= old_chains
[i
];
1876 for (; entry
!= NULL
; entry
= old_chains
[i
])
1878 const unsigned int hash
= IDENTIFIER_HASH_VALUE (entry
->name
);
1879 const size_t j
= ENTRY_INDEX (hash
, new_chain_count
);
1881 old_chains
[i
] = entry
->chain
;
1882 entry
->chain
= table
->chain
[j
];
1883 table
->chain
[j
] = entry
;
1886 table
->entry_count
= old_entry_count
;
1889 /* Insert a binding for NAME to TYPE into TABLE. */
1892 binding_table_insert (binding_table table
, tree name
, tree type
)
1894 const unsigned int hash
= IDENTIFIER_HASH_VALUE (name
);
1895 const size_t i
= ENTRY_INDEX (hash
, table
->chain_count
);
1896 binding_entry entry
= binding_entry_make (name
, type
);
1898 entry
->chain
= table
->chain
[i
];
1899 table
->chain
[i
] = entry
;
1900 ++table
->entry_count
;
1902 if (3 * table
->chain_count
< 5 * table
->entry_count
)
1903 binding_table_expand (table
);
1906 /* Return the binding_entry, if any, that maps NAME. */
1909 binding_table_find (binding_table table
, tree name
)
1911 const unsigned int hash
= IDENTIFIER_HASH_VALUE (name
);
1912 binding_entry entry
= table
->chain
[ENTRY_INDEX (hash
, table
->chain_count
)];
1914 while (entry
!= NULL
&& entry
->name
!= name
)
1915 entry
= entry
->chain
;
1920 /* Apply PROC -- with DATA -- to all entries in TABLE. */
1923 binding_table_foreach (binding_table table
, bt_foreach_proc proc
, void *data
)
1931 chain_count
= table
->chain_count
;
1932 for (i
= 0; i
< chain_count
; ++i
)
1934 binding_entry entry
= table
->chain
[i
];
1935 for (; entry
!= NULL
; entry
= entry
->chain
)
1940 #ifndef ENABLE_SCOPE_CHECKING
1941 # define ENABLE_SCOPE_CHECKING 0
1943 # define ENABLE_SCOPE_CHECKING 1
1946 /* A free list of "cxx_binding"s, connected by their PREVIOUS. */
1948 static GTY((deletable
)) cxx_binding
*free_bindings
;
1950 /* Initialize VALUE and TYPE field for BINDING, and set the PREVIOUS
1954 cxx_binding_init (cxx_binding
*binding
, tree value
, tree type
)
1956 binding
->value
= value
;
1957 binding
->type
= type
;
1958 binding
->previous
= NULL
;
1961 /* (GC)-allocate a binding object with VALUE and TYPE member initialized. */
1963 static cxx_binding
*
1964 cxx_binding_make (tree value
, tree type
)
1966 cxx_binding
*binding
;
1969 binding
= free_bindings
;
1970 free_bindings
= binding
->previous
;
1973 binding
= ggc_alloc
<cxx_binding
> ();
1975 cxx_binding_init (binding
, value
, type
);
1980 /* Put BINDING back on the free list. */
1983 cxx_binding_free (cxx_binding
*binding
)
1985 binding
->scope
= NULL
;
1986 binding
->previous
= free_bindings
;
1987 free_bindings
= binding
;
1990 /* Create a new binding for NAME (with the indicated VALUE and TYPE
1991 bindings) in the class scope indicated by SCOPE. */
1993 static cxx_binding
*
1994 new_class_binding (tree name
, tree value
, tree type
, cp_binding_level
*scope
)
1996 cp_class_binding cb
= {cxx_binding_make (value
, type
), name
};
1997 cxx_binding
*binding
= cb
.base
;
1998 vec_safe_push (scope
->class_shadowed
, cb
);
1999 binding
->scope
= scope
;
2003 /* Make DECL the innermost binding for ID. The LEVEL is the binding
2004 level at which this declaration is being bound. */
2007 push_binding (tree id
, tree decl
, cp_binding_level
* level
)
2009 cxx_binding
*binding
;
2011 if (level
!= class_binding_level
)
2013 binding
= cxx_binding_make (decl
, NULL_TREE
);
2014 binding
->scope
= level
;
2017 binding
= new_class_binding (id
, decl
, /*type=*/NULL_TREE
, level
);
2019 /* Now, fill in the binding information. */
2020 binding
->previous
= IDENTIFIER_BINDING (id
);
2021 INHERITED_VALUE_BINDING_P (binding
) = 0;
2022 LOCAL_BINDING_P (binding
) = (level
!= class_binding_level
);
2024 /* And put it on the front of the list of bindings for ID. */
2025 IDENTIFIER_BINDING (id
) = binding
;
2028 /* Remove the binding for DECL which should be the innermost binding
2032 pop_local_binding (tree id
, tree decl
)
2034 cxx_binding
*binding
;
2036 if (id
== NULL_TREE
)
2037 /* It's easiest to write the loops that call this function without
2038 checking whether or not the entities involved have names. We
2039 get here for such an entity. */
2042 /* Get the innermost binding for ID. */
2043 binding
= IDENTIFIER_BINDING (id
);
2045 /* The name should be bound. */
2046 gcc_assert (binding
!= NULL
);
2048 /* The DECL will be either the ordinary binding or the type
2049 binding for this identifier. Remove that binding. */
2050 if (binding
->value
== decl
)
2051 binding
->value
= NULL_TREE
;
2054 gcc_assert (binding
->type
== decl
);
2055 binding
->type
= NULL_TREE
;
2058 if (!binding
->value
&& !binding
->type
)
2060 /* We're completely done with the innermost binding for this
2061 identifier. Unhook it from the list of bindings. */
2062 IDENTIFIER_BINDING (id
) = binding
->previous
;
2064 /* Add it to the free list. */
2065 cxx_binding_free (binding
);
2069 /* Remove the bindings for the decls of the current level and leave
2070 the current scope. */
2073 pop_bindings_and_leave_scope (void)
2075 for (tree t
= get_local_decls (); t
; t
= DECL_CHAIN (t
))
2077 tree decl
= TREE_CODE (t
) == TREE_LIST
? TREE_VALUE (t
) : t
;
2078 tree name
= OVL_NAME (decl
);
2080 pop_local_binding (name
, decl
);
2086 /* Strip non dependent using declarations. If DECL is dependent,
2087 surreptitiously create a typename_type and return it. */
2090 strip_using_decl (tree decl
)
2092 if (decl
== NULL_TREE
)
2095 while (TREE_CODE (decl
) == USING_DECL
&& !DECL_DEPENDENT_P (decl
))
2096 decl
= USING_DECL_DECLS (decl
);
2098 if (TREE_CODE (decl
) == USING_DECL
&& DECL_DEPENDENT_P (decl
)
2099 && USING_DECL_TYPENAME_P (decl
))
2101 /* We have found a type introduced by a using
2102 declaration at class scope that refers to a dependent
2105 using typename :: [opt] nested-name-specifier unqualified-id ;
2107 decl
= make_typename_type (TREE_TYPE (decl
),
2109 typename_type
, tf_error
);
2110 if (decl
!= error_mark_node
)
2111 decl
= TYPE_NAME (decl
);
2117 /* Return true if OVL is an overload for an anticipated builtin. */
2120 anticipated_builtin_p (tree ovl
)
2122 if (TREE_CODE (ovl
) != OVERLOAD
)
2125 if (!OVL_HIDDEN_P (ovl
))
2128 tree fn
= OVL_FUNCTION (ovl
);
2129 gcc_checking_assert (DECL_ANTICIPATED (fn
));
2131 if (DECL_HIDDEN_FRIEND_P (fn
))
2137 /* BINDING records an existing declaration for a name in the current scope.
2138 But, DECL is another declaration for that same identifier in the
2139 same scope. This is the `struct stat' hack whereby a non-typedef
2140 class name or enum-name can be bound at the same level as some other
2144 A class name (9.1) or enumeration name (7.2) can be hidden by the
2145 name of an object, function, or enumerator declared in the same scope.
2146 If a class or enumeration name and an object, function, or enumerator
2147 are declared in the same scope (in any order) with the same name, the
2148 class or enumeration name is hidden wherever the object, function, or
2149 enumerator name is visible.
2151 It's the responsibility of the caller to check that
2152 inserting this name is valid here. Returns nonzero if the new binding
2156 supplement_binding_1 (cxx_binding
*binding
, tree decl
)
2158 tree bval
= binding
->value
;
2160 tree target_bval
= strip_using_decl (bval
);
2161 tree target_decl
= strip_using_decl (decl
);
2163 if (TREE_CODE (target_decl
) == TYPE_DECL
&& DECL_ARTIFICIAL (target_decl
)
2164 && target_decl
!= target_bval
2165 && (TREE_CODE (target_bval
) != TYPE_DECL
2166 /* We allow pushing an enum multiple times in a class
2167 template in order to handle late matching of underlying
2168 type on an opaque-enum-declaration followed by an
2170 || (processing_template_decl
2171 && TREE_CODE (TREE_TYPE (target_decl
)) == ENUMERAL_TYPE
2172 && TREE_CODE (TREE_TYPE (target_bval
)) == ENUMERAL_TYPE
2173 && (dependent_type_p (ENUM_UNDERLYING_TYPE
2174 (TREE_TYPE (target_decl
)))
2175 || dependent_type_p (ENUM_UNDERLYING_TYPE
2176 (TREE_TYPE (target_bval
)))))))
2177 /* The new name is the type name. */
2178 binding
->type
= decl
;
2179 else if (/* TARGET_BVAL is null when push_class_level_binding moves
2180 an inherited type-binding out of the way to make room
2181 for a new value binding. */
2183 /* TARGET_BVAL is error_mark_node when TARGET_DECL's name
2184 has been used in a non-class scope prior declaration.
2185 In that case, we should have already issued a
2186 diagnostic; for graceful error recovery purpose, pretend
2187 this was the intended declaration for that name. */
2188 || target_bval
== error_mark_node
2189 /* If TARGET_BVAL is anticipated but has not yet been
2190 declared, pretend it is not there at all. */
2191 || anticipated_builtin_p (target_bval
))
2192 binding
->value
= decl
;
2193 else if (TREE_CODE (target_bval
) == TYPE_DECL
2194 && DECL_ARTIFICIAL (target_bval
)
2195 && target_decl
!= target_bval
2196 && (TREE_CODE (target_decl
) != TYPE_DECL
2197 || same_type_p (TREE_TYPE (target_decl
),
2198 TREE_TYPE (target_bval
))))
2200 /* The old binding was a type name. It was placed in
2201 VALUE field because it was thought, at the point it was
2202 declared, to be the only entity with such a name. Move the
2203 type name into the type slot; it is now hidden by the new
2205 binding
->type
= bval
;
2206 binding
->value
= decl
;
2207 binding
->value_is_inherited
= false;
2209 else if (TREE_CODE (target_bval
) == TYPE_DECL
2210 && TREE_CODE (target_decl
) == TYPE_DECL
2211 && DECL_NAME (target_decl
) == DECL_NAME (target_bval
)
2212 && binding
->scope
->kind
!= sk_class
2213 && (same_type_p (TREE_TYPE (target_decl
), TREE_TYPE (target_bval
))
2214 /* If either type involves template parameters, we must
2215 wait until instantiation. */
2216 || uses_template_parms (TREE_TYPE (target_decl
))
2217 || uses_template_parms (TREE_TYPE (target_bval
))))
2218 /* We have two typedef-names, both naming the same type to have
2219 the same name. In general, this is OK because of:
2223 In a given scope, a typedef specifier can be used to redefine
2224 the name of any type declared in that scope to refer to the
2225 type to which it already refers.
2227 However, in class scopes, this rule does not apply due to the
2228 stricter language in [class.mem] prohibiting redeclarations of
2231 /* There can be two block-scope declarations of the same variable,
2232 so long as they are `extern' declarations. However, there cannot
2233 be two declarations of the same static data member:
2237 A member shall not be declared twice in the
2238 member-specification. */
2239 else if (VAR_P (target_decl
)
2240 && VAR_P (target_bval
)
2241 && DECL_EXTERNAL (target_decl
) && DECL_EXTERNAL (target_bval
)
2242 && !DECL_CLASS_SCOPE_P (target_decl
))
2244 duplicate_decls (decl
, binding
->value
, /*newdecl_is_friend=*/false);
2247 else if (TREE_CODE (decl
) == NAMESPACE_DECL
2248 && TREE_CODE (bval
) == NAMESPACE_DECL
2249 && DECL_NAMESPACE_ALIAS (decl
)
2250 && DECL_NAMESPACE_ALIAS (bval
)
2251 && ORIGINAL_NAMESPACE (bval
) == ORIGINAL_NAMESPACE (decl
))
2252 /* [namespace.alias]
2254 In a declarative region, a namespace-alias-definition can be
2255 used to redefine a namespace-alias declared in that declarative
2256 region to refer only to the namespace to which it already
2261 if (!error_operand_p (bval
))
2262 diagnose_name_conflict (decl
, bval
);
2269 /* Diagnose a name conflict between DECL and BVAL. */
2272 diagnose_name_conflict (tree decl
, tree bval
)
2274 if (TREE_CODE (decl
) == TREE_CODE (bval
)
2275 && TREE_CODE (decl
) != NAMESPACE_DECL
2276 && !DECL_DECLARES_FUNCTION_P (decl
)
2277 && (TREE_CODE (decl
) != TYPE_DECL
2278 || DECL_ARTIFICIAL (decl
) == DECL_ARTIFICIAL (bval
))
2279 && CP_DECL_CONTEXT (decl
) == CP_DECL_CONTEXT (bval
))
2280 error ("redeclaration of %q#D", decl
);
2282 error ("%q#D conflicts with a previous declaration", decl
);
2284 inform (location_of (bval
), "previous declaration %q#D", bval
);
2287 /* Wrapper for supplement_binding_1. */
2290 supplement_binding (cxx_binding
*binding
, tree decl
)
2293 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
2294 ret
= supplement_binding_1 (binding
, decl
);
2295 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
2299 /* Replace BINDING's current value on its scope's name list with
2303 update_local_overload (cxx_binding
*binding
, tree newval
)
2307 for (d
= &binding
->scope
->names
; ; d
= &TREE_CHAIN (*d
))
2308 if (*d
== binding
->value
)
2310 /* Stitch new list node in. */
2311 *d
= tree_cons (NULL_TREE
, NULL_TREE
, TREE_CHAIN (*d
));
2314 else if (TREE_CODE (*d
) == TREE_LIST
&& TREE_VALUE (*d
) == binding
->value
)
2317 TREE_VALUE (*d
) = newval
;
2320 /* Compares the parameter-type-lists of ONE and TWO and
2321 returns false if they are different. If the DECLs are template
2322 functions, the return types and the template parameter lists are
2323 compared too (DR 565). */
2326 matching_fn_p (tree one
, tree two
)
2328 if (!compparms (TYPE_ARG_TYPES (TREE_TYPE (one
)),
2329 TYPE_ARG_TYPES (TREE_TYPE (two
))))
2332 if (TREE_CODE (one
) == TEMPLATE_DECL
2333 && TREE_CODE (two
) == TEMPLATE_DECL
)
2335 /* Compare template parms. */
2336 if (!comp_template_parms (DECL_TEMPLATE_PARMS (one
),
2337 DECL_TEMPLATE_PARMS (two
)))
2340 /* And return type. */
2341 if (!same_type_p (TREE_TYPE (TREE_TYPE (one
)),
2342 TREE_TYPE (TREE_TYPE (two
))))
2349 /* Push DECL into nonclass LEVEL BINDING or SLOT. OLD is the current
2350 binding value (possibly with anticipated builtins stripped).
2351 Diagnose conflicts and return updated decl. */
2354 update_binding (cp_binding_level
*level
, cxx_binding
*binding
, tree
*slot
,
2355 tree old
, tree decl
, bool is_friend
)
2358 tree old_type
= slot
? MAYBE_STAT_TYPE (*slot
) : binding
->type
;
2359 tree to_type
= old_type
;
2361 gcc_assert (level
->kind
== sk_namespace
? !binding
2362 : level
->kind
!= sk_class
&& !slot
);
2363 if (old
== error_mark_node
)
2366 if (TREE_CODE (decl
) == TYPE_DECL
&& DECL_ARTIFICIAL (decl
))
2368 tree other
= to_type
;
2370 if (old
&& TREE_CODE (old
) == TYPE_DECL
&& DECL_ARTIFICIAL (old
))
2373 /* Pushing an artificial typedef. See if this matches either
2374 the type slot or the old value slot. */
2377 else if (same_type_p (TREE_TYPE (other
), TREE_TYPE (decl
)))
2378 /* Two artificial decls to same type. Do nothing. */
2385 /* Slide decl into the type slot, keep old unaltered */
2392 if (old
&& TREE_CODE (old
) == TYPE_DECL
&& DECL_ARTIFICIAL (old
))
2394 /* Slide old into the type slot. */
2399 if (DECL_DECLARES_FUNCTION_P (decl
))
2403 else if (OVL_P (old
))
2405 for (ovl_iterator
iter (old
); iter
; ++iter
)
2409 if (iter
.using_p () && matching_fn_p (fn
, decl
))
2411 /* If a function declaration in namespace scope or
2412 block scope has the same name and the same
2413 parameter-type- list (8.3.5) as a function
2414 introduced by a using-declaration, and the
2415 declarations do not declare the same function,
2416 the program is ill-formed. [namespace.udecl]/14 */
2417 if (tree match
= duplicate_decls (decl
, fn
, is_friend
))
2420 /* FIXME: To preserve existing error behavior, we
2421 still push the decl. This might change. */
2422 diagnose_name_conflict (decl
, fn
);
2429 if (to_type
!= old_type
2431 && MAYBE_CLASS_TYPE_P (TREE_TYPE (to_type
))
2432 && !(DECL_IN_SYSTEM_HEADER (decl
)
2433 && DECL_IN_SYSTEM_HEADER (to_type
)))
2434 warning (OPT_Wshadow
, "%q#D hides constructor for %q#D",
2437 to_val
= ovl_insert (decl
, old
);
2441 else if (TREE_CODE (old
) != TREE_CODE (decl
))
2442 /* Different kinds of decls conflict. */
2444 else if (TREE_CODE (old
) == TYPE_DECL
)
2446 if (same_type_p (TREE_TYPE (old
), TREE_TYPE (decl
)))
2447 /* Two type decls to the same type. Do nothing. */
2452 else if (TREE_CODE (old
) == NAMESPACE_DECL
)
2454 /* Two maybe-aliased namespaces. If they're to the same target
2455 namespace, that's ok. */
2456 if (ORIGINAL_NAMESPACE (old
) != ORIGINAL_NAMESPACE (decl
))
2459 /* The new one must be an alias at this point. */
2460 gcc_assert (DECL_NAMESPACE_ALIAS (decl
));
2463 else if (TREE_CODE (old
) == VAR_DECL
)
2465 /* There can be two block-scope declarations of the same
2466 variable, so long as they are `extern' declarations. */
2467 if (!DECL_EXTERNAL (old
) || !DECL_EXTERNAL (decl
))
2469 else if (tree match
= duplicate_decls (decl
, old
, false))
2477 diagnose_name_conflict (decl
, old
);
2484 if (level
->kind
== sk_namespace
|| to_type
== decl
|| to_val
== decl
)
2485 add_decl_to_level (level
, decl
);
2488 gcc_checking_assert (binding
->value
&& OVL_P (binding
->value
));
2489 update_local_overload (binding
, to_val
);
2494 if (STAT_HACK_P (*slot
))
2496 STAT_TYPE (*slot
) = to_type
;
2497 STAT_DECL (*slot
) = to_val
;
2500 *slot
= stat_hack (to_val
, to_type
);
2506 binding
->type
= to_type
;
2507 binding
->value
= to_val
;
2514 /* Table of identifiers to extern C declarations (or LISTS thereof). */
2516 static GTY(()) hash_table
<named_decl_hash
> *extern_c_decls
;
2518 /* DECL has C linkage. If we have an existing instance, make sure the
2519 new one is compatible. Make sure it has the same exception
2520 specification [7.5, 7.6]. Add DECL to the map. */
2523 check_extern_c_conflict (tree decl
)
2525 /* Ignore artificial or system header decls. */
2526 if (DECL_ARTIFICIAL (decl
) || DECL_IN_SYSTEM_HEADER (decl
))
2529 if (!extern_c_decls
)
2530 extern_c_decls
= hash_table
<named_decl_hash
>::create_ggc (127);
2532 tree
*slot
= extern_c_decls
2533 ->find_slot_with_hash (DECL_NAME (decl
),
2534 IDENTIFIER_HASH_VALUE (DECL_NAME (decl
)), INSERT
);
2535 if (tree old
= *slot
)
2537 if (TREE_CODE (old
) == OVERLOAD
)
2538 old
= OVL_FUNCTION (old
);
2541 if (DECL_CONTEXT (old
) == DECL_CONTEXT (decl
))
2542 ; /* If they're in the same context, we'll have already complained
2543 about a (possible) mismatch, when inserting the decl. */
2544 else if (!decls_match (decl
, old
))
2546 else if (TREE_CODE (decl
) == FUNCTION_DECL
2547 && !comp_except_specs (TYPE_RAISES_EXCEPTIONS (TREE_TYPE (old
)),
2548 TYPE_RAISES_EXCEPTIONS (TREE_TYPE (decl
)),
2551 else if (DECL_ASSEMBLER_NAME_SET_P (old
))
2552 SET_DECL_ASSEMBLER_NAME (decl
, DECL_ASSEMBLER_NAME (old
));
2556 pedwarn (input_location
, 0,
2557 "conflicting C language linkage declaration %q#D", decl
);
2558 inform (DECL_SOURCE_LOCATION (old
),
2559 "previous declaration %q#D", old
);
2561 inform (input_location
,
2562 "due to different exception specifications");
2567 /* The hash table expects OVERLOADS, so construct one with
2568 OLD as both the function and the chain. This allocate
2569 an excess OVERLOAD node, but it's rare to have multiple
2570 extern "C" decls of the same name. And we save
2571 complicating the hash table logic (which is used
2573 *slot
= ovl_make (old
, old
);
2575 slot
= &OVL_CHAIN (*slot
);
2577 /* Chain it on for c_linkage_binding's use. */
2578 *slot
= tree_cons (NULL_TREE
, decl
, *slot
);
2585 /* Returns a list of C-linkage decls with the name NAME. Used in
2586 c-family/c-pragma.c to implement redefine_extname pragma. */
2589 c_linkage_bindings (tree name
)
2592 if (tree
*slot
= extern_c_decls
2593 ->find_slot_with_hash (name
, IDENTIFIER_HASH_VALUE (name
), NO_INSERT
))
2595 tree result
= *slot
;
2596 if (TREE_CODE (result
) == OVERLOAD
)
2597 result
= OVL_CHAIN (result
);
2604 /* DECL is being declared at a local scope. Emit suitable shadow
2608 check_local_shadow (tree decl
)
2610 /* Don't complain about the parms we push and then pop
2611 while tentatively parsing a function declarator. */
2612 if (TREE_CODE (decl
) == PARM_DECL
&& !DECL_CONTEXT (decl
))
2615 /* Inline decls shadow nothing. */
2616 if (DECL_FROM_INLINE (decl
))
2619 /* External decls are something else. */
2620 if (DECL_EXTERNAL (decl
))
2623 tree old
= NULL_TREE
;
2624 cp_binding_level
*old_scope
= NULL
;
2625 if (cxx_binding
*binding
= outer_binding (DECL_NAME (decl
), NULL
, true))
2627 old
= binding
->value
;
2628 old_scope
= binding
->scope
;
2630 while (old
&& VAR_P (old
) && DECL_DEAD_FOR_LOCAL (old
))
2631 old
= DECL_SHADOWED_FOR_VAR (old
);
2633 tree shadowed
= NULL_TREE
;
2635 && (TREE_CODE (old
) == PARM_DECL
2637 || (TREE_CODE (old
) == TYPE_DECL
2638 && (!DECL_ARTIFICIAL (old
)
2639 || TREE_CODE (decl
) == TYPE_DECL
)))
2640 && (!DECL_ARTIFICIAL (decl
)
2641 || DECL_IMPLICIT_TYPEDEF_P (decl
)
2642 || (VAR_P (decl
) && DECL_ANON_UNION_VAR_P (decl
))))
2644 /* DECL shadows a local thing possibly of interest. */
2646 /* Don't complain if it's from an enclosing function. */
2647 if (DECL_CONTEXT (old
) == current_function_decl
2648 && TREE_CODE (decl
) != PARM_DECL
2649 && TREE_CODE (old
) == PARM_DECL
)
2651 /* Go to where the parms should be and see if we find
2653 cp_binding_level
*b
= current_binding_level
->level_chain
;
2655 if (FUNCTION_NEEDS_BODY_BLOCK (current_function_decl
))
2656 /* Skip the ctor/dtor cleanup level. */
2660 if (b
->kind
== sk_function_parms
)
2662 error ("declaration of %q#D shadows a parameter", decl
);
2667 /* The local structure or class can't use parameters of
2668 the containing function anyway. */
2669 if (DECL_CONTEXT (old
) != current_function_decl
)
2671 for (cp_binding_level
*scope
= current_binding_level
;
2672 scope
!= old_scope
; scope
= scope
->level_chain
)
2673 if (scope
->kind
== sk_class
2674 && !LAMBDA_TYPE_P (scope
->this_entity
))
2677 /* Error if redeclaring a local declared in a
2678 init-statement or in the condition of an if or
2679 switch statement when the new declaration is in the
2680 outermost block of the controlled statement.
2681 Redeclaring a variable from a for or while condition is
2682 detected elsewhere. */
2683 else if (VAR_P (old
)
2684 && old_scope
== current_binding_level
->level_chain
2685 && (old_scope
->kind
== sk_cond
|| old_scope
->kind
== sk_for
))
2687 error ("redeclaration of %q#D", decl
);
2688 inform (DECL_SOURCE_LOCATION (old
),
2689 "%q#D previously declared here", old
);
2693 3.3.3/3: The name declared in an exception-declaration (...)
2694 shall not be redeclared in the outermost block of the handler.
2695 3.3.3/2: A parameter name shall not be redeclared (...) in
2696 the outermost block of any handler associated with a
2698 3.4.1/15: The function parameter names shall not be redeclared
2699 in the exception-declaration nor in the outermost block of a
2700 handler for the function-try-block. */
2701 else if ((TREE_CODE (old
) == VAR_DECL
2702 && old_scope
== current_binding_level
->level_chain
2703 && old_scope
->kind
== sk_catch
)
2704 || (TREE_CODE (old
) == PARM_DECL
2705 && (current_binding_level
->kind
== sk_catch
2706 || current_binding_level
->level_chain
->kind
== sk_catch
)
2707 && in_function_try_handler
))
2709 if (permerror (input_location
, "redeclaration of %q#D", decl
))
2710 inform (DECL_SOURCE_LOCATION (old
),
2711 "%q#D previously declared here", old
);
2715 /* If '-Wshadow=compatible-local' is specified without other
2716 -Wshadow= flags, we will warn only when the type of the
2717 shadowing variable (DECL) can be converted to that of the
2718 shadowed parameter (OLD_LOCAL). The reason why we only check
2719 if DECL's type can be converted to OLD_LOCAL's type (but not the
2720 other way around) is because when users accidentally shadow a
2721 parameter, more than often they would use the variable
2722 thinking (mistakenly) it's still the parameter. It would be
2723 rare that users would use the variable in the place that
2724 expects the parameter but thinking it's a new decl. */
2726 enum opt_code warning_code
;
2728 warning_code
= OPT_Wshadow
;
2729 else if (warn_shadow_local
)
2730 warning_code
= OPT_Wshadow_local
;
2731 else if (warn_shadow_compatible_local
2732 && (same_type_p (TREE_TYPE (old
), TREE_TYPE (decl
))
2733 || (!dependent_type_p (TREE_TYPE (decl
))
2734 && !dependent_type_p (TREE_TYPE (old
))
2735 && can_convert (TREE_TYPE (old
), TREE_TYPE (decl
),
2737 warning_code
= OPT_Wshadow_compatible_local
;
2742 if (TREE_CODE (old
) == PARM_DECL
)
2743 msg
= "declaration of %q#D shadows a parameter";
2744 else if (is_capture_proxy (old
))
2745 msg
= "declaration of %qD shadows a lambda capture";
2747 msg
= "declaration of %qD shadows a previous local";
2749 if (warning_at (input_location
, warning_code
, msg
, decl
))
2752 goto inform_shadowed
;
2760 /* Don't warn for artificial things that are not implicit typedefs. */
2761 if (DECL_ARTIFICIAL (decl
) && !DECL_IMPLICIT_TYPEDEF_P (decl
))
2764 if (nonlambda_method_basetype ())
2765 if (tree member
= lookup_member (current_nonlambda_class_type (),
2766 DECL_NAME (decl
), /*protect=*/0,
2767 /*want_type=*/false, tf_warning_or_error
))
2769 member
= MAYBE_BASELINK_FUNCTIONS (member
);
2771 /* Warn if a variable shadows a non-function, or the variable
2772 is a function or a pointer-to-function. */
2774 || TREE_CODE (decl
) == FUNCTION_DECL
2775 || TYPE_PTRFN_P (TREE_TYPE (decl
))
2776 || TYPE_PTRMEMFUNC_P (TREE_TYPE (decl
)))
2778 if (warning_at (input_location
, OPT_Wshadow
,
2779 "declaration of %qD shadows a member of %qT",
2780 decl
, current_nonlambda_class_type ())
2784 goto inform_shadowed
;
2790 /* Now look for a namespace shadow. */
2791 old
= find_namespace_value (current_namespace
, DECL_NAME (decl
));
2794 || (TREE_CODE (old
) == TYPE_DECL
2795 && (!DECL_ARTIFICIAL (old
)
2796 || TREE_CODE (decl
) == TYPE_DECL
)))
2797 && !instantiating_current_function_p ())
2798 /* XXX shadow warnings in outer-more namespaces */
2800 if (warning_at (input_location
, OPT_Wshadow
,
2801 "declaration of %qD shadows a global declaration",
2805 goto inform_shadowed
;
2813 inform (DECL_SOURCE_LOCATION (shadowed
), "shadowed declaration is here");
2816 /* DECL is being pushed inside function CTX. Set its context, if
2820 set_decl_context_in_fn (tree ctx
, tree decl
)
2822 if (!DECL_CONTEXT (decl
)
2823 /* A local declaration for a function doesn't constitute
2825 && TREE_CODE (decl
) != FUNCTION_DECL
2826 /* A local declaration for an `extern' variable is in the
2827 scope of the current namespace, not the current
2829 && !(VAR_P (decl
) && DECL_EXTERNAL (decl
))
2830 /* When parsing the parameter list of a function declarator,
2831 don't set DECL_CONTEXT to an enclosing function. When we
2832 push the PARM_DECLs in order to process the function body,
2833 current_binding_level->this_entity will be set. */
2834 && !(TREE_CODE (decl
) == PARM_DECL
2835 && current_binding_level
->kind
== sk_function_parms
2836 && current_binding_level
->this_entity
== NULL
))
2837 DECL_CONTEXT (decl
) = ctx
;
2839 /* If this is the declaration for a namespace-scope function,
2840 but the declaration itself is in a local scope, mark the
2842 if (TREE_CODE (decl
) == FUNCTION_DECL
&& DECL_NAMESPACE_SCOPE_P (decl
))
2843 DECL_LOCAL_FUNCTION_P (decl
) = 1;
2846 /* DECL is a local-scope decl with linkage. SHADOWED is true if the
2847 name is already bound at the current level.
2849 [basic.link] If there is a visible declaration of an entity with
2850 linkage having the same name and type, ignoring entities declared
2851 outside the innermost enclosing namespace scope, the block scope
2852 declaration declares that same entity and receives the linkage of
2853 the previous declaration.
2855 Also, make sure that this decl matches any existing external decl
2856 in the enclosing namespace. */
2859 set_local_extern_decl_linkage (tree decl
, bool shadowed
)
2861 tree ns_value
= decl
; /* Unique marker. */
2865 tree loc_value
= innermost_non_namespace_value (DECL_NAME (decl
));
2869 = find_namespace_value (current_namespace
, DECL_NAME (decl
));
2870 loc_value
= ns_value
;
2872 if (loc_value
== error_mark_node
2873 /* An ambiguous lookup. */
2874 || (loc_value
&& TREE_CODE (loc_value
) == TREE_LIST
))
2875 loc_value
= NULL_TREE
;
2877 for (ovl_iterator
iter (loc_value
); iter
; ++iter
)
2878 if (!iter
.hidden_p ()
2879 && (TREE_STATIC (*iter
) || DECL_EXTERNAL (*iter
))
2880 && decls_match (*iter
, decl
))
2882 /* The standard only says that the local extern inherits
2883 linkage from the previous decl; in particular, default
2884 args are not shared. Add the decl into a hash table to
2885 make sure only the previous decl in this case is seen
2886 by the middle end. */
2887 struct cxx_int_tree_map
*h
;
2889 /* We inherit the outer decl's linkage. But we're a
2891 TREE_PUBLIC (decl
) = TREE_PUBLIC (*iter
);
2893 if (cp_function_chain
->extern_decl_map
== NULL
)
2894 cp_function_chain
->extern_decl_map
2895 = hash_table
<cxx_int_tree_map_hasher
>::create_ggc (20);
2897 h
= ggc_alloc
<cxx_int_tree_map
> ();
2898 h
->uid
= DECL_UID (decl
);
2900 cxx_int_tree_map
**loc
= cp_function_chain
->extern_decl_map
2901 ->find_slot (h
, INSERT
);
2907 if (TREE_PUBLIC (decl
))
2909 /* DECL is externally visible. Make sure it matches a matching
2910 decl in the namespace scope. We only really need to check
2911 this when inserting the decl, not when we find an existing
2912 match in the current scope. However, in practice we're
2913 going to be inserting a new decl in the majority of cases --
2914 who writes multiple extern decls for the same thing in the
2915 same local scope? Doing it here often avoids a duplicate
2916 namespace lookup. */
2918 /* Avoid repeating a lookup. */
2919 if (ns_value
== decl
)
2920 ns_value
= find_namespace_value (current_namespace
, DECL_NAME (decl
));
2922 if (ns_value
== error_mark_node
2923 || (ns_value
&& TREE_CODE (ns_value
) == TREE_LIST
))
2924 ns_value
= NULL_TREE
;
2926 for (ovl_iterator
iter (ns_value
); iter
; ++iter
)
2930 if (!(TREE_PUBLIC (other
) || DECL_EXTERNAL (other
)))
2931 ; /* Not externally visible. */
2932 else if (DECL_EXTERN_C_P (decl
) && DECL_EXTERN_C_P (other
))
2933 ; /* Both are extern "C", we'll check via that mechanism. */
2934 else if (TREE_CODE (other
) != TREE_CODE (decl
)
2935 || ((VAR_P (decl
) || matching_fn_p (other
, decl
))
2936 && !comptypes (TREE_TYPE (decl
), TREE_TYPE (other
),
2937 COMPARE_REDECLARATION
)))
2939 if (permerror (DECL_SOURCE_LOCATION (decl
),
2940 "local external declaration %q#D", decl
))
2941 inform (DECL_SOURCE_LOCATION (other
),
2942 "does not match previous declaration %q#D", other
);
2949 /* Record DECL as belonging to the current lexical scope. Check for
2950 errors (such as an incompatible declaration for the same name
2951 already seen in the same scope). IS_FRIEND is true if DECL is
2952 declared as a friend.
2954 Returns either DECL or an old decl for the same name. If an old
2955 decl is returned, it may have been smashed to agree with what DECL
2959 do_pushdecl (tree decl
, bool is_friend
)
2961 if (decl
== error_mark_node
)
2962 return error_mark_node
;
2964 if (!DECL_TEMPLATE_PARM_P (decl
) && current_function_decl
)
2965 set_decl_context_in_fn (current_function_decl
, decl
);
2967 /* The binding level we will be pushing into. During local class
2968 pushing, we want to push to the containing scope. */
2969 cp_binding_level
*level
= current_binding_level
;
2970 while (level
->kind
== sk_class
)
2971 level
= level
->level_chain
;
2973 /* An anonymous namespace has a NULL DECL_NAME, but we still want to
2974 insert it. Other NULL-named decls, not so much. */
2975 tree name
= DECL_NAME (decl
);
2976 if (name
|| TREE_CODE (decl
) == NAMESPACE_DECL
)
2978 cxx_binding
*binding
= NULL
; /* Local scope binding. */
2979 tree ns
= NULL_TREE
; /* Searched namespace. */
2980 tree
*slot
= NULL
; /* Binding slot in namespace. */
2981 tree old
= NULL_TREE
;
2983 if (level
->kind
== sk_namespace
)
2985 /* We look in the decl's namespace for an existing
2986 declaration, even though we push into the current
2988 ns
= (DECL_NAMESPACE_SCOPE_P (decl
)
2989 ? CP_DECL_CONTEXT (decl
) : current_namespace
);
2990 /* Create the binding, if this is current namespace, because
2991 that's where we'll be pushing anyway. */
2992 slot
= find_namespace_slot (ns
, name
, ns
== current_namespace
);
2994 old
= MAYBE_STAT_DECL (*slot
);
2998 binding
= find_local_binding (level
, name
);
3000 old
= binding
->value
;
3003 if (current_function_decl
&& VAR_OR_FUNCTION_DECL_P (decl
)
3004 && DECL_EXTERNAL (decl
))
3005 set_local_extern_decl_linkage (decl
, old
!= NULL_TREE
);
3007 if (old
== error_mark_node
)
3010 for (ovl_iterator
iter (old
); iter
; ++iter
)
3011 if (iter
.using_p ())
3012 ; /* Ignore using decls here. */
3013 else if (tree match
= duplicate_decls (decl
, *iter
, is_friend
))
3015 if (match
== error_mark_node
)
3017 else if (TREE_CODE (match
) == TYPE_DECL
)
3018 /* The IDENTIFIER will have the type referring to the
3019 now-smashed TYPE_DECL, because ...? Reset it. */
3020 SET_IDENTIFIER_TYPE_VALUE (name
, TREE_TYPE (match
));
3021 else if (iter
.hidden_p () && !DECL_HIDDEN_P (match
))
3023 /* Unhiding a previously hidden decl. */
3024 tree head
= iter
.reveal_node (old
);
3029 update_local_overload (binding
, head
);
3030 binding
->value
= head
;
3032 else if (STAT_HACK_P (*slot
))
3033 STAT_DECL (*slot
) = head
;
3037 if (DECL_EXTERN_C_P (match
))
3038 /* We need to check and register the decl now. */
3039 check_extern_c_conflict (match
);
3044 /* We are pushing a new decl. */
3046 /* Skip a hidden builtin we failed to match already. There can
3048 if (old
&& anticipated_builtin_p (old
))
3049 old
= OVL_CHAIN (old
);
3051 check_template_shadow (decl
);
3052 bool visible_injection
= false;
3054 if (DECL_DECLARES_FUNCTION_P (decl
))
3056 check_default_args (decl
);
3060 if (level
->kind
!= sk_namespace
)
3062 /* In a local class, a friend function declaration must
3063 find a matching decl in the innermost non-class scope.
3064 [class.friend/11] */
3065 error ("friend declaration %qD in local class without "
3066 "prior local declaration", decl
);
3067 /* Don't attempt to push it. */
3068 return error_mark_node
;
3070 if (!flag_friend_injection
)
3071 /* Hide it from ordinary lookup. */
3072 DECL_ANTICIPATED (decl
) = DECL_HIDDEN_FRIEND_P (decl
) = true;
3074 visible_injection
= true;
3078 if (level
->kind
!= sk_namespace
)
3080 check_local_shadow (decl
);
3082 if (TREE_CODE (decl
) == NAMESPACE_DECL
)
3083 /* A local namespace alias. */
3084 set_identifier_type_value (name
, NULL_TREE
);
3087 binding
= create_local_binding (level
, name
);
3091 ns
= current_namespace
;
3092 slot
= find_namespace_slot (ns
, name
, true);
3093 /* Update OLD to reflect the namespace we're going to be
3095 old
= MAYBE_STAT_DECL (*slot
);
3098 old
= update_binding (level
, binding
, slot
, old
, decl
, is_friend
);
3101 /* An existing decl matched, use it. */
3103 else if (TREE_CODE (decl
) == TYPE_DECL
)
3105 tree type
= TREE_TYPE (decl
);
3107 if (type
!= error_mark_node
)
3109 if (TYPE_NAME (type
) != decl
)
3110 set_underlying_type (decl
);
3113 set_identifier_type_value_with_scope (name
, decl
, level
);
3115 SET_IDENTIFIER_TYPE_VALUE (name
, global_type_node
);
3118 /* If this is a locally defined typedef in a function that
3119 is not a template instantation, record it to implement
3120 -Wunused-local-typedefs. */
3121 if (!instantiating_current_function_p ())
3122 record_locally_defined_typedef (decl
);
3124 else if (VAR_P (decl
))
3125 maybe_register_incomplete_var (decl
);
3126 else if (visible_injection
)
3127 warning (0, "injected friend %qD is visible"
3128 " due to %<-ffriend-injection%>", decl
);
3130 if ((VAR_P (decl
) || TREE_CODE (decl
) == FUNCTION_DECL
)
3131 && DECL_EXTERN_C_P (decl
))
3132 check_extern_c_conflict (decl
);
3135 add_decl_to_level (level
, decl
);
3140 /* Record a decl-node X as belonging to the current lexical scope.
3141 It's a friend if IS_FRIEND is true -- which affects exactly where
3145 pushdecl (tree x
, bool is_friend
)
3147 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
3148 tree ret
= do_pushdecl (x
, is_friend
);
3149 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
3153 /* Enter DECL into the symbol table, if that's appropriate. Returns
3154 DECL, or a modified version thereof. */
3157 maybe_push_decl (tree decl
)
3159 tree type
= TREE_TYPE (decl
);
3161 /* Add this decl to the current binding level, but not if it comes
3162 from another scope, e.g. a static member variable. TEM may equal
3163 DECL or it may be a previous decl of the same name. */
3164 if (decl
== error_mark_node
3165 || (TREE_CODE (decl
) != PARM_DECL
3166 && DECL_CONTEXT (decl
) != NULL_TREE
3167 /* Definitions of namespace members outside their namespace are
3169 && !DECL_NAMESPACE_SCOPE_P (decl
))
3170 || (TREE_CODE (decl
) == TEMPLATE_DECL
&& !namespace_bindings_p ())
3171 || type
== unknown_type_node
3172 /* The declaration of a template specialization does not affect
3173 the functions available for overload resolution, so we do not
3175 || (TREE_CODE (decl
) == FUNCTION_DECL
3176 && DECL_TEMPLATE_SPECIALIZATION (decl
)))
3179 return pushdecl (decl
);
3182 /* Bind DECL to ID in the current_binding_level, assumed to be a local
3183 binding level. If IS_USING is true, DECL got here through a
3184 using-declaration. */
3187 push_local_binding (tree id
, tree decl
, bool is_using
)
3189 /* Skip over any local classes. This makes sense if we call
3190 push_local_binding with a friend decl of a local class. */
3191 cp_binding_level
*b
= innermost_nonclass_level ();
3193 gcc_assert (b
->kind
!= sk_namespace
);
3194 if (find_local_binding (b
, id
))
3196 /* Supplement the existing binding. */
3197 if (!supplement_binding (IDENTIFIER_BINDING (id
), decl
))
3198 /* It didn't work. Something else must be bound at this
3199 level. Do not add DECL to the list of things to pop
3204 /* Create a new binding. */
3205 push_binding (id
, decl
, b
);
3207 if (TREE_CODE (decl
) == OVERLOAD
|| is_using
)
3208 /* We must put the OVERLOAD or using into a TREE_LIST since we
3209 cannot use the decl's chain itself. */
3210 decl
= build_tree_list (NULL_TREE
, decl
);
3212 /* And put DECL on the list of things declared by the current
3214 add_decl_to_level (b
, decl
);
3217 /* Check to see whether or not DECL is a variable that would have been
3218 in scope under the ARM, but is not in scope under the ANSI/ISO
3219 standard. If so, issue an error message. If name lookup would
3220 work in both cases, but return a different result, this function
3221 returns the result of ANSI/ISO lookup. Otherwise, it returns
3224 FIXME: Scheduled for removal after GCC-8 is done. */
3227 check_for_out_of_scope_variable (tree decl
)
3231 /* We only care about out of scope variables. */
3232 if (!(VAR_P (decl
) && DECL_DEAD_FOR_LOCAL (decl
)))
3235 shadowed
= DECL_HAS_SHADOWED_FOR_VAR_P (decl
)
3236 ? DECL_SHADOWED_FOR_VAR (decl
) : NULL_TREE
;
3237 while (shadowed
!= NULL_TREE
&& VAR_P (shadowed
)
3238 && DECL_DEAD_FOR_LOCAL (shadowed
))
3239 shadowed
= DECL_HAS_SHADOWED_FOR_VAR_P (shadowed
)
3240 ? DECL_SHADOWED_FOR_VAR (shadowed
) : NULL_TREE
;
3242 shadowed
= find_namespace_value (current_namespace
, DECL_NAME (decl
));
3245 if (!DECL_ERROR_REPORTED (decl
)
3247 && warning (0, "name lookup of %qD changed", DECL_NAME (decl
)))
3249 inform (DECL_SOURCE_LOCATION (shadowed
),
3250 "matches this %qD under ISO standard rules", shadowed
);
3251 inform (DECL_SOURCE_LOCATION (decl
),
3252 " matches this %qD under old rules", decl
);
3254 DECL_ERROR_REPORTED (decl
) = 1;
3258 /* If we have already complained about this declaration, there's no
3259 need to do it again. */
3260 if (DECL_ERROR_REPORTED (decl
))
3263 DECL_ERROR_REPORTED (decl
) = 1;
3265 if (TREE_TYPE (decl
) == error_mark_node
)
3268 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TREE_TYPE (decl
)))
3270 error ("name lookup of %qD changed for ISO %<for%> scoping",
3272 inform (DECL_SOURCE_LOCATION (decl
),
3273 "cannot use obsolete binding %qD because it has a destructor",
3275 return error_mark_node
;
3279 permerror (input_location
,
3280 "name lookup of %qD changed for ISO %<for%> scoping",
3282 if (flag_permissive
)
3283 inform (DECL_SOURCE_LOCATION (decl
),
3284 "using obsolete binding %qD", decl
);
3287 inform (input_location
, flag_permissive
3288 ? "this flexibility is deprecated and will be removed"
3289 : "if you use %<-fpermissive%> G++ will accept your code");
3296 /* true means unconditionally make a BLOCK for the next level pushed. */
3298 static bool keep_next_level_flag
;
3300 static int binding_depth
= 0;
3307 for (i
= 0; i
< depth
* 2; i
++)
3311 /* Return a string describing the kind of SCOPE we have. */
3313 cp_binding_level_descriptor (cp_binding_level
*scope
)
3315 /* The order of this table must match the "scope_kind"
3317 static const char* scope_kind_names
[] = {
3323 "function-parameter-scope",
3326 "template-parameter-scope",
3327 "template-explicit-spec-scope"
3329 const scope_kind kind
= scope
->explicit_spec_p
3330 ? sk_template_spec
: scope
->kind
;
3332 return scope_kind_names
[kind
];
3335 /* Output a debugging information about SCOPE when performing
3338 cp_binding_level_debug (cp_binding_level
*scope
, int line
, const char *action
)
3340 const char *desc
= cp_binding_level_descriptor (scope
);
3341 if (scope
->this_entity
)
3342 verbatim ("%s %<%s(%E)%> %p %d\n", action
, desc
,
3343 scope
->this_entity
, (void *) scope
, line
);
3345 verbatim ("%s %s %p %d\n", action
, desc
, (void *) scope
, line
);
3348 /* Return the estimated initial size of the hashtable of a NAMESPACE
3351 static inline size_t
3352 namespace_scope_ht_size (tree ns
)
3354 tree name
= DECL_NAME (ns
);
3356 return name
== std_identifier
3357 ? NAMESPACE_STD_HT_SIZE
3358 : (name
== global_identifier
3359 ? GLOBAL_SCOPE_HT_SIZE
3360 : NAMESPACE_ORDINARY_HT_SIZE
);
3363 /* A chain of binding_level structures awaiting reuse. */
3365 static GTY((deletable
)) cp_binding_level
*free_binding_level
;
3367 /* Insert SCOPE as the innermost binding level. */
3370 push_binding_level (cp_binding_level
*scope
)
3372 /* Add it to the front of currently active scopes stack. */
3373 scope
->level_chain
= current_binding_level
;
3374 current_binding_level
= scope
;
3375 keep_next_level_flag
= false;
3377 if (ENABLE_SCOPE_CHECKING
)
3379 scope
->binding_depth
= binding_depth
;
3380 indent (binding_depth
);
3381 cp_binding_level_debug (scope
, LOCATION_LINE (input_location
),
3387 /* Create a new KIND scope and make it the top of the active scopes stack.
3388 ENTITY is the scope of the associated C++ entity (namespace, class,
3389 function, C++0x enumeration); it is NULL otherwise. */
3392 begin_scope (scope_kind kind
, tree entity
)
3394 cp_binding_level
*scope
;
3396 /* Reuse or create a struct for this binding level. */
3397 if (!ENABLE_SCOPE_CHECKING
&& free_binding_level
)
3399 scope
= free_binding_level
;
3400 free_binding_level
= scope
->level_chain
;
3401 memset (scope
, 0, sizeof (cp_binding_level
));
3404 scope
= ggc_cleared_alloc
<cp_binding_level
> ();
3406 scope
->this_entity
= entity
;
3407 scope
->more_cleanups_ok
= true;
3414 case sk_template_spec
:
3415 scope
->explicit_spec_p
= true;
3416 kind
= sk_template_parms
;
3418 case sk_template_parms
:
3425 case sk_scoped_enum
:
3426 case sk_function_parms
:
3427 case sk_transaction
:
3429 scope
->keep
= keep_next_level_flag
;
3433 NAMESPACE_LEVEL (entity
) = scope
;
3437 /* Should not happen. */
3443 push_binding_level (scope
);
3448 /* We're about to leave current scope. Pop the top of the stack of
3449 currently active scopes. Return the enclosing scope, now active. */
3454 cp_binding_level
*scope
= current_binding_level
;
3456 if (scope
->kind
== sk_namespace
&& class_binding_level
)
3457 current_binding_level
= class_binding_level
;
3459 /* We cannot leave a scope, if there are none left. */
3460 if (NAMESPACE_LEVEL (global_namespace
))
3461 gcc_assert (!global_scope_p (scope
));
3463 if (ENABLE_SCOPE_CHECKING
)
3465 indent (--binding_depth
);
3466 cp_binding_level_debug (scope
, LOCATION_LINE (input_location
),
3470 /* Move one nesting level up. */
3471 current_binding_level
= scope
->level_chain
;
3473 /* Namespace-scopes are left most probably temporarily, not
3474 completely; they can be reopened later, e.g. in namespace-extension
3475 or any name binding activity that requires us to resume a
3476 namespace. For classes, we cache some binding levels. For other
3477 scopes, we just make the structure available for reuse. */
3478 if (scope
->kind
!= sk_namespace
3479 && scope
->kind
!= sk_class
)
3481 scope
->level_chain
= free_binding_level
;
3482 gcc_assert (!ENABLE_SCOPE_CHECKING
3483 || scope
->binding_depth
== binding_depth
);
3484 free_binding_level
= scope
;
3487 if (scope
->kind
== sk_class
)
3489 /* Reset DEFINING_CLASS_P to allow for reuse of a
3490 class-defining scope in a non-defining context. */
3491 scope
->defining_class_p
= 0;
3493 /* Find the innermost enclosing class scope, and reset
3494 CLASS_BINDING_LEVEL appropriately. */
3495 class_binding_level
= NULL
;
3496 for (scope
= current_binding_level
; scope
; scope
= scope
->level_chain
)
3497 if (scope
->kind
== sk_class
)
3499 class_binding_level
= scope
;
3504 return current_binding_level
;
3508 resume_scope (cp_binding_level
* b
)
3510 /* Resuming binding levels is meant only for namespaces,
3511 and those cannot nest into classes. */
3512 gcc_assert (!class_binding_level
);
3513 /* Also, resuming a non-directly nested namespace is a no-no. */
3514 gcc_assert (b
->level_chain
== current_binding_level
);
3515 current_binding_level
= b
;
3516 if (ENABLE_SCOPE_CHECKING
)
3518 b
->binding_depth
= binding_depth
;
3519 indent (binding_depth
);
3520 cp_binding_level_debug (b
, LOCATION_LINE (input_location
), "resume");
3525 /* Return the innermost binding level that is not for a class scope. */
3527 static cp_binding_level
*
3528 innermost_nonclass_level (void)
3530 cp_binding_level
*b
;
3532 b
= current_binding_level
;
3533 while (b
->kind
== sk_class
)
3539 /* We're defining an object of type TYPE. If it needs a cleanup, but
3540 we're not allowed to add any more objects with cleanups to the current
3541 scope, create a new binding level. */
3544 maybe_push_cleanup_level (tree type
)
3546 if (type
!= error_mark_node
3547 && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
)
3548 && current_binding_level
->more_cleanups_ok
== 0)
3550 begin_scope (sk_cleanup
, NULL
);
3551 current_binding_level
->statement_list
= push_stmt_list ();
3555 /* Return true if we are in the global binding level. */
3558 global_bindings_p (void)
3560 return global_scope_p (current_binding_level
);
3563 /* True if we are currently in a toplevel binding level. This
3564 means either the global binding level or a namespace in a toplevel
3565 binding level. Since there are no non-toplevel namespace levels,
3566 this really means any namespace or template parameter level. We
3567 also include a class whose context is toplevel. */
3570 toplevel_bindings_p (void)
3572 cp_binding_level
*b
= innermost_nonclass_level ();
3574 return b
->kind
== sk_namespace
|| b
->kind
== sk_template_parms
;
3577 /* True if this is a namespace scope, or if we are defining a class
3578 which is itself at namespace scope, or whose enclosing class is
3579 such a class, etc. */
3582 namespace_bindings_p (void)
3584 cp_binding_level
*b
= innermost_nonclass_level ();
3586 return b
->kind
== sk_namespace
;
3589 /* True if the innermost non-class scope is a block scope. */
3592 local_bindings_p (void)
3594 cp_binding_level
*b
= innermost_nonclass_level ();
3595 return b
->kind
< sk_function_parms
|| b
->kind
== sk_omp
;
3598 /* True if the current level needs to have a BLOCK made. */
3603 return (current_binding_level
->blocks
!= NULL_TREE
3604 || current_binding_level
->keep
3605 || current_binding_level
->kind
== sk_cleanup
3606 || current_binding_level
->names
!= NULL_TREE
3607 || current_binding_level
->using_directives
);
3610 /* Returns the kind of the innermost scope. */
3613 innermost_scope_kind (void)
3615 return current_binding_level
->kind
;
3618 /* Returns true if this scope was created to store template parameters. */
3621 template_parm_scope_p (void)
3623 return innermost_scope_kind () == sk_template_parms
;
3626 /* If KEEP is true, make a BLOCK node for the next binding level,
3627 unconditionally. Otherwise, use the normal logic to decide whether
3628 or not to create a BLOCK. */
3631 keep_next_level (bool keep
)
3633 keep_next_level_flag
= keep
;
3636 /* Return the list of declarations of the current local scope. */
3639 get_local_decls (void)
3641 gcc_assert (current_binding_level
->kind
!= sk_namespace
3642 && current_binding_level
->kind
!= sk_class
);
3643 return current_binding_level
->names
;
3646 /* Return how many function prototypes we are currently nested inside. */
3649 function_parm_depth (void)
3652 cp_binding_level
*b
;
3654 for (b
= current_binding_level
;
3655 b
->kind
== sk_function_parms
;
3662 /* For debugging. */
3663 static int no_print_functions
= 0;
3664 static int no_print_builtins
= 0;
3667 print_binding_level (cp_binding_level
* lvl
)
3671 fprintf (stderr
, " blocks=%p", (void *) lvl
->blocks
);
3672 if (lvl
->more_cleanups_ok
)
3673 fprintf (stderr
, " more-cleanups-ok");
3674 if (lvl
->have_cleanups
)
3675 fprintf (stderr
, " have-cleanups");
3676 fprintf (stderr
, "\n");
3679 fprintf (stderr
, " names:\t");
3680 /* We can probably fit 3 names to a line? */
3681 for (t
= lvl
->names
; t
; t
= TREE_CHAIN (t
))
3683 if (no_print_functions
&& (TREE_CODE (t
) == FUNCTION_DECL
))
3685 if (no_print_builtins
3686 && (TREE_CODE (t
) == TYPE_DECL
)
3687 && DECL_IS_BUILTIN (t
))
3690 /* Function decls tend to have longer names. */
3691 if (TREE_CODE (t
) == FUNCTION_DECL
)
3698 fprintf (stderr
, "\n\t");
3701 print_node_brief (stderr
, "", t
, 0);
3702 if (t
== error_mark_node
)
3706 fprintf (stderr
, "\n");
3708 if (vec_safe_length (lvl
->class_shadowed
))
3711 cp_class_binding
*b
;
3712 fprintf (stderr
, " class-shadowed:");
3713 FOR_EACH_VEC_ELT (*lvl
->class_shadowed
, i
, b
)
3714 fprintf (stderr
, " %s ", IDENTIFIER_POINTER (b
->identifier
));
3715 fprintf (stderr
, "\n");
3717 if (lvl
->type_shadowed
)
3719 fprintf (stderr
, " type-shadowed:");
3720 for (t
= lvl
->type_shadowed
; t
; t
= TREE_CHAIN (t
))
3722 fprintf (stderr
, " %s ", IDENTIFIER_POINTER (TREE_PURPOSE (t
)));
3724 fprintf (stderr
, "\n");
3729 debug (cp_binding_level
&ref
)
3731 print_binding_level (&ref
);
3735 debug (cp_binding_level
*ptr
)
3740 fprintf (stderr
, "<nil>\n");
3745 print_other_binding_stack (cp_binding_level
*stack
)
3747 cp_binding_level
*level
;
3748 for (level
= stack
; !global_scope_p (level
); level
= level
->level_chain
)
3750 fprintf (stderr
, "binding level %p\n", (void *) level
);
3751 print_binding_level (level
);
3756 print_binding_stack (void)
3758 cp_binding_level
*b
;
3759 fprintf (stderr
, "current_binding_level=%p\n"
3760 "class_binding_level=%p\n"
3761 "NAMESPACE_LEVEL (global_namespace)=%p\n",
3762 (void *) current_binding_level
, (void *) class_binding_level
,
3763 (void *) NAMESPACE_LEVEL (global_namespace
));
3764 if (class_binding_level
)
3766 for (b
= class_binding_level
; b
; b
= b
->level_chain
)
3767 if (b
== current_binding_level
)
3770 b
= class_binding_level
;
3772 b
= current_binding_level
;
3775 b
= current_binding_level
;
3776 print_other_binding_stack (b
);
3777 fprintf (stderr
, "global:\n");
3778 print_binding_level (NAMESPACE_LEVEL (global_namespace
));
3781 /* Return the type associated with ID. */
3784 identifier_type_value_1 (tree id
)
3786 /* There is no type with that name, anywhere. */
3787 if (REAL_IDENTIFIER_TYPE_VALUE (id
) == NULL_TREE
)
3789 /* This is not the type marker, but the real thing. */
3790 if (REAL_IDENTIFIER_TYPE_VALUE (id
) != global_type_node
)
3791 return REAL_IDENTIFIER_TYPE_VALUE (id
);
3792 /* Have to search for it. It must be on the global level, now.
3793 Ask lookup_name not to return non-types. */
3794 id
= lookup_name_real (id
, 2, 1, /*block_p=*/true, 0, 0);
3796 return TREE_TYPE (id
);
3800 /* Wrapper for identifier_type_value_1. */
3803 identifier_type_value (tree id
)
3806 timevar_start (TV_NAME_LOOKUP
);
3807 ret
= identifier_type_value_1 (id
);
3808 timevar_stop (TV_NAME_LOOKUP
);
3812 /* Push a definition of struct, union or enum tag named ID. into
3813 binding_level B. DECL is a TYPE_DECL for the type. We assume that
3814 the tag ID is not already defined. */
3817 set_identifier_type_value_with_scope (tree id
, tree decl
, cp_binding_level
*b
)
3821 if (b
->kind
!= sk_namespace
)
3823 /* Shadow the marker, not the real thing, so that the marker
3824 gets restored later. */
3825 tree old_type_value
= REAL_IDENTIFIER_TYPE_VALUE (id
);
3827 = tree_cons (id
, old_type_value
, b
->type_shadowed
);
3828 type
= decl
? TREE_TYPE (decl
) : NULL_TREE
;
3829 TREE_TYPE (b
->type_shadowed
) = type
;
3833 tree
*slot
= find_namespace_slot (current_namespace
, id
, true);
3835 update_binding (b
, NULL
, slot
, MAYBE_STAT_DECL (*slot
), decl
, false);
3837 /* Store marker instead of real type. */
3838 type
= global_type_node
;
3840 SET_IDENTIFIER_TYPE_VALUE (id
, type
);
3843 /* As set_identifier_type_value_with_scope, but using
3844 current_binding_level. */
3847 set_identifier_type_value (tree id
, tree decl
)
3849 set_identifier_type_value_with_scope (id
, decl
, current_binding_level
);
3852 /* Return the name for the constructor (or destructor) for the
3856 constructor_name (tree type
)
3858 tree decl
= TYPE_NAME (TYPE_MAIN_VARIANT (type
));
3860 return decl
? DECL_NAME (decl
) : NULL_TREE
;
3863 /* Returns TRUE if NAME is the name for the constructor for TYPE,
3864 which must be a class type. */
3867 constructor_name_p (tree name
, tree type
)
3869 gcc_assert (MAYBE_CLASS_TYPE_P (type
));
3871 /* These don't have names. */
3872 if (TREE_CODE (type
) == DECLTYPE_TYPE
3873 || TREE_CODE (type
) == TYPEOF_TYPE
)
3876 if (name
&& name
== constructor_name (type
))
3882 /* Counter used to create anonymous type names. */
3884 static GTY(()) int anon_cnt
;
3886 /* Return an IDENTIFIER which can be used as a name for
3887 unnamed structs and unions. */
3890 make_anon_name (void)
3894 sprintf (buf
, anon_aggrname_format (), anon_cnt
++);
3895 return get_identifier (buf
);
3898 /* This code is practically identical to that for creating
3899 anonymous names, but is just used for lambdas instead. This isn't really
3900 necessary, but it's convenient to avoid treating lambdas like other
3903 static GTY(()) int lambda_cnt
= 0;
3906 make_lambda_name (void)
3910 sprintf (buf
, LAMBDANAME_FORMAT
, lambda_cnt
++);
3911 return get_identifier (buf
);
3914 /* Insert another USING_DECL into the current binding level, returning
3915 this declaration. If this is a redeclaration, do nothing, and
3916 return NULL_TREE if this not in namespace scope (in namespace
3917 scope, a using decl might extend any previous bindings). */
3920 push_using_decl_1 (tree scope
, tree name
)
3924 gcc_assert (TREE_CODE (scope
) == NAMESPACE_DECL
);
3925 gcc_assert (identifier_p (name
));
3926 for (decl
= current_binding_level
->usings
; decl
; decl
= DECL_CHAIN (decl
))
3927 if (USING_DECL_SCOPE (decl
) == scope
&& DECL_NAME (decl
) == name
)
3930 return namespace_bindings_p () ? decl
: NULL_TREE
;
3931 decl
= build_lang_decl (USING_DECL
, name
, NULL_TREE
);
3932 USING_DECL_SCOPE (decl
) = scope
;
3933 DECL_CHAIN (decl
) = current_binding_level
->usings
;
3934 current_binding_level
->usings
= decl
;
3938 /* Wrapper for push_using_decl_1. */
3941 push_using_decl (tree scope
, tree name
)
3944 timevar_start (TV_NAME_LOOKUP
);
3945 ret
= push_using_decl_1 (scope
, name
);
3946 timevar_stop (TV_NAME_LOOKUP
);
3950 /* Same as pushdecl, but define X in binding-level LEVEL. We rely on the
3951 caller to set DECL_CONTEXT properly.
3953 Note that this must only be used when X will be the new innermost
3954 binding for its name, as we tack it onto the front of IDENTIFIER_BINDING
3955 without checking to see if the current IDENTIFIER_BINDING comes from a
3956 closer binding level than LEVEL. */
3959 do_pushdecl_with_scope (tree x
, cp_binding_level
*level
, bool is_friend
)
3961 cp_binding_level
*b
;
3963 if (level
->kind
== sk_class
)
3965 b
= class_binding_level
;
3966 class_binding_level
= level
;
3967 pushdecl_class_level (x
);
3968 class_binding_level
= b
;
3972 tree function_decl
= current_function_decl
;
3973 if (level
->kind
== sk_namespace
)
3974 current_function_decl
= NULL_TREE
;
3975 b
= current_binding_level
;
3976 current_binding_level
= level
;
3977 x
= pushdecl (x
, is_friend
);
3978 current_binding_level
= b
;
3979 current_function_decl
= function_decl
;
3984 /* Inject X into the local scope just before the function parms. */
3987 pushdecl_outermost_localscope (tree x
)
3989 cp_binding_level
*b
= NULL
;
3990 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
3992 /* Find the scope just inside the function parms. */
3993 for (cp_binding_level
*n
= current_binding_level
;
3994 n
->kind
!= sk_function_parms
; n
= b
->level_chain
)
3997 tree ret
= b
? do_pushdecl_with_scope (x
, b
, false) : error_mark_node
;
3998 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
4003 /* Check a non-member using-declaration. Return the name and scope
4004 being used, and the USING_DECL, or NULL_TREE on failure. */
4007 validate_nonmember_using_decl (tree decl
, tree scope
, tree name
)
4009 /* [namespace.udecl]
4010 A using-declaration for a class member shall be a
4011 member-declaration. */
4014 error ("%qT is not a namespace or unscoped enum", scope
);
4017 else if (scope
== error_mark_node
)
4020 if (TREE_CODE (decl
) == TEMPLATE_ID_EXPR
)
4023 A using-declaration shall not name a template-id. */
4024 error ("a using-declaration cannot specify a template-id. "
4025 "Try %<using %D%>", name
);
4029 if (TREE_CODE (decl
) == NAMESPACE_DECL
)
4031 error ("namespace %qD not allowed in using-declaration", decl
);
4035 if (TREE_CODE (decl
) == SCOPE_REF
)
4037 /* It's a nested name with template parameter dependent scope.
4038 This can only be using-declaration for class member. */
4039 error ("%qT is not a namespace", TREE_OPERAND (decl
, 0));
4043 decl
= OVL_FIRST (decl
);
4045 /* Make a USING_DECL. */
4046 tree using_decl
= push_using_decl (scope
, name
);
4048 if (using_decl
== NULL_TREE
4049 && at_function_scope_p ()
4051 /* C++11 7.3.3/10. */
4052 error ("%qD is already declared in this scope", name
);
4057 /* Process a local-scope or namespace-scope using declaration. SCOPE
4058 is the nominated scope to search for NAME. VALUE_P and TYPE_P
4059 point to the binding for NAME in the current scope and are
4063 do_nonmember_using_decl (tree scope
, tree name
, tree
*value_p
, tree
*type_p
)
4065 name_lookup
lookup (name
, 0);
4067 if (!qualified_namespace_lookup (scope
, &lookup
))
4069 error ("%qD not declared", name
);
4072 else if (TREE_CODE (lookup
.value
) == TREE_LIST
)
4074 error ("reference to %qD is ambiguous", name
);
4075 print_candidates (lookup
.value
);
4076 lookup
.value
= NULL_TREE
;
4079 if (lookup
.type
&& TREE_CODE (lookup
.type
) == TREE_LIST
)
4081 error ("reference to %qD is ambiguous", name
);
4082 print_candidates (lookup
.type
);
4083 lookup
.type
= NULL_TREE
;
4086 tree value
= *value_p
;
4087 tree type
= *type_p
;
4089 /* Shift the old and new bindings around so we're comparing class and
4090 enumeration names to each other. */
4091 if (value
&& DECL_IMPLICIT_TYPEDEF_P (value
))
4097 if (lookup
.value
&& DECL_IMPLICIT_TYPEDEF_P (lookup
.value
))
4099 lookup
.type
= lookup
.value
;
4100 lookup
.value
= NULL_TREE
;
4103 if (lookup
.value
&& lookup
.value
!= value
)
4105 /* Check for using functions. */
4106 if (OVL_P (lookup
.value
) && (!value
|| OVL_P (value
)))
4108 for (lkp_iterator
usings (lookup
.value
); usings
; ++usings
)
4110 tree new_fn
= *usings
;
4112 /* [namespace.udecl]
4114 If a function declaration in namespace scope or block
4115 scope has the same name and the same parameter types as a
4116 function introduced by a using declaration the program is
4119 for (ovl_iterator
old (value
); !found
&& old
; ++old
)
4123 if (new_fn
== old_fn
)
4124 /* The function already exists in the current
4127 else if (old
.using_p ())
4128 continue; /* This is a using decl. */
4129 else if (old
.hidden_p () && !DECL_HIDDEN_FRIEND_P (old_fn
))
4130 continue; /* This is an anticipated builtin. */
4131 else if (!matching_fn_p (new_fn
, old_fn
))
4132 continue; /* Parameters do not match. */
4133 else if (decls_match (new_fn
, old_fn
))
4137 diagnose_name_conflict (new_fn
, old_fn
);
4143 /* Unlike the overload case we don't drop anticipated
4144 builtins here. They don't cause a problem, and
4145 we'd like to match them with a future
4147 value
= ovl_insert (new_fn
, value
, true);
4151 /* Ignore anticipated builtins. */
4152 && !anticipated_builtin_p (value
)
4153 && !decls_match (lookup
.value
, value
))
4154 diagnose_name_conflict (lookup
.value
, value
);
4156 value
= lookup
.value
;
4159 if (lookup
.type
&& lookup
.type
!= type
)
4161 if (type
&& !decls_match (lookup
.type
, type
))
4162 diagnose_name_conflict (lookup
.type
, type
);
4167 /* If bind->value is empty, shift any class or enumeration name back. */
4178 /* Returns true if ANCESTOR encloses DESCENDANT, including matching.
4179 Both are namespaces. */
4182 is_nested_namespace (tree ancestor
, tree descendant
, bool inline_only
)
4184 int depth
= SCOPE_DEPTH (ancestor
);
4186 if (!depth
&& !inline_only
)
4187 /* The global namespace encloses everything. */
4190 while (SCOPE_DEPTH (descendant
) > depth
4191 && (!inline_only
|| DECL_NAMESPACE_INLINE_P (descendant
)))
4192 descendant
= CP_DECL_CONTEXT (descendant
);
4194 return ancestor
== descendant
;
4197 /* Returns true if ROOT (a namespace, class, or function) encloses
4198 CHILD. CHILD may be either a class type or a namespace. */
4201 is_ancestor (tree root
, tree child
)
4203 gcc_assert ((TREE_CODE (root
) == NAMESPACE_DECL
4204 || TREE_CODE (root
) == FUNCTION_DECL
4205 || CLASS_TYPE_P (root
)));
4206 gcc_assert ((TREE_CODE (child
) == NAMESPACE_DECL
4207 || CLASS_TYPE_P (child
)));
4209 /* The global namespace encloses everything. */
4210 if (root
== global_namespace
)
4213 /* Search until we reach namespace scope. */
4214 while (TREE_CODE (child
) != NAMESPACE_DECL
)
4216 /* If we've reached the ROOT, it encloses CHILD. */
4219 /* Go out one level. */
4221 child
= TYPE_NAME (child
);
4222 child
= CP_DECL_CONTEXT (child
);
4225 if (TREE_CODE (root
) == NAMESPACE_DECL
)
4226 return is_nested_namespace (root
, child
);
4231 /* Enter the class or namespace scope indicated by T suitable for name
4232 lookup. T can be arbitrary scope, not necessary nested inside the
4233 current scope. Returns a non-null scope to pop iff pop_scope
4234 should be called later to exit this scope. */
4239 if (TREE_CODE (t
) == NAMESPACE_DECL
)
4240 push_decl_namespace (t
);
4241 else if (CLASS_TYPE_P (t
))
4243 if (!at_class_scope_p ()
4244 || !same_type_p (current_class_type
, t
))
4245 push_nested_class (t
);
4247 /* T is the same as the current scope. There is therefore no
4248 need to re-enter the scope. Since we are not actually
4249 pushing a new scope, our caller should not call
4257 /* Leave scope pushed by push_scope. */
4264 if (TREE_CODE (t
) == NAMESPACE_DECL
)
4265 pop_decl_namespace ();
4266 else if CLASS_TYPE_P (t
)
4267 pop_nested_class ();
4270 /* Subroutine of push_inner_scope. */
4273 push_inner_scope_r (tree outer
, tree inner
)
4278 || (TREE_CODE (inner
) != NAMESPACE_DECL
&& !CLASS_TYPE_P (inner
)))
4281 prev
= CP_DECL_CONTEXT (TREE_CODE (inner
) == NAMESPACE_DECL
? inner
: TYPE_NAME (inner
));
4283 push_inner_scope_r (outer
, prev
);
4284 if (TREE_CODE (inner
) == NAMESPACE_DECL
)
4286 cp_binding_level
*save_template_parm
= 0;
4287 /* Temporary take out template parameter scopes. They are saved
4288 in reversed order in save_template_parm. */
4289 while (current_binding_level
->kind
== sk_template_parms
)
4291 cp_binding_level
*b
= current_binding_level
;
4292 current_binding_level
= b
->level_chain
;
4293 b
->level_chain
= save_template_parm
;
4294 save_template_parm
= b
;
4297 resume_scope (NAMESPACE_LEVEL (inner
));
4298 current_namespace
= inner
;
4300 /* Restore template parameter scopes. */
4301 while (save_template_parm
)
4303 cp_binding_level
*b
= save_template_parm
;
4304 save_template_parm
= b
->level_chain
;
4305 b
->level_chain
= current_binding_level
;
4306 current_binding_level
= b
;
4313 /* Enter the scope INNER from current scope. INNER must be a scope
4314 nested inside current scope. This works with both name lookup and
4315 pushing name into scope. In case a template parameter scope is present,
4316 namespace is pushed under the template parameter scope according to
4317 name lookup rule in 14.6.1/6.
4319 Return the former current scope suitable for pop_inner_scope. */
4322 push_inner_scope (tree inner
)
4324 tree outer
= current_scope ();
4326 outer
= current_namespace
;
4328 push_inner_scope_r (outer
, inner
);
4332 /* Exit the current scope INNER back to scope OUTER. */
4335 pop_inner_scope (tree outer
, tree inner
)
4338 || (TREE_CODE (inner
) != NAMESPACE_DECL
&& !CLASS_TYPE_P (inner
)))
4341 while (outer
!= inner
)
4343 if (TREE_CODE (inner
) == NAMESPACE_DECL
)
4345 cp_binding_level
*save_template_parm
= 0;
4346 /* Temporary take out template parameter scopes. They are saved
4347 in reversed order in save_template_parm. */
4348 while (current_binding_level
->kind
== sk_template_parms
)
4350 cp_binding_level
*b
= current_binding_level
;
4351 current_binding_level
= b
->level_chain
;
4352 b
->level_chain
= save_template_parm
;
4353 save_template_parm
= b
;
4358 /* Restore template parameter scopes. */
4359 while (save_template_parm
)
4361 cp_binding_level
*b
= save_template_parm
;
4362 save_template_parm
= b
->level_chain
;
4363 b
->level_chain
= current_binding_level
;
4364 current_binding_level
= b
;
4370 inner
= CP_DECL_CONTEXT (TREE_CODE (inner
) == NAMESPACE_DECL
? inner
: TYPE_NAME (inner
));
4374 /* Do a pushlevel for class declarations. */
4377 pushlevel_class (void)
4379 class_binding_level
= begin_scope (sk_class
, current_class_type
);
4382 /* ...and a poplevel for class declarations. */
4385 poplevel_class (void)
4387 cp_binding_level
*level
= class_binding_level
;
4388 cp_class_binding
*cb
;
4392 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
4393 gcc_assert (level
!= 0);
4395 /* If we're leaving a toplevel class, cache its binding level. */
4396 if (current_class_depth
== 1)
4397 previous_class_level
= level
;
4398 for (shadowed
= level
->type_shadowed
;
4400 shadowed
= TREE_CHAIN (shadowed
))
4401 SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (shadowed
), TREE_VALUE (shadowed
));
4403 /* Remove the bindings for all of the class-level declarations. */
4404 if (level
->class_shadowed
)
4406 FOR_EACH_VEC_ELT (*level
->class_shadowed
, i
, cb
)
4408 IDENTIFIER_BINDING (cb
->identifier
) = cb
->base
->previous
;
4409 cxx_binding_free (cb
->base
);
4411 ggc_free (level
->class_shadowed
);
4412 level
->class_shadowed
= NULL
;
4415 /* Now, pop out of the binding level which we created up in the
4416 `pushlevel_class' routine. */
4417 gcc_assert (current_binding_level
== level
);
4419 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
4422 /* Set INHERITED_VALUE_BINDING_P on BINDING to true or false, as
4423 appropriate. DECL is the value to which a name has just been
4424 bound. CLASS_TYPE is the class in which the lookup occurred. */
4427 set_inherited_value_binding_p (cxx_binding
*binding
, tree decl
,
4430 if (binding
->value
== decl
&& TREE_CODE (decl
) != TREE_LIST
)
4434 if (TREE_CODE (decl
) == OVERLOAD
)
4435 context
= ovl_scope (decl
);
4438 gcc_assert (DECL_P (decl
));
4439 context
= context_for_name_lookup (decl
);
4442 if (is_properly_derived_from (class_type
, context
))
4443 INHERITED_VALUE_BINDING_P (binding
) = 1;
4445 INHERITED_VALUE_BINDING_P (binding
) = 0;
4447 else if (binding
->value
== decl
)
4448 /* We only encounter a TREE_LIST when there is an ambiguity in the
4449 base classes. Such an ambiguity can be overridden by a
4450 definition in this class. */
4451 INHERITED_VALUE_BINDING_P (binding
) = 1;
4453 INHERITED_VALUE_BINDING_P (binding
) = 0;
4456 /* Make the declaration of X appear in CLASS scope. */
4459 pushdecl_class_level (tree x
)
4461 bool is_valid
= true;
4464 /* Do nothing if we're adding to an outer lambda closure type,
4465 outer_binding will add it later if it's needed. */
4466 if (current_class_type
!= class_binding_level
->this_entity
)
4469 subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
4470 /* Get the name of X. */
4471 tree name
= OVL_NAME (x
);
4475 is_valid
= push_class_level_binding (name
, x
);
4476 if (TREE_CODE (x
) == TYPE_DECL
)
4477 set_identifier_type_value (name
, x
);
4479 else if (ANON_AGGR_TYPE_P (TREE_TYPE (x
)))
4481 /* If X is an anonymous aggregate, all of its members are
4482 treated as if they were members of the class containing the
4483 aggregate, for naming purposes. */
4484 location_t save_location
= input_location
;
4485 tree anon
= TREE_TYPE (x
);
4486 if (vec
<tree
, va_gc
> *member_vec
= CLASSTYPE_MEMBER_VEC (anon
))
4487 for (unsigned ix
= member_vec
->length (); ix
--;)
4489 tree binding
= (*member_vec
)[ix
];
4490 if (STAT_HACK_P (binding
))
4492 if (!pushdecl_class_level (STAT_TYPE (binding
)))
4494 binding
= STAT_DECL (binding
);
4496 if (!pushdecl_class_level (binding
))
4500 for (tree f
= TYPE_FIELDS (anon
); f
; f
= DECL_CHAIN (f
))
4501 if (TREE_CODE (f
) == FIELD_DECL
)
4503 input_location
= DECL_SOURCE_LOCATION (f
);
4504 if (!pushdecl_class_level (f
))
4507 input_location
= save_location
;
4509 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
4513 /* Return the BINDING (if any) for NAME in SCOPE, which is a class
4514 scope. If the value returned is non-NULL, and the PREVIOUS field
4515 is not set, callers must set the PREVIOUS field explicitly. */
4517 static cxx_binding
*
4518 get_class_binding (tree name
, cp_binding_level
*scope
)
4523 cxx_binding
*binding
;
4525 class_type
= scope
->this_entity
;
4527 /* Get the type binding. */
4528 type_binding
= lookup_member (class_type
, name
,
4529 /*protect=*/2, /*want_type=*/true,
4530 tf_warning_or_error
);
4531 /* Get the value binding. */
4532 value_binding
= lookup_member (class_type
, name
,
4533 /*protect=*/2, /*want_type=*/false,
4534 tf_warning_or_error
);
4537 && (TREE_CODE (value_binding
) == TYPE_DECL
4538 || DECL_CLASS_TEMPLATE_P (value_binding
)
4539 || (TREE_CODE (value_binding
) == TREE_LIST
4540 && TREE_TYPE (value_binding
) == error_mark_node
4541 && (TREE_CODE (TREE_VALUE (value_binding
))
4543 /* We found a type binding, even when looking for a non-type
4544 binding. This means that we already processed this binding
4547 else if (value_binding
)
4549 if (TREE_CODE (value_binding
) == TREE_LIST
4550 && TREE_TYPE (value_binding
) == error_mark_node
)
4551 /* NAME is ambiguous. */
4553 else if (BASELINK_P (value_binding
))
4554 /* NAME is some overloaded functions. */
4555 value_binding
= BASELINK_FUNCTIONS (value_binding
);
4558 /* If we found either a type binding or a value binding, create a
4559 new binding object. */
4560 if (type_binding
|| value_binding
)
4562 binding
= new_class_binding (name
,
4566 /* This is a class-scope binding, not a block-scope binding. */
4567 LOCAL_BINDING_P (binding
) = 0;
4568 set_inherited_value_binding_p (binding
, value_binding
, class_type
);
4576 /* Make the declaration(s) of X appear in CLASS scope under the name
4577 NAME. Returns true if the binding is valid. */
4580 push_class_level_binding_1 (tree name
, tree x
)
4582 cxx_binding
*binding
;
4586 /* The class_binding_level will be NULL if x is a template
4587 parameter name in a member template. */
4588 if (!class_binding_level
)
4591 if (name
== error_mark_node
)
4594 /* Can happen for an erroneous declaration (c++/60384). */
4595 if (!identifier_p (name
))
4597 gcc_assert (errorcount
|| sorrycount
);
4601 /* Check for invalid member names. But don't worry about a default
4602 argument-scope lambda being pushed after the class is complete. */
4603 gcc_assert (TYPE_BEING_DEFINED (current_class_type
)
4604 || LAMBDA_TYPE_P (TREE_TYPE (decl
)));
4605 /* Check that we're pushing into the right binding level. */
4606 gcc_assert (current_class_type
== class_binding_level
->this_entity
);
4608 /* We could have been passed a tree list if this is an ambiguous
4609 declaration. If so, pull the declaration out because
4610 check_template_shadow will not handle a TREE_LIST. */
4611 if (TREE_CODE (decl
) == TREE_LIST
4612 && TREE_TYPE (decl
) == error_mark_node
)
4613 decl
= TREE_VALUE (decl
);
4615 if (!check_template_shadow (decl
))
4620 If T is the name of a class, then each of the following shall
4621 have a name different from T:
4623 -- every static data member of class T;
4625 -- every member of class T that is itself a type;
4627 -- every enumerator of every member of class T that is an
4630 -- every member of every anonymous union that is a member of
4633 (Non-static data members were also forbidden to have the same
4634 name as T until TC1.) */
4636 || TREE_CODE (x
) == CONST_DECL
4637 || (TREE_CODE (x
) == TYPE_DECL
4638 && !DECL_SELF_REFERENCE_P (x
))
4639 /* A data member of an anonymous union. */
4640 || (TREE_CODE (x
) == FIELD_DECL
4641 && DECL_CONTEXT (x
) != current_class_type
))
4642 && DECL_NAME (x
) == DECL_NAME (TYPE_NAME (current_class_type
)))
4644 tree scope
= context_for_name_lookup (x
);
4645 if (TYPE_P (scope
) && same_type_p (scope
, current_class_type
))
4647 error ("%qD has the same name as the class in which it is "
4654 /* Get the current binding for NAME in this class, if any. */
4655 binding
= IDENTIFIER_BINDING (name
);
4656 if (!binding
|| binding
->scope
!= class_binding_level
)
4658 binding
= get_class_binding (name
, class_binding_level
);
4659 /* If a new binding was created, put it at the front of the
4660 IDENTIFIER_BINDING list. */
4663 binding
->previous
= IDENTIFIER_BINDING (name
);
4664 IDENTIFIER_BINDING (name
) = binding
;
4668 /* If there is already a binding, then we may need to update the
4670 if (binding
&& binding
->value
)
4672 tree bval
= binding
->value
;
4673 tree old_decl
= NULL_TREE
;
4674 tree target_decl
= strip_using_decl (decl
);
4675 tree target_bval
= strip_using_decl (bval
);
4677 if (INHERITED_VALUE_BINDING_P (binding
))
4679 /* If the old binding was from a base class, and was for a
4680 tag name, slide it over to make room for the new binding.
4681 The old binding is still visible if explicitly qualified
4682 with a class-key. */
4683 if (TREE_CODE (target_bval
) == TYPE_DECL
4684 && DECL_ARTIFICIAL (target_bval
)
4685 && !(TREE_CODE (target_decl
) == TYPE_DECL
4686 && DECL_ARTIFICIAL (target_decl
)))
4688 old_decl
= binding
->type
;
4689 binding
->type
= bval
;
4690 binding
->value
= NULL_TREE
;
4691 INHERITED_VALUE_BINDING_P (binding
) = 0;
4696 /* Any inherited type declaration is hidden by the type
4697 declaration in the derived class. */
4698 if (TREE_CODE (target_decl
) == TYPE_DECL
4699 && DECL_ARTIFICIAL (target_decl
))
4700 binding
->type
= NULL_TREE
;
4703 else if (TREE_CODE (target_decl
) == OVERLOAD
4704 && OVL_P (target_bval
))
4706 else if (TREE_CODE (decl
) == USING_DECL
4707 && TREE_CODE (bval
) == USING_DECL
4708 && same_type_p (USING_DECL_SCOPE (decl
),
4709 USING_DECL_SCOPE (bval
)))
4710 /* This is a using redeclaration that will be diagnosed later
4711 in supplement_binding */
4713 else if (TREE_CODE (decl
) == USING_DECL
4714 && TREE_CODE (bval
) == USING_DECL
4715 && DECL_DEPENDENT_P (decl
)
4716 && DECL_DEPENDENT_P (bval
))
4718 else if (TREE_CODE (decl
) == USING_DECL
4719 && OVL_P (target_bval
))
4721 else if (TREE_CODE (bval
) == USING_DECL
4722 && OVL_P (target_decl
))
4725 if (old_decl
&& binding
->scope
== class_binding_level
)
4728 /* It is always safe to clear INHERITED_VALUE_BINDING_P
4729 here. This function is only used to register bindings
4730 from with the class definition itself. */
4731 INHERITED_VALUE_BINDING_P (binding
) = 0;
4736 /* Note that we declared this value so that we can issue an error if
4737 this is an invalid redeclaration of a name already used for some
4739 note_name_declared_in_class (name
, decl
);
4741 /* If we didn't replace an existing binding, put the binding on the
4742 stack of bindings for the identifier, and update the shadowed
4744 if (binding
&& binding
->scope
== class_binding_level
)
4745 /* Supplement the existing binding. */
4746 ok
= supplement_binding (binding
, decl
);
4749 /* Create a new binding. */
4750 push_binding (name
, decl
, class_binding_level
);
4757 /* Wrapper for push_class_level_binding_1. */
4760 push_class_level_binding (tree name
, tree x
)
4763 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
4764 ret
= push_class_level_binding_1 (name
, x
);
4765 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
4769 /* Process "using SCOPE::NAME" in a class scope. Return the
4770 USING_DECL created. */
4773 do_class_using_decl (tree scope
, tree name
)
4775 if (name
== error_mark_node
)
4778 if (!scope
|| !TYPE_P (scope
))
4780 error ("using-declaration for non-member at class scope");
4784 /* Make sure the name is not invalid */
4785 if (TREE_CODE (name
) == BIT_NOT_EXPR
)
4787 error ("%<%T::%D%> names destructor", scope
, name
);
4791 /* Using T::T declares inheriting ctors, even if T is a typedef. */
4792 if (MAYBE_CLASS_TYPE_P (scope
)
4793 && (name
== TYPE_IDENTIFIER (scope
)
4794 || constructor_name_p (name
, scope
)))
4796 maybe_warn_cpp0x (CPP0X_INHERITING_CTORS
);
4797 name
= ctor_identifier
;
4798 CLASSTYPE_NON_AGGREGATE (current_class_type
) = true;
4801 /* Cannot introduce a constructor name. */
4802 if (constructor_name_p (name
, current_class_type
))
4804 error ("%<%T::%D%> names constructor in %qT",
4805 scope
, name
, current_class_type
);
4809 /* From [namespace.udecl]:
4811 A using-declaration used as a member-declaration shall refer to a
4812 member of a base class of the class being defined.
4814 In general, we cannot check this constraint in a template because
4815 we do not know the entire set of base classes of the current
4816 class type. Morover, if SCOPE is dependent, it might match a
4817 non-dependent base. */
4819 tree decl
= NULL_TREE
;
4820 if (!dependent_scope_p (scope
))
4823 tree binfo
= lookup_base (current_class_type
, scope
, ba_any
, &b_kind
,
4824 tf_warning_or_error
);
4825 if (b_kind
< bk_proper_base
)
4827 /* If there are dependent bases, scope might resolve at
4828 instantiation time, even if it isn't exactly one of the
4830 if (b_kind
== bk_same_type
|| !any_dependent_bases_p ())
4832 error_not_base_type (scope
, current_class_type
);
4836 else if (name
== ctor_identifier
&& !binfo_direct_p (binfo
))
4838 error ("cannot inherit constructors from indirect base %qT", scope
);
4841 else if (!IDENTIFIER_CONV_OP_P (name
)
4842 || !dependent_type_p (TREE_TYPE (name
)))
4844 decl
= lookup_member (binfo
, name
, 0, false, tf_warning_or_error
);
4847 error ("no members matching %<%T::%D%> in %q#T", scope
, name
,
4852 /* The binfo from which the functions came does not matter. */
4853 if (BASELINK_P (decl
))
4854 decl
= BASELINK_FUNCTIONS (decl
);
4858 tree value
= build_lang_decl (USING_DECL
, name
, NULL_TREE
);
4859 USING_DECL_DECLS (value
) = decl
;
4860 USING_DECL_SCOPE (value
) = scope
;
4861 DECL_DEPENDENT_P (value
) = !decl
;
4867 /* Return the binding for NAME in NS. If NS is NULL, look in
4868 global_namespace. */
4871 get_namespace_binding (tree ns
, tree name
)
4873 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
4875 ns
= global_namespace
;
4876 gcc_checking_assert (!DECL_NAMESPACE_ALIAS (ns
));
4877 tree ret
= find_namespace_value (ns
, name
);
4878 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
4882 /* Push internal DECL into the global namespace. Does not do the
4883 full overload fn handling and does not add it to the list of things
4884 in the namespace. */
4887 set_global_binding (tree decl
)
4889 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
4891 tree
*slot
= find_namespace_slot (global_namespace
, DECL_NAME (decl
), true);
4894 /* The user's placed something in the implementor's namespace. */
4895 diagnose_name_conflict (decl
, MAYBE_STAT_DECL (*slot
));
4897 /* Force the binding, so compiler internals continue to work. */
4900 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
4903 /* Set the context of a declaration to scope. Complain if we are not
4907 set_decl_namespace (tree decl
, tree scope
, bool friendp
)
4909 /* Get rid of namespace aliases. */
4910 scope
= ORIGINAL_NAMESPACE (scope
);
4912 /* It is ok for friends to be qualified in parallel space. */
4913 if (!friendp
&& !is_nested_namespace (current_namespace
, scope
))
4914 error ("declaration of %qD not in a namespace surrounding %qD",
4916 DECL_CONTEXT (decl
) = FROB_CONTEXT (scope
);
4918 /* See whether this has been declared in the namespace or inline
4920 tree old
= NULL_TREE
;
4922 name_lookup
lookup (DECL_NAME (decl
), LOOKUP_HIDDEN
);
4923 if (!lookup
.search_qualified (scope
, /*usings=*/false))
4924 /* No old declaration at all. */
4929 /* If it's a TREE_LIST, the result of the lookup was ambiguous. */
4930 if (TREE_CODE (old
) == TREE_LIST
)
4933 DECL_CONTEXT (decl
) = FROB_CONTEXT (scope
);
4934 error ("reference to %qD is ambiguous", decl
);
4935 print_candidates (old
);
4939 if (!DECL_DECLARES_FUNCTION_P (decl
))
4941 /* Don't compare non-function decls with decls_match here, since
4942 it can't check for the correct constness at this
4943 point. pushdecl will find those errors later. */
4945 /* We might have found it in an inline namespace child of SCOPE. */
4946 if (TREE_CODE (decl
) == TREE_CODE (old
))
4947 DECL_CONTEXT (decl
) = DECL_CONTEXT (old
);
4950 /* Writing "N::i" to declare something directly in "N" is invalid. */
4951 if (CP_DECL_CONTEXT (decl
) == current_namespace
4952 && at_namespace_scope_p ())
4953 error ("explicit qualification in declaration of %qD", decl
);
4957 /* Since decl is a function, old should contain a function decl. */
4961 /* We handle these in check_explicit_instantiation_namespace. */
4962 if (processing_explicit_instantiation
)
4964 if (processing_template_decl
|| processing_specialization
)
4965 /* We have not yet called push_template_decl to turn a
4966 FUNCTION_DECL into a TEMPLATE_DECL, so the declarations won't
4967 match. But, we'll check later, when we construct the
4970 /* Instantiations or specializations of templates may be declared as
4971 friends in any namespace. */
4972 if (friendp
&& DECL_USE_TEMPLATE (decl
))
4978 for (lkp_iterator
iter (old
); iter
; ++iter
)
4980 if (iter
.using_p ())
4985 /* Adjust DECL_CONTEXT first so decls_match will return true
4986 if DECL will match a declaration in an inline namespace. */
4987 DECL_CONTEXT (decl
) = DECL_CONTEXT (ofn
);
4988 if (decls_match (decl
, ofn
))
4992 /* We found more than one matching declaration. */
4993 DECL_CONTEXT (decl
) = FROB_CONTEXT (scope
);
5002 if (DECL_HIDDEN_FRIEND_P (found
))
5004 pedwarn (DECL_SOURCE_LOCATION (decl
), 0,
5005 "%qD has not been declared within %qD", decl
, scope
);
5006 inform (DECL_SOURCE_LOCATION (found
),
5007 "only here as a %<friend%>");
5009 DECL_CONTEXT (decl
) = DECL_CONTEXT (found
);
5014 /* It didn't work, go back to the explicit scope. */
5015 DECL_CONTEXT (decl
) = FROB_CONTEXT (scope
);
5016 error ("%qD should have been declared inside %qD", decl
, scope
);
5019 /* Return the namespace where the current declaration is declared. */
5022 current_decl_namespace (void)
5025 /* If we have been pushed into a different namespace, use it. */
5026 if (!vec_safe_is_empty (decl_namespace_list
))
5027 return decl_namespace_list
->last ();
5029 if (current_class_type
)
5030 result
= decl_namespace_context (current_class_type
);
5031 else if (current_function_decl
)
5032 result
= decl_namespace_context (current_function_decl
);
5034 result
= current_namespace
;
5038 /* Process any ATTRIBUTES on a namespace definition. Returns true if
5039 attribute visibility is seen. */
5042 handle_namespace_attrs (tree ns
, tree attributes
)
5045 bool saw_vis
= false;
5047 for (d
= attributes
; d
; d
= TREE_CHAIN (d
))
5049 tree name
= get_attribute_name (d
);
5050 tree args
= TREE_VALUE (d
);
5052 if (is_attribute_p ("visibility", name
))
5054 /* attribute visibility is a property of the syntactic block
5055 rather than the namespace as a whole, so we don't touch the
5056 NAMESPACE_DECL at all. */
5057 tree x
= args
? TREE_VALUE (args
) : NULL_TREE
;
5058 if (x
== NULL_TREE
|| TREE_CODE (x
) != STRING_CST
|| TREE_CHAIN (args
))
5060 warning (OPT_Wattributes
,
5061 "%qD attribute requires a single NTBS argument",
5066 if (!TREE_PUBLIC (ns
))
5067 warning (OPT_Wattributes
,
5068 "%qD attribute is meaningless since members of the "
5069 "anonymous namespace get local symbols", name
);
5071 push_visibility (TREE_STRING_POINTER (x
), 1);
5074 else if (is_attribute_p ("abi_tag", name
))
5076 if (!DECL_NAME (ns
))
5078 warning (OPT_Wattributes
, "ignoring %qD attribute on anonymous "
5082 if (!DECL_NAMESPACE_INLINE_P (ns
))
5084 warning (OPT_Wattributes
, "ignoring %qD attribute on non-inline "
5090 tree dn
= DECL_NAME (ns
);
5091 args
= build_string (IDENTIFIER_LENGTH (dn
) + 1,
5092 IDENTIFIER_POINTER (dn
));
5093 TREE_TYPE (args
) = char_array_type_node
;
5094 args
= fix_string_type (args
);
5095 args
= build_tree_list (NULL_TREE
, args
);
5097 if (check_abi_tag_args (args
, name
))
5098 DECL_ATTRIBUTES (ns
) = tree_cons (name
, args
,
5099 DECL_ATTRIBUTES (ns
));
5103 warning (OPT_Wattributes
, "%qD attribute directive ignored",
5112 /* Temporarily set the namespace for the current declaration. */
5115 push_decl_namespace (tree decl
)
5117 if (TREE_CODE (decl
) != NAMESPACE_DECL
)
5118 decl
= decl_namespace_context (decl
);
5119 vec_safe_push (decl_namespace_list
, ORIGINAL_NAMESPACE (decl
));
5122 /* [namespace.memdef]/2 */
5125 pop_decl_namespace (void)
5127 decl_namespace_list
->pop ();
5130 /* Process a namespace-alias declaration. */
5133 do_namespace_alias (tree alias
, tree name_space
)
5135 if (name_space
== error_mark_node
)
5138 gcc_assert (TREE_CODE (name_space
) == NAMESPACE_DECL
);
5140 name_space
= ORIGINAL_NAMESPACE (name_space
);
5142 /* Build the alias. */
5143 alias
= build_lang_decl (NAMESPACE_DECL
, alias
, void_type_node
);
5144 DECL_NAMESPACE_ALIAS (alias
) = name_space
;
5145 DECL_EXTERNAL (alias
) = 1;
5146 DECL_CONTEXT (alias
) = FROB_CONTEXT (current_scope ());
5149 /* Emit debug info for namespace alias. */
5150 if (!building_stmt_list_p ())
5151 (*debug_hooks
->early_global_decl
) (alias
);
5154 /* Like pushdecl, only it places X in the current namespace,
5158 pushdecl_namespace_level (tree x
, bool is_friend
)
5160 cp_binding_level
*b
= current_binding_level
;
5163 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
5164 t
= do_pushdecl_with_scope
5165 (x
, NAMESPACE_LEVEL (current_namespace
), is_friend
);
5167 /* Now, the type_shadowed stack may screw us. Munge it so it does
5169 if (TREE_CODE (t
) == TYPE_DECL
)
5171 tree name
= DECL_NAME (t
);
5173 tree
*ptr
= (tree
*)0;
5174 for (; !global_scope_p (b
); b
= b
->level_chain
)
5176 tree shadowed
= b
->type_shadowed
;
5177 for (; shadowed
; shadowed
= TREE_CHAIN (shadowed
))
5178 if (TREE_PURPOSE (shadowed
) == name
)
5180 ptr
= &TREE_VALUE (shadowed
);
5181 /* Can't break out of the loop here because sometimes
5182 a binding level will have duplicate bindings for
5183 PT names. It's gross, but I haven't time to fix it. */
5186 newval
= TREE_TYPE (t
);
5187 if (ptr
== (tree
*)0)
5189 /* @@ This shouldn't be needed. My test case "zstring.cc" trips
5190 up here if this is changed to an assertion. --KR */
5191 SET_IDENTIFIER_TYPE_VALUE (name
, t
);
5198 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
5202 /* Process a using-declaration appearing in namespace scope. */
5205 finish_namespace_using_decl (tree decl
, tree scope
, tree name
)
5207 tree orig_decl
= decl
;
5209 gcc_checking_assert (current_binding_level
->kind
== sk_namespace
5210 && !processing_template_decl
);
5211 decl
= validate_nonmember_using_decl (decl
, scope
, name
);
5212 if (decl
== NULL_TREE
)
5215 tree
*slot
= find_namespace_slot (current_namespace
, name
, true);
5216 tree val
= slot
? MAYBE_STAT_DECL (*slot
) : NULL_TREE
;
5217 tree type
= slot
? MAYBE_STAT_TYPE (*slot
) : NULL_TREE
;
5218 do_nonmember_using_decl (scope
, name
, &val
, &type
);
5219 if (STAT_HACK_P (*slot
))
5221 STAT_DECL (*slot
) = val
;
5222 STAT_TYPE (*slot
) = type
;
5225 *slot
= stat_hack (val
, type
);
5229 /* Emit debug info. */
5230 cp_emit_debug_info_for_using (orig_decl
, current_namespace
);
5233 /* Process a using-declaration at function scope. */
5236 finish_local_using_decl (tree decl
, tree scope
, tree name
)
5238 tree orig_decl
= decl
;
5240 gcc_checking_assert (current_binding_level
->kind
!= sk_class
5241 && current_binding_level
->kind
!= sk_namespace
);
5242 decl
= validate_nonmember_using_decl (decl
, scope
, name
);
5243 if (decl
== NULL_TREE
)
5246 add_decl_expr (decl
);
5248 cxx_binding
*binding
= find_local_binding (current_binding_level
, name
);
5249 tree value
= binding
? binding
->value
: NULL_TREE
;
5250 tree type
= binding
? binding
->type
: NULL_TREE
;
5252 do_nonmember_using_decl (scope
, name
, &value
, &type
);
5256 else if (binding
&& value
== binding
->value
)
5258 else if (binding
&& binding
->value
&& TREE_CODE (value
) == OVERLOAD
)
5260 update_local_overload (IDENTIFIER_BINDING (name
), value
);
5261 IDENTIFIER_BINDING (name
)->value
= value
;
5264 /* Install the new binding. */
5265 push_local_binding (name
, value
, true);
5269 else if (binding
&& type
== binding
->type
)
5273 push_local_binding (name
, type
, true);
5274 set_identifier_type_value (name
, type
);
5277 /* Emit debug info. */
5278 if (!processing_template_decl
)
5279 cp_emit_debug_info_for_using (orig_decl
, current_scope ());
5282 /* Return the declarations that are members of the namespace NS. */
5285 cp_namespace_decls (tree ns
)
5287 return NAMESPACE_LEVEL (ns
)->names
;
5290 /* Combine prefer_type and namespaces_only into flags. */
5293 lookup_flags (int prefer_type
, int namespaces_only
)
5295 if (namespaces_only
)
5296 return LOOKUP_PREFER_NAMESPACES
;
5297 if (prefer_type
> 1)
5298 return LOOKUP_PREFER_TYPES
;
5299 if (prefer_type
> 0)
5300 return LOOKUP_PREFER_BOTH
;
5304 /* Given a lookup that returned VAL, use FLAGS to decide if we want to
5305 ignore it or not. Subroutine of lookup_name_real and
5306 lookup_type_scope. */
5309 qualify_lookup (tree val
, int flags
)
5311 if (val
== NULL_TREE
)
5313 if ((flags
& LOOKUP_PREFER_NAMESPACES
) && TREE_CODE (val
) == NAMESPACE_DECL
)
5315 if (flags
& LOOKUP_PREFER_TYPES
)
5317 tree target_val
= strip_using_decl (val
);
5318 if (TREE_CODE (target_val
) == TYPE_DECL
5319 || TREE_CODE (target_val
) == TEMPLATE_DECL
)
5322 if (flags
& (LOOKUP_PREFER_NAMESPACES
| LOOKUP_PREFER_TYPES
))
5324 /* Look through lambda things that we shouldn't be able to see. */
5325 if (!(flags
& LOOKUP_HIDDEN
) && is_lambda_ignored_entity (val
))
5330 /* Suggest alternatives for NAME, an IDENTIFIER_NODE for which name
5331 lookup failed. Search through all available namespaces and print out
5332 possible candidates. If no exact matches are found, and
5333 SUGGEST_MISSPELLINGS is true, then also look for near-matches and
5334 suggest the best near-match, if there is one. */
5337 suggest_alternatives_for (location_t location
, tree name
,
5338 bool suggest_misspellings
)
5340 vec
<tree
> candidates
= vNULL
;
5341 vec
<tree
> worklist
= vNULL
;
5342 unsigned limit
= PARAM_VALUE (CXX_MAX_NAMESPACES_FOR_DIAGNOSTIC_HELP
);
5343 bool limited
= false;
5345 /* Breadth-first search of namespaces. Up to limit namespaces
5346 searched (limit zero == unlimited). */
5347 worklist
.safe_push (global_namespace
);
5348 for (unsigned ix
= 0; ix
!= worklist
.length (); ix
++)
5350 tree ns
= worklist
[ix
];
5351 name_lookup
lookup (name
);
5353 if (lookup
.search_qualified (ns
, false))
5354 candidates
.safe_push (lookup
.value
);
5358 /* Look for child namespaces. We have to do this
5359 indirectly because they are chained in reverse order,
5360 which is confusing to the user. */
5361 vec
<tree
> children
= vNULL
;
5363 for (tree decl
= NAMESPACE_LEVEL (ns
)->names
;
5364 decl
; decl
= TREE_CHAIN (decl
))
5365 if (TREE_CODE (decl
) == NAMESPACE_DECL
5366 && !DECL_NAMESPACE_ALIAS (decl
)
5367 && !DECL_NAMESPACE_INLINE_P (decl
))
5368 children
.safe_push (decl
);
5370 while (!limited
&& !children
.is_empty ())
5372 if (worklist
.length () == limit
)
5374 /* Unconditionally warn that the search was truncated. */
5376 "maximum limit of %d namespaces searched for %qE",
5381 worklist
.safe_push (children
.pop ());
5383 children
.release ();
5386 worklist
.release ();
5388 if (candidates
.length ())
5390 inform_n (location
, candidates
.length (),
5391 "suggested alternative:",
5392 "suggested alternatives:");
5393 for (unsigned ix
= 0; ix
!= candidates
.length (); ix
++)
5395 tree val
= candidates
[ix
];
5397 inform (location_of (val
), " %qE", val
);
5399 candidates
.release ();
5401 else if (!suggest_misspellings
)
5403 else if (name_hint hint
= lookup_name_fuzzy (name
, FUZZY_LOOKUP_NAME
,
5406 /* Show a spelling correction. */
5407 gcc_rich_location
richloc (location
);
5409 richloc
.add_fixit_replace (hint
.suggestion ());
5410 inform (&richloc
, "suggested alternative: %qs", hint
.suggestion ());
5414 /* Subroutine of maybe_suggest_missing_header for handling unrecognized names
5415 for some of the most common names within "std::".
5416 Given non-NULL NAME, a name for lookup within "std::", return the header
5417 name defining it within the C++ Standard Library (with '<' and '>'),
5421 get_std_name_hint (const char *name
)
5423 struct std_name_hint
5428 static const std_name_hint hints
[] = {
5430 {"array", "<array>"}, // C++11
5432 {"complex", "<complex>"},
5433 {"complex_literals", "<complex>"},
5435 {"deque", "<deque>"},
5436 /* <forward_list>. */
5437 {"forward_list", "<forward_list>"}, // C++11
5439 {"basic_filebuf", "<fstream>"},
5440 {"basic_ifstream", "<fstream>"},
5441 {"basic_ofstream", "<fstream>"},
5442 {"basic_fstream", "<fstream>"},
5444 {"cin", "<iostream>"},
5445 {"cout", "<iostream>"},
5446 {"cerr", "<iostream>"},
5447 {"clog", "<iostream>"},
5448 {"wcin", "<iostream>"},
5449 {"wcout", "<iostream>"},
5450 {"wclog", "<iostream>"},
5455 {"multimap", "<map>"},
5457 {"make_shared", "<memory>"},
5458 {"make_unique", "<memory>"},
5459 {"shared_ptr", "<memory>"},
5460 {"unique_ptr", "<memory>"},
5461 {"weak_ptr", "<memory>"},
5463 {"queue", "<queue>"},
5464 {"priority_queue", "<queue>"},
5466 {"ostream", "<ostream>"},
5467 {"wostream", "<ostream>"},
5468 {"ends", "<ostream>"},
5469 {"flush", "<ostream>"},
5470 {"endl", "<ostream>"},
5473 {"multiset", "<set>"},
5475 {"basic_stringbuf", "<sstream>"},
5476 {"basic_istringstream", "<sstream>"},
5477 {"basic_ostringstream", "<sstream>"},
5478 {"basic_stringstream", "<sstream>"},
5480 {"stack", "<stack>"},
5482 {"make_tuple", "<tuple>"},
5483 {"tuple", "<tuple>"},
5485 {"string", "<string>"},
5486 {"wstring", "<string>"},
5487 {"u16string", "<string>"},
5488 {"u32string", "<string>"},
5489 /* <unordered_map>. */
5490 {"unordered_map", "<unordered_map>"}, // C++11
5491 {"unordered_multimap", "<unordered_map>"}, // C++11
5492 /* <unordered_set>. */
5493 {"unordered_set", "<unordered_set>"}, // C++11
5494 {"unordered_multiset", "<unordered_set>"}, // C++11
5496 {"forward", "<utility>"},
5497 {"make_pair", "<utility>"},
5498 {"move", "<utility>"},
5499 {"pair", "<utility>"},
5501 {"vector", "<vector>"},
5503 const size_t num_hints
= sizeof (hints
) / sizeof (hints
[0]);
5504 for (size_t i
= 0; i
< num_hints
; i
++)
5506 if (strcmp (name
, hints
[i
].name
) == 0)
5507 return hints
[i
].header
;
5512 /* If SCOPE is the "std" namespace, then suggest pertinent header
5513 files for NAME at LOCATION.
5514 Return true iff a suggestion was offered. */
5517 maybe_suggest_missing_header (location_t location
, tree name
, tree scope
)
5519 if (scope
== NULL_TREE
)
5521 if (TREE_CODE (scope
) != NAMESPACE_DECL
)
5523 /* We only offer suggestions for the "std" namespace. */
5524 if (scope
!= std_node
)
5526 gcc_assert (TREE_CODE (name
) == IDENTIFIER_NODE
);
5528 const char *name_str
= IDENTIFIER_POINTER (name
);
5529 const char *header_hint
= get_std_name_hint (name_str
);
5533 gcc_rich_location
richloc (location
);
5534 maybe_add_include_fixit (&richloc
, header_hint
);
5536 "%<std::%s%> is defined in header %qs;"
5537 " did you forget to %<#include %s%>?",
5538 name_str
, header_hint
, header_hint
);
5542 /* Look for alternatives for NAME, an IDENTIFIER_NODE for which name
5543 lookup failed within the explicitly provided SCOPE. Suggest the
5544 the best meaningful candidates (if any) as a fix-it hint.
5545 Return true iff a suggestion was provided. */
5548 suggest_alternative_in_explicit_scope (location_t location
, tree name
,
5551 /* Something went very wrong; don't suggest anything. */
5552 if (name
== error_mark_node
)
5555 /* Resolve any namespace aliases. */
5556 scope
= ORIGINAL_NAMESPACE (scope
);
5558 if (maybe_suggest_missing_header (location
, name
, scope
))
5561 cp_binding_level
*level
= NAMESPACE_LEVEL (scope
);
5563 best_match
<tree
, const char *> bm (name
);
5564 consider_binding_level (name
, bm
, level
, false, FUZZY_LOOKUP_NAME
);
5566 /* See if we have a good suggesion for the user. */
5567 const char *fuzzy_name
= bm
.get_best_meaningful_candidate ();
5570 gcc_rich_location
richloc (location
);
5571 richloc
.add_fixit_replace (fuzzy_name
);
5572 inform (&richloc
, "suggested alternative: %qs",
5580 /* Look up NAME (an IDENTIFIER_NODE) in SCOPE (either a NAMESPACE_DECL
5583 If PREFER_TYPE is > 0, we only return TYPE_DECLs or namespaces.
5584 If PREFER_TYPE is > 1, we only return TYPE_DECLs.
5586 Returns a DECL (or OVERLOAD, or BASELINK) representing the
5587 declaration found. If no suitable declaration can be found,
5588 ERROR_MARK_NODE is returned. If COMPLAIN is true and SCOPE is
5589 neither a class-type nor a namespace a diagnostic is issued. */
5592 lookup_qualified_name (tree scope
, tree name
, int prefer_type
, bool complain
,
5597 if (TREE_CODE (scope
) == NAMESPACE_DECL
)
5599 int flags
= lookup_flags (prefer_type
, /*namespaces_only*/false);
5601 flags
|= LOOKUP_HIDDEN
;
5602 name_lookup
lookup (name
, flags
);
5604 if (qualified_namespace_lookup (scope
, &lookup
))
5607 else if (cxx_dialect
!= cxx98
&& TREE_CODE (scope
) == ENUMERAL_TYPE
)
5608 t
= lookup_enumerator (scope
, name
);
5609 else if (is_class_type (scope
, complain
))
5610 t
= lookup_member (scope
, name
, 2, prefer_type
, tf_warning_or_error
);
5613 return error_mark_node
;
5618 Accepts the NAME to lookup and its qualifying SCOPE.
5619 Returns the name/type pair found into the cxx_binding *RESULT,
5620 or false on error. */
5623 qualified_namespace_lookup (tree scope
, name_lookup
*lookup
)
5625 timevar_start (TV_NAME_LOOKUP
);
5626 query_oracle (lookup
->name
);
5627 bool found
= lookup
->search_qualified (ORIGINAL_NAMESPACE (scope
));
5628 timevar_stop (TV_NAME_LOOKUP
);
5632 /* Helper function for lookup_name_fuzzy.
5633 Traverse binding level LVL, looking for good name matches for NAME
5636 consider_binding_level (tree name
, best_match
<tree
, const char *> &bm
,
5637 cp_binding_level
*lvl
, bool look_within_fields
,
5638 enum lookup_name_fuzzy_kind kind
)
5640 if (look_within_fields
)
5641 if (lvl
->this_entity
&& TREE_CODE (lvl
->this_entity
) == RECORD_TYPE
)
5643 tree type
= lvl
->this_entity
;
5644 bool want_type_p
= (kind
== FUZZY_LOOKUP_TYPENAME
);
5645 tree best_matching_field
5646 = lookup_member_fuzzy (type
, name
, want_type_p
);
5647 if (best_matching_field
)
5648 bm
.consider (IDENTIFIER_POINTER (best_matching_field
));
5651 /* Only suggest names reserved for the implementation if NAME begins
5652 with an underscore. */
5653 bool consider_implementation_names
= (IDENTIFIER_POINTER (name
)[0] == '_');
5655 for (tree t
= lvl
->names
; t
; t
= TREE_CHAIN (t
))
5659 /* OVERLOADs or decls from using declaration are wrapped into
5661 if (TREE_CODE (d
) == TREE_LIST
)
5662 d
= OVL_FIRST (TREE_VALUE (d
));
5664 /* Don't use bindings from implicitly declared functions,
5665 as they were likely misspellings themselves. */
5666 if (TREE_TYPE (d
) == error_mark_node
)
5669 /* Skip anticipated decls of builtin functions. */
5670 if (TREE_CODE (d
) == FUNCTION_DECL
5671 && DECL_BUILT_IN (d
)
5672 && DECL_ANTICIPATED (d
))
5675 tree suggestion
= DECL_NAME (d
);
5679 const char *suggestion_str
= IDENTIFIER_POINTER (suggestion
);
5681 /* Ignore internal names with spaces in them. */
5682 if (strchr (suggestion_str
, ' '))
5685 /* Don't suggest names that are reserved for use by the
5686 implementation, unless NAME began with an underscore. */
5687 if (name_reserved_for_implementation_p (suggestion_str
)
5688 && !consider_implementation_names
)
5691 bm
.consider (suggestion_str
);
5695 /* Subclass of deferred_diagnostic. Notify the user that the
5696 given macro was used before it was defined.
5697 This can be done in the C++ frontend since tokenization happens
5700 class macro_use_before_def
: public deferred_diagnostic
5703 /* Ctor. LOC is the location of the usage. MACRO is the
5704 macro that was used. */
5705 macro_use_before_def (location_t loc
, cpp_hashnode
*macro
)
5706 : deferred_diagnostic (loc
), m_macro (macro
)
5711 ~macro_use_before_def ()
5713 if (is_suppressed_p ())
5716 source_location def_loc
= cpp_macro_definition_location (m_macro
);
5717 if (def_loc
!= UNKNOWN_LOCATION
)
5719 inform (get_location (), "the macro %qs had not yet been defined",
5720 (const char *)m_macro
->ident
.str
);
5721 inform (def_loc
, "it was later defined here");
5726 cpp_hashnode
*m_macro
;
5729 /* Determine if it can ever make sense to offer RID as a suggestion for
5732 Subroutine of lookup_name_fuzzy. */
5735 suggest_rid_p (enum rid rid
)
5739 /* Support suggesting function-like keywords. */
5740 case RID_STATIC_ASSERT
:
5744 /* Support suggesting the various decl-specifier words, to handle
5745 e.g. "singed" vs "signed" typos. */
5746 if (cp_keyword_starts_decl_specifier_p (rid
))
5749 /* Otherwise, don't offer it. This avoids suggesting e.g. "if"
5750 and "do" for short misspellings, which are likely to lead to
5751 nonsensical results. */
5756 /* Search for near-matches for NAME within the current bindings, and within
5757 macro names, returning the best match as a const char *, or NULL if
5758 no reasonable match is found.
5760 Use LOC for any deferred diagnostics. */
5763 lookup_name_fuzzy (tree name
, enum lookup_name_fuzzy_kind kind
, location_t loc
)
5765 gcc_assert (TREE_CODE (name
) == IDENTIFIER_NODE
);
5767 /* First, try some well-known names in the C++ standard library, in case
5768 the user forgot a #include. */
5769 const char *header_hint
5770 = get_cp_stdlib_header_for_name (IDENTIFIER_POINTER (name
));
5772 return name_hint (NULL
,
5773 new suggest_missing_header (loc
,
5774 IDENTIFIER_POINTER (name
),
5777 best_match
<tree
, const char *> bm (name
);
5779 cp_binding_level
*lvl
;
5780 for (lvl
= scope_chain
->class_bindings
; lvl
; lvl
= lvl
->level_chain
)
5781 consider_binding_level (name
, bm
, lvl
, true, kind
);
5783 for (lvl
= current_binding_level
; lvl
; lvl
= lvl
->level_chain
)
5784 consider_binding_level (name
, bm
, lvl
, false, kind
);
5786 /* Consider macros: if the user misspelled a macro name e.g. "SOME_MACRO"
5788 x = SOME_OTHER_MACRO (y);
5789 then "SOME_OTHER_MACRO" will survive to the frontend and show up
5790 as a misspelled identifier.
5792 Use the best distance so far so that a candidate is only set if
5793 a macro is better than anything so far. This allows early rejection
5794 (without calculating the edit distance) of macro names that must have
5795 distance >= bm.get_best_distance (), and means that we only get a
5796 non-NULL result for best_macro_match if it's better than any of
5797 the identifiers already checked. */
5798 best_macro_match
bmm (name
, bm
.get_best_distance (), parse_in
);
5799 cpp_hashnode
*best_macro
= bmm
.get_best_meaningful_candidate ();
5800 /* If a macro is the closest so far to NAME, consider it. */
5802 bm
.consider ((const char *)best_macro
->ident
.str
);
5803 else if (bmm
.get_best_distance () == 0)
5805 /* If we have an exact match for a macro name, then the
5806 macro has been used before it was defined. */
5807 cpp_hashnode
*macro
= bmm
.blithely_get_best_candidate ();
5808 if (macro
&& (macro
->flags
& NODE_BUILTIN
) == 0)
5809 return name_hint (NULL
,
5810 new macro_use_before_def (loc
, macro
));
5813 /* Try the "starts_decl_specifier_p" keywords to detect
5814 "singed" vs "signed" typos. */
5815 for (unsigned i
= 0; i
< num_c_common_reswords
; i
++)
5817 const c_common_resword
*resword
= &c_common_reswords
[i
];
5819 if (!suggest_rid_p (resword
->rid
))
5822 tree resword_identifier
= ridpointers
[resword
->rid
];
5823 if (!resword_identifier
)
5825 gcc_assert (TREE_CODE (resword_identifier
) == IDENTIFIER_NODE
);
5827 /* Only consider reserved words that survived the
5828 filtering in init_reswords (e.g. for -std). */
5829 if (!IDENTIFIER_KEYWORD_P (resword_identifier
))
5832 bm
.consider (IDENTIFIER_POINTER (resword_identifier
));
5835 return name_hint (bm
.get_best_meaningful_candidate (), NULL
);
5838 /* Subroutine of outer_binding.
5840 Returns TRUE if BINDING is a binding to a template parameter of
5841 SCOPE. In that case SCOPE is the scope of a primary template
5842 parameter -- in the sense of G++, i.e, a template that has its own
5845 Returns FALSE otherwise. */
5848 binding_to_template_parms_of_scope_p (cxx_binding
*binding
,
5849 cp_binding_level
*scope
)
5851 tree binding_value
, tmpl
, tinfo
;
5854 if (!binding
|| !scope
|| !scope
->this_entity
)
5857 binding_value
= binding
->value
? binding
->value
: binding
->type
;
5858 tinfo
= get_template_info (scope
->this_entity
);
5860 /* BINDING_VALUE must be a template parm. */
5861 if (binding_value
== NULL_TREE
5862 || (!DECL_P (binding_value
)
5863 || !DECL_TEMPLATE_PARM_P (binding_value
)))
5866 /* The level of BINDING_VALUE. */
5868 template_type_parameter_p (binding_value
)
5869 ? TEMPLATE_PARM_LEVEL (TEMPLATE_TYPE_PARM_INDEX
5870 (TREE_TYPE (binding_value
)))
5871 : TEMPLATE_PARM_LEVEL (DECL_INITIAL (binding_value
));
5873 /* The template of the current scope, iff said scope is a primary
5876 && PRIMARY_TEMPLATE_P (TI_TEMPLATE (tinfo
))
5877 ? TI_TEMPLATE (tinfo
)
5880 /* If the level of the parm BINDING_VALUE equals the depth of TMPL,
5881 then BINDING_VALUE is a parameter of TMPL. */
5882 return (tmpl
&& level
== TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (tmpl
)));
5885 /* Return the innermost non-namespace binding for NAME from a scope
5886 containing BINDING, or, if BINDING is NULL, the current scope.
5887 Please note that for a given template, the template parameters are
5888 considered to be in the scope containing the current scope.
5889 If CLASS_P is false, then class bindings are ignored. */
5892 outer_binding (tree name
,
5893 cxx_binding
*binding
,
5897 cp_binding_level
*scope
;
5898 cp_binding_level
*outer_scope
;
5902 scope
= binding
->scope
->level_chain
;
5903 outer
= binding
->previous
;
5907 scope
= current_binding_level
;
5908 outer
= IDENTIFIER_BINDING (name
);
5910 outer_scope
= outer
? outer
->scope
: NULL
;
5912 /* Because we create class bindings lazily, we might be missing a
5913 class binding for NAME. If there are any class binding levels
5914 between the LAST_BINDING_LEVEL and the scope in which OUTER was
5915 declared, we must lookup NAME in those class scopes. */
5917 while (scope
&& scope
!= outer_scope
&& scope
->kind
!= sk_namespace
)
5919 if (scope
->kind
== sk_class
)
5921 cxx_binding
*class_binding
;
5923 class_binding
= get_class_binding (name
, scope
);
5926 /* Thread this new class-scope binding onto the
5927 IDENTIFIER_BINDING list so that future lookups
5929 class_binding
->previous
= outer
;
5931 binding
->previous
= class_binding
;
5933 IDENTIFIER_BINDING (name
) = class_binding
;
5934 return class_binding
;
5937 /* If we are in a member template, the template parms of the member
5938 template are considered to be inside the scope of the containing
5939 class, but within G++ the class bindings are all pushed between the
5940 template parms and the function body. So if the outer binding is
5941 a template parm for the current scope, return it now rather than
5942 look for a class binding. */
5943 if (outer_scope
&& outer_scope
->kind
== sk_template_parms
5944 && binding_to_template_parms_of_scope_p (outer
, scope
))
5947 scope
= scope
->level_chain
;
5953 /* Return the innermost block-scope or class-scope value binding for
5954 NAME, or NULL_TREE if there is no such binding. */
5957 innermost_non_namespace_value (tree name
)
5959 cxx_binding
*binding
;
5960 binding
= outer_binding (name
, /*binding=*/NULL
, /*class_p=*/true);
5961 return binding
? binding
->value
: NULL_TREE
;
5964 /* Look up NAME in the current binding level and its superiors in the
5965 namespace of variables, functions and typedefs. Return a ..._DECL
5966 node of some kind representing its definition if there is only one
5967 such declaration, or return a TREE_LIST with all the overloaded
5968 definitions if there are many, or return 0 if it is undefined.
5969 Hidden name, either friend declaration or built-in function, are
5972 If PREFER_TYPE is > 0, we prefer TYPE_DECLs or namespaces.
5973 If PREFER_TYPE is > 1, we reject non-type decls (e.g. namespaces).
5974 Otherwise we prefer non-TYPE_DECLs.
5976 If NONCLASS is nonzero, bindings in class scopes are ignored. If
5977 BLOCK_P is false, bindings in block scopes are ignored. */
5980 lookup_name_real_1 (tree name
, int prefer_type
, int nonclass
, bool block_p
,
5981 int namespaces_only
, int flags
)
5984 tree val
= NULL_TREE
;
5986 query_oracle (name
);
5988 /* Conversion operators are handled specially because ordinary
5989 unqualified name lookup will not find template conversion
5991 if (IDENTIFIER_CONV_OP_P (name
))
5993 cp_binding_level
*level
;
5995 for (level
= current_binding_level
;
5996 level
&& level
->kind
!= sk_namespace
;
5997 level
= level
->level_chain
)
6002 /* A conversion operator can only be declared in a class
6004 if (level
->kind
!= sk_class
)
6007 /* Lookup the conversion operator in the class. */
6008 class_type
= level
->this_entity
;
6009 operators
= lookup_fnfields (class_type
, name
, /*protect=*/0);
6017 flags
|= lookup_flags (prefer_type
, namespaces_only
);
6019 /* First, look in non-namespace scopes. */
6021 if (current_class_type
== NULL_TREE
)
6024 if (block_p
|| !nonclass
)
6025 for (iter
= outer_binding (name
, NULL
, !nonclass
);
6027 iter
= outer_binding (name
, iter
, !nonclass
))
6031 /* Skip entities we don't want. */
6032 if (LOCAL_BINDING_P (iter
) ? !block_p
: nonclass
)
6035 /* If this is the kind of thing we're looking for, we're done. */
6036 if (qualify_lookup (iter
->value
, flags
))
6037 binding
= iter
->value
;
6038 else if ((flags
& LOOKUP_PREFER_TYPES
)
6039 && qualify_lookup (iter
->type
, flags
))
6040 binding
= iter
->type
;
6042 binding
= NULL_TREE
;
6046 if (TREE_CODE (binding
) == TYPE_DECL
&& DECL_HIDDEN_P (binding
))
6048 /* A non namespace-scope binding can only be hidden in the
6049 presence of a local class, due to friend declarations.
6051 In particular, consider:
6059 B* b; // error: B is hidden
6060 C* c; // OK, finds ::C
6063 B *b; // error: B is hidden
6064 C *c; // OK, finds ::C
6069 The standard says that "B" is a local class in "f"
6070 (but not nested within "A") -- but that name lookup
6071 for "B" does not find this declaration until it is
6072 declared directly with "f".
6078 If a friend declaration appears in a local class and
6079 the name specified is an unqualified name, a prior
6080 declaration is looked up without considering scopes
6081 that are outside the innermost enclosing non-class
6082 scope. For a friend function declaration, if there is
6083 no prior declaration, the program is ill-formed. For a
6084 friend class declaration, if there is no prior
6085 declaration, the class that is specified belongs to the
6086 innermost enclosing non-class scope, but if it is
6087 subsequently referenced, its name is not found by name
6088 lookup until a matching declaration is provided in the
6089 innermost enclosing nonclass scope.
6091 So just keep looking for a non-hidden binding.
6093 gcc_assert (TREE_CODE (binding
) == TYPE_DECL
);
6101 /* Now lookup in namespace scopes. */
6104 name_lookup
lookup (name
, flags
);
6105 if (lookup
.search_unqualified
6106 (current_decl_namespace (), current_binding_level
))
6110 /* If we have a single function from a using decl, pull it out. */
6111 if (val
&& TREE_CODE (val
) == OVERLOAD
&& !really_overloaded_fn (val
))
6112 val
= OVL_FUNCTION (val
);
6117 /* Wrapper for lookup_name_real_1. */
6120 lookup_name_real (tree name
, int prefer_type
, int nonclass
, bool block_p
,
6121 int namespaces_only
, int flags
)
6124 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
6125 ret
= lookup_name_real_1 (name
, prefer_type
, nonclass
, block_p
,
6126 namespaces_only
, flags
);
6127 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
6132 lookup_name_nonclass (tree name
)
6134 return lookup_name_real (name
, 0, 1, /*block_p=*/true, 0, 0);
6138 lookup_name (tree name
)
6140 return lookup_name_real (name
, 0, 0, /*block_p=*/true, 0, 0);
6144 lookup_name_prefer_type (tree name
, int prefer_type
)
6146 return lookup_name_real (name
, prefer_type
, 0, /*block_p=*/true, 0, 0);
6149 /* Look up NAME for type used in elaborated name specifier in
6150 the scopes given by SCOPE. SCOPE can be either TS_CURRENT or
6151 TS_WITHIN_ENCLOSING_NON_CLASS. Although not implied by the
6152 name, more scopes are checked if cleanup or template parameter
6153 scope is encountered.
6155 Unlike lookup_name_real, we make sure that NAME is actually
6156 declared in the desired scope, not from inheritance, nor using
6157 directive. For using declaration, there is DR138 still waiting
6158 to be resolved. Hidden name coming from an earlier friend
6159 declaration is also returned.
6161 A TYPE_DECL best matching the NAME is returned. Catching error
6162 and issuing diagnostics are caller's responsibility. */
6165 lookup_type_scope_1 (tree name
, tag_scope scope
)
6167 cxx_binding
*iter
= NULL
;
6168 tree val
= NULL_TREE
;
6169 cp_binding_level
*level
= NULL
;
6171 /* Look in non-namespace scope first. */
6172 if (current_binding_level
->kind
!= sk_namespace
)
6173 iter
= outer_binding (name
, NULL
, /*class_p=*/ true);
6174 for (; iter
; iter
= outer_binding (name
, iter
, /*class_p=*/ true))
6176 /* Check if this is the kind of thing we're looking for.
6177 If SCOPE is TS_CURRENT, also make sure it doesn't come from
6178 base class. For ITER->VALUE, we can simply use
6179 INHERITED_VALUE_BINDING_P. For ITER->TYPE, we have to use
6182 We check ITER->TYPE before ITER->VALUE in order to handle
6183 typedef struct C {} C;
6186 if (qualify_lookup (iter
->type
, LOOKUP_PREFER_TYPES
)
6187 && (scope
!= ts_current
6188 || LOCAL_BINDING_P (iter
)
6189 || DECL_CONTEXT (iter
->type
) == iter
->scope
->this_entity
))
6191 else if ((scope
!= ts_current
6192 || !INHERITED_VALUE_BINDING_P (iter
))
6193 && qualify_lookup (iter
->value
, LOOKUP_PREFER_TYPES
))
6200 /* Look in namespace scope. */
6202 level
= iter
->scope
;
6205 tree ns
= current_decl_namespace ();
6207 if (tree
*slot
= find_namespace_slot (ns
, name
))
6209 /* If this is the kind of thing we're looking for, we're done. */
6210 if (tree type
= MAYBE_STAT_TYPE (*slot
))
6211 if (qualify_lookup (type
, LOOKUP_PREFER_TYPES
))
6215 if (tree decl
= MAYBE_STAT_DECL (*slot
))
6216 if (qualify_lookup (decl
, LOOKUP_PREFER_TYPES
))
6219 level
= NAMESPACE_LEVEL (ns
);
6223 /* Type found, check if it is in the allowed scopes, ignoring cleanup
6224 and template parameter scopes. */
6227 cp_binding_level
*b
= current_binding_level
;
6233 if (b
->kind
== sk_cleanup
|| b
->kind
== sk_template_parms
6234 || b
->kind
== sk_function_parms
)
6236 else if (b
->kind
== sk_class
6237 && scope
== ts_within_enclosing_non_class
)
6247 /* Wrapper for lookup_type_scope_1. */
6250 lookup_type_scope (tree name
, tag_scope scope
)
6253 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
6254 ret
= lookup_type_scope_1 (name
, scope
);
6255 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
6259 /* Returns true iff DECL is a block-scope extern declaration of a function
6263 is_local_extern (tree decl
)
6265 cxx_binding
*binding
;
6267 /* For functions, this is easy. */
6268 if (TREE_CODE (decl
) == FUNCTION_DECL
)
6269 return DECL_LOCAL_FUNCTION_P (decl
);
6273 if (!current_function_decl
)
6276 /* For variables, this is not easy. We need to look at the binding stack
6277 for the identifier to see whether the decl we have is a local. */
6278 for (binding
= IDENTIFIER_BINDING (DECL_NAME (decl
));
6279 binding
&& binding
->scope
->kind
!= sk_namespace
;
6280 binding
= binding
->previous
)
6281 if (binding
->value
== decl
)
6282 return LOCAL_BINDING_P (binding
);
6287 /* The type TYPE is being declared. If it is a class template, or a
6288 specialization of a class template, do any processing required and
6289 perform error-checking. If IS_FRIEND is nonzero, this TYPE is
6290 being declared a friend. B is the binding level at which this TYPE
6293 Returns the TYPE_DECL for TYPE, which may have been altered by this
6297 maybe_process_template_type_declaration (tree type
, int is_friend
,
6298 cp_binding_level
*b
)
6300 tree decl
= TYPE_NAME (type
);
6302 if (processing_template_parmlist
)
6303 /* You can't declare a new template type in a template parameter
6304 list. But, you can declare a non-template type:
6306 template <class A*> struct S;
6308 is a forward-declaration of `A'. */
6310 else if (b
->kind
== sk_namespace
6311 && current_binding_level
->kind
!= sk_namespace
)
6312 /* If this new type is being injected into a containing scope,
6313 then it's not a template type. */
6317 gcc_assert (MAYBE_CLASS_TYPE_P (type
)
6318 || TREE_CODE (type
) == ENUMERAL_TYPE
);
6320 if (processing_template_decl
)
6322 /* This may change after the call to
6323 push_template_decl_real, but we want the original value. */
6324 tree name
= DECL_NAME (decl
);
6326 decl
= push_template_decl_real (decl
, is_friend
);
6327 if (decl
== error_mark_node
)
6328 return error_mark_node
;
6330 /* If the current binding level is the binding level for the
6331 template parameters (see the comment in
6332 begin_template_parm_list) and the enclosing level is a class
6333 scope, and we're not looking at a friend, push the
6334 declaration of the member class into the class scope. In the
6335 friend case, push_template_decl will already have put the
6336 friend into global scope, if appropriate. */
6337 if (TREE_CODE (type
) != ENUMERAL_TYPE
6338 && !is_friend
&& b
->kind
== sk_template_parms
6339 && b
->level_chain
->kind
== sk_class
)
6341 finish_member_declaration (CLASSTYPE_TI_TEMPLATE (type
));
6343 if (!COMPLETE_TYPE_P (current_class_type
))
6345 maybe_add_class_template_decl_list (current_class_type
,
6346 type
, /*friend_p=*/0);
6347 /* Put this UTD in the table of UTDs for the class. */
6348 if (CLASSTYPE_NESTED_UTDS (current_class_type
) == NULL
)
6349 CLASSTYPE_NESTED_UTDS (current_class_type
) =
6350 binding_table_new (SCOPE_DEFAULT_HT_SIZE
);
6352 binding_table_insert
6353 (CLASSTYPE_NESTED_UTDS (current_class_type
), name
, type
);
6362 /* Push a tag name NAME for struct/class/union/enum type TYPE. In case
6363 that the NAME is a class template, the tag is processed but not pushed.
6365 The pushed scope depend on the SCOPE parameter:
6366 - When SCOPE is TS_CURRENT, put it into the inner-most non-sk_cleanup
6368 - When SCOPE is TS_GLOBAL, put it in the inner-most non-class and
6369 non-template-parameter scope. This case is needed for forward
6371 - When SCOPE is TS_WITHIN_ENCLOSING_NON_CLASS, this is similar to
6372 TS_GLOBAL case except that names within template-parameter scopes
6373 are not pushed at all.
6375 Returns TYPE upon success and ERROR_MARK_NODE otherwise. */
6378 do_pushtag (tree name
, tree type
, tag_scope scope
)
6382 cp_binding_level
*b
= current_binding_level
;
6383 while (/* Cleanup scopes are not scopes from the point of view of
6385 b
->kind
== sk_cleanup
6386 /* Neither are function parameter scopes. */
6387 || b
->kind
== sk_function_parms
6388 /* Neither are the scopes used to hold template parameters
6389 for an explicit specialization. For an ordinary template
6390 declaration, these scopes are not scopes from the point of
6391 view of the language. */
6392 || (b
->kind
== sk_template_parms
6393 && (b
->explicit_spec_p
|| scope
== ts_global
))
6394 || (b
->kind
== sk_class
6395 && (scope
!= ts_current
6396 /* We may be defining a new type in the initializer
6397 of a static member variable. We allow this when
6398 not pedantic, and it is particularly useful for
6399 type punning via an anonymous union. */
6400 || COMPLETE_TYPE_P (b
->this_entity
))))
6403 gcc_assert (identifier_p (name
));
6405 /* Do C++ gratuitous typedefing. */
6406 if (identifier_type_value_1 (name
) != type
)
6410 tree context
= TYPE_CONTEXT (type
);
6414 tree cs
= current_scope ();
6416 if (scope
== ts_current
6417 || (cs
&& TREE_CODE (cs
) == FUNCTION_DECL
))
6419 else if (cs
&& TYPE_P (cs
))
6420 /* When declaring a friend class of a local class, we want
6421 to inject the newly named class into the scope
6422 containing the local class, not the namespace
6424 context
= decl_function_context (get_type_decl (cs
));
6427 context
= current_namespace
;
6429 if (b
->kind
== sk_class
6430 || (b
->kind
== sk_template_parms
6431 && b
->level_chain
->kind
== sk_class
))
6434 tdef
= create_implicit_typedef (name
, type
);
6435 DECL_CONTEXT (tdef
) = FROB_CONTEXT (context
);
6436 if (scope
== ts_within_enclosing_non_class
)
6438 /* This is a friend. Make this TYPE_DECL node hidden from
6439 ordinary name lookup. Its corresponding TEMPLATE_DECL
6440 will be marked in push_template_decl_real. */
6441 retrofit_lang_decl (tdef
);
6442 DECL_ANTICIPATED (tdef
) = 1;
6443 DECL_FRIEND_P (tdef
) = 1;
6446 decl
= maybe_process_template_type_declaration
6447 (type
, scope
== ts_within_enclosing_non_class
, b
);
6448 if (decl
== error_mark_node
)
6451 if (b
->kind
== sk_class
)
6453 if (!TYPE_BEING_DEFINED (current_class_type
)
6454 && !LAMBDA_TYPE_P (type
))
6455 return error_mark_node
;
6457 if (!PROCESSING_REAL_TEMPLATE_DECL_P ())
6458 /* Put this TYPE_DECL on the TYPE_FIELDS list for the
6459 class. But if it's a member template class, we want
6460 the TEMPLATE_DECL, not the TYPE_DECL, so this is done
6462 finish_member_declaration (decl
);
6464 pushdecl_class_level (decl
);
6466 else if (b
->kind
!= sk_template_parms
)
6468 decl
= do_pushdecl_with_scope (decl
, b
, /*is_friend=*/false);
6469 if (decl
== error_mark_node
)
6472 if (DECL_CONTEXT (decl
) == std_node
6473 && init_list_identifier
== DECL_NAME (TYPE_NAME (type
))
6474 && !CLASSTYPE_TEMPLATE_INFO (type
))
6476 error ("declaration of std::initializer_list does not match "
6477 "#include <initializer_list>, isn't a template");
6478 return error_mark_node
;
6483 set_identifier_type_value_with_scope (name
, tdef
, b
);
6485 TYPE_CONTEXT (type
) = DECL_CONTEXT (decl
);
6487 /* If this is a local class, keep track of it. We need this
6488 information for name-mangling, and so that it is possible to
6489 find all function definitions in a translation unit in a
6490 convenient way. (It's otherwise tricky to find a member
6491 function definition it's only pointed to from within a local
6493 if (TYPE_FUNCTION_SCOPE_P (type
))
6495 if (processing_template_decl
)
6497 /* Push a DECL_EXPR so we call pushtag at the right time in
6498 template instantiation rather than in some nested context. */
6499 add_decl_expr (decl
);
6501 /* Lambdas use LAMBDA_EXPR_DISCRIMINATOR instead. */
6502 else if (!LAMBDA_TYPE_P (type
))
6503 vec_safe_push (local_classes
, type
);
6507 if (b
->kind
== sk_class
6508 && !COMPLETE_TYPE_P (current_class_type
))
6510 maybe_add_class_template_decl_list (current_class_type
,
6511 type
, /*friend_p=*/0);
6513 if (CLASSTYPE_NESTED_UTDS (current_class_type
) == NULL
)
6514 CLASSTYPE_NESTED_UTDS (current_class_type
)
6515 = binding_table_new (SCOPE_DEFAULT_HT_SIZE
);
6517 binding_table_insert
6518 (CLASSTYPE_NESTED_UTDS (current_class_type
), name
, type
);
6521 decl
= TYPE_NAME (type
);
6522 gcc_assert (TREE_CODE (decl
) == TYPE_DECL
);
6524 /* Set type visibility now if this is a forward declaration. */
6525 TREE_PUBLIC (decl
) = 1;
6526 determine_visibility (decl
);
6531 /* Wrapper for do_pushtag. */
6534 pushtag (tree name
, tree type
, tag_scope scope
)
6537 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
6538 ret
= do_pushtag (name
, type
, scope
);
6539 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
6544 /* Subroutines for reverting temporarily to top-level for instantiation
6545 of templates and such. We actually need to clear out the class- and
6546 local-value slots of all identifiers, so that only the global values
6547 are at all visible. Simply setting current_binding_level to the global
6548 scope isn't enough, because more binding levels may be pushed. */
6549 struct saved_scope
*scope_chain
;
6551 /* Return true if ID has not already been marked. */
6554 store_binding_p (tree id
)
6556 if (!id
|| !IDENTIFIER_BINDING (id
))
6559 if (IDENTIFIER_MARKED (id
))
6565 /* Add an appropriate binding to *OLD_BINDINGS which needs to already
6566 have enough space reserved. */
6569 store_binding (tree id
, vec
<cxx_saved_binding
, va_gc
> **old_bindings
)
6571 cxx_saved_binding saved
;
6573 gcc_checking_assert (store_binding_p (id
));
6575 IDENTIFIER_MARKED (id
) = 1;
6577 saved
.identifier
= id
;
6578 saved
.binding
= IDENTIFIER_BINDING (id
);
6579 saved
.real_type_value
= REAL_IDENTIFIER_TYPE_VALUE (id
);
6580 (*old_bindings
)->quick_push (saved
);
6581 IDENTIFIER_BINDING (id
) = NULL
;
6585 store_bindings (tree names
, vec
<cxx_saved_binding
, va_gc
> **old_bindings
)
6587 static vec
<tree
> bindings_need_stored
;
6591 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
6592 for (t
= names
; t
; t
= TREE_CHAIN (t
))
6594 if (TREE_CODE (t
) == TREE_LIST
)
6595 id
= TREE_PURPOSE (t
);
6599 if (store_binding_p (id
))
6600 bindings_need_stored
.safe_push (id
);
6602 if (!bindings_need_stored
.is_empty ())
6604 vec_safe_reserve_exact (*old_bindings
, bindings_need_stored
.length ());
6605 for (i
= 0; bindings_need_stored
.iterate (i
, &id
); ++i
)
6607 /* We can apparently have duplicates in NAMES. */
6608 if (store_binding_p (id
))
6609 store_binding (id
, old_bindings
);
6611 bindings_need_stored
.truncate (0);
6613 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
6616 /* Like store_bindings, but NAMES is a vector of cp_class_binding
6617 objects, rather than a TREE_LIST. */
6620 store_class_bindings (vec
<cp_class_binding
, va_gc
> *names
,
6621 vec
<cxx_saved_binding
, va_gc
> **old_bindings
)
6623 static vec
<tree
> bindings_need_stored
;
6625 cp_class_binding
*cb
;
6627 for (i
= 0; vec_safe_iterate (names
, i
, &cb
); ++i
)
6628 if (store_binding_p (cb
->identifier
))
6629 bindings_need_stored
.safe_push (cb
->identifier
);
6630 if (!bindings_need_stored
.is_empty ())
6633 vec_safe_reserve_exact (*old_bindings
, bindings_need_stored
.length ());
6634 for (i
= 0; bindings_need_stored
.iterate (i
, &id
); ++i
)
6635 store_binding (id
, old_bindings
);
6636 bindings_need_stored
.truncate (0);
6640 /* A chain of saved_scope structures awaiting reuse. */
6642 static GTY((deletable
)) struct saved_scope
*free_saved_scope
;
6645 do_push_to_top_level (void)
6647 struct saved_scope
*s
;
6648 cp_binding_level
*b
;
6649 cxx_saved_binding
*sb
;
6653 /* Reuse or create a new structure for this saved scope. */
6654 if (free_saved_scope
!= NULL
)
6656 s
= free_saved_scope
;
6657 free_saved_scope
= s
->prev
;
6659 vec
<cxx_saved_binding
, va_gc
> *old_bindings
= s
->old_bindings
;
6660 memset (s
, 0, sizeof (*s
));
6661 /* Also reuse the structure's old_bindings vector. */
6662 vec_safe_truncate (old_bindings
, 0);
6663 s
->old_bindings
= old_bindings
;
6666 s
= ggc_cleared_alloc
<saved_scope
> ();
6668 b
= scope_chain
? current_binding_level
: 0;
6670 /* If we're in the middle of some function, save our state. */
6674 push_function_context ();
6679 if (scope_chain
&& previous_class_level
)
6680 store_class_bindings (previous_class_level
->class_shadowed
,
6683 /* Have to include the global scope, because class-scope decls
6684 aren't listed anywhere useful. */
6685 for (; b
; b
= b
->level_chain
)
6689 /* Template IDs are inserted into the global level. If they were
6690 inserted into namespace level, finish_file wouldn't find them
6691 when doing pending instantiations. Therefore, don't stop at
6692 namespace level, but continue until :: . */
6693 if (global_scope_p (b
))
6696 store_bindings (b
->names
, &s
->old_bindings
);
6697 /* We also need to check class_shadowed to save class-level type
6698 bindings, since pushclass doesn't fill in b->names. */
6699 if (b
->kind
== sk_class
)
6700 store_class_bindings (b
->class_shadowed
, &s
->old_bindings
);
6702 /* Unwind type-value slots back to top level. */
6703 for (t
= b
->type_shadowed
; t
; t
= TREE_CHAIN (t
))
6704 SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (t
), TREE_VALUE (t
));
6707 FOR_EACH_VEC_SAFE_ELT (s
->old_bindings
, i
, sb
)
6708 IDENTIFIER_MARKED (sb
->identifier
) = 0;
6710 s
->prev
= scope_chain
;
6712 s
->need_pop_function_context
= need_pop
;
6713 s
->function_decl
= current_function_decl
;
6714 s
->unevaluated_operand
= cp_unevaluated_operand
;
6715 s
->inhibit_evaluation_warnings
= c_inhibit_evaluation_warnings
;
6716 s
->x_stmt_tree
.stmts_are_full_exprs_p
= true;
6719 current_function_decl
= NULL_TREE
;
6720 vec_alloc (current_lang_base
, 10);
6721 current_lang_name
= lang_name_cplusplus
;
6722 current_namespace
= global_namespace
;
6723 push_class_stack ();
6724 cp_unevaluated_operand
= 0;
6725 c_inhibit_evaluation_warnings
= 0;
6729 do_pop_from_top_level (void)
6731 struct saved_scope
*s
= scope_chain
;
6732 cxx_saved_binding
*saved
;
6735 /* Clear out class-level bindings cache. */
6736 if (previous_class_level
)
6737 invalidate_class_lookup_cache ();
6740 current_lang_base
= 0;
6742 scope_chain
= s
->prev
;
6743 FOR_EACH_VEC_SAFE_ELT (s
->old_bindings
, i
, saved
)
6745 tree id
= saved
->identifier
;
6747 IDENTIFIER_BINDING (id
) = saved
->binding
;
6748 SET_IDENTIFIER_TYPE_VALUE (id
, saved
->real_type_value
);
6751 /* If we were in the middle of compiling a function, restore our
6753 if (s
->need_pop_function_context
)
6754 pop_function_context ();
6755 current_function_decl
= s
->function_decl
;
6756 cp_unevaluated_operand
= s
->unevaluated_operand
;
6757 c_inhibit_evaluation_warnings
= s
->inhibit_evaluation_warnings
;
6759 /* Make this saved_scope structure available for reuse by
6760 push_to_top_level. */
6761 s
->prev
= free_saved_scope
;
6762 free_saved_scope
= s
;
6765 /* Push into the scope of the namespace NS, even if it is deeply
6766 nested within another namespace. */
6769 do_push_nested_namespace (tree ns
)
6771 if (ns
== global_namespace
)
6772 do_push_to_top_level ();
6775 do_push_nested_namespace (CP_DECL_CONTEXT (ns
));
6777 (find_namespace_value (current_namespace
, DECL_NAME (ns
)) == ns
);
6778 resume_scope (NAMESPACE_LEVEL (ns
));
6779 current_namespace
= ns
;
6783 /* Pop back from the scope of the namespace NS, which was previously
6784 entered with push_nested_namespace. */
6787 do_pop_nested_namespace (tree ns
)
6789 while (ns
!= global_namespace
)
6791 ns
= CP_DECL_CONTEXT (ns
);
6792 current_namespace
= ns
;
6796 do_pop_from_top_level ();
6799 /* Add TARGET to USINGS, if it does not already exist there.
6800 We used to build the complete graph of usings at this point, from
6801 the POV of the source namespaces. Now we build that as we perform
6802 the unqualified search. */
6805 add_using_namespace (vec
<tree
, va_gc
> *&usings
, tree target
)
6808 for (unsigned ix
= usings
->length (); ix
--;)
6809 if ((*usings
)[ix
] == target
)
6812 vec_safe_push (usings
, target
);
6815 /* Tell the debug system of a using directive. */
6818 emit_debug_info_using_namespace (tree from
, tree target
, bool implicit
)
6820 /* Emit debugging info. */
6821 tree context
= from
!= global_namespace
? from
: NULL_TREE
;
6822 debug_hooks
->imported_module_or_decl (target
, NULL_TREE
, context
, false,
6826 /* Process a namespace-scope using directive. */
6829 finish_namespace_using_directive (tree target
, tree attribs
)
6831 gcc_checking_assert (namespace_bindings_p ());
6832 if (target
== error_mark_node
)
6835 add_using_namespace (DECL_NAMESPACE_USING (current_namespace
),
6836 ORIGINAL_NAMESPACE (target
));
6837 emit_debug_info_using_namespace (current_namespace
,
6838 ORIGINAL_NAMESPACE (target
), false);
6840 if (attribs
== error_mark_node
)
6843 for (tree a
= attribs
; a
; a
= TREE_CHAIN (a
))
6845 tree name
= get_attribute_name (a
);
6846 if (is_attribute_p ("strong", name
))
6848 warning (0, "strong using directive no longer supported");
6849 if (CP_DECL_CONTEXT (target
) == current_namespace
)
6850 inform (DECL_SOURCE_LOCATION (target
),
6851 "you may use an inline namespace instead");
6854 warning (OPT_Wattributes
, "%qD attribute directive ignored", name
);
6858 /* Process a function-scope using-directive. */
6861 finish_local_using_directive (tree target
, tree attribs
)
6863 gcc_checking_assert (local_bindings_p ());
6864 if (target
== error_mark_node
)
6868 warning (OPT_Wattributes
, "attributes ignored on local using directive");
6870 add_stmt (build_stmt (input_location
, USING_STMT
, target
));
6872 add_using_namespace (current_binding_level
->using_directives
,
6873 ORIGINAL_NAMESPACE (target
));
6876 /* Pushes X into the global namespace. */
6879 pushdecl_top_level (tree x
, bool is_friend
)
6881 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
6882 do_push_to_top_level ();
6883 x
= pushdecl_namespace_level (x
, is_friend
);
6884 do_pop_from_top_level ();
6885 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
6889 /* Pushes X into the global namespace and calls cp_finish_decl to
6890 register the variable, initializing it with INIT. */
6893 pushdecl_top_level_and_finish (tree x
, tree init
)
6895 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
6896 do_push_to_top_level ();
6897 x
= pushdecl_namespace_level (x
, false);
6898 cp_finish_decl (x
, init
, false, NULL_TREE
, 0);
6899 do_pop_from_top_level ();
6900 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
6904 /* Enter the namespaces from current_namerspace to NS. */
6907 push_inline_namespaces (tree ns
)
6910 if (ns
!= current_namespace
)
6912 gcc_assert (ns
!= global_namespace
);
6913 count
+= push_inline_namespaces (CP_DECL_CONTEXT (ns
));
6914 resume_scope (NAMESPACE_LEVEL (ns
));
6915 current_namespace
= ns
;
6921 /* Push into the scope of the NAME namespace. If NAME is NULL_TREE,
6922 then we enter an anonymous namespace. If MAKE_INLINE is true, then
6923 we create an inline namespace (it is up to the caller to check upon
6924 redefinition). Return the number of namespaces entered. */
6927 push_namespace (tree name
, bool make_inline
)
6929 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
6932 /* We should not get here if the global_namespace is not yet constructed
6933 nor if NAME designates the global namespace: The global scope is
6934 constructed elsewhere. */
6935 gcc_checking_assert (global_namespace
!= NULL
&& name
!= global_identifier
);
6937 tree ns
= NULL_TREE
;
6939 name_lookup
lookup (name
, 0);
6940 if (!lookup
.search_qualified (current_namespace
, /*usings=*/false))
6942 else if (TREE_CODE (lookup
.value
) != NAMESPACE_DECL
)
6944 else if (tree dna
= DECL_NAMESPACE_ALIAS (lookup
.value
))
6946 /* A namespace alias is not allowed here, but if the alias
6947 is for a namespace also inside the current scope,
6948 accept it with a diagnostic. That's better than dying
6950 if (is_nested_namespace (current_namespace
, CP_DECL_CONTEXT (dna
)))
6952 error ("namespace alias %qD not allowed here, "
6953 "assuming %qD", lookup
.value
, dna
);
6961 bool new_ns
= false;
6963 /* DR2061. NS might be a member of an inline namespace. We
6964 need to push into those namespaces. */
6965 count
+= push_inline_namespaces (CP_DECL_CONTEXT (ns
));
6968 ns
= build_lang_decl (NAMESPACE_DECL
, name
, void_type_node
);
6969 SCOPE_DEPTH (ns
) = SCOPE_DEPTH (current_namespace
) + 1;
6970 if (!SCOPE_DEPTH (ns
))
6971 /* We only allow depth 255. */
6972 sorry ("cannot nest more than %d namespaces",
6973 SCOPE_DEPTH (current_namespace
));
6974 DECL_CONTEXT (ns
) = FROB_CONTEXT (current_namespace
);
6977 if (pushdecl (ns
) == error_mark_node
)
6983 SET_DECL_ASSEMBLER_NAME (ns
, anon_identifier
);
6986 add_using_namespace (DECL_NAMESPACE_USING (current_namespace
),
6989 else if (TREE_PUBLIC (current_namespace
))
6990 TREE_PUBLIC (ns
) = 1;
6994 DECL_NAMESPACE_INLINE_P (ns
) = true;
6995 vec_safe_push (DECL_NAMESPACE_INLINEES (current_namespace
), ns
);
6998 if (!name
|| make_inline
)
6999 emit_debug_info_using_namespace (current_namespace
, ns
, true);
7005 if (make_inline
&& !DECL_NAMESPACE_INLINE_P (ns
))
7007 error ("inline namespace must be specified at initial definition");
7008 inform (DECL_SOURCE_LOCATION (ns
), "%qD defined here", ns
);
7011 begin_scope (sk_namespace
, ns
);
7013 resume_scope (NAMESPACE_LEVEL (ns
));
7014 current_namespace
= ns
;
7018 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
7022 /* Pop from the scope of the current namespace. */
7025 pop_namespace (void)
7027 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
7029 gcc_assert (current_namespace
!= global_namespace
);
7030 current_namespace
= CP_DECL_CONTEXT (current_namespace
);
7031 /* The binding level is not popped, as it might be re-opened later. */
7034 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
7037 /* External entry points for do_{push_to/pop_from}_top_level. */
7040 push_to_top_level (void)
7042 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
7043 do_push_to_top_level ();
7044 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
7048 pop_from_top_level (void)
7050 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
7051 do_pop_from_top_level ();
7052 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
7055 /* External entry points for do_{push,pop}_nested_namespace. */
7058 push_nested_namespace (tree ns
)
7060 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
7061 do_push_nested_namespace (ns
);
7062 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
7066 pop_nested_namespace (tree ns
)
7068 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
7069 gcc_assert (current_namespace
== ns
);
7070 do_pop_nested_namespace (ns
);
7071 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
7074 /* Pop off extraneous binding levels left over due to syntax errors.
7075 We don't pop past namespaces, as they might be valid. */
7078 pop_everything (void)
7080 if (ENABLE_SCOPE_CHECKING
)
7081 verbatim ("XXX entering pop_everything ()\n");
7082 while (!namespace_bindings_p ())
7084 if (current_binding_level
->kind
== sk_class
)
7085 pop_nested_class ();
7089 if (ENABLE_SCOPE_CHECKING
)
7090 verbatim ("XXX leaving pop_everything ()\n");
7093 /* Emit debugging information for using declarations and directives.
7094 If input tree is overloaded fn then emit debug info for all
7098 cp_emit_debug_info_for_using (tree t
, tree context
)
7100 /* Don't try to emit any debug information if we have errors. */
7104 /* Ignore this FUNCTION_DECL if it refers to a builtin declaration
7105 of a builtin function. */
7106 if (TREE_CODE (t
) == FUNCTION_DECL
7107 && DECL_EXTERNAL (t
)
7108 && DECL_BUILT_IN (t
))
7111 /* Do not supply context to imported_module_or_decl, if
7112 it is a global namespace. */
7113 if (context
== global_namespace
)
7114 context
= NULL_TREE
;
7116 t
= MAYBE_BASELINK_FUNCTIONS (t
);
7118 /* FIXME: Handle TEMPLATE_DECLs. */
7119 for (lkp_iterator
iter (t
); iter
; ++iter
)
7122 if (TREE_CODE (fn
) != TEMPLATE_DECL
)
7124 if (building_stmt_list_p ())
7125 add_stmt (build_stmt (input_location
, USING_STMT
, fn
));
7127 debug_hooks
->imported_module_or_decl (fn
, NULL_TREE
, context
,
7133 #include "gt-cp-name-lookup.h"