1 /* Definitions for C++ name lookup routines.
2 Copyright (C) 2003-2018 Free Software Foundation, Inc.
3 Contributed by Gabriel Dos Reis <gdr@integrable-solutions.net>
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3, or (at your option)
12 GCC is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING3. If not see
19 <http://www.gnu.org/licenses/>. */
22 #define INCLUDE_UNIQUE_PTR
24 #include "coretypes.h"
27 #include "stringpool.h"
28 #include "print-tree.h"
31 #include "c-family/c-pragma.h"
33 #include "gcc-rich-location.h"
34 #include "spellcheck-tree.h"
36 #include "c-family/name-hint.h"
37 #include "c-family/known-headers.h"
38 #include "c-family/c-spellcheck.h"
40 static cxx_binding
*cxx_binding_make (tree value
, tree type
);
41 static cp_binding_level
*innermost_nonclass_level (void);
42 static void set_identifier_type_value_with_scope (tree id
, tree decl
,
44 static bool maybe_suggest_missing_std_header (location_t location
, tree name
);
46 /* Create an overload suitable for recording an artificial TYPE_DECL
47 and another decl. We use this machanism to implement the struct
48 stat hack within a namespace. It'd be nice to use it everywhere. */
50 #define STAT_HACK_P(N) ((N) && TREE_CODE (N) == OVERLOAD && OVL_LOOKUP_P (N))
51 #define STAT_TYPE(N) TREE_TYPE (N)
52 #define STAT_DECL(N) OVL_FUNCTION (N)
53 #define MAYBE_STAT_DECL(N) (STAT_HACK_P (N) ? STAT_DECL (N) : N)
54 #define MAYBE_STAT_TYPE(N) (STAT_HACK_P (N) ? STAT_TYPE (N) : NULL_TREE)
56 /* Create a STAT_HACK node with DECL as the value binding and TYPE as
60 stat_hack (tree decl
= NULL_TREE
, tree type
= NULL_TREE
)
62 tree result
= make_node (OVERLOAD
);
64 /* Mark this as a lookup, so we can tell this is a stat hack. */
65 OVL_LOOKUP_P (result
) = true;
66 STAT_DECL (result
) = decl
;
67 STAT_TYPE (result
) = type
;
71 /* Create a local binding level for NAME. */
74 create_local_binding (cp_binding_level
*level
, tree name
)
76 cxx_binding
*binding
= cxx_binding_make (NULL
, NULL
);
78 INHERITED_VALUE_BINDING_P (binding
) = false;
79 LOCAL_BINDING_P (binding
) = true;
80 binding
->scope
= level
;
81 binding
->previous
= IDENTIFIER_BINDING (name
);
83 IDENTIFIER_BINDING (name
) = binding
;
88 /* Find the binding for NAME in namespace NS. If CREATE_P is true,
89 make an empty binding if there wasn't one. */
92 find_namespace_slot (tree ns
, tree name
, bool create_p
= false)
94 tree
*slot
= DECL_NAMESPACE_BINDINGS (ns
)
95 ->find_slot_with_hash (name
, name
? IDENTIFIER_HASH_VALUE (name
) : 0,
96 create_p
? INSERT
: NO_INSERT
);
101 find_namespace_value (tree ns
, tree name
)
103 tree
*b
= find_namespace_slot (ns
, name
);
105 return b
? MAYBE_STAT_DECL (*b
) : NULL_TREE
;
108 /* Add DECL to the list of things declared in B. */
111 add_decl_to_level (cp_binding_level
*b
, tree decl
)
113 gcc_assert (b
->kind
!= sk_class
);
115 /* Make sure we don't create a circular list. xref_tag can end
116 up pushing the same artificial decl more than once. We
117 should have already detected that in update_binding. */
118 gcc_assert (b
->names
!= decl
);
120 /* We build up the list in reverse order, and reverse it later if
122 TREE_CHAIN (decl
) = b
->names
;
125 /* If appropriate, add decl to separate list of statics. We
126 include extern variables because they might turn out to be
127 static later. It's OK for this list to contain a few false
129 if (b
->kind
== sk_namespace
131 && (TREE_STATIC (decl
) || DECL_EXTERNAL (decl
)))
132 || (TREE_CODE (decl
) == FUNCTION_DECL
133 && (!TREE_PUBLIC (decl
)
134 || decl_anon_ns_mem_p (decl
)
135 || DECL_DECLARED_INLINE_P (decl
)))))
136 vec_safe_push (static_decls
, decl
);
139 /* Find the binding for NAME in the local binding level B. */
142 find_local_binding (cp_binding_level
*b
, tree name
)
144 if (cxx_binding
*binding
= IDENTIFIER_BINDING (name
))
145 for (;; b
= b
->level_chain
)
147 if (binding
->scope
== b
148 && !(VAR_P (binding
->value
)
149 && DECL_DEAD_FOR_LOCAL (binding
->value
)))
152 /* Cleanup contours are transparent to the language. */
153 if (b
->kind
!= sk_cleanup
)
162 typedef std::pair
<tree
, tree
> using_pair
;
163 typedef vec
<using_pair
, va_heap
, vl_embed
> using_queue
;
166 tree name
; /* The identifier being looked for. */
167 tree value
; /* A (possibly ambiguous) set of things found. */
168 tree type
; /* A type that has been found. */
169 int flags
; /* Lookup flags. */
170 bool deduping
; /* Full deduping is needed because using declarations
172 vec
<tree
, va_heap
, vl_embed
> *scopes
;
173 name_lookup
*previous
; /* Previously active lookup. */
176 /* Marked scope stack for outermost name lookup. */
177 static vec
<tree
, va_heap
, vl_embed
> *shared_scopes
;
178 /* Currently active lookup. */
179 static name_lookup
*active
;
182 name_lookup (tree n
, int f
= 0)
183 : name (n
), value (NULL_TREE
), type (NULL_TREE
), flags (f
),
184 deduping (false), scopes (NULL
), previous (NULL
)
193 private: /* Uncopyable, unmovable, unassignable. I am a rock. */
194 name_lookup (const name_lookup
&);
195 name_lookup
&operator= (const name_lookup
&);
198 static bool seen_p (tree scope
)
200 return LOOKUP_SEEN_P (scope
);
202 static bool found_p (tree scope
)
204 return LOOKUP_FOUND_P (scope
);
207 void mark_seen (tree scope
); /* Mark and add to scope vector. */
208 static void mark_found (tree scope
)
210 gcc_checking_assert (seen_p (scope
));
211 LOOKUP_FOUND_P (scope
) = true;
213 bool see_and_mark (tree scope
)
215 bool ret
= seen_p (scope
);
220 bool find_and_mark (tree scope
);
223 void preserve_state ();
224 void restore_state ();
227 static tree
ambiguous (tree thing
, tree current
);
228 void add_overload (tree fns
);
229 void add_value (tree new_val
);
230 void add_type (tree new_type
);
231 bool process_binding (tree val_bind
, tree type_bind
);
233 /* Look in only namespace. */
234 bool search_namespace_only (tree scope
);
235 /* Look in namespace and its (recursive) inlines. Ignore using
236 directives. Return true if something found (inc dups). */
237 bool search_namespace (tree scope
);
238 /* Look in the using directives of namespace + inlines using
239 qualified lookup rules. */
240 bool search_usings (tree scope
);
243 using_queue
*queue_namespace (using_queue
*queue
, int depth
, tree scope
);
244 using_queue
*do_queue_usings (using_queue
*queue
, int depth
,
245 vec
<tree
, va_gc
> *usings
);
246 using_queue
*queue_usings (using_queue
*queue
, int depth
,
247 vec
<tree
, va_gc
> *usings
)
250 queue
= do_queue_usings (queue
, depth
, usings
);
257 void adl_expr (tree
);
258 void adl_type (tree
);
259 void adl_template_arg (tree
);
260 void adl_class (tree
);
261 void adl_bases (tree
);
262 void adl_class_only (tree
);
263 void adl_namespace (tree
);
264 void adl_namespace_only (tree
);
267 /* Search namespace + inlines + maybe usings as qualified lookup. */
268 bool search_qualified (tree scope
, bool usings
= true);
270 /* Search namespace + inlines + usings as unqualified lookup. */
271 bool search_unqualified (tree scope
, cp_binding_level
*);
273 /* ADL lookup of ARGS. */
274 tree
search_adl (tree fns
, vec
<tree
, va_gc
> *args
);
277 /* Scope stack shared by all outermost lookups. This avoids us
278 allocating and freeing on every single lookup. */
279 vec
<tree
, va_heap
, vl_embed
> *name_lookup::shared_scopes
;
281 /* Currently active lookup. */
282 name_lookup
*name_lookup::active
;
284 /* Name lookup is recursive, becase ADL can cause template
285 instatiation. This is of course a rare event, so we optimize for
286 it not happening. When we discover an active name-lookup, which
287 must be an ADL lookup, we need to unmark the marked scopes and also
288 unmark the lookup we might have been accumulating. */
291 name_lookup::preserve_state ()
296 unsigned length
= vec_safe_length (previous
->scopes
);
297 vec_safe_reserve (previous
->scopes
, length
* 2);
298 for (unsigned ix
= length
; ix
--;)
300 tree decl
= (*previous
->scopes
)[ix
];
302 gcc_checking_assert (LOOKUP_SEEN_P (decl
));
303 LOOKUP_SEEN_P (decl
) = false;
305 /* Preserve the FOUND_P state on the interrupted lookup's
307 if (LOOKUP_FOUND_P (decl
))
309 LOOKUP_FOUND_P (decl
) = false;
310 previous
->scopes
->quick_push (decl
);
314 /* Unmark the outer partial lookup. */
315 if (previous
->deduping
)
316 lookup_mark (previous
->value
, false);
319 scopes
= shared_scopes
;
323 /* Restore the marking state of a lookup we interrupted. */
326 name_lookup::restore_state ()
329 lookup_mark (value
, false);
331 /* Unmark and empty this lookup's scope stack. */
332 for (unsigned ix
= vec_safe_length (scopes
); ix
--;)
334 tree decl
= scopes
->pop ();
335 gcc_checking_assert (LOOKUP_SEEN_P (decl
));
336 LOOKUP_SEEN_P (decl
) = false;
337 LOOKUP_FOUND_P (decl
) = false;
345 unsigned length
= vec_safe_length (previous
->scopes
);
346 for (unsigned ix
= 0; ix
!= length
; ix
++)
348 tree decl
= (*previous
->scopes
)[ix
];
349 if (LOOKUP_SEEN_P (decl
))
351 /* The remainder of the scope stack must be recording
352 FOUND_P decls, which we want to pop off. */
355 tree decl
= previous
->scopes
->pop ();
356 gcc_checking_assert (LOOKUP_SEEN_P (decl
)
357 && !LOOKUP_FOUND_P (decl
));
358 LOOKUP_FOUND_P (decl
) = true;
360 while (++ix
!= length
);
364 gcc_checking_assert (!LOOKUP_FOUND_P (decl
));
365 LOOKUP_SEEN_P (decl
) = true;
368 /* Remark the outer partial lookup. */
369 if (previous
->deduping
)
370 lookup_mark (previous
->value
, true);
373 shared_scopes
= scopes
;
377 name_lookup::mark_seen (tree scope
)
379 gcc_checking_assert (!seen_p (scope
));
380 LOOKUP_SEEN_P (scope
) = true;
381 vec_safe_push (scopes
, scope
);
385 name_lookup::find_and_mark (tree scope
)
387 bool result
= LOOKUP_FOUND_P (scope
);
390 LOOKUP_FOUND_P (scope
) = true;
391 if (!LOOKUP_SEEN_P (scope
))
392 vec_safe_push (scopes
, scope
);
398 /* THING and CURRENT are ambiguous, concatenate them. */
401 name_lookup::ambiguous (tree thing
, tree current
)
403 if (TREE_CODE (current
) != TREE_LIST
)
405 current
= build_tree_list (NULL_TREE
, current
);
406 TREE_TYPE (current
) = error_mark_node
;
408 current
= tree_cons (NULL_TREE
, thing
, current
);
409 TREE_TYPE (current
) = error_mark_node
;
414 /* FNS is a new overload set to add to the exising set. */
417 name_lookup::add_overload (tree fns
)
419 if (!deduping
&& TREE_CODE (fns
) == OVERLOAD
)
422 if (flags
& LOOKUP_HIDDEN
)
423 probe
= ovl_skip_hidden (probe
);
424 if (probe
&& TREE_CODE (probe
) == OVERLOAD
&& OVL_USING_P (probe
))
426 /* We're about to add something found by a using
427 declaration, so need to engage deduping mode. */
428 lookup_mark (value
, true);
433 value
= lookup_maybe_add (fns
, value
, deduping
);
436 /* Add a NEW_VAL, a found value binding into the current value binding. */
439 name_lookup::add_value (tree new_val
)
441 if (OVL_P (new_val
) && (!value
|| OVL_P (value
)))
442 add_overload (new_val
);
445 else if (value
== new_val
)
447 else if ((TREE_CODE (value
) == TYPE_DECL
448 && TREE_CODE (new_val
) == TYPE_DECL
449 && same_type_p (TREE_TYPE (value
), TREE_TYPE (new_val
))))
450 /* Typedefs to the same type. */;
451 else if (TREE_CODE (value
) == NAMESPACE_DECL
452 && TREE_CODE (new_val
) == NAMESPACE_DECL
453 && ORIGINAL_NAMESPACE (value
) == ORIGINAL_NAMESPACE (new_val
))
454 /* Namespace (possibly aliased) to the same namespace. Locate
456 value
= ORIGINAL_NAMESPACE (value
);
461 /* Disengage deduping mode. */
462 lookup_mark (value
, false);
465 value
= ambiguous (new_val
, value
);
469 /* Add a NEW_TYPE, a found type binding into the current type binding. */
472 name_lookup::add_type (tree new_type
)
476 else if (TREE_CODE (type
) == TREE_LIST
477 || !same_type_p (TREE_TYPE (type
), TREE_TYPE (new_type
)))
478 type
= ambiguous (new_type
, type
);
481 /* Process a found binding containing NEW_VAL and NEW_TYPE. Returns
482 true if we actually found something noteworthy. */
485 name_lookup::process_binding (tree new_val
, tree new_type
)
487 /* Did we really see a type? */
489 && (LOOKUP_NAMESPACES_ONLY (flags
)
490 || (!(flags
& LOOKUP_HIDDEN
)
491 && DECL_LANG_SPECIFIC (new_type
)
492 && DECL_ANTICIPATED (new_type
))))
493 new_type
= NULL_TREE
;
495 if (new_val
&& !(flags
& LOOKUP_HIDDEN
))
496 new_val
= ovl_skip_hidden (new_val
);
498 /* Do we really see a value? */
500 switch (TREE_CODE (new_val
))
503 /* If we expect types or namespaces, and not templates,
504 or this is not a template class. */
505 if ((LOOKUP_QUALIFIERS_ONLY (flags
)
506 && !DECL_TYPE_TEMPLATE_P (new_val
)))
510 if (LOOKUP_NAMESPACES_ONLY (flags
)
511 || (new_type
&& (flags
& LOOKUP_PREFER_TYPES
)))
515 if (LOOKUP_TYPES_ONLY (flags
))
519 if (LOOKUP_QUALIFIERS_ONLY (flags
))
526 new_type
= NULL_TREE
;
529 /* Merge into the lookup */
535 return new_val
!= NULL_TREE
;
538 /* Look in exactly namespace SCOPE. */
541 name_lookup::search_namespace_only (tree scope
)
545 if (tree
*binding
= find_namespace_slot (scope
, name
))
546 found
|= process_binding (MAYBE_STAT_DECL (*binding
),
547 MAYBE_STAT_TYPE (*binding
));
552 /* Conditionally look in namespace SCOPE and inline children. */
555 name_lookup::search_namespace (tree scope
)
557 if (see_and_mark (scope
))
558 /* We've visited this scope before. Return what we found then. */
559 return found_p (scope
);
561 /* Look in exactly namespace. */
562 bool found
= search_namespace_only (scope
);
564 /* Recursively look in its inline children. */
565 if (vec
<tree
, va_gc
> *inlinees
= DECL_NAMESPACE_INLINEES (scope
))
566 for (unsigned ix
= inlinees
->length (); ix
--;)
567 found
|= search_namespace ((*inlinees
)[ix
]);
575 /* Recursively follow using directives of SCOPE & its inline children.
576 Such following is essentially a flood-fill algorithm. */
579 name_lookup::search_usings (tree scope
)
581 /* We do not check seen_p here, as that was already set during the
582 namespace_only walk. */
587 if (vec
<tree
, va_gc
> *usings
= DECL_NAMESPACE_USING (scope
))
588 for (unsigned ix
= usings
->length (); ix
--;)
589 found
|= search_qualified ((*usings
)[ix
], true);
591 /* Look in its inline children. */
592 if (vec
<tree
, va_gc
> *inlinees
= DECL_NAMESPACE_INLINEES (scope
))
593 for (unsigned ix
= inlinees
->length (); ix
--;)
594 found
|= search_usings ((*inlinees
)[ix
]);
602 /* Qualified namespace lookup in SCOPE.
603 1) Look in SCOPE (+inlines). If found, we're done.
604 2) Otherwise, if USINGS is true,
605 recurse for every using directive of SCOPE (+inlines).
607 Trickiness is (a) loops and (b) multiple paths to same namespace.
608 In both cases we want to not repeat any lookups, and know whether
609 to stop the caller's step #2. Do this via the FOUND_P marker. */
612 name_lookup::search_qualified (tree scope
, bool usings
)
617 found
= found_p (scope
);
620 found
= search_namespace (scope
);
621 if (!found
&& usings
)
622 found
= search_usings (scope
);
628 /* Add SCOPE to the unqualified search queue, recursively add its
629 inlines and those via using directives. */
631 name_lookup::using_queue
*
632 name_lookup::queue_namespace (using_queue
*queue
, int depth
, tree scope
)
634 if (see_and_mark (scope
))
639 while (SCOPE_DEPTH (common
) > depth
)
640 common
= CP_DECL_CONTEXT (common
);
641 vec_safe_push (queue
, using_pair (common
, scope
));
643 /* Queue its inline children. */
644 if (vec
<tree
, va_gc
> *inlinees
= DECL_NAMESPACE_INLINEES (scope
))
645 for (unsigned ix
= inlinees
->length (); ix
--;)
646 queue
= queue_namespace (queue
, depth
, (*inlinees
)[ix
]);
648 /* Queue its using targets. */
649 queue
= queue_usings (queue
, depth
, DECL_NAMESPACE_USING (scope
));
654 /* Add the namespaces in USINGS to the unqualified search queue. */
656 name_lookup::using_queue
*
657 name_lookup::do_queue_usings (using_queue
*queue
, int depth
,
658 vec
<tree
, va_gc
> *usings
)
660 for (unsigned ix
= usings
->length (); ix
--;)
661 queue
= queue_namespace (queue
, depth
, (*usings
)[ix
]);
666 /* Unqualified namespace lookup in SCOPE.
667 1) add scope+inlins to worklist.
668 2) recursively add target of every using directive
669 3) for each worklist item where SCOPE is common ancestor, search it
670 4) if nothing find, scope=parent, goto 1. */
673 name_lookup::search_unqualified (tree scope
, cp_binding_level
*level
)
675 /* Make static to avoid continual reallocation. We're not
677 static using_queue
*queue
= NULL
;
679 int length
= vec_safe_length (queue
);
681 /* Queue local using-directives. */
682 for (; level
->kind
!= sk_namespace
; level
= level
->level_chain
)
683 queue
= queue_usings (queue
, SCOPE_DEPTH (scope
), level
->using_directives
);
685 for (; !found
; scope
= CP_DECL_CONTEXT (scope
))
687 gcc_assert (!DECL_NAMESPACE_ALIAS (scope
));
688 int depth
= SCOPE_DEPTH (scope
);
690 /* Queue namespaces reachable from SCOPE. */
691 queue
= queue_namespace (queue
, depth
, scope
);
693 /* Search every queued namespace where SCOPE is the common
694 ancestor. Adjust the others. */
695 unsigned ix
= length
;
698 using_pair
&pair
= (*queue
)[ix
];
699 while (pair
.first
== scope
)
701 found
|= search_namespace_only (pair
.second
);
702 pair
= queue
->pop ();
703 if (ix
== queue
->length ())
706 /* The depth is the same as SCOPE, find the parent scope. */
707 if (SCOPE_DEPTH (pair
.first
) == depth
)
708 pair
.first
= CP_DECL_CONTEXT (pair
.first
);
711 while (ix
< queue
->length ());
713 if (scope
== global_namespace
)
716 /* If looking for hidden names, we only look in the innermost
717 namespace scope. [namespace.memdef]/3 If a friend
718 declaration in a non-local class first declares a class,
719 function, class template or function template the friend is a
720 member of the innermost enclosing namespace. See also
721 [basic.lookup.unqual]/7 */
722 if (flags
& LOOKUP_HIDDEN
)
726 vec_safe_truncate (queue
, length
);
731 /* FNS is a value binding. If it is a (set of overloaded) functions,
732 add them into the current value. */
735 name_lookup::add_fns (tree fns
)
739 else if (TREE_CODE (fns
) == OVERLOAD
)
741 if (TREE_TYPE (fns
) != unknown_type_node
)
742 fns
= OVL_FUNCTION (fns
);
744 else if (!DECL_DECLARES_FUNCTION_P (fns
))
750 /* Add functions of a namespace to the lookup structure. */
753 name_lookup::adl_namespace_only (tree scope
)
757 /* Look down into inline namespaces. */
758 if (vec
<tree
, va_gc
> *inlinees
= DECL_NAMESPACE_INLINEES (scope
))
759 for (unsigned ix
= inlinees
->length (); ix
--;)
760 adl_namespace_only ((*inlinees
)[ix
]);
762 if (tree fns
= find_namespace_value (scope
, name
))
763 add_fns (ovl_skip_hidden (fns
));
766 /* Find the containing non-inlined namespace, add it and all its
770 name_lookup::adl_namespace (tree scope
)
775 /* Find the containing non-inline namespace. */
776 while (DECL_NAMESPACE_INLINE_P (scope
))
777 scope
= CP_DECL_CONTEXT (scope
);
779 adl_namespace_only (scope
);
782 /* Adds the class and its friends to the lookup structure. */
785 name_lookup::adl_class_only (tree type
)
787 /* Backend-built structures, such as __builtin_va_list, aren't
788 affected by all this. */
789 if (!CLASS_TYPE_P (type
))
792 type
= TYPE_MAIN_VARIANT (type
);
794 if (see_and_mark (type
))
797 tree context
= decl_namespace_context (type
);
798 adl_namespace (context
);
800 complete_type (type
);
803 for (tree list
= DECL_FRIENDLIST (TYPE_MAIN_DECL (type
)); list
;
804 list
= TREE_CHAIN (list
))
805 if (name
== FRIEND_NAME (list
))
806 for (tree friends
= FRIEND_DECLS (list
); friends
;
807 friends
= TREE_CHAIN (friends
))
809 tree fn
= TREE_VALUE (friends
);
811 /* Only interested in global functions with potentially hidden
812 (i.e. unqualified) declarations. */
813 if (CP_DECL_CONTEXT (fn
) != context
)
816 /* Only interested in anticipated friends. (Non-anticipated
817 ones will have been inserted during the namespace
819 if (!DECL_ANTICIPATED (fn
))
822 /* Template specializations are never found by name lookup.
823 (Templates themselves can be found, but not template
825 if (TREE_CODE (fn
) == FUNCTION_DECL
&& DECL_USE_TEMPLATE (fn
))
832 /* Adds the class and its bases to the lookup structure.
833 Returns true on error. */
836 name_lookup::adl_bases (tree type
)
838 adl_class_only (type
);
840 /* Process baseclasses. */
841 if (tree binfo
= TYPE_BINFO (type
))
846 for (i
= 0; BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); i
++)
847 adl_bases (BINFO_TYPE (base_binfo
));
851 /* Adds everything associated with a class argument type to the lookup
852 structure. Returns true on error.
854 If T is a class type (including unions), its associated classes are: the
855 class itself; the class of which it is a member, if any; and its direct
856 and indirect base classes. Its associated namespaces are the namespaces
857 of which its associated classes are members. Furthermore, if T is a
858 class template specialization, its associated namespaces and classes
859 also include: the namespaces and classes associated with the types of
860 the template arguments provided for template type parameters (excluding
861 template template parameters); the namespaces of which any template
862 template arguments are members; and the classes of which any member
863 templates used as template template arguments are members. [ Note:
864 non-type template arguments do not contribute to the set of associated
865 namespaces. --end note] */
868 name_lookup::adl_class (tree type
)
870 /* Backend build structures, such as __builtin_va_list, aren't
871 affected by all this. */
872 if (!CLASS_TYPE_P (type
))
875 type
= TYPE_MAIN_VARIANT (type
);
876 /* We don't set found here because we have to have set seen first,
877 which is done in the adl_bases walk. */
884 if (TYPE_CLASS_SCOPE_P (type
))
885 adl_class_only (TYPE_CONTEXT (type
));
887 /* Process template arguments. */
888 if (CLASSTYPE_TEMPLATE_INFO (type
)
889 && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (type
)))
891 tree list
= INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (type
));
892 for (int i
= 0; i
< TREE_VEC_LENGTH (list
); ++i
)
893 adl_template_arg (TREE_VEC_ELT (list
, i
));
898 name_lookup::adl_expr (tree expr
)
903 gcc_assert (!TYPE_P (expr
));
905 if (TREE_TYPE (expr
) != unknown_type_node
)
907 adl_type (TREE_TYPE (expr
));
911 if (TREE_CODE (expr
) == ADDR_EXPR
)
912 expr
= TREE_OPERAND (expr
, 0);
913 if (TREE_CODE (expr
) == COMPONENT_REF
914 || TREE_CODE (expr
) == OFFSET_REF
)
915 expr
= TREE_OPERAND (expr
, 1);
916 expr
= MAYBE_BASELINK_FUNCTIONS (expr
);
919 for (lkp_iterator
iter (expr
); iter
; ++iter
)
920 adl_type (TREE_TYPE (*iter
));
921 else if (TREE_CODE (expr
) == TEMPLATE_ID_EXPR
)
923 /* The working paper doesn't currently say how to handle
924 template-id arguments. The sensible thing would seem to be
925 to handle the list of template candidates like a normal
926 overload set, and handle the template arguments like we do
927 for class template specializations. */
929 /* First the templates. */
930 adl_expr (TREE_OPERAND (expr
, 0));
932 /* Now the arguments. */
933 if (tree args
= TREE_OPERAND (expr
, 1))
934 for (int ix
= TREE_VEC_LENGTH (args
); ix
--;)
935 adl_template_arg (TREE_VEC_ELT (args
, ix
));
940 name_lookup::adl_type (tree type
)
945 if (TYPE_PTRDATAMEM_P (type
))
947 /* Pointer to member: associate class type and value type. */
948 adl_type (TYPE_PTRMEM_CLASS_TYPE (type
));
949 adl_type (TYPE_PTRMEM_POINTED_TO_TYPE (type
));
953 switch (TREE_CODE (type
))
956 if (TYPE_PTRMEMFUNC_P (type
))
958 adl_type (TYPE_PTRMEMFUNC_FN_TYPE (type
));
967 /* The basetype is referenced in the first arg type, so just
970 /* Associate the parameter types. */
971 for (tree args
= TYPE_ARG_TYPES (type
); args
; args
= TREE_CHAIN (args
))
972 adl_type (TREE_VALUE (args
));
978 adl_type (TREE_TYPE (type
));
982 if (TYPE_CLASS_SCOPE_P (type
))
983 adl_class_only (TYPE_CONTEXT (type
));
984 adl_namespace (decl_namespace_context (type
));
988 gcc_assert (type
== unknown_type_node
989 || type
== init_list_type_node
);
992 case TYPE_PACK_EXPANSION
:
993 adl_type (PACK_EXPANSION_PATTERN (type
));
1001 /* Adds everything associated with a template argument to the lookup
1005 name_lookup::adl_template_arg (tree arg
)
1007 /* [basic.lookup.koenig]
1009 If T is a template-id, its associated namespaces and classes are
1010 ... the namespaces and classes associated with the types of the
1011 template arguments provided for template type parameters
1012 (excluding template template parameters); the namespaces in which
1013 any template template arguments are defined; and the classes in
1014 which any member templates used as template template arguments
1015 are defined. [Note: non-type template arguments do not
1016 contribute to the set of associated namespaces. ] */
1018 /* Consider first template template arguments. */
1019 if (TREE_CODE (arg
) == TEMPLATE_TEMPLATE_PARM
1020 || TREE_CODE (arg
) == UNBOUND_CLASS_TEMPLATE
)
1022 else if (TREE_CODE (arg
) == TEMPLATE_DECL
)
1024 tree ctx
= CP_DECL_CONTEXT (arg
);
1026 /* It's not a member template. */
1027 if (TREE_CODE (ctx
) == NAMESPACE_DECL
)
1028 adl_namespace (ctx
);
1029 /* Otherwise, it must be member template. */
1031 adl_class_only (ctx
);
1033 /* It's an argument pack; handle it recursively. */
1034 else if (ARGUMENT_PACK_P (arg
))
1036 tree args
= ARGUMENT_PACK_ARGS (arg
);
1037 int i
, len
= TREE_VEC_LENGTH (args
);
1038 for (i
= 0; i
< len
; ++i
)
1039 adl_template_arg (TREE_VEC_ELT (args
, i
));
1041 /* It's not a template template argument, but it is a type template
1043 else if (TYPE_P (arg
))
1047 /* Perform ADL lookup. FNS is the existing lookup result and ARGS are
1048 the call arguments. */
1051 name_lookup::search_adl (tree fns
, vec
<tree
, va_gc
> *args
)
1056 lookup_mark (fns
, true);
1063 FOR_EACH_VEC_ELT_REVERSE (*args
, ix
, arg
)
1064 /* OMP reduction operators put an ADL-significant type as the
1076 static bool qualified_namespace_lookup (tree
, name_lookup
*);
1077 static void consider_binding_level (tree name
,
1078 best_match
<tree
, const char *> &bm
,
1079 cp_binding_level
*lvl
,
1080 bool look_within_fields
,
1081 enum lookup_name_fuzzy_kind kind
);
1082 static void diagnose_name_conflict (tree
, tree
);
1084 /* ADL lookup of NAME. FNS is the result of regular lookup, and we
1085 don't add duplicates to it. ARGS is the vector of call
1086 arguments (which will not be empty). */
1089 lookup_arg_dependent (tree name
, tree fns
, vec
<tree
, va_gc
> *args
)
1091 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
1092 name_lookup
lookup (name
);
1093 fns
= lookup
.search_adl (fns
, args
);
1094 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
1098 /* FNS is an overload set of conversion functions. Return the
1099 overloads converting to TYPE. */
1102 extract_conversion_operator (tree fns
, tree type
)
1104 tree convs
= NULL_TREE
;
1105 tree tpls
= NULL_TREE
;
1107 for (ovl_iterator
iter (fns
); iter
; ++iter
)
1109 if (same_type_p (DECL_CONV_FN_TYPE (*iter
), type
))
1110 convs
= lookup_add (*iter
, convs
);
1112 if (TREE_CODE (*iter
) == TEMPLATE_DECL
)
1113 tpls
= lookup_add (*iter
, tpls
);
1122 /* Binary search of (ordered) MEMBER_VEC for NAME. */
1125 member_vec_binary_search (vec
<tree
, va_gc
> *member_vec
, tree name
)
1127 for (unsigned lo
= 0, hi
= member_vec
->length (); lo
< hi
;)
1129 unsigned mid
= (lo
+ hi
) / 2;
1130 tree binding
= (*member_vec
)[mid
];
1131 tree binding_name
= OVL_NAME (binding
);
1133 if (binding_name
> name
)
1135 else if (binding_name
< name
)
1144 /* Linear search of (unordered) MEMBER_VEC for NAME. */
1147 member_vec_linear_search (vec
<tree
, va_gc
> *member_vec
, tree name
)
1149 for (int ix
= member_vec
->length (); ix
--;)
1150 if (tree binding
= (*member_vec
)[ix
])
1151 if (OVL_NAME (binding
) == name
)
1157 /* Linear search of (partially ordered) fields of KLASS for NAME. */
1160 fields_linear_search (tree klass
, tree name
, bool want_type
)
1162 for (tree fields
= TYPE_FIELDS (klass
); fields
; fields
= DECL_CHAIN (fields
))
1166 if (TREE_CODE (decl
) == FIELD_DECL
1167 && ANON_AGGR_TYPE_P (TREE_TYPE (decl
)))
1169 if (tree temp
= search_anon_aggr (TREE_TYPE (decl
), name
, want_type
))
1173 if (DECL_NAME (decl
) != name
)
1176 if (TREE_CODE (decl
) == USING_DECL
)
1178 decl
= strip_using_decl (decl
);
1179 if (is_overloaded_fn (decl
))
1183 if (DECL_DECLARES_FUNCTION_P (decl
))
1184 /* Functions are found separately. */
1187 if (!want_type
|| DECL_DECLARES_TYPE_P (decl
))
1194 /* Look for NAME member inside of anonymous aggregate ANON. Although
1195 such things should only contain FIELD_DECLs, we check that too
1196 late, and would give very confusing errors if we weren't
1200 search_anon_aggr (tree anon
, tree name
, bool want_type
)
1202 gcc_assert (COMPLETE_TYPE_P (anon
));
1203 tree ret
= get_class_binding_direct (anon
, name
, want_type
);
1207 /* Look for NAME as an immediate member of KLASS (including
1208 anon-members or unscoped enum member). TYPE_OR_FNS is zero for
1209 regular search. >0 to get a type binding (if there is one) and <0
1210 if you want (just) the member function binding.
1212 Use this if you do not want lazy member creation. */
1215 get_class_binding_direct (tree klass
, tree name
, int type_or_fns
)
1217 gcc_checking_assert (RECORD_OR_UNION_TYPE_P (klass
));
1219 /* Conversion operators can only be found by the marker conversion
1221 bool conv_op
= IDENTIFIER_CONV_OP_P (name
);
1222 tree lookup
= conv_op
? conv_op_identifier
: name
;
1223 tree val
= NULL_TREE
;
1224 vec
<tree
, va_gc
> *member_vec
= CLASSTYPE_MEMBER_VEC (klass
);
1226 if (COMPLETE_TYPE_P (klass
) && member_vec
)
1228 val
= member_vec_binary_search (member_vec
, lookup
);
1231 else if (type_or_fns
> 0)
1233 if (STAT_HACK_P (val
))
1234 val
= STAT_TYPE (val
);
1235 else if (!DECL_DECLARES_TYPE_P (val
))
1238 else if (STAT_HACK_P (val
))
1239 val
= STAT_DECL (val
);
1241 if (val
&& TREE_CODE (val
) == OVERLOAD
1242 && TREE_CODE (OVL_FUNCTION (val
)) == USING_DECL
)
1244 /* An overload with a dependent USING_DECL. Does the caller
1245 want the USING_DECL or the functions? */
1246 if (type_or_fns
< 0)
1247 val
= OVL_CHAIN (val
);
1249 val
= OVL_FUNCTION (val
);
1254 if (member_vec
&& type_or_fns
<= 0)
1255 val
= member_vec_linear_search (member_vec
, lookup
);
1257 if (type_or_fns
< 0)
1258 /* Don't bother looking for field. We don't want it. */;
1259 else if (!val
|| (TREE_CODE (val
) == OVERLOAD
&& OVL_USING_P (val
)))
1260 /* Dependent using declarations are a 'field', make sure we
1261 return that even if we saw an overload already. */
1262 if (tree field_val
= fields_linear_search (klass
, lookup
,
1264 if (!val
|| TREE_CODE (field_val
) == USING_DECL
)
1268 /* Extract the conversion operators asked for, unless the general
1269 conversion operator was requested. */
1272 gcc_checking_assert (OVL_FUNCTION (val
) == conv_op_marker
);
1273 val
= OVL_CHAIN (val
);
1274 if (tree type
= TREE_TYPE (name
))
1275 val
= extract_conversion_operator (val
, type
);
1281 /* Look for NAME's binding in exactly KLASS. See
1282 get_class_binding_direct for argument description. Does lazy
1283 special function creation as necessary. */
1286 get_class_binding (tree klass
, tree name
, int type_or_fns
)
1288 klass
= complete_type (klass
);
1290 if (COMPLETE_TYPE_P (klass
))
1292 /* Lazily declare functions, if we're going to search these. */
1293 if (IDENTIFIER_CTOR_P (name
))
1295 if (CLASSTYPE_LAZY_DEFAULT_CTOR (klass
))
1296 lazily_declare_fn (sfk_constructor
, klass
);
1297 if (CLASSTYPE_LAZY_COPY_CTOR (klass
))
1298 lazily_declare_fn (sfk_copy_constructor
, klass
);
1299 if (CLASSTYPE_LAZY_MOVE_CTOR (klass
))
1300 lazily_declare_fn (sfk_move_constructor
, klass
);
1302 else if (IDENTIFIER_DTOR_P (name
))
1304 if (CLASSTYPE_LAZY_DESTRUCTOR (klass
))
1305 lazily_declare_fn (sfk_destructor
, klass
);
1307 else if (name
== assign_op_identifier
)
1309 if (CLASSTYPE_LAZY_COPY_ASSIGN (klass
))
1310 lazily_declare_fn (sfk_copy_assignment
, klass
);
1311 if (CLASSTYPE_LAZY_MOVE_ASSIGN (klass
))
1312 lazily_declare_fn (sfk_move_assignment
, klass
);
1316 return get_class_binding_direct (klass
, name
, type_or_fns
);
1319 /* Find the slot containing overloads called 'NAME'. If there is no
1320 such slot and the class is complete, create an empty one, at the
1321 correct point in the sorted member vector. Otherwise return NULL.
1322 Deals with conv_op marker handling. */
1325 find_member_slot (tree klass
, tree name
)
1327 bool complete_p
= COMPLETE_TYPE_P (klass
);
1329 vec
<tree
, va_gc
> *member_vec
= CLASSTYPE_MEMBER_VEC (klass
);
1332 vec_alloc (member_vec
, 8);
1333 CLASSTYPE_MEMBER_VEC (klass
) = member_vec
;
1336 /* If the class is complete but had no member_vec, we need
1337 to add the TYPE_FIELDS into it. We're also most likely
1338 to be adding ctors & dtors, so ask for 6 spare slots (the
1339 abstract cdtors and their clones). */
1340 set_class_bindings (klass
, 6);
1341 member_vec
= CLASSTYPE_MEMBER_VEC (klass
);
1345 if (IDENTIFIER_CONV_OP_P (name
))
1346 name
= conv_op_identifier
;
1348 unsigned ix
, length
= member_vec
->length ();
1349 for (ix
= 0; ix
< length
; ix
++)
1351 tree
*slot
= &(*member_vec
)[ix
];
1352 tree fn_name
= OVL_NAME (*slot
);
1354 if (fn_name
== name
)
1356 /* If we found an existing slot, it must be a function set.
1357 Even with insertion after completion, because those only
1358 happen with artificial fns that have unspellable names.
1359 This means we do not have to deal with the stat hack
1361 gcc_checking_assert (OVL_P (*slot
));
1362 if (name
== conv_op_identifier
)
1364 gcc_checking_assert (OVL_FUNCTION (*slot
) == conv_op_marker
);
1365 /* Skip the conv-op marker. */
1366 slot
= &OVL_CHAIN (*slot
);
1371 if (complete_p
&& fn_name
> name
)
1375 /* No slot found, add one if the class is complete. */
1378 /* Do exact allocation, as we don't expect to add many. */
1379 gcc_assert (name
!= conv_op_identifier
);
1380 vec_safe_reserve_exact (member_vec
, 1);
1381 CLASSTYPE_MEMBER_VEC (klass
) = member_vec
;
1382 member_vec
->quick_insert (ix
, NULL_TREE
);
1383 return &(*member_vec
)[ix
];
1389 /* KLASS is an incomplete class to which we're adding a method NAME.
1390 Add a slot and deal with conv_op marker handling. */
1393 add_member_slot (tree klass
, tree name
)
1395 gcc_assert (!COMPLETE_TYPE_P (klass
));
1397 vec
<tree
, va_gc
> *member_vec
= CLASSTYPE_MEMBER_VEC (klass
);
1398 vec_safe_push (member_vec
, NULL_TREE
);
1399 CLASSTYPE_MEMBER_VEC (klass
) = member_vec
;
1401 tree
*slot
= &member_vec
->last ();
1402 if (IDENTIFIER_CONV_OP_P (name
))
1404 /* Install the marker prefix. */
1405 *slot
= ovl_make (conv_op_marker
, NULL_TREE
);
1406 slot
= &OVL_CHAIN (*slot
);
1412 /* Comparison function to compare two MEMBER_VEC entries by name.
1413 Because we can have duplicates during insertion of TYPE_FIELDS, we
1414 do extra checking so deduping doesn't have to deal with so many
1418 member_name_cmp (const void *a_p
, const void *b_p
)
1420 tree a
= *(const tree
*)a_p
;
1421 tree b
= *(const tree
*)b_p
;
1422 tree name_a
= DECL_NAME (TREE_CODE (a
) == OVERLOAD
? OVL_FUNCTION (a
) : a
);
1423 tree name_b
= DECL_NAME (TREE_CODE (b
) == OVERLOAD
? OVL_FUNCTION (b
) : b
);
1425 gcc_checking_assert (name_a
&& name_b
);
1426 if (name_a
!= name_b
)
1427 return name_a
< name_b
? -1 : +1;
1429 if (name_a
== conv_op_identifier
)
1431 /* Strip the conv-op markers. */
1432 gcc_checking_assert (OVL_FUNCTION (a
) == conv_op_marker
1433 && OVL_FUNCTION (b
) == conv_op_marker
);
1438 if (TREE_CODE (a
) == OVERLOAD
)
1439 a
= OVL_FUNCTION (a
);
1440 if (TREE_CODE (b
) == OVERLOAD
)
1441 b
= OVL_FUNCTION (b
);
1443 /* We're in STAT_HACK or USING_DECL territory (or possibly error-land). */
1444 if (TREE_CODE (a
) != TREE_CODE (b
))
1446 /* If one of them is a TYPE_DECL, it loses. */
1447 if (TREE_CODE (a
) == TYPE_DECL
)
1449 else if (TREE_CODE (b
) == TYPE_DECL
)
1452 /* If one of them is a USING_DECL, it loses. */
1453 if (TREE_CODE (a
) == USING_DECL
)
1455 else if (TREE_CODE (b
) == USING_DECL
)
1458 /* There are no other cases with different kinds of decls, as
1459 duplicate detection should have kicked in earlier. However,
1460 some erroneous cases get though. */
1461 gcc_assert (errorcount
);
1464 /* Using source location would be the best thing here, but we can
1465 get identically-located decls in the following circumstances:
1467 1) duplicate artificial type-decls for the same type.
1469 2) pack expansions of using-decls.
1471 We should not be doing #1, but in either case it doesn't matter
1472 how we order these. Use UID as a proxy for source ordering, so
1473 that identically-located decls still have a well-defined stable
1475 if (DECL_UID (a
) != DECL_UID (b
))
1476 return DECL_UID (a
) < DECL_UID (b
) ? -1 : +1;
1477 gcc_assert (a
== b
);
1482 gt_pointer_operator new_value
;
1486 /* This routine compares two fields like member_name_cmp but using the
1487 pointer operator in resort_field_decl_data. We don't have to deal
1488 with duplicates here. */
1491 resort_member_name_cmp (const void *a_p
, const void *b_p
)
1493 tree a
= *(const tree
*)a_p
;
1494 tree b
= *(const tree
*)b_p
;
1495 tree name_a
= OVL_NAME (a
);
1496 tree name_b
= OVL_NAME (b
);
1498 resort_data
.new_value (&name_a
, resort_data
.cookie
);
1499 resort_data
.new_value (&name_b
, resort_data
.cookie
);
1501 gcc_checking_assert (name_a
!= name_b
);
1503 return name_a
< name_b
? -1 : +1;
1506 /* Resort CLASSTYPE_MEMBER_VEC because pointers have been reordered. */
1509 resort_type_member_vec (void *obj
, void */
*orig_obj*/
,
1510 gt_pointer_operator new_value
, void* cookie
)
1512 if (vec
<tree
, va_gc
> *member_vec
= (vec
<tree
, va_gc
> *) obj
)
1514 resort_data
.new_value
= new_value
;
1515 resort_data
.cookie
= cookie
;
1516 member_vec
->qsort (resort_member_name_cmp
);
1520 /* Recursively count the number of fields in KLASS, including anonymous
1524 count_class_fields (tree klass
)
1526 unsigned n_fields
= 0;
1528 for (tree fields
= TYPE_FIELDS (klass
); fields
; fields
= DECL_CHAIN (fields
))
1529 if (DECL_DECLARES_FUNCTION_P (fields
))
1530 /* Functions are dealt with separately. */;
1531 else if (TREE_CODE (fields
) == FIELD_DECL
1532 && ANON_AGGR_TYPE_P (TREE_TYPE (fields
)))
1533 n_fields
+= count_class_fields (TREE_TYPE (fields
));
1534 else if (DECL_NAME (fields
))
1540 /* Append all the nonfunction members fields of KLASS to MEMBER_VEC.
1541 Recurse for anonymous members. MEMBER_VEC must have space. */
1544 member_vec_append_class_fields (vec
<tree
, va_gc
> *member_vec
, tree klass
)
1546 for (tree fields
= TYPE_FIELDS (klass
); fields
; fields
= DECL_CHAIN (fields
))
1547 if (DECL_DECLARES_FUNCTION_P (fields
))
1548 /* Functions are handled separately. */;
1549 else if (TREE_CODE (fields
) == FIELD_DECL
1550 && ANON_AGGR_TYPE_P (TREE_TYPE (fields
)))
1551 member_vec_append_class_fields (member_vec
, TREE_TYPE (fields
));
1552 else if (DECL_NAME (fields
))
1554 tree field
= fields
;
1555 /* Mark a conv-op USING_DECL with the conv-op-marker. */
1556 if (TREE_CODE (field
) == USING_DECL
1557 && IDENTIFIER_CONV_OP_P (DECL_NAME (field
)))
1558 field
= ovl_make (conv_op_marker
, field
);
1559 member_vec
->quick_push (field
);
1563 /* Append all of the enum values of ENUMTYPE to MEMBER_VEC.
1564 MEMBER_VEC must have space. */
1567 member_vec_append_enum_values (vec
<tree
, va_gc
> *member_vec
, tree enumtype
)
1569 for (tree values
= TYPE_VALUES (enumtype
);
1570 values
; values
= TREE_CHAIN (values
))
1571 member_vec
->quick_push (TREE_VALUE (values
));
1574 /* MEMBER_VEC has just had new DECLs added to it, but is sorted.
1575 DeDup adjacent DECLS of the same name. We already dealt with
1576 conflict resolution when adding the fields or methods themselves.
1577 There are three cases (which could all be combined):
1578 1) a TYPE_DECL and non TYPE_DECL. Deploy STAT_HACK as appropriate.
1579 2) a USING_DECL and an overload. If the USING_DECL is dependent,
1580 it wins. Otherwise the OVERLOAD does.
1581 3) two USING_DECLS. ...
1583 member_name_cmp will have ordered duplicates as
1584 <fns><using><type> */
1587 member_vec_dedup (vec
<tree
, va_gc
> *member_vec
)
1589 unsigned len
= member_vec
->length ();
1595 tree name
= OVL_NAME ((*member_vec
)[0]);
1596 for (unsigned jx
, ix
= 0; ix
< len
; ix
= jx
)
1598 tree current
= NULL_TREE
;
1599 tree to_type
= NULL_TREE
;
1600 tree to_using
= NULL_TREE
;
1601 tree marker
= NULL_TREE
;
1603 for (jx
= ix
; jx
< len
; jx
++)
1605 tree next
= (*member_vec
)[jx
];
1608 tree next_name
= OVL_NAME (next
);
1609 if (next_name
!= name
)
1616 if (IDENTIFIER_CONV_OP_P (name
))
1619 next
= OVL_CHAIN (next
);
1622 if (TREE_CODE (next
) == USING_DECL
)
1624 if (IDENTIFIER_CTOR_P (name
))
1625 /* Dependent inherited ctor. */
1628 next
= strip_using_decl (next
);
1629 if (TREE_CODE (next
) == USING_DECL
)
1635 if (is_overloaded_fn (next
))
1639 if (DECL_DECLARES_TYPE_P (next
))
1654 current
= ovl_make (to_using
, current
);
1662 current
= stat_hack (current
, to_type
);
1669 OVL_CHAIN (marker
) = current
;
1672 (*member_vec
)[store
++] = current
;
1676 while (store
++ < len
)
1680 /* Add the non-function members to CLASSTYPE_MEMBER_VEC. If there is
1681 no existing MEMBER_VEC and fewer than 8 fields, do nothing. We
1682 know there must be at least 1 field -- the self-reference
1683 TYPE_DECL, except for anon aggregates, which will have at least
1687 set_class_bindings (tree klass
, unsigned extra
)
1689 unsigned n_fields
= count_class_fields (klass
);
1690 vec
<tree
, va_gc
> *member_vec
= CLASSTYPE_MEMBER_VEC (klass
);
1692 if (member_vec
|| n_fields
>= 8)
1694 /* Append the new fields. */
1695 vec_safe_reserve_exact (member_vec
, extra
+ n_fields
);
1696 member_vec_append_class_fields (member_vec
, klass
);
1701 CLASSTYPE_MEMBER_VEC (klass
) = member_vec
;
1702 member_vec
->qsort (member_name_cmp
);
1703 member_vec_dedup (member_vec
);
1707 /* Insert lately defined enum ENUMTYPE into KLASS for the sorted case. */
1710 insert_late_enum_def_bindings (tree klass
, tree enumtype
)
1713 vec
<tree
, va_gc
> *member_vec
= CLASSTYPE_MEMBER_VEC (klass
);
1715 /* The enum bindings will already be on the TYPE_FIELDS, so don't
1716 count them twice. */
1718 n_fields
= count_class_fields (klass
);
1720 n_fields
= list_length (TYPE_VALUES (enumtype
));
1722 if (member_vec
|| n_fields
>= 8)
1724 vec_safe_reserve_exact (member_vec
, n_fields
);
1725 if (CLASSTYPE_MEMBER_VEC (klass
))
1726 member_vec_append_enum_values (member_vec
, enumtype
);
1728 member_vec_append_class_fields (member_vec
, klass
);
1729 CLASSTYPE_MEMBER_VEC (klass
) = member_vec
;
1730 member_vec
->qsort (member_name_cmp
);
1731 member_vec_dedup (member_vec
);
1735 /* Compute the chain index of a binding_entry given the HASH value of its
1736 name and the total COUNT of chains. COUNT is assumed to be a power
1739 #define ENTRY_INDEX(HASH, COUNT) (((HASH) >> 3) & ((COUNT) - 1))
1741 /* A free list of "binding_entry"s awaiting for re-use. */
1743 static GTY((deletable
)) binding_entry free_binding_entry
= NULL
;
1745 /* The binding oracle; see cp-tree.h. */
1747 cp_binding_oracle_function
*cp_binding_oracle
;
1749 /* If we have a binding oracle, ask it for all namespace-scoped
1750 definitions of NAME. */
1753 query_oracle (tree name
)
1755 if (!cp_binding_oracle
)
1758 /* LOOKED_UP holds the set of identifiers that we have already
1759 looked up with the oracle. */
1760 static hash_set
<tree
> looked_up
;
1761 if (looked_up
.add (name
))
1764 cp_binding_oracle (CP_ORACLE_IDENTIFIER
, name
);
1767 /* Create a binding_entry object for (NAME, TYPE). */
1769 static inline binding_entry
1770 binding_entry_make (tree name
, tree type
)
1772 binding_entry entry
;
1774 if (free_binding_entry
)
1776 entry
= free_binding_entry
;
1777 free_binding_entry
= entry
->chain
;
1780 entry
= ggc_alloc
<binding_entry_s
> ();
1784 entry
->chain
= NULL
;
1789 /* Put ENTRY back on the free list. */
1792 binding_entry_free (binding_entry entry
)
1796 entry
->chain
= free_binding_entry
;
1797 free_binding_entry
= entry
;
1801 /* The datatype used to implement the mapping from names to types at
1803 struct GTY(()) binding_table_s
{
1804 /* Array of chains of "binding_entry"s */
1805 binding_entry
* GTY((length ("%h.chain_count"))) chain
;
1807 /* The number of chains in this table. This is the length of the
1808 member "chain" considered as an array. */
1811 /* Number of "binding_entry"s in this table. */
1815 /* Construct TABLE with an initial CHAIN_COUNT. */
1818 binding_table_construct (binding_table table
, size_t chain_count
)
1820 table
->chain_count
= chain_count
;
1821 table
->entry_count
= 0;
1822 table
->chain
= ggc_cleared_vec_alloc
<binding_entry
> (table
->chain_count
);
1825 /* Make TABLE's entries ready for reuse. */
1828 binding_table_free (binding_table table
)
1836 for (i
= 0, count
= table
->chain_count
; i
< count
; ++i
)
1838 binding_entry temp
= table
->chain
[i
];
1839 while (temp
!= NULL
)
1841 binding_entry entry
= temp
;
1842 temp
= entry
->chain
;
1843 binding_entry_free (entry
);
1845 table
->chain
[i
] = NULL
;
1847 table
->entry_count
= 0;
1851 /* Allocate a table with CHAIN_COUNT, assumed to be a power of two. */
1853 static inline binding_table
1854 binding_table_new (size_t chain_count
)
1856 binding_table table
= ggc_alloc
<binding_table_s
> ();
1857 table
->chain
= NULL
;
1858 binding_table_construct (table
, chain_count
);
1862 /* Expand TABLE to twice its current chain_count. */
1865 binding_table_expand (binding_table table
)
1867 const size_t old_chain_count
= table
->chain_count
;
1868 const size_t old_entry_count
= table
->entry_count
;
1869 const size_t new_chain_count
= 2 * old_chain_count
;
1870 binding_entry
*old_chains
= table
->chain
;
1873 binding_table_construct (table
, new_chain_count
);
1874 for (i
= 0; i
< old_chain_count
; ++i
)
1876 binding_entry entry
= old_chains
[i
];
1877 for (; entry
!= NULL
; entry
= old_chains
[i
])
1879 const unsigned int hash
= IDENTIFIER_HASH_VALUE (entry
->name
);
1880 const size_t j
= ENTRY_INDEX (hash
, new_chain_count
);
1882 old_chains
[i
] = entry
->chain
;
1883 entry
->chain
= table
->chain
[j
];
1884 table
->chain
[j
] = entry
;
1887 table
->entry_count
= old_entry_count
;
1890 /* Insert a binding for NAME to TYPE into TABLE. */
1893 binding_table_insert (binding_table table
, tree name
, tree type
)
1895 const unsigned int hash
= IDENTIFIER_HASH_VALUE (name
);
1896 const size_t i
= ENTRY_INDEX (hash
, table
->chain_count
);
1897 binding_entry entry
= binding_entry_make (name
, type
);
1899 entry
->chain
= table
->chain
[i
];
1900 table
->chain
[i
] = entry
;
1901 ++table
->entry_count
;
1903 if (3 * table
->chain_count
< 5 * table
->entry_count
)
1904 binding_table_expand (table
);
1907 /* Return the binding_entry, if any, that maps NAME. */
1910 binding_table_find (binding_table table
, tree name
)
1912 const unsigned int hash
= IDENTIFIER_HASH_VALUE (name
);
1913 binding_entry entry
= table
->chain
[ENTRY_INDEX (hash
, table
->chain_count
)];
1915 while (entry
!= NULL
&& entry
->name
!= name
)
1916 entry
= entry
->chain
;
1921 /* Apply PROC -- with DATA -- to all entries in TABLE. */
1924 binding_table_foreach (binding_table table
, bt_foreach_proc proc
, void *data
)
1932 chain_count
= table
->chain_count
;
1933 for (i
= 0; i
< chain_count
; ++i
)
1935 binding_entry entry
= table
->chain
[i
];
1936 for (; entry
!= NULL
; entry
= entry
->chain
)
1941 #ifndef ENABLE_SCOPE_CHECKING
1942 # define ENABLE_SCOPE_CHECKING 0
1944 # define ENABLE_SCOPE_CHECKING 1
1947 /* A free list of "cxx_binding"s, connected by their PREVIOUS. */
1949 static GTY((deletable
)) cxx_binding
*free_bindings
;
1951 /* Initialize VALUE and TYPE field for BINDING, and set the PREVIOUS
1955 cxx_binding_init (cxx_binding
*binding
, tree value
, tree type
)
1957 binding
->value
= value
;
1958 binding
->type
= type
;
1959 binding
->previous
= NULL
;
1962 /* (GC)-allocate a binding object with VALUE and TYPE member initialized. */
1964 static cxx_binding
*
1965 cxx_binding_make (tree value
, tree type
)
1967 cxx_binding
*binding
;
1970 binding
= free_bindings
;
1971 free_bindings
= binding
->previous
;
1974 binding
= ggc_alloc
<cxx_binding
> ();
1976 cxx_binding_init (binding
, value
, type
);
1981 /* Put BINDING back on the free list. */
1984 cxx_binding_free (cxx_binding
*binding
)
1986 binding
->scope
= NULL
;
1987 binding
->previous
= free_bindings
;
1988 free_bindings
= binding
;
1991 /* Create a new binding for NAME (with the indicated VALUE and TYPE
1992 bindings) in the class scope indicated by SCOPE. */
1994 static cxx_binding
*
1995 new_class_binding (tree name
, tree value
, tree type
, cp_binding_level
*scope
)
1997 cp_class_binding cb
= {cxx_binding_make (value
, type
), name
};
1998 cxx_binding
*binding
= cb
.base
;
1999 vec_safe_push (scope
->class_shadowed
, cb
);
2000 binding
->scope
= scope
;
2004 /* Make DECL the innermost binding for ID. The LEVEL is the binding
2005 level at which this declaration is being bound. */
2008 push_binding (tree id
, tree decl
, cp_binding_level
* level
)
2010 cxx_binding
*binding
;
2012 if (level
!= class_binding_level
)
2014 binding
= cxx_binding_make (decl
, NULL_TREE
);
2015 binding
->scope
= level
;
2018 binding
= new_class_binding (id
, decl
, /*type=*/NULL_TREE
, level
);
2020 /* Now, fill in the binding information. */
2021 binding
->previous
= IDENTIFIER_BINDING (id
);
2022 INHERITED_VALUE_BINDING_P (binding
) = 0;
2023 LOCAL_BINDING_P (binding
) = (level
!= class_binding_level
);
2025 /* And put it on the front of the list of bindings for ID. */
2026 IDENTIFIER_BINDING (id
) = binding
;
2029 /* Remove the binding for DECL which should be the innermost binding
2033 pop_local_binding (tree id
, tree decl
)
2035 cxx_binding
*binding
;
2037 if (id
== NULL_TREE
)
2038 /* It's easiest to write the loops that call this function without
2039 checking whether or not the entities involved have names. We
2040 get here for such an entity. */
2043 /* Get the innermost binding for ID. */
2044 binding
= IDENTIFIER_BINDING (id
);
2046 /* The name should be bound. */
2047 gcc_assert (binding
!= NULL
);
2049 /* The DECL will be either the ordinary binding or the type
2050 binding for this identifier. Remove that binding. */
2051 if (binding
->value
== decl
)
2052 binding
->value
= NULL_TREE
;
2055 gcc_assert (binding
->type
== decl
);
2056 binding
->type
= NULL_TREE
;
2059 if (!binding
->value
&& !binding
->type
)
2061 /* We're completely done with the innermost binding for this
2062 identifier. Unhook it from the list of bindings. */
2063 IDENTIFIER_BINDING (id
) = binding
->previous
;
2065 /* Add it to the free list. */
2066 cxx_binding_free (binding
);
2070 /* Remove the bindings for the decls of the current level and leave
2071 the current scope. */
2074 pop_bindings_and_leave_scope (void)
2076 for (tree t
= get_local_decls (); t
; t
= DECL_CHAIN (t
))
2078 tree decl
= TREE_CODE (t
) == TREE_LIST
? TREE_VALUE (t
) : t
;
2079 tree name
= OVL_NAME (decl
);
2081 pop_local_binding (name
, decl
);
2087 /* Strip non dependent using declarations. If DECL is dependent,
2088 surreptitiously create a typename_type and return it. */
2091 strip_using_decl (tree decl
)
2093 if (decl
== NULL_TREE
)
2096 while (TREE_CODE (decl
) == USING_DECL
&& !DECL_DEPENDENT_P (decl
))
2097 decl
= USING_DECL_DECLS (decl
);
2099 if (TREE_CODE (decl
) == USING_DECL
&& DECL_DEPENDENT_P (decl
)
2100 && USING_DECL_TYPENAME_P (decl
))
2102 /* We have found a type introduced by a using
2103 declaration at class scope that refers to a dependent
2106 using typename :: [opt] nested-name-specifier unqualified-id ;
2108 decl
= make_typename_type (TREE_TYPE (decl
),
2110 typename_type
, tf_error
);
2111 if (decl
!= error_mark_node
)
2112 decl
= TYPE_NAME (decl
);
2118 /* Return true if OVL is an overload for an anticipated builtin. */
2121 anticipated_builtin_p (tree ovl
)
2123 if (TREE_CODE (ovl
) != OVERLOAD
)
2126 if (!OVL_HIDDEN_P (ovl
))
2129 tree fn
= OVL_FUNCTION (ovl
);
2130 gcc_checking_assert (DECL_ANTICIPATED (fn
));
2132 if (DECL_HIDDEN_FRIEND_P (fn
))
2138 /* BINDING records an existing declaration for a name in the current scope.
2139 But, DECL is another declaration for that same identifier in the
2140 same scope. This is the `struct stat' hack whereby a non-typedef
2141 class name or enum-name can be bound at the same level as some other
2145 A class name (9.1) or enumeration name (7.2) can be hidden by the
2146 name of an object, function, or enumerator declared in the same scope.
2147 If a class or enumeration name and an object, function, or enumerator
2148 are declared in the same scope (in any order) with the same name, the
2149 class or enumeration name is hidden wherever the object, function, or
2150 enumerator name is visible.
2152 It's the responsibility of the caller to check that
2153 inserting this name is valid here. Returns nonzero if the new binding
2157 supplement_binding_1 (cxx_binding
*binding
, tree decl
)
2159 tree bval
= binding
->value
;
2161 tree target_bval
= strip_using_decl (bval
);
2162 tree target_decl
= strip_using_decl (decl
);
2164 if (TREE_CODE (target_decl
) == TYPE_DECL
&& DECL_ARTIFICIAL (target_decl
)
2165 && target_decl
!= target_bval
2166 && (TREE_CODE (target_bval
) != TYPE_DECL
2167 /* We allow pushing an enum multiple times in a class
2168 template in order to handle late matching of underlying
2169 type on an opaque-enum-declaration followed by an
2171 || (processing_template_decl
2172 && TREE_CODE (TREE_TYPE (target_decl
)) == ENUMERAL_TYPE
2173 && TREE_CODE (TREE_TYPE (target_bval
)) == ENUMERAL_TYPE
2174 && (dependent_type_p (ENUM_UNDERLYING_TYPE
2175 (TREE_TYPE (target_decl
)))
2176 || dependent_type_p (ENUM_UNDERLYING_TYPE
2177 (TREE_TYPE (target_bval
)))))))
2178 /* The new name is the type name. */
2179 binding
->type
= decl
;
2180 else if (/* TARGET_BVAL is null when push_class_level_binding moves
2181 an inherited type-binding out of the way to make room
2182 for a new value binding. */
2184 /* TARGET_BVAL is error_mark_node when TARGET_DECL's name
2185 has been used in a non-class scope prior declaration.
2186 In that case, we should have already issued a
2187 diagnostic; for graceful error recovery purpose, pretend
2188 this was the intended declaration for that name. */
2189 || target_bval
== error_mark_node
2190 /* If TARGET_BVAL is anticipated but has not yet been
2191 declared, pretend it is not there at all. */
2192 || anticipated_builtin_p (target_bval
))
2193 binding
->value
= decl
;
2194 else if (TREE_CODE (target_bval
) == TYPE_DECL
2195 && DECL_ARTIFICIAL (target_bval
)
2196 && target_decl
!= target_bval
2197 && (TREE_CODE (target_decl
) != TYPE_DECL
2198 || same_type_p (TREE_TYPE (target_decl
),
2199 TREE_TYPE (target_bval
))))
2201 /* The old binding was a type name. It was placed in
2202 VALUE field because it was thought, at the point it was
2203 declared, to be the only entity with such a name. Move the
2204 type name into the type slot; it is now hidden by the new
2206 binding
->type
= bval
;
2207 binding
->value
= decl
;
2208 binding
->value_is_inherited
= false;
2210 else if (TREE_CODE (target_bval
) == TYPE_DECL
2211 && TREE_CODE (target_decl
) == TYPE_DECL
2212 && DECL_NAME (target_decl
) == DECL_NAME (target_bval
)
2213 && binding
->scope
->kind
!= sk_class
2214 && (same_type_p (TREE_TYPE (target_decl
), TREE_TYPE (target_bval
))
2215 /* If either type involves template parameters, we must
2216 wait until instantiation. */
2217 || uses_template_parms (TREE_TYPE (target_decl
))
2218 || uses_template_parms (TREE_TYPE (target_bval
))))
2219 /* We have two typedef-names, both naming the same type to have
2220 the same name. In general, this is OK because of:
2224 In a given scope, a typedef specifier can be used to redefine
2225 the name of any type declared in that scope to refer to the
2226 type to which it already refers.
2228 However, in class scopes, this rule does not apply due to the
2229 stricter language in [class.mem] prohibiting redeclarations of
2232 /* There can be two block-scope declarations of the same variable,
2233 so long as they are `extern' declarations. However, there cannot
2234 be two declarations of the same static data member:
2238 A member shall not be declared twice in the
2239 member-specification. */
2240 else if (VAR_P (target_decl
)
2241 && VAR_P (target_bval
)
2242 && DECL_EXTERNAL (target_decl
) && DECL_EXTERNAL (target_bval
)
2243 && !DECL_CLASS_SCOPE_P (target_decl
))
2245 duplicate_decls (decl
, binding
->value
, /*newdecl_is_friend=*/false);
2248 else if (TREE_CODE (decl
) == NAMESPACE_DECL
2249 && TREE_CODE (bval
) == NAMESPACE_DECL
2250 && DECL_NAMESPACE_ALIAS (decl
)
2251 && DECL_NAMESPACE_ALIAS (bval
)
2252 && ORIGINAL_NAMESPACE (bval
) == ORIGINAL_NAMESPACE (decl
))
2253 /* [namespace.alias]
2255 In a declarative region, a namespace-alias-definition can be
2256 used to redefine a namespace-alias declared in that declarative
2257 region to refer only to the namespace to which it already
2262 if (!error_operand_p (bval
))
2263 diagnose_name_conflict (decl
, bval
);
2270 /* Diagnose a name conflict between DECL and BVAL. */
2273 diagnose_name_conflict (tree decl
, tree bval
)
2275 if (TREE_CODE (decl
) == TREE_CODE (bval
)
2276 && TREE_CODE (decl
) != NAMESPACE_DECL
2277 && !DECL_DECLARES_FUNCTION_P (decl
)
2278 && (TREE_CODE (decl
) != TYPE_DECL
2279 || DECL_ARTIFICIAL (decl
) == DECL_ARTIFICIAL (bval
))
2280 && CP_DECL_CONTEXT (decl
) == CP_DECL_CONTEXT (bval
))
2281 error ("redeclaration of %q#D", decl
);
2283 error ("%q#D conflicts with a previous declaration", decl
);
2285 inform (location_of (bval
), "previous declaration %q#D", bval
);
2288 /* Wrapper for supplement_binding_1. */
2291 supplement_binding (cxx_binding
*binding
, tree decl
)
2294 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
2295 ret
= supplement_binding_1 (binding
, decl
);
2296 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
2300 /* Replace BINDING's current value on its scope's name list with
2304 update_local_overload (cxx_binding
*binding
, tree newval
)
2308 for (d
= &binding
->scope
->names
; ; d
= &TREE_CHAIN (*d
))
2309 if (*d
== binding
->value
)
2311 /* Stitch new list node in. */
2312 *d
= tree_cons (NULL_TREE
, NULL_TREE
, TREE_CHAIN (*d
));
2315 else if (TREE_CODE (*d
) == TREE_LIST
&& TREE_VALUE (*d
) == binding
->value
)
2318 TREE_VALUE (*d
) = newval
;
2321 /* Compares the parameter-type-lists of ONE and TWO and
2322 returns false if they are different. If the DECLs are template
2323 functions, the return types and the template parameter lists are
2324 compared too (DR 565). */
2327 matching_fn_p (tree one
, tree two
)
2329 if (!compparms (TYPE_ARG_TYPES (TREE_TYPE (one
)),
2330 TYPE_ARG_TYPES (TREE_TYPE (two
))))
2333 if (TREE_CODE (one
) == TEMPLATE_DECL
2334 && TREE_CODE (two
) == TEMPLATE_DECL
)
2336 /* Compare template parms. */
2337 if (!comp_template_parms (DECL_TEMPLATE_PARMS (one
),
2338 DECL_TEMPLATE_PARMS (two
)))
2341 /* And return type. */
2342 if (!same_type_p (TREE_TYPE (TREE_TYPE (one
)),
2343 TREE_TYPE (TREE_TYPE (two
))))
2350 /* Push DECL into nonclass LEVEL BINDING or SLOT. OLD is the current
2351 binding value (possibly with anticipated builtins stripped).
2352 Diagnose conflicts and return updated decl. */
2355 update_binding (cp_binding_level
*level
, cxx_binding
*binding
, tree
*slot
,
2356 tree old
, tree decl
, bool is_friend
)
2359 tree old_type
= slot
? MAYBE_STAT_TYPE (*slot
) : binding
->type
;
2360 tree to_type
= old_type
;
2362 gcc_assert (level
->kind
== sk_namespace
? !binding
2363 : level
->kind
!= sk_class
&& !slot
);
2364 if (old
== error_mark_node
)
2367 if (TREE_CODE (decl
) == TYPE_DECL
&& DECL_ARTIFICIAL (decl
))
2369 tree other
= to_type
;
2371 if (old
&& TREE_CODE (old
) == TYPE_DECL
&& DECL_ARTIFICIAL (old
))
2374 /* Pushing an artificial typedef. See if this matches either
2375 the type slot or the old value slot. */
2378 else if (same_type_p (TREE_TYPE (other
), TREE_TYPE (decl
)))
2379 /* Two artificial decls to same type. Do nothing. */
2386 /* Slide decl into the type slot, keep old unaltered */
2393 if (old
&& TREE_CODE (old
) == TYPE_DECL
&& DECL_ARTIFICIAL (old
))
2395 /* Slide old into the type slot. */
2400 if (DECL_DECLARES_FUNCTION_P (decl
))
2404 else if (OVL_P (old
))
2406 for (ovl_iterator
iter (old
); iter
; ++iter
)
2410 if (iter
.using_p () && matching_fn_p (fn
, decl
))
2412 /* If a function declaration in namespace scope or
2413 block scope has the same name and the same
2414 parameter-type- list (8.3.5) as a function
2415 introduced by a using-declaration, and the
2416 declarations do not declare the same function,
2417 the program is ill-formed. [namespace.udecl]/14 */
2418 if (tree match
= duplicate_decls (decl
, fn
, is_friend
))
2421 /* FIXME: To preserve existing error behavior, we
2422 still push the decl. This might change. */
2423 diagnose_name_conflict (decl
, fn
);
2430 if (to_type
!= old_type
2432 && MAYBE_CLASS_TYPE_P (TREE_TYPE (to_type
))
2433 && !(DECL_IN_SYSTEM_HEADER (decl
)
2434 && DECL_IN_SYSTEM_HEADER (to_type
)))
2435 warning (OPT_Wshadow
, "%q#D hides constructor for %q#D",
2438 to_val
= ovl_insert (decl
, old
);
2442 else if (TREE_CODE (old
) != TREE_CODE (decl
))
2443 /* Different kinds of decls conflict. */
2445 else if (TREE_CODE (old
) == TYPE_DECL
)
2447 if (same_type_p (TREE_TYPE (old
), TREE_TYPE (decl
)))
2448 /* Two type decls to the same type. Do nothing. */
2453 else if (TREE_CODE (old
) == NAMESPACE_DECL
)
2455 /* Two maybe-aliased namespaces. If they're to the same target
2456 namespace, that's ok. */
2457 if (ORIGINAL_NAMESPACE (old
) != ORIGINAL_NAMESPACE (decl
))
2460 /* The new one must be an alias at this point. */
2461 gcc_assert (DECL_NAMESPACE_ALIAS (decl
));
2464 else if (TREE_CODE (old
) == VAR_DECL
)
2466 /* There can be two block-scope declarations of the same
2467 variable, so long as they are `extern' declarations. */
2468 if (!DECL_EXTERNAL (old
) || !DECL_EXTERNAL (decl
))
2470 else if (tree match
= duplicate_decls (decl
, old
, false))
2478 diagnose_name_conflict (decl
, old
);
2485 if (level
->kind
== sk_namespace
|| to_type
== decl
|| to_val
== decl
)
2486 add_decl_to_level (level
, decl
);
2489 gcc_checking_assert (binding
->value
&& OVL_P (binding
->value
));
2490 update_local_overload (binding
, to_val
);
2495 if (STAT_HACK_P (*slot
))
2497 STAT_TYPE (*slot
) = to_type
;
2498 STAT_DECL (*slot
) = to_val
;
2501 *slot
= stat_hack (to_val
, to_type
);
2507 binding
->type
= to_type
;
2508 binding
->value
= to_val
;
2515 /* Table of identifiers to extern C declarations (or LISTS thereof). */
2517 static GTY(()) hash_table
<named_decl_hash
> *extern_c_decls
;
2519 /* DECL has C linkage. If we have an existing instance, make sure the
2520 new one is compatible. Make sure it has the same exception
2521 specification [7.5, 7.6]. Add DECL to the map. */
2524 check_extern_c_conflict (tree decl
)
2526 /* Ignore artificial or system header decls. */
2527 if (DECL_ARTIFICIAL (decl
) || DECL_IN_SYSTEM_HEADER (decl
))
2530 /* This only applies to decls at namespace scope. */
2531 if (!DECL_NAMESPACE_SCOPE_P (decl
))
2534 if (!extern_c_decls
)
2535 extern_c_decls
= hash_table
<named_decl_hash
>::create_ggc (127);
2537 tree
*slot
= extern_c_decls
2538 ->find_slot_with_hash (DECL_NAME (decl
),
2539 IDENTIFIER_HASH_VALUE (DECL_NAME (decl
)), INSERT
);
2540 if (tree old
= *slot
)
2542 if (TREE_CODE (old
) == OVERLOAD
)
2543 old
= OVL_FUNCTION (old
);
2546 if (DECL_CONTEXT (old
) == DECL_CONTEXT (decl
))
2547 ; /* If they're in the same context, we'll have already complained
2548 about a (possible) mismatch, when inserting the decl. */
2549 else if (!decls_match (decl
, old
))
2551 else if (TREE_CODE (decl
) == FUNCTION_DECL
2552 && !comp_except_specs (TYPE_RAISES_EXCEPTIONS (TREE_TYPE (old
)),
2553 TYPE_RAISES_EXCEPTIONS (TREE_TYPE (decl
)),
2556 else if (DECL_ASSEMBLER_NAME_SET_P (old
))
2557 SET_DECL_ASSEMBLER_NAME (decl
, DECL_ASSEMBLER_NAME (old
));
2561 pedwarn (input_location
, 0,
2562 "conflicting C language linkage declaration %q#D", decl
);
2563 inform (DECL_SOURCE_LOCATION (old
),
2564 "previous declaration %q#D", old
);
2566 inform (input_location
,
2567 "due to different exception specifications");
2572 /* The hash table expects OVERLOADS, so construct one with
2573 OLD as both the function and the chain. This allocate
2574 an excess OVERLOAD node, but it's rare to have multiple
2575 extern "C" decls of the same name. And we save
2576 complicating the hash table logic (which is used
2578 *slot
= ovl_make (old
, old
);
2580 slot
= &OVL_CHAIN (*slot
);
2582 /* Chain it on for c_linkage_binding's use. */
2583 *slot
= tree_cons (NULL_TREE
, decl
, *slot
);
2590 /* Returns a list of C-linkage decls with the name NAME. Used in
2591 c-family/c-pragma.c to implement redefine_extname pragma. */
2594 c_linkage_bindings (tree name
)
2597 if (tree
*slot
= extern_c_decls
2598 ->find_slot_with_hash (name
, IDENTIFIER_HASH_VALUE (name
), NO_INSERT
))
2600 tree result
= *slot
;
2601 if (TREE_CODE (result
) == OVERLOAD
)
2602 result
= OVL_CHAIN (result
);
2609 /* DECL is being declared at a local scope. Emit suitable shadow
2613 check_local_shadow (tree decl
)
2615 /* Don't complain about the parms we push and then pop
2616 while tentatively parsing a function declarator. */
2617 if (TREE_CODE (decl
) == PARM_DECL
&& !DECL_CONTEXT (decl
))
2620 /* Inline decls shadow nothing. */
2621 if (DECL_FROM_INLINE (decl
))
2624 /* External decls are something else. */
2625 if (DECL_EXTERNAL (decl
))
2628 tree old
= NULL_TREE
;
2629 cp_binding_level
*old_scope
= NULL
;
2630 if (cxx_binding
*binding
= outer_binding (DECL_NAME (decl
), NULL
, true))
2632 old
= binding
->value
;
2633 old_scope
= binding
->scope
;
2635 while (old
&& VAR_P (old
) && DECL_DEAD_FOR_LOCAL (old
))
2636 old
= DECL_SHADOWED_FOR_VAR (old
);
2638 tree shadowed
= NULL_TREE
;
2640 && (TREE_CODE (old
) == PARM_DECL
2642 || (TREE_CODE (old
) == TYPE_DECL
2643 && (!DECL_ARTIFICIAL (old
)
2644 || TREE_CODE (decl
) == TYPE_DECL
)))
2645 && DECL_FUNCTION_SCOPE_P (old
)
2646 && (!DECL_ARTIFICIAL (decl
)
2647 || DECL_IMPLICIT_TYPEDEF_P (decl
)
2648 || (VAR_P (decl
) && DECL_ANON_UNION_VAR_P (decl
))))
2650 /* DECL shadows a local thing possibly of interest. */
2652 /* Don't complain if it's from an enclosing function. */
2653 if (DECL_CONTEXT (old
) == current_function_decl
2654 && TREE_CODE (decl
) != PARM_DECL
2655 && TREE_CODE (old
) == PARM_DECL
)
2657 /* Go to where the parms should be and see if we find
2659 cp_binding_level
*b
= current_binding_level
->level_chain
;
2661 if (FUNCTION_NEEDS_BODY_BLOCK (current_function_decl
))
2662 /* Skip the ctor/dtor cleanup level. */
2666 if (b
->kind
== sk_function_parms
)
2668 error ("declaration of %q#D shadows a parameter", decl
);
2673 /* The local structure or class can't use parameters of
2674 the containing function anyway. */
2675 if (DECL_CONTEXT (old
) != current_function_decl
)
2677 for (cp_binding_level
*scope
= current_binding_level
;
2678 scope
!= old_scope
; scope
= scope
->level_chain
)
2679 if (scope
->kind
== sk_class
2680 && !LAMBDA_TYPE_P (scope
->this_entity
))
2683 /* Error if redeclaring a local declared in a
2684 init-statement or in the condition of an if or
2685 switch statement when the new declaration is in the
2686 outermost block of the controlled statement.
2687 Redeclaring a variable from a for or while condition is
2688 detected elsewhere. */
2689 else if (VAR_P (old
)
2690 && old_scope
== current_binding_level
->level_chain
2691 && (old_scope
->kind
== sk_cond
|| old_scope
->kind
== sk_for
))
2693 error ("redeclaration of %q#D", decl
);
2694 inform (DECL_SOURCE_LOCATION (old
),
2695 "%q#D previously declared here", old
);
2699 3.3.3/3: The name declared in an exception-declaration (...)
2700 shall not be redeclared in the outermost block of the handler.
2701 3.3.3/2: A parameter name shall not be redeclared (...) in
2702 the outermost block of any handler associated with a
2704 3.4.1/15: The function parameter names shall not be redeclared
2705 in the exception-declaration nor in the outermost block of a
2706 handler for the function-try-block. */
2707 else if ((TREE_CODE (old
) == VAR_DECL
2708 && old_scope
== current_binding_level
->level_chain
2709 && old_scope
->kind
== sk_catch
)
2710 || (TREE_CODE (old
) == PARM_DECL
2711 && (current_binding_level
->kind
== sk_catch
2712 || current_binding_level
->level_chain
->kind
== sk_catch
)
2713 && in_function_try_handler
))
2715 if (permerror (input_location
, "redeclaration of %q#D", decl
))
2716 inform (DECL_SOURCE_LOCATION (old
),
2717 "%q#D previously declared here", old
);
2721 /* If '-Wshadow=compatible-local' is specified without other
2722 -Wshadow= flags, we will warn only when the type of the
2723 shadowing variable (DECL) can be converted to that of the
2724 shadowed parameter (OLD_LOCAL). The reason why we only check
2725 if DECL's type can be converted to OLD_LOCAL's type (but not the
2726 other way around) is because when users accidentally shadow a
2727 parameter, more than often they would use the variable
2728 thinking (mistakenly) it's still the parameter. It would be
2729 rare that users would use the variable in the place that
2730 expects the parameter but thinking it's a new decl. */
2732 enum opt_code warning_code
;
2734 warning_code
= OPT_Wshadow
;
2735 else if (warn_shadow_local
)
2736 warning_code
= OPT_Wshadow_local
;
2737 else if (warn_shadow_compatible_local
2738 && (same_type_p (TREE_TYPE (old
), TREE_TYPE (decl
))
2739 || (!dependent_type_p (TREE_TYPE (decl
))
2740 && !dependent_type_p (TREE_TYPE (old
))
2741 && can_convert (TREE_TYPE (old
), TREE_TYPE (decl
),
2743 warning_code
= OPT_Wshadow_compatible_local
;
2748 if (TREE_CODE (old
) == PARM_DECL
)
2749 msg
= "declaration of %q#D shadows a parameter";
2750 else if (is_capture_proxy (old
))
2751 msg
= "declaration of %qD shadows a lambda capture";
2753 msg
= "declaration of %qD shadows a previous local";
2755 if (warning_at (input_location
, warning_code
, msg
, decl
))
2758 goto inform_shadowed
;
2766 /* Don't warn for artificial things that are not implicit typedefs. */
2767 if (DECL_ARTIFICIAL (decl
) && !DECL_IMPLICIT_TYPEDEF_P (decl
))
2770 if (nonlambda_method_basetype ())
2771 if (tree member
= lookup_member (current_nonlambda_class_type (),
2772 DECL_NAME (decl
), /*protect=*/0,
2773 /*want_type=*/false, tf_warning_or_error
))
2775 member
= MAYBE_BASELINK_FUNCTIONS (member
);
2777 /* Warn if a variable shadows a non-function, or the variable
2778 is a function or a pointer-to-function. */
2780 || TREE_CODE (decl
) == FUNCTION_DECL
2781 || TYPE_PTRFN_P (TREE_TYPE (decl
))
2782 || TYPE_PTRMEMFUNC_P (TREE_TYPE (decl
)))
2784 if (warning_at (input_location
, OPT_Wshadow
,
2785 "declaration of %qD shadows a member of %qT",
2786 decl
, current_nonlambda_class_type ())
2790 goto inform_shadowed
;
2796 /* Now look for a namespace shadow. */
2797 old
= find_namespace_value (current_namespace
, DECL_NAME (decl
));
2800 || (TREE_CODE (old
) == TYPE_DECL
2801 && (!DECL_ARTIFICIAL (old
)
2802 || TREE_CODE (decl
) == TYPE_DECL
)))
2803 && !instantiating_current_function_p ())
2804 /* XXX shadow warnings in outer-more namespaces */
2806 if (warning_at (input_location
, OPT_Wshadow
,
2807 "declaration of %qD shadows a global declaration",
2811 goto inform_shadowed
;
2819 inform (DECL_SOURCE_LOCATION (shadowed
), "shadowed declaration is here");
2822 /* DECL is being pushed inside function CTX. Set its context, if
2826 set_decl_context_in_fn (tree ctx
, tree decl
)
2828 if (!DECL_CONTEXT (decl
)
2829 /* A local declaration for a function doesn't constitute
2831 && TREE_CODE (decl
) != FUNCTION_DECL
2832 /* A local declaration for an `extern' variable is in the
2833 scope of the current namespace, not the current
2835 && !(VAR_P (decl
) && DECL_EXTERNAL (decl
))
2836 /* When parsing the parameter list of a function declarator,
2837 don't set DECL_CONTEXT to an enclosing function. When we
2838 push the PARM_DECLs in order to process the function body,
2839 current_binding_level->this_entity will be set. */
2840 && !(TREE_CODE (decl
) == PARM_DECL
2841 && current_binding_level
->kind
== sk_function_parms
2842 && current_binding_level
->this_entity
== NULL
))
2843 DECL_CONTEXT (decl
) = ctx
;
2845 /* If this is the declaration for a namespace-scope function,
2846 but the declaration itself is in a local scope, mark the
2848 if (TREE_CODE (decl
) == FUNCTION_DECL
&& DECL_NAMESPACE_SCOPE_P (decl
))
2849 DECL_LOCAL_FUNCTION_P (decl
) = 1;
2852 /* DECL is a local-scope decl with linkage. SHADOWED is true if the
2853 name is already bound at the current level.
2855 [basic.link] If there is a visible declaration of an entity with
2856 linkage having the same name and type, ignoring entities declared
2857 outside the innermost enclosing namespace scope, the block scope
2858 declaration declares that same entity and receives the linkage of
2859 the previous declaration.
2861 Also, make sure that this decl matches any existing external decl
2862 in the enclosing namespace. */
2865 set_local_extern_decl_linkage (tree decl
, bool shadowed
)
2867 tree ns_value
= decl
; /* Unique marker. */
2871 tree loc_value
= innermost_non_namespace_value (DECL_NAME (decl
));
2875 = find_namespace_value (current_namespace
, DECL_NAME (decl
));
2876 loc_value
= ns_value
;
2878 if (loc_value
== error_mark_node
2879 /* An ambiguous lookup. */
2880 || (loc_value
&& TREE_CODE (loc_value
) == TREE_LIST
))
2881 loc_value
= NULL_TREE
;
2883 for (ovl_iterator
iter (loc_value
); iter
; ++iter
)
2884 if (!iter
.hidden_p ()
2885 && (TREE_STATIC (*iter
) || DECL_EXTERNAL (*iter
))
2886 && decls_match (*iter
, decl
))
2888 /* The standard only says that the local extern inherits
2889 linkage from the previous decl; in particular, default
2890 args are not shared. Add the decl into a hash table to
2891 make sure only the previous decl in this case is seen
2892 by the middle end. */
2893 struct cxx_int_tree_map
*h
;
2895 /* We inherit the outer decl's linkage. But we're a
2897 TREE_PUBLIC (decl
) = TREE_PUBLIC (*iter
);
2899 if (cp_function_chain
->extern_decl_map
== NULL
)
2900 cp_function_chain
->extern_decl_map
2901 = hash_table
<cxx_int_tree_map_hasher
>::create_ggc (20);
2903 h
= ggc_alloc
<cxx_int_tree_map
> ();
2904 h
->uid
= DECL_UID (decl
);
2906 cxx_int_tree_map
**loc
= cp_function_chain
->extern_decl_map
2907 ->find_slot (h
, INSERT
);
2913 if (TREE_PUBLIC (decl
))
2915 /* DECL is externally visible. Make sure it matches a matching
2916 decl in the namespace scope. We only really need to check
2917 this when inserting the decl, not when we find an existing
2918 match in the current scope. However, in practice we're
2919 going to be inserting a new decl in the majority of cases --
2920 who writes multiple extern decls for the same thing in the
2921 same local scope? Doing it here often avoids a duplicate
2922 namespace lookup. */
2924 /* Avoid repeating a lookup. */
2925 if (ns_value
== decl
)
2926 ns_value
= find_namespace_value (current_namespace
, DECL_NAME (decl
));
2928 if (ns_value
== error_mark_node
2929 || (ns_value
&& TREE_CODE (ns_value
) == TREE_LIST
))
2930 ns_value
= NULL_TREE
;
2932 for (ovl_iterator
iter (ns_value
); iter
; ++iter
)
2936 if (!(TREE_PUBLIC (other
) || DECL_EXTERNAL (other
)))
2937 ; /* Not externally visible. */
2938 else if (DECL_EXTERN_C_P (decl
) && DECL_EXTERN_C_P (other
))
2939 ; /* Both are extern "C", we'll check via that mechanism. */
2940 else if (TREE_CODE (other
) != TREE_CODE (decl
)
2941 || ((VAR_P (decl
) || matching_fn_p (other
, decl
))
2942 && !comptypes (TREE_TYPE (decl
), TREE_TYPE (other
),
2943 COMPARE_REDECLARATION
)))
2945 if (permerror (DECL_SOURCE_LOCATION (decl
),
2946 "local external declaration %q#D", decl
))
2947 inform (DECL_SOURCE_LOCATION (other
),
2948 "does not match previous declaration %q#D", other
);
2955 /* Record DECL as belonging to the current lexical scope. Check for
2956 errors (such as an incompatible declaration for the same name
2957 already seen in the same scope). IS_FRIEND is true if DECL is
2958 declared as a friend.
2960 Returns either DECL or an old decl for the same name. If an old
2961 decl is returned, it may have been smashed to agree with what DECL
2965 do_pushdecl (tree decl
, bool is_friend
)
2967 if (decl
== error_mark_node
)
2968 return error_mark_node
;
2970 if (!DECL_TEMPLATE_PARM_P (decl
) && current_function_decl
)
2971 set_decl_context_in_fn (current_function_decl
, decl
);
2973 /* The binding level we will be pushing into. During local class
2974 pushing, we want to push to the containing scope. */
2975 cp_binding_level
*level
= current_binding_level
;
2976 while (level
->kind
== sk_class
)
2977 level
= level
->level_chain
;
2979 /* An anonymous namespace has a NULL DECL_NAME, but we still want to
2980 insert it. Other NULL-named decls, not so much. */
2981 tree name
= DECL_NAME (decl
);
2982 if (name
|| TREE_CODE (decl
) == NAMESPACE_DECL
)
2984 cxx_binding
*binding
= NULL
; /* Local scope binding. */
2985 tree ns
= NULL_TREE
; /* Searched namespace. */
2986 tree
*slot
= NULL
; /* Binding slot in namespace. */
2987 tree old
= NULL_TREE
;
2989 if (level
->kind
== sk_namespace
)
2991 /* We look in the decl's namespace for an existing
2992 declaration, even though we push into the current
2994 ns
= (DECL_NAMESPACE_SCOPE_P (decl
)
2995 ? CP_DECL_CONTEXT (decl
) : current_namespace
);
2996 /* Create the binding, if this is current namespace, because
2997 that's where we'll be pushing anyway. */
2998 slot
= find_namespace_slot (ns
, name
, ns
== current_namespace
);
3000 old
= MAYBE_STAT_DECL (*slot
);
3004 binding
= find_local_binding (level
, name
);
3006 old
= binding
->value
;
3009 if (current_function_decl
&& VAR_OR_FUNCTION_DECL_P (decl
)
3010 && DECL_EXTERNAL (decl
))
3011 set_local_extern_decl_linkage (decl
, old
!= NULL_TREE
);
3013 if (old
== error_mark_node
)
3016 for (ovl_iterator
iter (old
); iter
; ++iter
)
3017 if (iter
.using_p ())
3018 ; /* Ignore using decls here. */
3019 else if (tree match
= duplicate_decls (decl
, *iter
, is_friend
))
3021 if (match
== error_mark_node
)
3023 else if (TREE_CODE (match
) == TYPE_DECL
)
3024 /* The IDENTIFIER will have the type referring to the
3025 now-smashed TYPE_DECL, because ...? Reset it. */
3026 SET_IDENTIFIER_TYPE_VALUE (name
, TREE_TYPE (match
));
3027 else if (iter
.hidden_p () && !DECL_HIDDEN_P (match
))
3029 /* Unhiding a previously hidden decl. */
3030 tree head
= iter
.reveal_node (old
);
3035 update_local_overload (binding
, head
);
3036 binding
->value
= head
;
3038 else if (STAT_HACK_P (*slot
))
3039 STAT_DECL (*slot
) = head
;
3043 if (DECL_EXTERN_C_P (match
))
3044 /* We need to check and register the decl now. */
3045 check_extern_c_conflict (match
);
3050 /* We are pushing a new decl. */
3052 /* Skip a hidden builtin we failed to match already. There can
3054 if (old
&& anticipated_builtin_p (old
))
3055 old
= OVL_CHAIN (old
);
3057 check_template_shadow (decl
);
3058 bool visible_injection
= false;
3060 if (DECL_DECLARES_FUNCTION_P (decl
))
3062 check_default_args (decl
);
3066 if (level
->kind
!= sk_namespace
)
3068 /* In a local class, a friend function declaration must
3069 find a matching decl in the innermost non-class scope.
3070 [class.friend/11] */
3071 error ("friend declaration %qD in local class without "
3072 "prior local declaration", decl
);
3073 /* Don't attempt to push it. */
3074 return error_mark_node
;
3076 if (!flag_friend_injection
)
3077 /* Hide it from ordinary lookup. */
3078 DECL_ANTICIPATED (decl
) = DECL_HIDDEN_FRIEND_P (decl
) = true;
3080 visible_injection
= true;
3084 if (level
->kind
!= sk_namespace
)
3086 check_local_shadow (decl
);
3088 if (TREE_CODE (decl
) == NAMESPACE_DECL
)
3089 /* A local namespace alias. */
3090 set_identifier_type_value (name
, NULL_TREE
);
3093 binding
= create_local_binding (level
, name
);
3097 ns
= current_namespace
;
3098 slot
= find_namespace_slot (ns
, name
, true);
3099 /* Update OLD to reflect the namespace we're going to be
3101 old
= MAYBE_STAT_DECL (*slot
);
3104 old
= update_binding (level
, binding
, slot
, old
, decl
, is_friend
);
3107 /* An existing decl matched, use it. */
3109 else if (TREE_CODE (decl
) == TYPE_DECL
)
3111 tree type
= TREE_TYPE (decl
);
3113 if (type
!= error_mark_node
)
3115 if (TYPE_NAME (type
) != decl
)
3116 set_underlying_type (decl
);
3119 set_identifier_type_value_with_scope (name
, decl
, level
);
3121 SET_IDENTIFIER_TYPE_VALUE (name
, global_type_node
);
3124 /* If this is a locally defined typedef in a function that
3125 is not a template instantation, record it to implement
3126 -Wunused-local-typedefs. */
3127 if (!instantiating_current_function_p ())
3128 record_locally_defined_typedef (decl
);
3130 else if (VAR_P (decl
))
3131 maybe_register_incomplete_var (decl
);
3132 else if (visible_injection
)
3133 warning (0, "injected friend %qD is visible"
3134 " due to %<-ffriend-injection%>", decl
);
3136 if ((VAR_P (decl
) || TREE_CODE (decl
) == FUNCTION_DECL
)
3137 && DECL_EXTERN_C_P (decl
))
3138 check_extern_c_conflict (decl
);
3141 add_decl_to_level (level
, decl
);
3146 /* Record a decl-node X as belonging to the current lexical scope.
3147 It's a friend if IS_FRIEND is true -- which affects exactly where
3151 pushdecl (tree x
, bool is_friend
)
3153 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
3154 tree ret
= do_pushdecl (x
, is_friend
);
3155 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
3159 /* Enter DECL into the symbol table, if that's appropriate. Returns
3160 DECL, or a modified version thereof. */
3163 maybe_push_decl (tree decl
)
3165 tree type
= TREE_TYPE (decl
);
3167 /* Add this decl to the current binding level, but not if it comes
3168 from another scope, e.g. a static member variable. TEM may equal
3169 DECL or it may be a previous decl of the same name. */
3170 if (decl
== error_mark_node
3171 || (TREE_CODE (decl
) != PARM_DECL
3172 && DECL_CONTEXT (decl
) != NULL_TREE
3173 /* Definitions of namespace members outside their namespace are
3175 && !DECL_NAMESPACE_SCOPE_P (decl
))
3176 || (TREE_CODE (decl
) == TEMPLATE_DECL
&& !namespace_bindings_p ())
3177 || type
== unknown_type_node
3178 /* The declaration of a template specialization does not affect
3179 the functions available for overload resolution, so we do not
3181 || (TREE_CODE (decl
) == FUNCTION_DECL
3182 && DECL_TEMPLATE_SPECIALIZATION (decl
)))
3185 return pushdecl (decl
);
3188 /* Bind DECL to ID in the current_binding_level, assumed to be a local
3189 binding level. If IS_USING is true, DECL got here through a
3190 using-declaration. */
3193 push_local_binding (tree id
, tree decl
, bool is_using
)
3195 /* Skip over any local classes. This makes sense if we call
3196 push_local_binding with a friend decl of a local class. */
3197 cp_binding_level
*b
= innermost_nonclass_level ();
3199 gcc_assert (b
->kind
!= sk_namespace
);
3200 if (find_local_binding (b
, id
))
3202 /* Supplement the existing binding. */
3203 if (!supplement_binding (IDENTIFIER_BINDING (id
), decl
))
3204 /* It didn't work. Something else must be bound at this
3205 level. Do not add DECL to the list of things to pop
3210 /* Create a new binding. */
3211 push_binding (id
, decl
, b
);
3213 if (TREE_CODE (decl
) == OVERLOAD
|| is_using
)
3214 /* We must put the OVERLOAD or using into a TREE_LIST since we
3215 cannot use the decl's chain itself. */
3216 decl
= build_tree_list (NULL_TREE
, decl
);
3218 /* And put DECL on the list of things declared by the current
3220 add_decl_to_level (b
, decl
);
3223 /* Check to see whether or not DECL is a variable that would have been
3224 in scope under the ARM, but is not in scope under the ANSI/ISO
3225 standard. If so, issue an error message. If name lookup would
3226 work in both cases, but return a different result, this function
3227 returns the result of ANSI/ISO lookup. Otherwise, it returns
3230 FIXME: Scheduled for removal after GCC-8 is done. */
3233 check_for_out_of_scope_variable (tree decl
)
3237 /* We only care about out of scope variables. */
3238 if (!(VAR_P (decl
) && DECL_DEAD_FOR_LOCAL (decl
)))
3241 shadowed
= DECL_HAS_SHADOWED_FOR_VAR_P (decl
)
3242 ? DECL_SHADOWED_FOR_VAR (decl
) : NULL_TREE
;
3243 while (shadowed
!= NULL_TREE
&& VAR_P (shadowed
)
3244 && DECL_DEAD_FOR_LOCAL (shadowed
))
3245 shadowed
= DECL_HAS_SHADOWED_FOR_VAR_P (shadowed
)
3246 ? DECL_SHADOWED_FOR_VAR (shadowed
) : NULL_TREE
;
3248 shadowed
= find_namespace_value (current_namespace
, DECL_NAME (decl
));
3251 if (!DECL_ERROR_REPORTED (decl
)
3253 && warning (0, "name lookup of %qD changed", DECL_NAME (decl
)))
3255 inform (DECL_SOURCE_LOCATION (shadowed
),
3256 "matches this %qD under ISO standard rules", shadowed
);
3257 inform (DECL_SOURCE_LOCATION (decl
),
3258 " matches this %qD under old rules", decl
);
3260 DECL_ERROR_REPORTED (decl
) = 1;
3264 /* If we have already complained about this declaration, there's no
3265 need to do it again. */
3266 if (DECL_ERROR_REPORTED (decl
))
3269 DECL_ERROR_REPORTED (decl
) = 1;
3271 if (TREE_TYPE (decl
) == error_mark_node
)
3274 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TREE_TYPE (decl
)))
3276 error ("name lookup of %qD changed for ISO %<for%> scoping",
3278 inform (DECL_SOURCE_LOCATION (decl
),
3279 "cannot use obsolete binding %qD because it has a destructor",
3281 return error_mark_node
;
3285 permerror (input_location
,
3286 "name lookup of %qD changed for ISO %<for%> scoping",
3288 if (flag_permissive
)
3289 inform (DECL_SOURCE_LOCATION (decl
),
3290 "using obsolete binding %qD", decl
);
3293 inform (input_location
, flag_permissive
3294 ? "this flexibility is deprecated and will be removed"
3295 : "if you use %<-fpermissive%> G++ will accept your code");
3302 /* true means unconditionally make a BLOCK for the next level pushed. */
3304 static bool keep_next_level_flag
;
3306 static int binding_depth
= 0;
3313 for (i
= 0; i
< depth
* 2; i
++)
3317 /* Return a string describing the kind of SCOPE we have. */
3319 cp_binding_level_descriptor (cp_binding_level
*scope
)
3321 /* The order of this table must match the "scope_kind"
3323 static const char* scope_kind_names
[] = {
3329 "function-parameter-scope",
3332 "template-parameter-scope",
3333 "template-explicit-spec-scope"
3335 const scope_kind kind
= scope
->explicit_spec_p
3336 ? sk_template_spec
: scope
->kind
;
3338 return scope_kind_names
[kind
];
3341 /* Output a debugging information about SCOPE when performing
3344 cp_binding_level_debug (cp_binding_level
*scope
, int line
, const char *action
)
3346 const char *desc
= cp_binding_level_descriptor (scope
);
3347 if (scope
->this_entity
)
3348 verbatim ("%s %<%s(%E)%> %p %d\n", action
, desc
,
3349 scope
->this_entity
, (void *) scope
, line
);
3351 verbatim ("%s %s %p %d\n", action
, desc
, (void *) scope
, line
);
3354 /* Return the estimated initial size of the hashtable of a NAMESPACE
3357 static inline size_t
3358 namespace_scope_ht_size (tree ns
)
3360 tree name
= DECL_NAME (ns
);
3362 return name
== std_identifier
3363 ? NAMESPACE_STD_HT_SIZE
3364 : (name
== global_identifier
3365 ? GLOBAL_SCOPE_HT_SIZE
3366 : NAMESPACE_ORDINARY_HT_SIZE
);
3369 /* A chain of binding_level structures awaiting reuse. */
3371 static GTY((deletable
)) cp_binding_level
*free_binding_level
;
3373 /* Insert SCOPE as the innermost binding level. */
3376 push_binding_level (cp_binding_level
*scope
)
3378 /* Add it to the front of currently active scopes stack. */
3379 scope
->level_chain
= current_binding_level
;
3380 current_binding_level
= scope
;
3381 keep_next_level_flag
= false;
3383 if (ENABLE_SCOPE_CHECKING
)
3385 scope
->binding_depth
= binding_depth
;
3386 indent (binding_depth
);
3387 cp_binding_level_debug (scope
, LOCATION_LINE (input_location
),
3393 /* Create a new KIND scope and make it the top of the active scopes stack.
3394 ENTITY is the scope of the associated C++ entity (namespace, class,
3395 function, C++0x enumeration); it is NULL otherwise. */
3398 begin_scope (scope_kind kind
, tree entity
)
3400 cp_binding_level
*scope
;
3402 /* Reuse or create a struct for this binding level. */
3403 if (!ENABLE_SCOPE_CHECKING
&& free_binding_level
)
3405 scope
= free_binding_level
;
3406 free_binding_level
= scope
->level_chain
;
3407 memset (scope
, 0, sizeof (cp_binding_level
));
3410 scope
= ggc_cleared_alloc
<cp_binding_level
> ();
3412 scope
->this_entity
= entity
;
3413 scope
->more_cleanups_ok
= true;
3420 case sk_template_spec
:
3421 scope
->explicit_spec_p
= true;
3422 kind
= sk_template_parms
;
3424 case sk_template_parms
:
3431 case sk_scoped_enum
:
3432 case sk_function_parms
:
3433 case sk_transaction
:
3435 scope
->keep
= keep_next_level_flag
;
3439 NAMESPACE_LEVEL (entity
) = scope
;
3443 /* Should not happen. */
3449 push_binding_level (scope
);
3454 /* We're about to leave current scope. Pop the top of the stack of
3455 currently active scopes. Return the enclosing scope, now active. */
3460 cp_binding_level
*scope
= current_binding_level
;
3462 if (scope
->kind
== sk_namespace
&& class_binding_level
)
3463 current_binding_level
= class_binding_level
;
3465 /* We cannot leave a scope, if there are none left. */
3466 if (NAMESPACE_LEVEL (global_namespace
))
3467 gcc_assert (!global_scope_p (scope
));
3469 if (ENABLE_SCOPE_CHECKING
)
3471 indent (--binding_depth
);
3472 cp_binding_level_debug (scope
, LOCATION_LINE (input_location
),
3476 /* Move one nesting level up. */
3477 current_binding_level
= scope
->level_chain
;
3479 /* Namespace-scopes are left most probably temporarily, not
3480 completely; they can be reopened later, e.g. in namespace-extension
3481 or any name binding activity that requires us to resume a
3482 namespace. For classes, we cache some binding levels. For other
3483 scopes, we just make the structure available for reuse. */
3484 if (scope
->kind
!= sk_namespace
3485 && scope
->kind
!= sk_class
)
3487 scope
->level_chain
= free_binding_level
;
3488 gcc_assert (!ENABLE_SCOPE_CHECKING
3489 || scope
->binding_depth
== binding_depth
);
3490 free_binding_level
= scope
;
3493 if (scope
->kind
== sk_class
)
3495 /* Reset DEFINING_CLASS_P to allow for reuse of a
3496 class-defining scope in a non-defining context. */
3497 scope
->defining_class_p
= 0;
3499 /* Find the innermost enclosing class scope, and reset
3500 CLASS_BINDING_LEVEL appropriately. */
3501 class_binding_level
= NULL
;
3502 for (scope
= current_binding_level
; scope
; scope
= scope
->level_chain
)
3503 if (scope
->kind
== sk_class
)
3505 class_binding_level
= scope
;
3510 return current_binding_level
;
3514 resume_scope (cp_binding_level
* b
)
3516 /* Resuming binding levels is meant only for namespaces,
3517 and those cannot nest into classes. */
3518 gcc_assert (!class_binding_level
);
3519 /* Also, resuming a non-directly nested namespace is a no-no. */
3520 gcc_assert (b
->level_chain
== current_binding_level
);
3521 current_binding_level
= b
;
3522 if (ENABLE_SCOPE_CHECKING
)
3524 b
->binding_depth
= binding_depth
;
3525 indent (binding_depth
);
3526 cp_binding_level_debug (b
, LOCATION_LINE (input_location
), "resume");
3531 /* Return the innermost binding level that is not for a class scope. */
3533 static cp_binding_level
*
3534 innermost_nonclass_level (void)
3536 cp_binding_level
*b
;
3538 b
= current_binding_level
;
3539 while (b
->kind
== sk_class
)
3545 /* We're defining an object of type TYPE. If it needs a cleanup, but
3546 we're not allowed to add any more objects with cleanups to the current
3547 scope, create a new binding level. */
3550 maybe_push_cleanup_level (tree type
)
3552 if (type
!= error_mark_node
3553 && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
)
3554 && current_binding_level
->more_cleanups_ok
== 0)
3556 begin_scope (sk_cleanup
, NULL
);
3557 current_binding_level
->statement_list
= push_stmt_list ();
3561 /* Return true if we are in the global binding level. */
3564 global_bindings_p (void)
3566 return global_scope_p (current_binding_level
);
3569 /* True if we are currently in a toplevel binding level. This
3570 means either the global binding level or a namespace in a toplevel
3571 binding level. Since there are no non-toplevel namespace levels,
3572 this really means any namespace or template parameter level. We
3573 also include a class whose context is toplevel. */
3576 toplevel_bindings_p (void)
3578 cp_binding_level
*b
= innermost_nonclass_level ();
3580 return b
->kind
== sk_namespace
|| b
->kind
== sk_template_parms
;
3583 /* True if this is a namespace scope, or if we are defining a class
3584 which is itself at namespace scope, or whose enclosing class is
3585 such a class, etc. */
3588 namespace_bindings_p (void)
3590 cp_binding_level
*b
= innermost_nonclass_level ();
3592 return b
->kind
== sk_namespace
;
3595 /* True if the innermost non-class scope is a block scope. */
3598 local_bindings_p (void)
3600 cp_binding_level
*b
= innermost_nonclass_level ();
3601 return b
->kind
< sk_function_parms
|| b
->kind
== sk_omp
;
3604 /* True if the current level needs to have a BLOCK made. */
3609 return (current_binding_level
->blocks
!= NULL_TREE
3610 || current_binding_level
->keep
3611 || current_binding_level
->kind
== sk_cleanup
3612 || current_binding_level
->names
!= NULL_TREE
3613 || current_binding_level
->using_directives
);
3616 /* Returns the kind of the innermost scope. */
3619 innermost_scope_kind (void)
3621 return current_binding_level
->kind
;
3624 /* Returns true if this scope was created to store template parameters. */
3627 template_parm_scope_p (void)
3629 return innermost_scope_kind () == sk_template_parms
;
3632 /* If KEEP is true, make a BLOCK node for the next binding level,
3633 unconditionally. Otherwise, use the normal logic to decide whether
3634 or not to create a BLOCK. */
3637 keep_next_level (bool keep
)
3639 keep_next_level_flag
= keep
;
3642 /* Return the list of declarations of the current local scope. */
3645 get_local_decls (void)
3647 gcc_assert (current_binding_level
->kind
!= sk_namespace
3648 && current_binding_level
->kind
!= sk_class
);
3649 return current_binding_level
->names
;
3652 /* Return how many function prototypes we are currently nested inside. */
3655 function_parm_depth (void)
3658 cp_binding_level
*b
;
3660 for (b
= current_binding_level
;
3661 b
->kind
== sk_function_parms
;
3668 /* For debugging. */
3669 static int no_print_functions
= 0;
3670 static int no_print_builtins
= 0;
3673 print_binding_level (cp_binding_level
* lvl
)
3677 fprintf (stderr
, " blocks=%p", (void *) lvl
->blocks
);
3678 if (lvl
->more_cleanups_ok
)
3679 fprintf (stderr
, " more-cleanups-ok");
3680 if (lvl
->have_cleanups
)
3681 fprintf (stderr
, " have-cleanups");
3682 fprintf (stderr
, "\n");
3685 fprintf (stderr
, " names:\t");
3686 /* We can probably fit 3 names to a line? */
3687 for (t
= lvl
->names
; t
; t
= TREE_CHAIN (t
))
3689 if (no_print_functions
&& (TREE_CODE (t
) == FUNCTION_DECL
))
3691 if (no_print_builtins
3692 && (TREE_CODE (t
) == TYPE_DECL
)
3693 && DECL_IS_BUILTIN (t
))
3696 /* Function decls tend to have longer names. */
3697 if (TREE_CODE (t
) == FUNCTION_DECL
)
3704 fprintf (stderr
, "\n\t");
3707 print_node_brief (stderr
, "", t
, 0);
3708 if (t
== error_mark_node
)
3712 fprintf (stderr
, "\n");
3714 if (vec_safe_length (lvl
->class_shadowed
))
3717 cp_class_binding
*b
;
3718 fprintf (stderr
, " class-shadowed:");
3719 FOR_EACH_VEC_ELT (*lvl
->class_shadowed
, i
, b
)
3720 fprintf (stderr
, " %s ", IDENTIFIER_POINTER (b
->identifier
));
3721 fprintf (stderr
, "\n");
3723 if (lvl
->type_shadowed
)
3725 fprintf (stderr
, " type-shadowed:");
3726 for (t
= lvl
->type_shadowed
; t
; t
= TREE_CHAIN (t
))
3728 fprintf (stderr
, " %s ", IDENTIFIER_POINTER (TREE_PURPOSE (t
)));
3730 fprintf (stderr
, "\n");
3735 debug (cp_binding_level
&ref
)
3737 print_binding_level (&ref
);
3741 debug (cp_binding_level
*ptr
)
3746 fprintf (stderr
, "<nil>\n");
3751 print_other_binding_stack (cp_binding_level
*stack
)
3753 cp_binding_level
*level
;
3754 for (level
= stack
; !global_scope_p (level
); level
= level
->level_chain
)
3756 fprintf (stderr
, "binding level %p\n", (void *) level
);
3757 print_binding_level (level
);
3762 print_binding_stack (void)
3764 cp_binding_level
*b
;
3765 fprintf (stderr
, "current_binding_level=%p\n"
3766 "class_binding_level=%p\n"
3767 "NAMESPACE_LEVEL (global_namespace)=%p\n",
3768 (void *) current_binding_level
, (void *) class_binding_level
,
3769 (void *) NAMESPACE_LEVEL (global_namespace
));
3770 if (class_binding_level
)
3772 for (b
= class_binding_level
; b
; b
= b
->level_chain
)
3773 if (b
== current_binding_level
)
3776 b
= class_binding_level
;
3778 b
= current_binding_level
;
3781 b
= current_binding_level
;
3782 print_other_binding_stack (b
);
3783 fprintf (stderr
, "global:\n");
3784 print_binding_level (NAMESPACE_LEVEL (global_namespace
));
3787 /* Return the type associated with ID. */
3790 identifier_type_value_1 (tree id
)
3792 /* There is no type with that name, anywhere. */
3793 if (REAL_IDENTIFIER_TYPE_VALUE (id
) == NULL_TREE
)
3795 /* This is not the type marker, but the real thing. */
3796 if (REAL_IDENTIFIER_TYPE_VALUE (id
) != global_type_node
)
3797 return REAL_IDENTIFIER_TYPE_VALUE (id
);
3798 /* Have to search for it. It must be on the global level, now.
3799 Ask lookup_name not to return non-types. */
3800 id
= lookup_name_real (id
, 2, 1, /*block_p=*/true, 0, 0);
3802 return TREE_TYPE (id
);
3806 /* Wrapper for identifier_type_value_1. */
3809 identifier_type_value (tree id
)
3812 timevar_start (TV_NAME_LOOKUP
);
3813 ret
= identifier_type_value_1 (id
);
3814 timevar_stop (TV_NAME_LOOKUP
);
3818 /* Push a definition of struct, union or enum tag named ID. into
3819 binding_level B. DECL is a TYPE_DECL for the type. We assume that
3820 the tag ID is not already defined. */
3823 set_identifier_type_value_with_scope (tree id
, tree decl
, cp_binding_level
*b
)
3827 if (b
->kind
!= sk_namespace
)
3829 /* Shadow the marker, not the real thing, so that the marker
3830 gets restored later. */
3831 tree old_type_value
= REAL_IDENTIFIER_TYPE_VALUE (id
);
3833 = tree_cons (id
, old_type_value
, b
->type_shadowed
);
3834 type
= decl
? TREE_TYPE (decl
) : NULL_TREE
;
3835 TREE_TYPE (b
->type_shadowed
) = type
;
3839 tree
*slot
= find_namespace_slot (current_namespace
, id
, true);
3841 update_binding (b
, NULL
, slot
, MAYBE_STAT_DECL (*slot
), decl
, false);
3843 /* Store marker instead of real type. */
3844 type
= global_type_node
;
3846 SET_IDENTIFIER_TYPE_VALUE (id
, type
);
3849 /* As set_identifier_type_value_with_scope, but using
3850 current_binding_level. */
3853 set_identifier_type_value (tree id
, tree decl
)
3855 set_identifier_type_value_with_scope (id
, decl
, current_binding_level
);
3858 /* Return the name for the constructor (or destructor) for the
3862 constructor_name (tree type
)
3864 tree decl
= TYPE_NAME (TYPE_MAIN_VARIANT (type
));
3866 return decl
? DECL_NAME (decl
) : NULL_TREE
;
3869 /* Returns TRUE if NAME is the name for the constructor for TYPE,
3870 which must be a class type. */
3873 constructor_name_p (tree name
, tree type
)
3875 gcc_assert (MAYBE_CLASS_TYPE_P (type
));
3877 /* These don't have names. */
3878 if (TREE_CODE (type
) == DECLTYPE_TYPE
3879 || TREE_CODE (type
) == TYPEOF_TYPE
)
3882 if (name
&& name
== constructor_name (type
))
3888 /* Counter used to create anonymous type names. */
3890 static GTY(()) int anon_cnt
;
3892 /* Return an IDENTIFIER which can be used as a name for
3893 unnamed structs and unions. */
3896 make_anon_name (void)
3900 sprintf (buf
, anon_aggrname_format (), anon_cnt
++);
3901 return get_identifier (buf
);
3904 /* This code is practically identical to that for creating
3905 anonymous names, but is just used for lambdas instead. This isn't really
3906 necessary, but it's convenient to avoid treating lambdas like other
3909 static GTY(()) int lambda_cnt
= 0;
3912 make_lambda_name (void)
3916 sprintf (buf
, LAMBDANAME_FORMAT
, lambda_cnt
++);
3917 return get_identifier (buf
);
3920 /* Insert another USING_DECL into the current binding level, returning
3921 this declaration. If this is a redeclaration, do nothing, and
3922 return NULL_TREE if this not in namespace scope (in namespace
3923 scope, a using decl might extend any previous bindings). */
3926 push_using_decl_1 (tree scope
, tree name
)
3930 gcc_assert (TREE_CODE (scope
) == NAMESPACE_DECL
);
3931 gcc_assert (identifier_p (name
));
3932 for (decl
= current_binding_level
->usings
; decl
; decl
= DECL_CHAIN (decl
))
3933 if (USING_DECL_SCOPE (decl
) == scope
&& DECL_NAME (decl
) == name
)
3936 return namespace_bindings_p () ? decl
: NULL_TREE
;
3937 decl
= build_lang_decl (USING_DECL
, name
, NULL_TREE
);
3938 USING_DECL_SCOPE (decl
) = scope
;
3939 DECL_CHAIN (decl
) = current_binding_level
->usings
;
3940 current_binding_level
->usings
= decl
;
3944 /* Wrapper for push_using_decl_1. */
3947 push_using_decl (tree scope
, tree name
)
3950 timevar_start (TV_NAME_LOOKUP
);
3951 ret
= push_using_decl_1 (scope
, name
);
3952 timevar_stop (TV_NAME_LOOKUP
);
3956 /* Same as pushdecl, but define X in binding-level LEVEL. We rely on the
3957 caller to set DECL_CONTEXT properly.
3959 Note that this must only be used when X will be the new innermost
3960 binding for its name, as we tack it onto the front of IDENTIFIER_BINDING
3961 without checking to see if the current IDENTIFIER_BINDING comes from a
3962 closer binding level than LEVEL. */
3965 do_pushdecl_with_scope (tree x
, cp_binding_level
*level
, bool is_friend
)
3967 cp_binding_level
*b
;
3969 if (level
->kind
== sk_class
)
3971 b
= class_binding_level
;
3972 class_binding_level
= level
;
3973 pushdecl_class_level (x
);
3974 class_binding_level
= b
;
3978 tree function_decl
= current_function_decl
;
3979 if (level
->kind
== sk_namespace
)
3980 current_function_decl
= NULL_TREE
;
3981 b
= current_binding_level
;
3982 current_binding_level
= level
;
3983 x
= pushdecl (x
, is_friend
);
3984 current_binding_level
= b
;
3985 current_function_decl
= function_decl
;
3990 /* Inject X into the local scope just before the function parms. */
3993 pushdecl_outermost_localscope (tree x
)
3995 cp_binding_level
*b
= NULL
;
3996 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
3998 /* Find the scope just inside the function parms. */
3999 for (cp_binding_level
*n
= current_binding_level
;
4000 n
->kind
!= sk_function_parms
; n
= b
->level_chain
)
4003 tree ret
= b
? do_pushdecl_with_scope (x
, b
, false) : error_mark_node
;
4004 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
4009 /* Check a non-member using-declaration. Return the name and scope
4010 being used, and the USING_DECL, or NULL_TREE on failure. */
4013 validate_nonmember_using_decl (tree decl
, tree scope
, tree name
)
4015 /* [namespace.udecl]
4016 A using-declaration for a class member shall be a
4017 member-declaration. */
4020 error ("%qT is not a namespace or unscoped enum", scope
);
4023 else if (scope
== error_mark_node
)
4026 if (TREE_CODE (decl
) == TEMPLATE_ID_EXPR
)
4029 A using-declaration shall not name a template-id. */
4030 error ("a using-declaration cannot specify a template-id. "
4031 "Try %<using %D%>", name
);
4035 if (TREE_CODE (decl
) == NAMESPACE_DECL
)
4037 error ("namespace %qD not allowed in using-declaration", decl
);
4041 if (TREE_CODE (decl
) == SCOPE_REF
)
4043 /* It's a nested name with template parameter dependent scope.
4044 This can only be using-declaration for class member. */
4045 error ("%qT is not a namespace", TREE_OPERAND (decl
, 0));
4049 decl
= OVL_FIRST (decl
);
4051 /* Make a USING_DECL. */
4052 tree using_decl
= push_using_decl (scope
, name
);
4054 if (using_decl
== NULL_TREE
4055 && at_function_scope_p ()
4057 /* C++11 7.3.3/10. */
4058 error ("%qD is already declared in this scope", name
);
4063 /* Process a local-scope or namespace-scope using declaration. SCOPE
4064 is the nominated scope to search for NAME. VALUE_P and TYPE_P
4065 point to the binding for NAME in the current scope and are
4069 do_nonmember_using_decl (tree scope
, tree name
, tree
*value_p
, tree
*type_p
)
4071 name_lookup
lookup (name
, 0);
4073 if (!qualified_namespace_lookup (scope
, &lookup
))
4075 error ("%qD not declared", name
);
4078 else if (TREE_CODE (lookup
.value
) == TREE_LIST
)
4080 error ("reference to %qD is ambiguous", name
);
4081 print_candidates (lookup
.value
);
4082 lookup
.value
= NULL_TREE
;
4085 if (lookup
.type
&& TREE_CODE (lookup
.type
) == TREE_LIST
)
4087 error ("reference to %qD is ambiguous", name
);
4088 print_candidates (lookup
.type
);
4089 lookup
.type
= NULL_TREE
;
4092 tree value
= *value_p
;
4093 tree type
= *type_p
;
4095 /* Shift the old and new bindings around so we're comparing class and
4096 enumeration names to each other. */
4097 if (value
&& DECL_IMPLICIT_TYPEDEF_P (value
))
4103 if (lookup
.value
&& DECL_IMPLICIT_TYPEDEF_P (lookup
.value
))
4105 lookup
.type
= lookup
.value
;
4106 lookup
.value
= NULL_TREE
;
4109 if (lookup
.value
&& lookup
.value
!= value
)
4111 /* Check for using functions. */
4112 if (OVL_P (lookup
.value
) && (!value
|| OVL_P (value
)))
4114 for (lkp_iterator
usings (lookup
.value
); usings
; ++usings
)
4116 tree new_fn
= *usings
;
4118 /* [namespace.udecl]
4120 If a function declaration in namespace scope or block
4121 scope has the same name and the same parameter types as a
4122 function introduced by a using declaration the program is
4125 for (ovl_iterator
old (value
); !found
&& old
; ++old
)
4129 if (new_fn
== old_fn
)
4130 /* The function already exists in the current
4133 else if (old
.using_p ())
4134 continue; /* This is a using decl. */
4135 else if (old
.hidden_p () && !DECL_HIDDEN_FRIEND_P (old_fn
))
4136 continue; /* This is an anticipated builtin. */
4137 else if (!matching_fn_p (new_fn
, old_fn
))
4138 continue; /* Parameters do not match. */
4139 else if (decls_match (new_fn
, old_fn
))
4143 diagnose_name_conflict (new_fn
, old_fn
);
4149 /* Unlike the overload case we don't drop anticipated
4150 builtins here. They don't cause a problem, and
4151 we'd like to match them with a future
4153 value
= ovl_insert (new_fn
, value
, true);
4157 /* Ignore anticipated builtins. */
4158 && !anticipated_builtin_p (value
)
4159 && !decls_match (lookup
.value
, value
))
4160 diagnose_name_conflict (lookup
.value
, value
);
4162 value
= lookup
.value
;
4165 if (lookup
.type
&& lookup
.type
!= type
)
4167 if (type
&& !decls_match (lookup
.type
, type
))
4168 diagnose_name_conflict (lookup
.type
, type
);
4173 /* If bind->value is empty, shift any class or enumeration name back. */
4184 /* Returns true if ANCESTOR encloses DESCENDANT, including matching.
4185 Both are namespaces. */
4188 is_nested_namespace (tree ancestor
, tree descendant
, bool inline_only
)
4190 int depth
= SCOPE_DEPTH (ancestor
);
4192 if (!depth
&& !inline_only
)
4193 /* The global namespace encloses everything. */
4196 while (SCOPE_DEPTH (descendant
) > depth
4197 && (!inline_only
|| DECL_NAMESPACE_INLINE_P (descendant
)))
4198 descendant
= CP_DECL_CONTEXT (descendant
);
4200 return ancestor
== descendant
;
4203 /* Returns true if ROOT (a namespace, class, or function) encloses
4204 CHILD. CHILD may be either a class type or a namespace. */
4207 is_ancestor (tree root
, tree child
)
4209 gcc_assert ((TREE_CODE (root
) == NAMESPACE_DECL
4210 || TREE_CODE (root
) == FUNCTION_DECL
4211 || CLASS_TYPE_P (root
)));
4212 gcc_assert ((TREE_CODE (child
) == NAMESPACE_DECL
4213 || CLASS_TYPE_P (child
)));
4215 /* The global namespace encloses everything. */
4216 if (root
== global_namespace
)
4219 /* Search until we reach namespace scope. */
4220 while (TREE_CODE (child
) != NAMESPACE_DECL
)
4222 /* If we've reached the ROOT, it encloses CHILD. */
4225 /* Go out one level. */
4227 child
= TYPE_NAME (child
);
4228 child
= CP_DECL_CONTEXT (child
);
4231 if (TREE_CODE (root
) == NAMESPACE_DECL
)
4232 return is_nested_namespace (root
, child
);
4237 /* Enter the class or namespace scope indicated by T suitable for name
4238 lookup. T can be arbitrary scope, not necessary nested inside the
4239 current scope. Returns a non-null scope to pop iff pop_scope
4240 should be called later to exit this scope. */
4245 if (TREE_CODE (t
) == NAMESPACE_DECL
)
4246 push_decl_namespace (t
);
4247 else if (CLASS_TYPE_P (t
))
4249 if (!at_class_scope_p ()
4250 || !same_type_p (current_class_type
, t
))
4251 push_nested_class (t
);
4253 /* T is the same as the current scope. There is therefore no
4254 need to re-enter the scope. Since we are not actually
4255 pushing a new scope, our caller should not call
4263 /* Leave scope pushed by push_scope. */
4270 if (TREE_CODE (t
) == NAMESPACE_DECL
)
4271 pop_decl_namespace ();
4272 else if CLASS_TYPE_P (t
)
4273 pop_nested_class ();
4276 /* Subroutine of push_inner_scope. */
4279 push_inner_scope_r (tree outer
, tree inner
)
4284 || (TREE_CODE (inner
) != NAMESPACE_DECL
&& !CLASS_TYPE_P (inner
)))
4287 prev
= CP_DECL_CONTEXT (TREE_CODE (inner
) == NAMESPACE_DECL
? inner
: TYPE_NAME (inner
));
4289 push_inner_scope_r (outer
, prev
);
4290 if (TREE_CODE (inner
) == NAMESPACE_DECL
)
4292 cp_binding_level
*save_template_parm
= 0;
4293 /* Temporary take out template parameter scopes. They are saved
4294 in reversed order in save_template_parm. */
4295 while (current_binding_level
->kind
== sk_template_parms
)
4297 cp_binding_level
*b
= current_binding_level
;
4298 current_binding_level
= b
->level_chain
;
4299 b
->level_chain
= save_template_parm
;
4300 save_template_parm
= b
;
4303 resume_scope (NAMESPACE_LEVEL (inner
));
4304 current_namespace
= inner
;
4306 /* Restore template parameter scopes. */
4307 while (save_template_parm
)
4309 cp_binding_level
*b
= save_template_parm
;
4310 save_template_parm
= b
->level_chain
;
4311 b
->level_chain
= current_binding_level
;
4312 current_binding_level
= b
;
4319 /* Enter the scope INNER from current scope. INNER must be a scope
4320 nested inside current scope. This works with both name lookup and
4321 pushing name into scope. In case a template parameter scope is present,
4322 namespace is pushed under the template parameter scope according to
4323 name lookup rule in 14.6.1/6.
4325 Return the former current scope suitable for pop_inner_scope. */
4328 push_inner_scope (tree inner
)
4330 tree outer
= current_scope ();
4332 outer
= current_namespace
;
4334 push_inner_scope_r (outer
, inner
);
4338 /* Exit the current scope INNER back to scope OUTER. */
4341 pop_inner_scope (tree outer
, tree inner
)
4344 || (TREE_CODE (inner
) != NAMESPACE_DECL
&& !CLASS_TYPE_P (inner
)))
4347 while (outer
!= inner
)
4349 if (TREE_CODE (inner
) == NAMESPACE_DECL
)
4351 cp_binding_level
*save_template_parm
= 0;
4352 /* Temporary take out template parameter scopes. They are saved
4353 in reversed order in save_template_parm. */
4354 while (current_binding_level
->kind
== sk_template_parms
)
4356 cp_binding_level
*b
= current_binding_level
;
4357 current_binding_level
= b
->level_chain
;
4358 b
->level_chain
= save_template_parm
;
4359 save_template_parm
= b
;
4364 /* Restore template parameter scopes. */
4365 while (save_template_parm
)
4367 cp_binding_level
*b
= save_template_parm
;
4368 save_template_parm
= b
->level_chain
;
4369 b
->level_chain
= current_binding_level
;
4370 current_binding_level
= b
;
4376 inner
= CP_DECL_CONTEXT (TREE_CODE (inner
) == NAMESPACE_DECL
? inner
: TYPE_NAME (inner
));
4380 /* Do a pushlevel for class declarations. */
4383 pushlevel_class (void)
4385 class_binding_level
= begin_scope (sk_class
, current_class_type
);
4388 /* ...and a poplevel for class declarations. */
4391 poplevel_class (void)
4393 cp_binding_level
*level
= class_binding_level
;
4394 cp_class_binding
*cb
;
4398 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
4399 gcc_assert (level
!= 0);
4401 /* If we're leaving a toplevel class, cache its binding level. */
4402 if (current_class_depth
== 1)
4403 previous_class_level
= level
;
4404 for (shadowed
= level
->type_shadowed
;
4406 shadowed
= TREE_CHAIN (shadowed
))
4407 SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (shadowed
), TREE_VALUE (shadowed
));
4409 /* Remove the bindings for all of the class-level declarations. */
4410 if (level
->class_shadowed
)
4412 FOR_EACH_VEC_ELT (*level
->class_shadowed
, i
, cb
)
4414 IDENTIFIER_BINDING (cb
->identifier
) = cb
->base
->previous
;
4415 cxx_binding_free (cb
->base
);
4417 ggc_free (level
->class_shadowed
);
4418 level
->class_shadowed
= NULL
;
4421 /* Now, pop out of the binding level which we created up in the
4422 `pushlevel_class' routine. */
4423 gcc_assert (current_binding_level
== level
);
4425 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
4428 /* Set INHERITED_VALUE_BINDING_P on BINDING to true or false, as
4429 appropriate. DECL is the value to which a name has just been
4430 bound. CLASS_TYPE is the class in which the lookup occurred. */
4433 set_inherited_value_binding_p (cxx_binding
*binding
, tree decl
,
4436 if (binding
->value
== decl
&& TREE_CODE (decl
) != TREE_LIST
)
4440 if (TREE_CODE (decl
) == OVERLOAD
)
4441 context
= ovl_scope (decl
);
4444 gcc_assert (DECL_P (decl
));
4445 context
= context_for_name_lookup (decl
);
4448 if (is_properly_derived_from (class_type
, context
))
4449 INHERITED_VALUE_BINDING_P (binding
) = 1;
4451 INHERITED_VALUE_BINDING_P (binding
) = 0;
4453 else if (binding
->value
== decl
)
4454 /* We only encounter a TREE_LIST when there is an ambiguity in the
4455 base classes. Such an ambiguity can be overridden by a
4456 definition in this class. */
4457 INHERITED_VALUE_BINDING_P (binding
) = 1;
4459 INHERITED_VALUE_BINDING_P (binding
) = 0;
4462 /* Make the declaration of X appear in CLASS scope. */
4465 pushdecl_class_level (tree x
)
4467 bool is_valid
= true;
4470 /* Do nothing if we're adding to an outer lambda closure type,
4471 outer_binding will add it later if it's needed. */
4472 if (current_class_type
!= class_binding_level
->this_entity
)
4475 subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
4476 /* Get the name of X. */
4477 tree name
= OVL_NAME (x
);
4481 is_valid
= push_class_level_binding (name
, x
);
4482 if (TREE_CODE (x
) == TYPE_DECL
)
4483 set_identifier_type_value (name
, x
);
4485 else if (ANON_AGGR_TYPE_P (TREE_TYPE (x
)))
4487 /* If X is an anonymous aggregate, all of its members are
4488 treated as if they were members of the class containing the
4489 aggregate, for naming purposes. */
4490 location_t save_location
= input_location
;
4491 tree anon
= TREE_TYPE (x
);
4492 if (vec
<tree
, va_gc
> *member_vec
= CLASSTYPE_MEMBER_VEC (anon
))
4493 for (unsigned ix
= member_vec
->length (); ix
--;)
4495 tree binding
= (*member_vec
)[ix
];
4496 if (STAT_HACK_P (binding
))
4498 if (!pushdecl_class_level (STAT_TYPE (binding
)))
4500 binding
= STAT_DECL (binding
);
4502 if (!pushdecl_class_level (binding
))
4506 for (tree f
= TYPE_FIELDS (anon
); f
; f
= DECL_CHAIN (f
))
4507 if (TREE_CODE (f
) == FIELD_DECL
)
4509 input_location
= DECL_SOURCE_LOCATION (f
);
4510 if (!pushdecl_class_level (f
))
4513 input_location
= save_location
;
4515 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
4519 /* Return the BINDING (if any) for NAME in SCOPE, which is a class
4520 scope. If the value returned is non-NULL, and the PREVIOUS field
4521 is not set, callers must set the PREVIOUS field explicitly. */
4523 static cxx_binding
*
4524 get_class_binding (tree name
, cp_binding_level
*scope
)
4529 cxx_binding
*binding
;
4531 class_type
= scope
->this_entity
;
4533 /* Get the type binding. */
4534 type_binding
= lookup_member (class_type
, name
,
4535 /*protect=*/2, /*want_type=*/true,
4536 tf_warning_or_error
);
4537 /* Get the value binding. */
4538 value_binding
= lookup_member (class_type
, name
,
4539 /*protect=*/2, /*want_type=*/false,
4540 tf_warning_or_error
);
4543 && (TREE_CODE (value_binding
) == TYPE_DECL
4544 || DECL_CLASS_TEMPLATE_P (value_binding
)
4545 || (TREE_CODE (value_binding
) == TREE_LIST
4546 && TREE_TYPE (value_binding
) == error_mark_node
4547 && (TREE_CODE (TREE_VALUE (value_binding
))
4549 /* We found a type binding, even when looking for a non-type
4550 binding. This means that we already processed this binding
4553 else if (value_binding
)
4555 if (TREE_CODE (value_binding
) == TREE_LIST
4556 && TREE_TYPE (value_binding
) == error_mark_node
)
4557 /* NAME is ambiguous. */
4559 else if (BASELINK_P (value_binding
))
4560 /* NAME is some overloaded functions. */
4561 value_binding
= BASELINK_FUNCTIONS (value_binding
);
4564 /* If we found either a type binding or a value binding, create a
4565 new binding object. */
4566 if (type_binding
|| value_binding
)
4568 binding
= new_class_binding (name
,
4572 /* This is a class-scope binding, not a block-scope binding. */
4573 LOCAL_BINDING_P (binding
) = 0;
4574 set_inherited_value_binding_p (binding
, value_binding
, class_type
);
4582 /* Make the declaration(s) of X appear in CLASS scope under the name
4583 NAME. Returns true if the binding is valid. */
4586 push_class_level_binding_1 (tree name
, tree x
)
4588 cxx_binding
*binding
;
4592 /* The class_binding_level will be NULL if x is a template
4593 parameter name in a member template. */
4594 if (!class_binding_level
)
4597 if (name
== error_mark_node
)
4600 /* Can happen for an erroneous declaration (c++/60384). */
4601 if (!identifier_p (name
))
4603 gcc_assert (errorcount
|| sorrycount
);
4607 /* Check for invalid member names. But don't worry about a default
4608 argument-scope lambda being pushed after the class is complete. */
4609 gcc_assert (TYPE_BEING_DEFINED (current_class_type
)
4610 || LAMBDA_TYPE_P (TREE_TYPE (decl
)));
4611 /* Check that we're pushing into the right binding level. */
4612 gcc_assert (current_class_type
== class_binding_level
->this_entity
);
4614 /* We could have been passed a tree list if this is an ambiguous
4615 declaration. If so, pull the declaration out because
4616 check_template_shadow will not handle a TREE_LIST. */
4617 if (TREE_CODE (decl
) == TREE_LIST
4618 && TREE_TYPE (decl
) == error_mark_node
)
4619 decl
= TREE_VALUE (decl
);
4621 if (!check_template_shadow (decl
))
4626 If T is the name of a class, then each of the following shall
4627 have a name different from T:
4629 -- every static data member of class T;
4631 -- every member of class T that is itself a type;
4633 -- every enumerator of every member of class T that is an
4636 -- every member of every anonymous union that is a member of
4639 (Non-static data members were also forbidden to have the same
4640 name as T until TC1.) */
4642 || TREE_CODE (x
) == CONST_DECL
4643 || (TREE_CODE (x
) == TYPE_DECL
4644 && !DECL_SELF_REFERENCE_P (x
))
4645 /* A data member of an anonymous union. */
4646 || (TREE_CODE (x
) == FIELD_DECL
4647 && DECL_CONTEXT (x
) != current_class_type
))
4648 && DECL_NAME (x
) == DECL_NAME (TYPE_NAME (current_class_type
)))
4650 tree scope
= context_for_name_lookup (x
);
4651 if (TYPE_P (scope
) && same_type_p (scope
, current_class_type
))
4653 error ("%qD has the same name as the class in which it is "
4660 /* Get the current binding for NAME in this class, if any. */
4661 binding
= IDENTIFIER_BINDING (name
);
4662 if (!binding
|| binding
->scope
!= class_binding_level
)
4664 binding
= get_class_binding (name
, class_binding_level
);
4665 /* If a new binding was created, put it at the front of the
4666 IDENTIFIER_BINDING list. */
4669 binding
->previous
= IDENTIFIER_BINDING (name
);
4670 IDENTIFIER_BINDING (name
) = binding
;
4674 /* If there is already a binding, then we may need to update the
4676 if (binding
&& binding
->value
)
4678 tree bval
= binding
->value
;
4679 tree old_decl
= NULL_TREE
;
4680 tree target_decl
= strip_using_decl (decl
);
4681 tree target_bval
= strip_using_decl (bval
);
4683 if (INHERITED_VALUE_BINDING_P (binding
))
4685 /* If the old binding was from a base class, and was for a
4686 tag name, slide it over to make room for the new binding.
4687 The old binding is still visible if explicitly qualified
4688 with a class-key. */
4689 if (TREE_CODE (target_bval
) == TYPE_DECL
4690 && DECL_ARTIFICIAL (target_bval
)
4691 && !(TREE_CODE (target_decl
) == TYPE_DECL
4692 && DECL_ARTIFICIAL (target_decl
)))
4694 old_decl
= binding
->type
;
4695 binding
->type
= bval
;
4696 binding
->value
= NULL_TREE
;
4697 INHERITED_VALUE_BINDING_P (binding
) = 0;
4702 /* Any inherited type declaration is hidden by the type
4703 declaration in the derived class. */
4704 if (TREE_CODE (target_decl
) == TYPE_DECL
4705 && DECL_ARTIFICIAL (target_decl
))
4706 binding
->type
= NULL_TREE
;
4709 else if (TREE_CODE (target_decl
) == OVERLOAD
4710 && OVL_P (target_bval
))
4712 else if (TREE_CODE (decl
) == USING_DECL
4713 && TREE_CODE (bval
) == USING_DECL
4714 && same_type_p (USING_DECL_SCOPE (decl
),
4715 USING_DECL_SCOPE (bval
)))
4716 /* This is a using redeclaration that will be diagnosed later
4717 in supplement_binding */
4719 else if (TREE_CODE (decl
) == USING_DECL
4720 && TREE_CODE (bval
) == USING_DECL
4721 && DECL_DEPENDENT_P (decl
)
4722 && DECL_DEPENDENT_P (bval
))
4724 else if (TREE_CODE (decl
) == USING_DECL
4725 && OVL_P (target_bval
))
4727 else if (TREE_CODE (bval
) == USING_DECL
4728 && OVL_P (target_decl
))
4731 if (old_decl
&& binding
->scope
== class_binding_level
)
4734 /* It is always safe to clear INHERITED_VALUE_BINDING_P
4735 here. This function is only used to register bindings
4736 from with the class definition itself. */
4737 INHERITED_VALUE_BINDING_P (binding
) = 0;
4742 /* Note that we declared this value so that we can issue an error if
4743 this is an invalid redeclaration of a name already used for some
4745 note_name_declared_in_class (name
, decl
);
4747 /* If we didn't replace an existing binding, put the binding on the
4748 stack of bindings for the identifier, and update the shadowed
4750 if (binding
&& binding
->scope
== class_binding_level
)
4751 /* Supplement the existing binding. */
4752 ok
= supplement_binding (binding
, decl
);
4755 /* Create a new binding. */
4756 push_binding (name
, decl
, class_binding_level
);
4763 /* Wrapper for push_class_level_binding_1. */
4766 push_class_level_binding (tree name
, tree x
)
4769 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
4770 ret
= push_class_level_binding_1 (name
, x
);
4771 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
4775 /* Process "using SCOPE::NAME" in a class scope. Return the
4776 USING_DECL created. */
4779 do_class_using_decl (tree scope
, tree name
)
4781 if (name
== error_mark_node
)
4784 if (!scope
|| !TYPE_P (scope
))
4786 error ("using-declaration for non-member at class scope");
4790 /* Make sure the name is not invalid */
4791 if (TREE_CODE (name
) == BIT_NOT_EXPR
)
4793 error ("%<%T::%D%> names destructor", scope
, name
);
4797 /* Using T::T declares inheriting ctors, even if T is a typedef. */
4798 if (MAYBE_CLASS_TYPE_P (scope
)
4799 && (name
== TYPE_IDENTIFIER (scope
)
4800 || constructor_name_p (name
, scope
)))
4802 maybe_warn_cpp0x (CPP0X_INHERITING_CTORS
);
4803 name
= ctor_identifier
;
4804 CLASSTYPE_NON_AGGREGATE (current_class_type
) = true;
4807 /* Cannot introduce a constructor name. */
4808 if (constructor_name_p (name
, current_class_type
))
4810 error ("%<%T::%D%> names constructor in %qT",
4811 scope
, name
, current_class_type
);
4815 /* From [namespace.udecl]:
4817 A using-declaration used as a member-declaration shall refer to a
4818 member of a base class of the class being defined.
4820 In general, we cannot check this constraint in a template because
4821 we do not know the entire set of base classes of the current
4822 class type. Morover, if SCOPE is dependent, it might match a
4823 non-dependent base. */
4825 tree decl
= NULL_TREE
;
4826 if (!dependent_scope_p (scope
))
4829 tree binfo
= lookup_base (current_class_type
, scope
, ba_any
, &b_kind
,
4830 tf_warning_or_error
);
4831 if (b_kind
< bk_proper_base
)
4833 /* If there are dependent bases, scope might resolve at
4834 instantiation time, even if it isn't exactly one of the
4836 if (b_kind
== bk_same_type
|| !any_dependent_bases_p ())
4838 error_not_base_type (scope
, current_class_type
);
4842 else if (name
== ctor_identifier
&& !binfo_direct_p (binfo
))
4844 error ("cannot inherit constructors from indirect base %qT", scope
);
4847 else if (!IDENTIFIER_CONV_OP_P (name
)
4848 || !dependent_type_p (TREE_TYPE (name
)))
4850 decl
= lookup_member (binfo
, name
, 0, false, tf_warning_or_error
);
4853 error ("no members matching %<%T::%D%> in %q#T", scope
, name
,
4858 /* The binfo from which the functions came does not matter. */
4859 if (BASELINK_P (decl
))
4860 decl
= BASELINK_FUNCTIONS (decl
);
4864 tree value
= build_lang_decl (USING_DECL
, name
, NULL_TREE
);
4865 USING_DECL_DECLS (value
) = decl
;
4866 USING_DECL_SCOPE (value
) = scope
;
4867 DECL_DEPENDENT_P (value
) = !decl
;
4873 /* Return the binding for NAME in NS. If NS is NULL, look in
4874 global_namespace. */
4877 get_namespace_binding (tree ns
, tree name
)
4879 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
4881 ns
= global_namespace
;
4882 gcc_checking_assert (!DECL_NAMESPACE_ALIAS (ns
));
4883 tree ret
= find_namespace_value (ns
, name
);
4884 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
4888 /* Push internal DECL into the global namespace. Does not do the
4889 full overload fn handling and does not add it to the list of things
4890 in the namespace. */
4893 set_global_binding (tree decl
)
4895 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
4897 tree
*slot
= find_namespace_slot (global_namespace
, DECL_NAME (decl
), true);
4900 /* The user's placed something in the implementor's namespace. */
4901 diagnose_name_conflict (decl
, MAYBE_STAT_DECL (*slot
));
4903 /* Force the binding, so compiler internals continue to work. */
4906 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
4909 /* Set the context of a declaration to scope. Complain if we are not
4913 set_decl_namespace (tree decl
, tree scope
, bool friendp
)
4915 /* Get rid of namespace aliases. */
4916 scope
= ORIGINAL_NAMESPACE (scope
);
4918 /* It is ok for friends to be qualified in parallel space. */
4919 if (!friendp
&& !is_nested_namespace (current_namespace
, scope
))
4920 error ("declaration of %qD not in a namespace surrounding %qD",
4922 DECL_CONTEXT (decl
) = FROB_CONTEXT (scope
);
4924 /* See whether this has been declared in the namespace or inline
4926 tree old
= NULL_TREE
;
4928 name_lookup
lookup (DECL_NAME (decl
), LOOKUP_HIDDEN
);
4929 if (!lookup
.search_qualified (scope
, /*usings=*/false))
4930 /* No old declaration at all. */
4935 /* If it's a TREE_LIST, the result of the lookup was ambiguous. */
4936 if (TREE_CODE (old
) == TREE_LIST
)
4939 DECL_CONTEXT (decl
) = FROB_CONTEXT (scope
);
4940 error ("reference to %qD is ambiguous", decl
);
4941 print_candidates (old
);
4945 if (!DECL_DECLARES_FUNCTION_P (decl
))
4947 /* Don't compare non-function decls with decls_match here, since
4948 it can't check for the correct constness at this
4949 point. pushdecl will find those errors later. */
4951 /* We might have found it in an inline namespace child of SCOPE. */
4952 if (TREE_CODE (decl
) == TREE_CODE (old
))
4953 DECL_CONTEXT (decl
) = DECL_CONTEXT (old
);
4956 /* Writing "N::i" to declare something directly in "N" is invalid. */
4957 if (CP_DECL_CONTEXT (decl
) == current_namespace
4958 && at_namespace_scope_p ())
4959 error ("explicit qualification in declaration of %qD", decl
);
4963 /* Since decl is a function, old should contain a function decl. */
4967 /* We handle these in check_explicit_instantiation_namespace. */
4968 if (processing_explicit_instantiation
)
4970 if (processing_template_decl
|| processing_specialization
)
4971 /* We have not yet called push_template_decl to turn a
4972 FUNCTION_DECL into a TEMPLATE_DECL, so the declarations won't
4973 match. But, we'll check later, when we construct the
4976 /* Instantiations or specializations of templates may be declared as
4977 friends in any namespace. */
4978 if (friendp
&& DECL_USE_TEMPLATE (decl
))
4984 for (lkp_iterator
iter (old
); iter
; ++iter
)
4986 if (iter
.using_p ())
4991 /* Adjust DECL_CONTEXT first so decls_match will return true
4992 if DECL will match a declaration in an inline namespace. */
4993 DECL_CONTEXT (decl
) = DECL_CONTEXT (ofn
);
4994 if (decls_match (decl
, ofn
))
4998 /* We found more than one matching declaration. */
4999 DECL_CONTEXT (decl
) = FROB_CONTEXT (scope
);
5008 if (DECL_HIDDEN_FRIEND_P (found
))
5010 pedwarn (DECL_SOURCE_LOCATION (decl
), 0,
5011 "%qD has not been declared within %qD", decl
, scope
);
5012 inform (DECL_SOURCE_LOCATION (found
),
5013 "only here as a %<friend%>");
5015 DECL_CONTEXT (decl
) = DECL_CONTEXT (found
);
5020 /* It didn't work, go back to the explicit scope. */
5021 DECL_CONTEXT (decl
) = FROB_CONTEXT (scope
);
5022 error ("%qD should have been declared inside %qD", decl
, scope
);
5025 /* Return the namespace where the current declaration is declared. */
5028 current_decl_namespace (void)
5031 /* If we have been pushed into a different namespace, use it. */
5032 if (!vec_safe_is_empty (decl_namespace_list
))
5033 return decl_namespace_list
->last ();
5035 if (current_class_type
)
5036 result
= decl_namespace_context (current_class_type
);
5037 else if (current_function_decl
)
5038 result
= decl_namespace_context (current_function_decl
);
5040 result
= current_namespace
;
5044 /* Process any ATTRIBUTES on a namespace definition. Returns true if
5045 attribute visibility is seen. */
5048 handle_namespace_attrs (tree ns
, tree attributes
)
5051 bool saw_vis
= false;
5053 if (attributes
== error_mark_node
)
5056 for (d
= attributes
; d
; d
= TREE_CHAIN (d
))
5058 tree name
= get_attribute_name (d
);
5059 tree args
= TREE_VALUE (d
);
5061 if (is_attribute_p ("visibility", name
))
5063 /* attribute visibility is a property of the syntactic block
5064 rather than the namespace as a whole, so we don't touch the
5065 NAMESPACE_DECL at all. */
5066 tree x
= args
? TREE_VALUE (args
) : NULL_TREE
;
5067 if (x
== NULL_TREE
|| TREE_CODE (x
) != STRING_CST
|| TREE_CHAIN (args
))
5069 warning (OPT_Wattributes
,
5070 "%qD attribute requires a single NTBS argument",
5075 if (!TREE_PUBLIC (ns
))
5076 warning (OPT_Wattributes
,
5077 "%qD attribute is meaningless since members of the "
5078 "anonymous namespace get local symbols", name
);
5080 push_visibility (TREE_STRING_POINTER (x
), 1);
5083 else if (is_attribute_p ("abi_tag", name
))
5085 if (!DECL_NAME (ns
))
5087 warning (OPT_Wattributes
, "ignoring %qD attribute on anonymous "
5091 if (!DECL_NAMESPACE_INLINE_P (ns
))
5093 warning (OPT_Wattributes
, "ignoring %qD attribute on non-inline "
5099 tree dn
= DECL_NAME (ns
);
5100 args
= build_string (IDENTIFIER_LENGTH (dn
) + 1,
5101 IDENTIFIER_POINTER (dn
));
5102 TREE_TYPE (args
) = char_array_type_node
;
5103 args
= fix_string_type (args
);
5104 args
= build_tree_list (NULL_TREE
, args
);
5106 if (check_abi_tag_args (args
, name
))
5107 DECL_ATTRIBUTES (ns
) = tree_cons (name
, args
,
5108 DECL_ATTRIBUTES (ns
));
5112 warning (OPT_Wattributes
, "%qD attribute directive ignored",
5121 /* Temporarily set the namespace for the current declaration. */
5124 push_decl_namespace (tree decl
)
5126 if (TREE_CODE (decl
) != NAMESPACE_DECL
)
5127 decl
= decl_namespace_context (decl
);
5128 vec_safe_push (decl_namespace_list
, ORIGINAL_NAMESPACE (decl
));
5131 /* [namespace.memdef]/2 */
5134 pop_decl_namespace (void)
5136 decl_namespace_list
->pop ();
5139 /* Process a namespace-alias declaration. */
5142 do_namespace_alias (tree alias
, tree name_space
)
5144 if (name_space
== error_mark_node
)
5147 gcc_assert (TREE_CODE (name_space
) == NAMESPACE_DECL
);
5149 name_space
= ORIGINAL_NAMESPACE (name_space
);
5151 /* Build the alias. */
5152 alias
= build_lang_decl (NAMESPACE_DECL
, alias
, void_type_node
);
5153 DECL_NAMESPACE_ALIAS (alias
) = name_space
;
5154 DECL_EXTERNAL (alias
) = 1;
5155 DECL_CONTEXT (alias
) = FROB_CONTEXT (current_scope ());
5158 /* Emit debug info for namespace alias. */
5159 if (!building_stmt_list_p ())
5160 (*debug_hooks
->early_global_decl
) (alias
);
5163 /* Like pushdecl, only it places X in the current namespace,
5167 pushdecl_namespace_level (tree x
, bool is_friend
)
5169 cp_binding_level
*b
= current_binding_level
;
5172 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
5173 t
= do_pushdecl_with_scope
5174 (x
, NAMESPACE_LEVEL (current_namespace
), is_friend
);
5176 /* Now, the type_shadowed stack may screw us. Munge it so it does
5178 if (TREE_CODE (t
) == TYPE_DECL
)
5180 tree name
= DECL_NAME (t
);
5182 tree
*ptr
= (tree
*)0;
5183 for (; !global_scope_p (b
); b
= b
->level_chain
)
5185 tree shadowed
= b
->type_shadowed
;
5186 for (; shadowed
; shadowed
= TREE_CHAIN (shadowed
))
5187 if (TREE_PURPOSE (shadowed
) == name
)
5189 ptr
= &TREE_VALUE (shadowed
);
5190 /* Can't break out of the loop here because sometimes
5191 a binding level will have duplicate bindings for
5192 PT names. It's gross, but I haven't time to fix it. */
5195 newval
= TREE_TYPE (t
);
5196 if (ptr
== (tree
*)0)
5198 /* @@ This shouldn't be needed. My test case "zstring.cc" trips
5199 up here if this is changed to an assertion. --KR */
5200 SET_IDENTIFIER_TYPE_VALUE (name
, t
);
5207 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
5211 /* Process a using-declaration appearing in namespace scope. */
5214 finish_namespace_using_decl (tree decl
, tree scope
, tree name
)
5216 tree orig_decl
= decl
;
5218 gcc_checking_assert (current_binding_level
->kind
== sk_namespace
5219 && !processing_template_decl
);
5220 decl
= validate_nonmember_using_decl (decl
, scope
, name
);
5221 if (decl
== NULL_TREE
)
5224 tree
*slot
= find_namespace_slot (current_namespace
, name
, true);
5225 tree val
= slot
? MAYBE_STAT_DECL (*slot
) : NULL_TREE
;
5226 tree type
= slot
? MAYBE_STAT_TYPE (*slot
) : NULL_TREE
;
5227 do_nonmember_using_decl (scope
, name
, &val
, &type
);
5228 if (STAT_HACK_P (*slot
))
5230 STAT_DECL (*slot
) = val
;
5231 STAT_TYPE (*slot
) = type
;
5234 *slot
= stat_hack (val
, type
);
5238 /* Emit debug info. */
5239 cp_emit_debug_info_for_using (orig_decl
, current_namespace
);
5242 /* Process a using-declaration at function scope. */
5245 finish_local_using_decl (tree decl
, tree scope
, tree name
)
5247 tree orig_decl
= decl
;
5249 gcc_checking_assert (current_binding_level
->kind
!= sk_class
5250 && current_binding_level
->kind
!= sk_namespace
);
5251 decl
= validate_nonmember_using_decl (decl
, scope
, name
);
5252 if (decl
== NULL_TREE
)
5255 add_decl_expr (decl
);
5257 cxx_binding
*binding
= find_local_binding (current_binding_level
, name
);
5258 tree value
= binding
? binding
->value
: NULL_TREE
;
5259 tree type
= binding
? binding
->type
: NULL_TREE
;
5261 do_nonmember_using_decl (scope
, name
, &value
, &type
);
5265 else if (binding
&& value
== binding
->value
)
5267 else if (binding
&& binding
->value
&& TREE_CODE (value
) == OVERLOAD
)
5269 update_local_overload (IDENTIFIER_BINDING (name
), value
);
5270 IDENTIFIER_BINDING (name
)->value
= value
;
5273 /* Install the new binding. */
5274 push_local_binding (name
, value
, true);
5278 else if (binding
&& type
== binding
->type
)
5282 push_local_binding (name
, type
, true);
5283 set_identifier_type_value (name
, type
);
5286 /* Emit debug info. */
5287 if (!processing_template_decl
)
5288 cp_emit_debug_info_for_using (orig_decl
, current_scope ());
5291 /* Return the declarations that are members of the namespace NS. */
5294 cp_namespace_decls (tree ns
)
5296 return NAMESPACE_LEVEL (ns
)->names
;
5299 /* Combine prefer_type and namespaces_only into flags. */
5302 lookup_flags (int prefer_type
, int namespaces_only
)
5304 if (namespaces_only
)
5305 return LOOKUP_PREFER_NAMESPACES
;
5306 if (prefer_type
> 1)
5307 return LOOKUP_PREFER_TYPES
;
5308 if (prefer_type
> 0)
5309 return LOOKUP_PREFER_BOTH
;
5313 /* Given a lookup that returned VAL, use FLAGS to decide if we want to
5314 ignore it or not. Subroutine of lookup_name_real and
5315 lookup_type_scope. */
5318 qualify_lookup (tree val
, int flags
)
5320 if (val
== NULL_TREE
)
5322 if ((flags
& LOOKUP_PREFER_NAMESPACES
) && TREE_CODE (val
) == NAMESPACE_DECL
)
5324 if (flags
& LOOKUP_PREFER_TYPES
)
5326 tree target_val
= strip_using_decl (val
);
5327 if (TREE_CODE (target_val
) == TYPE_DECL
5328 || TREE_CODE (target_val
) == TEMPLATE_DECL
)
5331 if (flags
& (LOOKUP_PREFER_NAMESPACES
| LOOKUP_PREFER_TYPES
))
5333 /* Look through lambda things that we shouldn't be able to see. */
5334 if (!(flags
& LOOKUP_HIDDEN
) && is_lambda_ignored_entity (val
))
5339 /* Is there a "using namespace std;" directive within USINGS? */
5342 using_directives_contain_std_p (vec
<tree
, va_gc
> *usings
)
5347 for (unsigned ix
= usings
->length (); ix
--;)
5348 if ((*usings
)[ix
] == std_node
)
5354 /* Is there a "using namespace std;" directive within the current
5355 namespace (or its ancestors)?
5356 Compare with name_lookup::search_unqualified. */
5359 has_using_namespace_std_directive_p ()
5361 /* Look at local using-directives. */
5362 for (cp_binding_level
*level
= current_binding_level
;
5363 level
->kind
!= sk_namespace
;
5364 level
= level
->level_chain
)
5365 if (using_directives_contain_std_p (level
->using_directives
))
5368 /* Look at this namespace and its ancestors. */
5369 for (tree scope
= current_namespace
; scope
; scope
= CP_DECL_CONTEXT (scope
))
5371 if (using_directives_contain_std_p (DECL_NAMESPACE_USING (scope
)))
5374 if (scope
== global_namespace
)
5381 /* Suggest alternatives for NAME, an IDENTIFIER_NODE for which name
5382 lookup failed. Search through all available namespaces and print out
5383 possible candidates. If no exact matches are found, and
5384 SUGGEST_MISSPELLINGS is true, then also look for near-matches and
5385 suggest the best near-match, if there is one. */
5388 suggest_alternatives_for (location_t location
, tree name
,
5389 bool suggest_misspellings
)
5391 vec
<tree
> candidates
= vNULL
;
5392 vec
<tree
> worklist
= vNULL
;
5393 unsigned limit
= PARAM_VALUE (CXX_MAX_NAMESPACES_FOR_DIAGNOSTIC_HELP
);
5394 bool limited
= false;
5396 /* Breadth-first search of namespaces. Up to limit namespaces
5397 searched (limit zero == unlimited). */
5398 worklist
.safe_push (global_namespace
);
5399 for (unsigned ix
= 0; ix
!= worklist
.length (); ix
++)
5401 tree ns
= worklist
[ix
];
5402 name_lookup
lookup (name
);
5404 if (lookup
.search_qualified (ns
, false))
5405 candidates
.safe_push (lookup
.value
);
5409 /* Look for child namespaces. We have to do this
5410 indirectly because they are chained in reverse order,
5411 which is confusing to the user. */
5412 vec
<tree
> children
= vNULL
;
5414 for (tree decl
= NAMESPACE_LEVEL (ns
)->names
;
5415 decl
; decl
= TREE_CHAIN (decl
))
5416 if (TREE_CODE (decl
) == NAMESPACE_DECL
5417 && !DECL_NAMESPACE_ALIAS (decl
)
5418 && !DECL_NAMESPACE_INLINE_P (decl
))
5419 children
.safe_push (decl
);
5421 while (!limited
&& !children
.is_empty ())
5423 if (worklist
.length () == limit
)
5425 /* Unconditionally warn that the search was truncated. */
5427 "maximum limit of %d namespaces searched for %qE",
5432 worklist
.safe_push (children
.pop ());
5434 children
.release ();
5437 worklist
.release ();
5439 if (candidates
.length ())
5441 inform_n (location
, candidates
.length (),
5442 "suggested alternative:",
5443 "suggested alternatives:");
5444 for (unsigned ix
= 0; ix
!= candidates
.length (); ix
++)
5446 tree val
= candidates
[ix
];
5448 inform (location_of (val
), " %qE", val
);
5450 candidates
.release ();
5454 /* No candidates were found in the available namespaces. */
5456 /* If there's a "using namespace std;" active, and this
5457 is one of the most common "std::" names, then it's probably a
5458 missing #include. */
5459 if (has_using_namespace_std_directive_p ())
5460 if (maybe_suggest_missing_std_header (location
, name
))
5463 /* Otherwise, consider misspellings. */
5464 if (!suggest_misspellings
)
5466 if (name_hint hint
= lookup_name_fuzzy (name
, FUZZY_LOOKUP_NAME
,
5469 /* Show a spelling correction. */
5470 gcc_rich_location
richloc (location
);
5472 richloc
.add_fixit_replace (hint
.suggestion ());
5473 inform (&richloc
, "suggested alternative: %qs", hint
.suggestion ());
5477 /* A well-known name within the C++ standard library, returned by
5478 get_std_name_hint. */
5480 struct std_name_hint
5482 /* A name within "std::". */
5485 /* The header name defining it within the C++ Standard Library
5486 (with '<' and '>'). */
5489 /* The dialect of C++ in which this was added. */
5490 enum cxx_dialect min_dialect
;
5493 /* Subroutine of maybe_suggest_missing_header for handling unrecognized names
5494 for some of the most common names within "std::".
5495 Given non-NULL NAME, return the std_name_hint for it, or NULL. */
5497 static const std_name_hint
*
5498 get_std_name_hint (const char *name
)
5500 static const std_name_hint hints
[] = {
5502 {"any", "<any>", cxx17
},
5503 {"any_cast", "<any>", cxx17
},
5504 {"make_any", "<any>", cxx17
},
5506 {"array", "<array>", cxx11
},
5508 {"atomic", "<atomic>", cxx11
},
5509 {"atomic_flag", "<atomic>", cxx11
},
5511 {"bitset", "<bitset>", cxx11
},
5513 {"complex", "<complex>", cxx98
},
5514 {"complex_literals", "<complex>", cxx98
},
5515 /* <condition_variable>. */
5516 {"condition_variable", "<condition_variable>", cxx11
},
5517 {"condition_variable_any", "<condition_variable>", cxx11
},
5519 {"deque", "<deque>", cxx98
},
5520 /* <forward_list>. */
5521 {"forward_list", "<forward_list>", cxx11
},
5523 {"basic_filebuf", "<fstream>", cxx98
},
5524 {"basic_ifstream", "<fstream>", cxx98
},
5525 {"basic_ofstream", "<fstream>", cxx98
},
5526 {"basic_fstream", "<fstream>", cxx98
},
5527 {"fstream", "<fstream>", cxx98
},
5528 {"ifstream", "<fstream>", cxx98
},
5529 {"ofstream", "<fstream>", cxx98
},
5531 {"bind", "<functional>", cxx11
},
5532 {"function", "<functional>", cxx11
},
5533 {"hash", "<functional>", cxx11
},
5534 {"mem_fn", "<functional>", cxx11
},
5536 {"async", "<future>", cxx11
},
5537 {"future", "<future>", cxx11
},
5538 {"packaged_task", "<future>", cxx11
},
5539 {"promise", "<future>", cxx11
},
5541 {"cin", "<iostream>", cxx98
},
5542 {"cout", "<iostream>", cxx98
},
5543 {"cerr", "<iostream>", cxx98
},
5544 {"clog", "<iostream>", cxx98
},
5545 {"wcin", "<iostream>", cxx98
},
5546 {"wcout", "<iostream>", cxx98
},
5547 {"wclog", "<iostream>", cxx98
},
5549 {"istream", "<istream>", cxx98
},
5551 {"advance", "<iterator>", cxx98
},
5552 {"back_inserter", "<iterator>", cxx98
},
5553 {"begin", "<iterator>", cxx11
},
5554 {"distance", "<iterator>", cxx98
},
5555 {"end", "<iterator>", cxx11
},
5556 {"front_inserter", "<iterator>", cxx98
},
5557 {"inserter", "<iterator>", cxx98
},
5558 {"istream_iterator", "<iterator>", cxx98
},
5559 {"istreambuf_iterator", "<iterator>", cxx98
},
5560 {"iterator_traits", "<iterator>", cxx98
},
5561 {"move_iterator", "<iterator>", cxx11
},
5562 {"next", "<iterator>", cxx11
},
5563 {"ostream_iterator", "<iterator>", cxx98
},
5564 {"ostreambuf_iterator", "<iterator>", cxx98
},
5565 {"prev", "<iterator>", cxx11
},
5566 {"reverse_iterator", "<iterator>", cxx98
},
5568 {"ostream", "<ostream>", cxx98
},
5570 {"list", "<list>", cxx98
},
5572 {"map", "<map>", cxx98
},
5573 {"multimap", "<map>", cxx98
},
5575 {"make_shared", "<memory>", cxx11
},
5576 {"make_unique", "<memory>", cxx11
},
5577 {"shared_ptr", "<memory>", cxx11
},
5578 {"unique_ptr", "<memory>", cxx11
},
5579 {"weak_ptr", "<memory>", cxx11
},
5581 {"mutex", "<mutex>", cxx11
},
5582 {"timed_mutex", "<mutex>", cxx11
},
5583 {"recursive_mutex", "<mutex>", cxx11
},
5584 {"recursive_timed_mutex", "<mutex>", cxx11
},
5585 {"once_flag", "<mutex>", cxx11
},
5586 {"call_once,", "<mutex>", cxx11
},
5587 {"lock", "<mutex>", cxx11
},
5588 {"scoped_lock", "<mutex>", cxx17
},
5589 {"try_lock", "<mutex>", cxx11
},
5590 {"lock_guard", "<mutex>", cxx11
},
5591 {"unique_lock", "<mutex>", cxx11
},
5593 {"optional", "<optional>", cxx17
},
5594 {"make_optional", "<optional>", cxx17
},
5596 {"ostream", "<ostream>", cxx98
},
5597 {"wostream", "<ostream>", cxx98
},
5598 {"ends", "<ostream>", cxx98
},
5599 {"flush", "<ostream>", cxx98
},
5600 {"endl", "<ostream>", cxx98
},
5602 {"queue", "<queue>", cxx98
},
5603 {"priority_queue", "<queue>", cxx98
},
5605 {"set", "<set>", cxx98
},
5606 {"multiset", "<set>", cxx98
},
5607 /* <shared_mutex>. */
5608 {"shared_lock", "<shared_mutex>", cxx14
},
5609 {"shared_mutex", "<shared_mutex>", cxx17
},
5610 {"shared_timed_mutex", "<shared_mutex>", cxx14
},
5612 {"basic_stringbuf", "<sstream>", cxx98
},
5613 {"basic_istringstream", "<sstream>", cxx98
},
5614 {"basic_ostringstream", "<sstream>", cxx98
},
5615 {"basic_stringstream", "<sstream>", cxx98
},
5616 {"istringstream", "<sstream>", cxx98
},
5617 {"ostringstream", "<sstream>", cxx98
},
5618 {"stringstream", "<sstream>", cxx98
},
5620 {"stack", "<stack>", cxx98
},
5622 {"basic_string", "<string>", cxx98
},
5623 {"string", "<string>", cxx98
},
5624 {"wstring", "<string>", cxx98
},
5625 {"u16string", "<string>", cxx11
},
5626 {"u32string", "<string>", cxx11
},
5627 /* <string_view>. */
5628 {"string_view", "<string_view>", cxx17
},
5630 {"thread", "<thread>", cxx11
},
5632 {"make_tuple", "<tuple>", cxx11
},
5633 {"tuple", "<tuple>", cxx11
},
5634 {"tuple_element", "<tuple>", cxx11
},
5635 {"tuple_size", "<tuple>", cxx11
},
5636 /* <unordered_map>. */
5637 {"unordered_map", "<unordered_map>", cxx11
},
5638 {"unordered_multimap", "<unordered_map>", cxx11
},
5639 /* <unordered_set>. */
5640 {"unordered_set", "<unordered_set>", cxx11
},
5641 {"unordered_multiset", "<unordered_set>", cxx11
},
5643 {"declval", "<utility>", cxx11
},
5644 {"forward", "<utility>", cxx11
},
5645 {"make_pair", "<utility>", cxx98
},
5646 {"move", "<utility>", cxx11
},
5647 {"pair", "<utility>", cxx98
},
5649 {"variant", "<variant>", cxx17
},
5650 {"visit", "<variant>", cxx17
},
5652 {"vector", "<vector>", cxx98
},
5654 const size_t num_hints
= sizeof (hints
) / sizeof (hints
[0]);
5655 for (size_t i
= 0; i
< num_hints
; i
++)
5657 if (strcmp (name
, hints
[i
].name
) == 0)
5663 /* Describe DIALECT. */
5666 get_cxx_dialect_name (enum cxx_dialect dialect
)
5685 /* Suggest pertinent header files for NAME at LOCATION, for common
5686 names within the "std" namespace.
5687 Return true iff a suggestion was offered. */
5690 maybe_suggest_missing_std_header (location_t location
, tree name
)
5692 gcc_assert (TREE_CODE (name
) == IDENTIFIER_NODE
);
5694 const char *name_str
= IDENTIFIER_POINTER (name
);
5695 const std_name_hint
*header_hint
= get_std_name_hint (name_str
);
5699 gcc_rich_location
richloc (location
);
5700 if (cxx_dialect
>= header_hint
->min_dialect
)
5702 const char *header
= header_hint
->header
;
5703 maybe_add_include_fixit (&richloc
, header
);
5705 "%<std::%s%> is defined in header %qs;"
5706 " did you forget to %<#include %s%>?",
5707 name_str
, header
, header
);
5712 "%<std::%s%> is only available from %s onwards",
5713 name_str
, get_cxx_dialect_name (header_hint
->min_dialect
));
5718 /* If SCOPE is the "std" namespace, then suggest pertinent header
5719 files for NAME at LOCATION.
5720 Return true iff a suggestion was offered. */
5723 maybe_suggest_missing_header (location_t location
, tree name
, tree scope
)
5725 if (scope
== NULL_TREE
)
5727 if (TREE_CODE (scope
) != NAMESPACE_DECL
)
5729 /* We only offer suggestions for the "std" namespace. */
5730 if (scope
!= std_node
)
5732 return maybe_suggest_missing_std_header (location
, name
);
5735 /* Look for alternatives for NAME, an IDENTIFIER_NODE for which name
5736 lookup failed within the explicitly provided SCOPE. Suggest the
5737 the best meaningful candidates (if any) as a fix-it hint.
5738 Return true iff a suggestion was provided. */
5741 suggest_alternative_in_explicit_scope (location_t location
, tree name
,
5744 /* Something went very wrong; don't suggest anything. */
5745 if (name
== error_mark_node
)
5748 /* Resolve any namespace aliases. */
5749 scope
= ORIGINAL_NAMESPACE (scope
);
5751 if (maybe_suggest_missing_header (location
, name
, scope
))
5754 cp_binding_level
*level
= NAMESPACE_LEVEL (scope
);
5756 best_match
<tree
, const char *> bm (name
);
5757 consider_binding_level (name
, bm
, level
, false, FUZZY_LOOKUP_NAME
);
5759 /* See if we have a good suggesion for the user. */
5760 const char *fuzzy_name
= bm
.get_best_meaningful_candidate ();
5763 gcc_rich_location
richloc (location
);
5764 richloc
.add_fixit_replace (fuzzy_name
);
5765 inform (&richloc
, "suggested alternative: %qs",
5773 /* Look up NAME (an IDENTIFIER_NODE) in SCOPE (either a NAMESPACE_DECL
5776 If PREFER_TYPE is > 0, we only return TYPE_DECLs or namespaces.
5777 If PREFER_TYPE is > 1, we only return TYPE_DECLs.
5779 Returns a DECL (or OVERLOAD, or BASELINK) representing the
5780 declaration found. If no suitable declaration can be found,
5781 ERROR_MARK_NODE is returned. If COMPLAIN is true and SCOPE is
5782 neither a class-type nor a namespace a diagnostic is issued. */
5785 lookup_qualified_name (tree scope
, tree name
, int prefer_type
, bool complain
,
5790 if (TREE_CODE (scope
) == NAMESPACE_DECL
)
5792 int flags
= lookup_flags (prefer_type
, /*namespaces_only*/false);
5794 flags
|= LOOKUP_HIDDEN
;
5795 name_lookup
lookup (name
, flags
);
5797 if (qualified_namespace_lookup (scope
, &lookup
))
5800 else if (cxx_dialect
!= cxx98
&& TREE_CODE (scope
) == ENUMERAL_TYPE
)
5801 t
= lookup_enumerator (scope
, name
);
5802 else if (is_class_type (scope
, complain
))
5803 t
= lookup_member (scope
, name
, 2, prefer_type
, tf_warning_or_error
);
5806 return error_mark_node
;
5811 Accepts the NAME to lookup and its qualifying SCOPE.
5812 Returns the name/type pair found into the cxx_binding *RESULT,
5813 or false on error. */
5816 qualified_namespace_lookup (tree scope
, name_lookup
*lookup
)
5818 timevar_start (TV_NAME_LOOKUP
);
5819 query_oracle (lookup
->name
);
5820 bool found
= lookup
->search_qualified (ORIGINAL_NAMESPACE (scope
));
5821 timevar_stop (TV_NAME_LOOKUP
);
5825 /* Helper function for lookup_name_fuzzy.
5826 Traverse binding level LVL, looking for good name matches for NAME
5829 consider_binding_level (tree name
, best_match
<tree
, const char *> &bm
,
5830 cp_binding_level
*lvl
, bool look_within_fields
,
5831 enum lookup_name_fuzzy_kind kind
)
5833 if (look_within_fields
)
5834 if (lvl
->this_entity
&& TREE_CODE (lvl
->this_entity
) == RECORD_TYPE
)
5836 tree type
= lvl
->this_entity
;
5837 bool want_type_p
= (kind
== FUZZY_LOOKUP_TYPENAME
);
5838 tree best_matching_field
5839 = lookup_member_fuzzy (type
, name
, want_type_p
);
5840 if (best_matching_field
)
5841 bm
.consider (IDENTIFIER_POINTER (best_matching_field
));
5844 /* Only suggest names reserved for the implementation if NAME begins
5845 with an underscore. */
5846 bool consider_implementation_names
= (IDENTIFIER_POINTER (name
)[0] == '_');
5848 for (tree t
= lvl
->names
; t
; t
= TREE_CHAIN (t
))
5852 /* OVERLOADs or decls from using declaration are wrapped into
5854 if (TREE_CODE (d
) == TREE_LIST
)
5855 d
= OVL_FIRST (TREE_VALUE (d
));
5857 /* Don't use bindings from implicitly declared functions,
5858 as they were likely misspellings themselves. */
5859 if (TREE_TYPE (d
) == error_mark_node
)
5862 /* Skip anticipated decls of builtin functions. */
5863 if (TREE_CODE (d
) == FUNCTION_DECL
5864 && DECL_BUILT_IN (d
)
5865 && DECL_ANTICIPATED (d
))
5868 /* Skip compiler-generated variables (e.g. __for_begin/__for_end
5869 within range for). */
5870 if (TREE_CODE (d
) == VAR_DECL
5871 && DECL_ARTIFICIAL (d
))
5874 tree suggestion
= DECL_NAME (d
);
5878 const char *suggestion_str
= IDENTIFIER_POINTER (suggestion
);
5880 /* Ignore internal names with spaces in them. */
5881 if (strchr (suggestion_str
, ' '))
5884 /* Don't suggest names that are reserved for use by the
5885 implementation, unless NAME began with an underscore. */
5886 if (name_reserved_for_implementation_p (suggestion_str
)
5887 && !consider_implementation_names
)
5890 bm
.consider (suggestion_str
);
5894 /* Subclass of deferred_diagnostic. Notify the user that the
5895 given macro was used before it was defined.
5896 This can be done in the C++ frontend since tokenization happens
5899 class macro_use_before_def
: public deferred_diagnostic
5902 /* Factory function. Return a new macro_use_before_def instance if
5903 appropriate, or return NULL. */
5904 static macro_use_before_def
*
5905 maybe_make (location_t use_loc
, cpp_hashnode
*macro
)
5907 source_location def_loc
= cpp_macro_definition_location (macro
);
5908 if (def_loc
== UNKNOWN_LOCATION
)
5911 /* We only want to issue a note if the macro was used *before* it was
5913 We don't want to issue a note for cases where a macro was incorrectly
5914 used, leaving it unexpanded (e.g. by using the wrong argument
5916 if (!linemap_location_before_p (line_table
, use_loc
, def_loc
))
5919 return new macro_use_before_def (use_loc
, macro
);
5923 /* Ctor. LOC is the location of the usage. MACRO is the
5924 macro that was used. */
5925 macro_use_before_def (location_t loc
, cpp_hashnode
*macro
)
5926 : deferred_diagnostic (loc
), m_macro (macro
)
5931 ~macro_use_before_def ()
5933 if (is_suppressed_p ())
5936 inform (get_location (), "the macro %qs had not yet been defined",
5937 (const char *)m_macro
->ident
.str
);
5938 inform (cpp_macro_definition_location (m_macro
),
5939 "it was later defined here");
5943 cpp_hashnode
*m_macro
;
5946 /* Determine if it can ever make sense to offer RID as a suggestion for
5949 Subroutine of lookup_name_fuzzy. */
5952 suggest_rid_p (enum rid rid
)
5956 /* Support suggesting function-like keywords. */
5957 case RID_STATIC_ASSERT
:
5961 /* Support suggesting the various decl-specifier words, to handle
5962 e.g. "singed" vs "signed" typos. */
5963 if (cp_keyword_starts_decl_specifier_p (rid
))
5966 /* Otherwise, don't offer it. This avoids suggesting e.g. "if"
5967 and "do" for short misspellings, which are likely to lead to
5968 nonsensical results. */
5973 /* Search for near-matches for NAME within the current bindings, and within
5974 macro names, returning the best match as a const char *, or NULL if
5975 no reasonable match is found.
5977 Use LOC for any deferred diagnostics. */
5980 lookup_name_fuzzy (tree name
, enum lookup_name_fuzzy_kind kind
, location_t loc
)
5982 gcc_assert (TREE_CODE (name
) == IDENTIFIER_NODE
);
5984 /* First, try some well-known names in the C++ standard library, in case
5985 the user forgot a #include. */
5986 const char *header_hint
5987 = get_cp_stdlib_header_for_name (IDENTIFIER_POINTER (name
));
5989 return name_hint (NULL
,
5990 new suggest_missing_header (loc
,
5991 IDENTIFIER_POINTER (name
),
5994 best_match
<tree
, const char *> bm (name
);
5996 cp_binding_level
*lvl
;
5997 for (lvl
= scope_chain
->class_bindings
; lvl
; lvl
= lvl
->level_chain
)
5998 consider_binding_level (name
, bm
, lvl
, true, kind
);
6000 for (lvl
= current_binding_level
; lvl
; lvl
= lvl
->level_chain
)
6001 consider_binding_level (name
, bm
, lvl
, false, kind
);
6003 /* Consider macros: if the user misspelled a macro name e.g. "SOME_MACRO"
6005 x = SOME_OTHER_MACRO (y);
6006 then "SOME_OTHER_MACRO" will survive to the frontend and show up
6007 as a misspelled identifier.
6009 Use the best distance so far so that a candidate is only set if
6010 a macro is better than anything so far. This allows early rejection
6011 (without calculating the edit distance) of macro names that must have
6012 distance >= bm.get_best_distance (), and means that we only get a
6013 non-NULL result for best_macro_match if it's better than any of
6014 the identifiers already checked. */
6015 best_macro_match
bmm (name
, bm
.get_best_distance (), parse_in
);
6016 cpp_hashnode
*best_macro
= bmm
.get_best_meaningful_candidate ();
6017 /* If a macro is the closest so far to NAME, consider it. */
6019 bm
.consider ((const char *)best_macro
->ident
.str
);
6020 else if (bmm
.get_best_distance () == 0)
6022 /* If we have an exact match for a macro name, then either the
6023 macro was used with the wrong argument count, or the macro
6024 has been used before it was defined. */
6025 cpp_hashnode
*macro
= bmm
.blithely_get_best_candidate ();
6026 if (macro
&& (macro
->flags
& NODE_BUILTIN
) == 0)
6027 return name_hint (NULL
,
6028 macro_use_before_def::maybe_make (loc
, macro
));
6031 /* Try the "starts_decl_specifier_p" keywords to detect
6032 "singed" vs "signed" typos. */
6033 for (unsigned i
= 0; i
< num_c_common_reswords
; i
++)
6035 const c_common_resword
*resword
= &c_common_reswords
[i
];
6037 if (!suggest_rid_p (resword
->rid
))
6040 tree resword_identifier
= ridpointers
[resword
->rid
];
6041 if (!resword_identifier
)
6043 gcc_assert (TREE_CODE (resword_identifier
) == IDENTIFIER_NODE
);
6045 /* Only consider reserved words that survived the
6046 filtering in init_reswords (e.g. for -std). */
6047 if (!IDENTIFIER_KEYWORD_P (resword_identifier
))
6050 bm
.consider (IDENTIFIER_POINTER (resword_identifier
));
6053 return name_hint (bm
.get_best_meaningful_candidate (), NULL
);
6056 /* Subroutine of outer_binding.
6058 Returns TRUE if BINDING is a binding to a template parameter of
6059 SCOPE. In that case SCOPE is the scope of a primary template
6060 parameter -- in the sense of G++, i.e, a template that has its own
6063 Returns FALSE otherwise. */
6066 binding_to_template_parms_of_scope_p (cxx_binding
*binding
,
6067 cp_binding_level
*scope
)
6069 tree binding_value
, tmpl
, tinfo
;
6072 if (!binding
|| !scope
|| !scope
->this_entity
)
6075 binding_value
= binding
->value
? binding
->value
: binding
->type
;
6076 tinfo
= get_template_info (scope
->this_entity
);
6078 /* BINDING_VALUE must be a template parm. */
6079 if (binding_value
== NULL_TREE
6080 || (!DECL_P (binding_value
)
6081 || !DECL_TEMPLATE_PARM_P (binding_value
)))
6084 /* The level of BINDING_VALUE. */
6086 template_type_parameter_p (binding_value
)
6087 ? TEMPLATE_PARM_LEVEL (TEMPLATE_TYPE_PARM_INDEX
6088 (TREE_TYPE (binding_value
)))
6089 : TEMPLATE_PARM_LEVEL (DECL_INITIAL (binding_value
));
6091 /* The template of the current scope, iff said scope is a primary
6094 && PRIMARY_TEMPLATE_P (TI_TEMPLATE (tinfo
))
6095 ? TI_TEMPLATE (tinfo
)
6098 /* If the level of the parm BINDING_VALUE equals the depth of TMPL,
6099 then BINDING_VALUE is a parameter of TMPL. */
6100 return (tmpl
&& level
== TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (tmpl
)));
6103 /* Return the innermost non-namespace binding for NAME from a scope
6104 containing BINDING, or, if BINDING is NULL, the current scope.
6105 Please note that for a given template, the template parameters are
6106 considered to be in the scope containing the current scope.
6107 If CLASS_P is false, then class bindings are ignored. */
6110 outer_binding (tree name
,
6111 cxx_binding
*binding
,
6115 cp_binding_level
*scope
;
6116 cp_binding_level
*outer_scope
;
6120 scope
= binding
->scope
->level_chain
;
6121 outer
= binding
->previous
;
6125 scope
= current_binding_level
;
6126 outer
= IDENTIFIER_BINDING (name
);
6128 outer_scope
= outer
? outer
->scope
: NULL
;
6130 /* Because we create class bindings lazily, we might be missing a
6131 class binding for NAME. If there are any class binding levels
6132 between the LAST_BINDING_LEVEL and the scope in which OUTER was
6133 declared, we must lookup NAME in those class scopes. */
6135 while (scope
&& scope
!= outer_scope
&& scope
->kind
!= sk_namespace
)
6137 if (scope
->kind
== sk_class
)
6139 cxx_binding
*class_binding
;
6141 class_binding
= get_class_binding (name
, scope
);
6144 /* Thread this new class-scope binding onto the
6145 IDENTIFIER_BINDING list so that future lookups
6147 class_binding
->previous
= outer
;
6149 binding
->previous
= class_binding
;
6151 IDENTIFIER_BINDING (name
) = class_binding
;
6152 return class_binding
;
6155 /* If we are in a member template, the template parms of the member
6156 template are considered to be inside the scope of the containing
6157 class, but within G++ the class bindings are all pushed between the
6158 template parms and the function body. So if the outer binding is
6159 a template parm for the current scope, return it now rather than
6160 look for a class binding. */
6161 if (outer_scope
&& outer_scope
->kind
== sk_template_parms
6162 && binding_to_template_parms_of_scope_p (outer
, scope
))
6165 scope
= scope
->level_chain
;
6171 /* Return the innermost block-scope or class-scope value binding for
6172 NAME, or NULL_TREE if there is no such binding. */
6175 innermost_non_namespace_value (tree name
)
6177 cxx_binding
*binding
;
6178 binding
= outer_binding (name
, /*binding=*/NULL
, /*class_p=*/true);
6179 return binding
? binding
->value
: NULL_TREE
;
6182 /* Look up NAME in the current binding level and its superiors in the
6183 namespace of variables, functions and typedefs. Return a ..._DECL
6184 node of some kind representing its definition if there is only one
6185 such declaration, or return a TREE_LIST with all the overloaded
6186 definitions if there are many, or return 0 if it is undefined.
6187 Hidden name, either friend declaration or built-in function, are
6190 If PREFER_TYPE is > 0, we prefer TYPE_DECLs or namespaces.
6191 If PREFER_TYPE is > 1, we reject non-type decls (e.g. namespaces).
6192 Otherwise we prefer non-TYPE_DECLs.
6194 If NONCLASS is nonzero, bindings in class scopes are ignored. If
6195 BLOCK_P is false, bindings in block scopes are ignored. */
6198 lookup_name_real_1 (tree name
, int prefer_type
, int nonclass
, bool block_p
,
6199 int namespaces_only
, int flags
)
6202 tree val
= NULL_TREE
;
6204 query_oracle (name
);
6206 /* Conversion operators are handled specially because ordinary
6207 unqualified name lookup will not find template conversion
6209 if (IDENTIFIER_CONV_OP_P (name
))
6211 cp_binding_level
*level
;
6213 for (level
= current_binding_level
;
6214 level
&& level
->kind
!= sk_namespace
;
6215 level
= level
->level_chain
)
6220 /* A conversion operator can only be declared in a class
6222 if (level
->kind
!= sk_class
)
6225 /* Lookup the conversion operator in the class. */
6226 class_type
= level
->this_entity
;
6227 operators
= lookup_fnfields (class_type
, name
, /*protect=*/0);
6235 flags
|= lookup_flags (prefer_type
, namespaces_only
);
6237 /* First, look in non-namespace scopes. */
6239 if (current_class_type
== NULL_TREE
)
6242 if (block_p
|| !nonclass
)
6243 for (iter
= outer_binding (name
, NULL
, !nonclass
);
6245 iter
= outer_binding (name
, iter
, !nonclass
))
6249 /* Skip entities we don't want. */
6250 if (LOCAL_BINDING_P (iter
) ? !block_p
: nonclass
)
6253 /* If this is the kind of thing we're looking for, we're done. */
6254 if (qualify_lookup (iter
->value
, flags
))
6255 binding
= iter
->value
;
6256 else if ((flags
& LOOKUP_PREFER_TYPES
)
6257 && qualify_lookup (iter
->type
, flags
))
6258 binding
= iter
->type
;
6260 binding
= NULL_TREE
;
6264 if (TREE_CODE (binding
) == TYPE_DECL
&& DECL_HIDDEN_P (binding
))
6266 /* A non namespace-scope binding can only be hidden in the
6267 presence of a local class, due to friend declarations.
6269 In particular, consider:
6277 B* b; // error: B is hidden
6278 C* c; // OK, finds ::C
6281 B *b; // error: B is hidden
6282 C *c; // OK, finds ::C
6287 The standard says that "B" is a local class in "f"
6288 (but not nested within "A") -- but that name lookup
6289 for "B" does not find this declaration until it is
6290 declared directly with "f".
6296 If a friend declaration appears in a local class and
6297 the name specified is an unqualified name, a prior
6298 declaration is looked up without considering scopes
6299 that are outside the innermost enclosing non-class
6300 scope. For a friend function declaration, if there is
6301 no prior declaration, the program is ill-formed. For a
6302 friend class declaration, if there is no prior
6303 declaration, the class that is specified belongs to the
6304 innermost enclosing non-class scope, but if it is
6305 subsequently referenced, its name is not found by name
6306 lookup until a matching declaration is provided in the
6307 innermost enclosing nonclass scope.
6309 So just keep looking for a non-hidden binding.
6311 gcc_assert (TREE_CODE (binding
) == TYPE_DECL
);
6319 /* Now lookup in namespace scopes. */
6322 name_lookup
lookup (name
, flags
);
6323 if (lookup
.search_unqualified
6324 (current_decl_namespace (), current_binding_level
))
6328 /* If we have a single function from a using decl, pull it out. */
6329 if (val
&& TREE_CODE (val
) == OVERLOAD
&& !really_overloaded_fn (val
))
6330 val
= OVL_FUNCTION (val
);
6335 /* Wrapper for lookup_name_real_1. */
6338 lookup_name_real (tree name
, int prefer_type
, int nonclass
, bool block_p
,
6339 int namespaces_only
, int flags
)
6342 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
6343 ret
= lookup_name_real_1 (name
, prefer_type
, nonclass
, block_p
,
6344 namespaces_only
, flags
);
6345 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
6350 lookup_name_nonclass (tree name
)
6352 return lookup_name_real (name
, 0, 1, /*block_p=*/true, 0, 0);
6356 lookup_name (tree name
)
6358 return lookup_name_real (name
, 0, 0, /*block_p=*/true, 0, 0);
6362 lookup_name_prefer_type (tree name
, int prefer_type
)
6364 return lookup_name_real (name
, prefer_type
, 0, /*block_p=*/true, 0, 0);
6367 /* Look up NAME for type used in elaborated name specifier in
6368 the scopes given by SCOPE. SCOPE can be either TS_CURRENT or
6369 TS_WITHIN_ENCLOSING_NON_CLASS. Although not implied by the
6370 name, more scopes are checked if cleanup or template parameter
6371 scope is encountered.
6373 Unlike lookup_name_real, we make sure that NAME is actually
6374 declared in the desired scope, not from inheritance, nor using
6375 directive. For using declaration, there is DR138 still waiting
6376 to be resolved. Hidden name coming from an earlier friend
6377 declaration is also returned.
6379 A TYPE_DECL best matching the NAME is returned. Catching error
6380 and issuing diagnostics are caller's responsibility. */
6383 lookup_type_scope_1 (tree name
, tag_scope scope
)
6385 cxx_binding
*iter
= NULL
;
6386 tree val
= NULL_TREE
;
6387 cp_binding_level
*level
= NULL
;
6389 /* Look in non-namespace scope first. */
6390 if (current_binding_level
->kind
!= sk_namespace
)
6391 iter
= outer_binding (name
, NULL
, /*class_p=*/ true);
6392 for (; iter
; iter
= outer_binding (name
, iter
, /*class_p=*/ true))
6394 /* Check if this is the kind of thing we're looking for.
6395 If SCOPE is TS_CURRENT, also make sure it doesn't come from
6396 base class. For ITER->VALUE, we can simply use
6397 INHERITED_VALUE_BINDING_P. For ITER->TYPE, we have to use
6400 We check ITER->TYPE before ITER->VALUE in order to handle
6401 typedef struct C {} C;
6404 if (qualify_lookup (iter
->type
, LOOKUP_PREFER_TYPES
)
6405 && (scope
!= ts_current
6406 || LOCAL_BINDING_P (iter
)
6407 || DECL_CONTEXT (iter
->type
) == iter
->scope
->this_entity
))
6409 else if ((scope
!= ts_current
6410 || !INHERITED_VALUE_BINDING_P (iter
))
6411 && qualify_lookup (iter
->value
, LOOKUP_PREFER_TYPES
))
6418 /* Look in namespace scope. */
6420 level
= iter
->scope
;
6423 tree ns
= current_decl_namespace ();
6425 if (tree
*slot
= find_namespace_slot (ns
, name
))
6427 /* If this is the kind of thing we're looking for, we're done. */
6428 if (tree type
= MAYBE_STAT_TYPE (*slot
))
6429 if (qualify_lookup (type
, LOOKUP_PREFER_TYPES
))
6433 if (tree decl
= MAYBE_STAT_DECL (*slot
))
6434 if (qualify_lookup (decl
, LOOKUP_PREFER_TYPES
))
6437 level
= NAMESPACE_LEVEL (ns
);
6441 /* Type found, check if it is in the allowed scopes, ignoring cleanup
6442 and template parameter scopes. */
6445 cp_binding_level
*b
= current_binding_level
;
6451 if (b
->kind
== sk_cleanup
|| b
->kind
== sk_template_parms
6452 || b
->kind
== sk_function_parms
)
6454 else if (b
->kind
== sk_class
6455 && scope
== ts_within_enclosing_non_class
)
6465 /* Wrapper for lookup_type_scope_1. */
6468 lookup_type_scope (tree name
, tag_scope scope
)
6471 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
6472 ret
= lookup_type_scope_1 (name
, scope
);
6473 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
6477 /* Returns true iff DECL is a block-scope extern declaration of a function
6481 is_local_extern (tree decl
)
6483 cxx_binding
*binding
;
6485 /* For functions, this is easy. */
6486 if (TREE_CODE (decl
) == FUNCTION_DECL
)
6487 return DECL_LOCAL_FUNCTION_P (decl
);
6491 if (!current_function_decl
)
6494 /* For variables, this is not easy. We need to look at the binding stack
6495 for the identifier to see whether the decl we have is a local. */
6496 for (binding
= IDENTIFIER_BINDING (DECL_NAME (decl
));
6497 binding
&& binding
->scope
->kind
!= sk_namespace
;
6498 binding
= binding
->previous
)
6499 if (binding
->value
== decl
)
6500 return LOCAL_BINDING_P (binding
);
6505 /* The type TYPE is being declared. If it is a class template, or a
6506 specialization of a class template, do any processing required and
6507 perform error-checking. If IS_FRIEND is nonzero, this TYPE is
6508 being declared a friend. B is the binding level at which this TYPE
6511 Returns the TYPE_DECL for TYPE, which may have been altered by this
6515 maybe_process_template_type_declaration (tree type
, int is_friend
,
6516 cp_binding_level
*b
)
6518 tree decl
= TYPE_NAME (type
);
6520 if (processing_template_parmlist
)
6521 /* You can't declare a new template type in a template parameter
6522 list. But, you can declare a non-template type:
6524 template <class A*> struct S;
6526 is a forward-declaration of `A'. */
6528 else if (b
->kind
== sk_namespace
6529 && current_binding_level
->kind
!= sk_namespace
)
6530 /* If this new type is being injected into a containing scope,
6531 then it's not a template type. */
6535 gcc_assert (MAYBE_CLASS_TYPE_P (type
)
6536 || TREE_CODE (type
) == ENUMERAL_TYPE
);
6538 if (processing_template_decl
)
6540 /* This may change after the call to
6541 push_template_decl_real, but we want the original value. */
6542 tree name
= DECL_NAME (decl
);
6544 decl
= push_template_decl_real (decl
, is_friend
);
6545 if (decl
== error_mark_node
)
6546 return error_mark_node
;
6548 /* If the current binding level is the binding level for the
6549 template parameters (see the comment in
6550 begin_template_parm_list) and the enclosing level is a class
6551 scope, and we're not looking at a friend, push the
6552 declaration of the member class into the class scope. In the
6553 friend case, push_template_decl will already have put the
6554 friend into global scope, if appropriate. */
6555 if (TREE_CODE (type
) != ENUMERAL_TYPE
6556 && !is_friend
&& b
->kind
== sk_template_parms
6557 && b
->level_chain
->kind
== sk_class
)
6559 finish_member_declaration (CLASSTYPE_TI_TEMPLATE (type
));
6561 if (!COMPLETE_TYPE_P (current_class_type
))
6563 maybe_add_class_template_decl_list (current_class_type
,
6564 type
, /*friend_p=*/0);
6565 /* Put this UTD in the table of UTDs for the class. */
6566 if (CLASSTYPE_NESTED_UTDS (current_class_type
) == NULL
)
6567 CLASSTYPE_NESTED_UTDS (current_class_type
) =
6568 binding_table_new (SCOPE_DEFAULT_HT_SIZE
);
6570 binding_table_insert
6571 (CLASSTYPE_NESTED_UTDS (current_class_type
), name
, type
);
6580 /* Push a tag name NAME for struct/class/union/enum type TYPE. In case
6581 that the NAME is a class template, the tag is processed but not pushed.
6583 The pushed scope depend on the SCOPE parameter:
6584 - When SCOPE is TS_CURRENT, put it into the inner-most non-sk_cleanup
6586 - When SCOPE is TS_GLOBAL, put it in the inner-most non-class and
6587 non-template-parameter scope. This case is needed for forward
6589 - When SCOPE is TS_WITHIN_ENCLOSING_NON_CLASS, this is similar to
6590 TS_GLOBAL case except that names within template-parameter scopes
6591 are not pushed at all.
6593 Returns TYPE upon success and ERROR_MARK_NODE otherwise. */
6596 do_pushtag (tree name
, tree type
, tag_scope scope
)
6600 cp_binding_level
*b
= current_binding_level
;
6601 while (/* Cleanup scopes are not scopes from the point of view of
6603 b
->kind
== sk_cleanup
6604 /* Neither are function parameter scopes. */
6605 || b
->kind
== sk_function_parms
6606 /* Neither are the scopes used to hold template parameters
6607 for an explicit specialization. For an ordinary template
6608 declaration, these scopes are not scopes from the point of
6609 view of the language. */
6610 || (b
->kind
== sk_template_parms
6611 && (b
->explicit_spec_p
|| scope
== ts_global
))
6612 || (b
->kind
== sk_class
6613 && (scope
!= ts_current
6614 /* We may be defining a new type in the initializer
6615 of a static member variable. We allow this when
6616 not pedantic, and it is particularly useful for
6617 type punning via an anonymous union. */
6618 || COMPLETE_TYPE_P (b
->this_entity
))))
6621 gcc_assert (identifier_p (name
));
6623 /* Do C++ gratuitous typedefing. */
6624 if (identifier_type_value_1 (name
) != type
)
6628 tree context
= TYPE_CONTEXT (type
);
6632 tree cs
= current_scope ();
6634 if (scope
== ts_current
6635 || (cs
&& TREE_CODE (cs
) == FUNCTION_DECL
))
6637 else if (cs
&& TYPE_P (cs
))
6638 /* When declaring a friend class of a local class, we want
6639 to inject the newly named class into the scope
6640 containing the local class, not the namespace
6642 context
= decl_function_context (get_type_decl (cs
));
6645 context
= current_namespace
;
6647 if (b
->kind
== sk_class
6648 || (b
->kind
== sk_template_parms
6649 && b
->level_chain
->kind
== sk_class
))
6652 tdef
= create_implicit_typedef (name
, type
);
6653 DECL_CONTEXT (tdef
) = FROB_CONTEXT (context
);
6654 if (scope
== ts_within_enclosing_non_class
)
6656 /* This is a friend. Make this TYPE_DECL node hidden from
6657 ordinary name lookup. Its corresponding TEMPLATE_DECL
6658 will be marked in push_template_decl_real. */
6659 retrofit_lang_decl (tdef
);
6660 DECL_ANTICIPATED (tdef
) = 1;
6661 DECL_FRIEND_P (tdef
) = 1;
6664 decl
= maybe_process_template_type_declaration
6665 (type
, scope
== ts_within_enclosing_non_class
, b
);
6666 if (decl
== error_mark_node
)
6669 if (b
->kind
== sk_class
)
6671 if (!TYPE_BEING_DEFINED (current_class_type
)
6672 && !LAMBDA_TYPE_P (type
))
6673 return error_mark_node
;
6675 if (!PROCESSING_REAL_TEMPLATE_DECL_P ())
6676 /* Put this TYPE_DECL on the TYPE_FIELDS list for the
6677 class. But if it's a member template class, we want
6678 the TEMPLATE_DECL, not the TYPE_DECL, so this is done
6680 finish_member_declaration (decl
);
6682 pushdecl_class_level (decl
);
6684 else if (b
->kind
!= sk_template_parms
)
6686 decl
= do_pushdecl_with_scope (decl
, b
, /*is_friend=*/false);
6687 if (decl
== error_mark_node
)
6690 if (DECL_CONTEXT (decl
) == std_node
6691 && init_list_identifier
== DECL_NAME (TYPE_NAME (type
))
6692 && !CLASSTYPE_TEMPLATE_INFO (type
))
6694 error ("declaration of %<std::initializer_list%> does not match "
6695 "%<#include <initializer_list>%>, isn't a template");
6696 return error_mark_node
;
6701 set_identifier_type_value_with_scope (name
, tdef
, b
);
6703 TYPE_CONTEXT (type
) = DECL_CONTEXT (decl
);
6705 /* If this is a local class, keep track of it. We need this
6706 information for name-mangling, and so that it is possible to
6707 find all function definitions in a translation unit in a
6708 convenient way. (It's otherwise tricky to find a member
6709 function definition it's only pointed to from within a local
6711 if (TYPE_FUNCTION_SCOPE_P (type
))
6713 if (processing_template_decl
)
6715 /* Push a DECL_EXPR so we call pushtag at the right time in
6716 template instantiation rather than in some nested context. */
6717 add_decl_expr (decl
);
6719 /* Lambdas use LAMBDA_EXPR_DISCRIMINATOR instead. */
6720 else if (!LAMBDA_TYPE_P (type
))
6721 vec_safe_push (local_classes
, type
);
6725 if (b
->kind
== sk_class
6726 && !COMPLETE_TYPE_P (current_class_type
))
6728 maybe_add_class_template_decl_list (current_class_type
,
6729 type
, /*friend_p=*/0);
6731 if (CLASSTYPE_NESTED_UTDS (current_class_type
) == NULL
)
6732 CLASSTYPE_NESTED_UTDS (current_class_type
)
6733 = binding_table_new (SCOPE_DEFAULT_HT_SIZE
);
6735 binding_table_insert
6736 (CLASSTYPE_NESTED_UTDS (current_class_type
), name
, type
);
6739 decl
= TYPE_NAME (type
);
6740 gcc_assert (TREE_CODE (decl
) == TYPE_DECL
);
6742 /* Set type visibility now if this is a forward declaration. */
6743 TREE_PUBLIC (decl
) = 1;
6744 determine_visibility (decl
);
6749 /* Wrapper for do_pushtag. */
6752 pushtag (tree name
, tree type
, tag_scope scope
)
6755 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
6756 ret
= do_pushtag (name
, type
, scope
);
6757 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
6762 /* Subroutines for reverting temporarily to top-level for instantiation
6763 of templates and such. We actually need to clear out the class- and
6764 local-value slots of all identifiers, so that only the global values
6765 are at all visible. Simply setting current_binding_level to the global
6766 scope isn't enough, because more binding levels may be pushed. */
6767 struct saved_scope
*scope_chain
;
6769 /* Return true if ID has not already been marked. */
6772 store_binding_p (tree id
)
6774 if (!id
|| !IDENTIFIER_BINDING (id
))
6777 if (IDENTIFIER_MARKED (id
))
6783 /* Add an appropriate binding to *OLD_BINDINGS which needs to already
6784 have enough space reserved. */
6787 store_binding (tree id
, vec
<cxx_saved_binding
, va_gc
> **old_bindings
)
6789 cxx_saved_binding saved
;
6791 gcc_checking_assert (store_binding_p (id
));
6793 IDENTIFIER_MARKED (id
) = 1;
6795 saved
.identifier
= id
;
6796 saved
.binding
= IDENTIFIER_BINDING (id
);
6797 saved
.real_type_value
= REAL_IDENTIFIER_TYPE_VALUE (id
);
6798 (*old_bindings
)->quick_push (saved
);
6799 IDENTIFIER_BINDING (id
) = NULL
;
6803 store_bindings (tree names
, vec
<cxx_saved_binding
, va_gc
> **old_bindings
)
6805 static vec
<tree
> bindings_need_stored
;
6809 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
6810 for (t
= names
; t
; t
= TREE_CHAIN (t
))
6812 if (TREE_CODE (t
) == TREE_LIST
)
6813 id
= TREE_PURPOSE (t
);
6817 if (store_binding_p (id
))
6818 bindings_need_stored
.safe_push (id
);
6820 if (!bindings_need_stored
.is_empty ())
6822 vec_safe_reserve_exact (*old_bindings
, bindings_need_stored
.length ());
6823 for (i
= 0; bindings_need_stored
.iterate (i
, &id
); ++i
)
6825 /* We can apparently have duplicates in NAMES. */
6826 if (store_binding_p (id
))
6827 store_binding (id
, old_bindings
);
6829 bindings_need_stored
.truncate (0);
6831 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
6834 /* Like store_bindings, but NAMES is a vector of cp_class_binding
6835 objects, rather than a TREE_LIST. */
6838 store_class_bindings (vec
<cp_class_binding
, va_gc
> *names
,
6839 vec
<cxx_saved_binding
, va_gc
> **old_bindings
)
6841 static vec
<tree
> bindings_need_stored
;
6843 cp_class_binding
*cb
;
6845 for (i
= 0; vec_safe_iterate (names
, i
, &cb
); ++i
)
6846 if (store_binding_p (cb
->identifier
))
6847 bindings_need_stored
.safe_push (cb
->identifier
);
6848 if (!bindings_need_stored
.is_empty ())
6851 vec_safe_reserve_exact (*old_bindings
, bindings_need_stored
.length ());
6852 for (i
= 0; bindings_need_stored
.iterate (i
, &id
); ++i
)
6853 store_binding (id
, old_bindings
);
6854 bindings_need_stored
.truncate (0);
6858 /* A chain of saved_scope structures awaiting reuse. */
6860 static GTY((deletable
)) struct saved_scope
*free_saved_scope
;
6863 do_push_to_top_level (void)
6865 struct saved_scope
*s
;
6866 cp_binding_level
*b
;
6867 cxx_saved_binding
*sb
;
6871 /* Reuse or create a new structure for this saved scope. */
6872 if (free_saved_scope
!= NULL
)
6874 s
= free_saved_scope
;
6875 free_saved_scope
= s
->prev
;
6877 vec
<cxx_saved_binding
, va_gc
> *old_bindings
= s
->old_bindings
;
6878 memset (s
, 0, sizeof (*s
));
6879 /* Also reuse the structure's old_bindings vector. */
6880 vec_safe_truncate (old_bindings
, 0);
6881 s
->old_bindings
= old_bindings
;
6884 s
= ggc_cleared_alloc
<saved_scope
> ();
6886 b
= scope_chain
? current_binding_level
: 0;
6888 /* If we're in the middle of some function, save our state. */
6892 push_function_context ();
6897 if (scope_chain
&& previous_class_level
)
6898 store_class_bindings (previous_class_level
->class_shadowed
,
6901 /* Have to include the global scope, because class-scope decls
6902 aren't listed anywhere useful. */
6903 for (; b
; b
= b
->level_chain
)
6907 /* Template IDs are inserted into the global level. If they were
6908 inserted into namespace level, finish_file wouldn't find them
6909 when doing pending instantiations. Therefore, don't stop at
6910 namespace level, but continue until :: . */
6911 if (global_scope_p (b
))
6914 store_bindings (b
->names
, &s
->old_bindings
);
6915 /* We also need to check class_shadowed to save class-level type
6916 bindings, since pushclass doesn't fill in b->names. */
6917 if (b
->kind
== sk_class
)
6918 store_class_bindings (b
->class_shadowed
, &s
->old_bindings
);
6920 /* Unwind type-value slots back to top level. */
6921 for (t
= b
->type_shadowed
; t
; t
= TREE_CHAIN (t
))
6922 SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (t
), TREE_VALUE (t
));
6925 FOR_EACH_VEC_SAFE_ELT (s
->old_bindings
, i
, sb
)
6926 IDENTIFIER_MARKED (sb
->identifier
) = 0;
6928 s
->prev
= scope_chain
;
6930 s
->need_pop_function_context
= need_pop
;
6931 s
->function_decl
= current_function_decl
;
6932 s
->unevaluated_operand
= cp_unevaluated_operand
;
6933 s
->inhibit_evaluation_warnings
= c_inhibit_evaluation_warnings
;
6934 s
->x_stmt_tree
.stmts_are_full_exprs_p
= true;
6937 current_function_decl
= NULL_TREE
;
6938 vec_alloc (current_lang_base
, 10);
6939 current_lang_name
= lang_name_cplusplus
;
6940 current_namespace
= global_namespace
;
6941 push_class_stack ();
6942 cp_unevaluated_operand
= 0;
6943 c_inhibit_evaluation_warnings
= 0;
6947 do_pop_from_top_level (void)
6949 struct saved_scope
*s
= scope_chain
;
6950 cxx_saved_binding
*saved
;
6953 /* Clear out class-level bindings cache. */
6954 if (previous_class_level
)
6955 invalidate_class_lookup_cache ();
6958 current_lang_base
= 0;
6960 scope_chain
= s
->prev
;
6961 FOR_EACH_VEC_SAFE_ELT (s
->old_bindings
, i
, saved
)
6963 tree id
= saved
->identifier
;
6965 IDENTIFIER_BINDING (id
) = saved
->binding
;
6966 SET_IDENTIFIER_TYPE_VALUE (id
, saved
->real_type_value
);
6969 /* If we were in the middle of compiling a function, restore our
6971 if (s
->need_pop_function_context
)
6972 pop_function_context ();
6973 current_function_decl
= s
->function_decl
;
6974 cp_unevaluated_operand
= s
->unevaluated_operand
;
6975 c_inhibit_evaluation_warnings
= s
->inhibit_evaluation_warnings
;
6977 /* Make this saved_scope structure available for reuse by
6978 push_to_top_level. */
6979 s
->prev
= free_saved_scope
;
6980 free_saved_scope
= s
;
6983 /* Push into the scope of the namespace NS, even if it is deeply
6984 nested within another namespace. */
6987 do_push_nested_namespace (tree ns
)
6989 if (ns
== global_namespace
)
6990 do_push_to_top_level ();
6993 do_push_nested_namespace (CP_DECL_CONTEXT (ns
));
6995 (find_namespace_value (current_namespace
, DECL_NAME (ns
)) == ns
);
6996 resume_scope (NAMESPACE_LEVEL (ns
));
6997 current_namespace
= ns
;
7001 /* Pop back from the scope of the namespace NS, which was previously
7002 entered with push_nested_namespace. */
7005 do_pop_nested_namespace (tree ns
)
7007 while (ns
!= global_namespace
)
7009 ns
= CP_DECL_CONTEXT (ns
);
7010 current_namespace
= ns
;
7014 do_pop_from_top_level ();
7017 /* Add TARGET to USINGS, if it does not already exist there.
7018 We used to build the complete graph of usings at this point, from
7019 the POV of the source namespaces. Now we build that as we perform
7020 the unqualified search. */
7023 add_using_namespace (vec
<tree
, va_gc
> *&usings
, tree target
)
7026 for (unsigned ix
= usings
->length (); ix
--;)
7027 if ((*usings
)[ix
] == target
)
7030 vec_safe_push (usings
, target
);
7033 /* Tell the debug system of a using directive. */
7036 emit_debug_info_using_namespace (tree from
, tree target
, bool implicit
)
7038 /* Emit debugging info. */
7039 tree context
= from
!= global_namespace
? from
: NULL_TREE
;
7040 debug_hooks
->imported_module_or_decl (target
, NULL_TREE
, context
, false,
7044 /* Process a namespace-scope using directive. */
7047 finish_namespace_using_directive (tree target
, tree attribs
)
7049 gcc_checking_assert (namespace_bindings_p ());
7050 if (target
== error_mark_node
)
7053 add_using_namespace (DECL_NAMESPACE_USING (current_namespace
),
7054 ORIGINAL_NAMESPACE (target
));
7055 emit_debug_info_using_namespace (current_namespace
,
7056 ORIGINAL_NAMESPACE (target
), false);
7058 if (attribs
== error_mark_node
)
7061 for (tree a
= attribs
; a
; a
= TREE_CHAIN (a
))
7063 tree name
= get_attribute_name (a
);
7064 if (is_attribute_p ("strong", name
))
7066 warning (0, "strong using directive no longer supported");
7067 if (CP_DECL_CONTEXT (target
) == current_namespace
)
7068 inform (DECL_SOURCE_LOCATION (target
),
7069 "you may use an inline namespace instead");
7072 warning (OPT_Wattributes
, "%qD attribute directive ignored", name
);
7076 /* Process a function-scope using-directive. */
7079 finish_local_using_directive (tree target
, tree attribs
)
7081 gcc_checking_assert (local_bindings_p ());
7082 if (target
== error_mark_node
)
7086 warning (OPT_Wattributes
, "attributes ignored on local using directive");
7088 add_stmt (build_stmt (input_location
, USING_STMT
, target
));
7090 add_using_namespace (current_binding_level
->using_directives
,
7091 ORIGINAL_NAMESPACE (target
));
7094 /* Pushes X into the global namespace. */
7097 pushdecl_top_level (tree x
, bool is_friend
)
7099 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
7100 do_push_to_top_level ();
7101 x
= pushdecl_namespace_level (x
, is_friend
);
7102 do_pop_from_top_level ();
7103 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
7107 /* Pushes X into the global namespace and calls cp_finish_decl to
7108 register the variable, initializing it with INIT. */
7111 pushdecl_top_level_and_finish (tree x
, tree init
)
7113 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
7114 do_push_to_top_level ();
7115 x
= pushdecl_namespace_level (x
, false);
7116 cp_finish_decl (x
, init
, false, NULL_TREE
, 0);
7117 do_pop_from_top_level ();
7118 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
7122 /* Enter the namespaces from current_namerspace to NS. */
7125 push_inline_namespaces (tree ns
)
7128 if (ns
!= current_namespace
)
7130 gcc_assert (ns
!= global_namespace
);
7131 count
+= push_inline_namespaces (CP_DECL_CONTEXT (ns
));
7132 resume_scope (NAMESPACE_LEVEL (ns
));
7133 current_namespace
= ns
;
7139 /* Push into the scope of the NAME namespace. If NAME is NULL_TREE,
7140 then we enter an anonymous namespace. If MAKE_INLINE is true, then
7141 we create an inline namespace (it is up to the caller to check upon
7142 redefinition). Return the number of namespaces entered. */
7145 push_namespace (tree name
, bool make_inline
)
7147 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
7150 /* We should not get here if the global_namespace is not yet constructed
7151 nor if NAME designates the global namespace: The global scope is
7152 constructed elsewhere. */
7153 gcc_checking_assert (global_namespace
!= NULL
&& name
!= global_identifier
);
7155 tree ns
= NULL_TREE
;
7157 name_lookup
lookup (name
, 0);
7158 if (!lookup
.search_qualified (current_namespace
, /*usings=*/false))
7160 else if (TREE_CODE (lookup
.value
) != NAMESPACE_DECL
)
7162 else if (tree dna
= DECL_NAMESPACE_ALIAS (lookup
.value
))
7164 /* A namespace alias is not allowed here, but if the alias
7165 is for a namespace also inside the current scope,
7166 accept it with a diagnostic. That's better than dying
7168 if (is_nested_namespace (current_namespace
, CP_DECL_CONTEXT (dna
)))
7170 error ("namespace alias %qD not allowed here, "
7171 "assuming %qD", lookup
.value
, dna
);
7179 bool new_ns
= false;
7181 /* DR2061. NS might be a member of an inline namespace. We
7182 need to push into those namespaces. */
7183 count
+= push_inline_namespaces (CP_DECL_CONTEXT (ns
));
7186 ns
= build_lang_decl (NAMESPACE_DECL
, name
, void_type_node
);
7187 SCOPE_DEPTH (ns
) = SCOPE_DEPTH (current_namespace
) + 1;
7188 if (!SCOPE_DEPTH (ns
))
7189 /* We only allow depth 255. */
7190 sorry ("cannot nest more than %d namespaces",
7191 SCOPE_DEPTH (current_namespace
));
7192 DECL_CONTEXT (ns
) = FROB_CONTEXT (current_namespace
);
7195 if (pushdecl (ns
) == error_mark_node
)
7201 SET_DECL_ASSEMBLER_NAME (ns
, anon_identifier
);
7204 add_using_namespace (DECL_NAMESPACE_USING (current_namespace
),
7207 else if (TREE_PUBLIC (current_namespace
))
7208 TREE_PUBLIC (ns
) = 1;
7212 DECL_NAMESPACE_INLINE_P (ns
) = true;
7213 vec_safe_push (DECL_NAMESPACE_INLINEES (current_namespace
), ns
);
7216 if (!name
|| make_inline
)
7217 emit_debug_info_using_namespace (current_namespace
, ns
, true);
7223 if (make_inline
&& !DECL_NAMESPACE_INLINE_P (ns
))
7225 error ("inline namespace must be specified at initial definition");
7226 inform (DECL_SOURCE_LOCATION (ns
), "%qD defined here", ns
);
7229 begin_scope (sk_namespace
, ns
);
7231 resume_scope (NAMESPACE_LEVEL (ns
));
7232 current_namespace
= ns
;
7236 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
7240 /* Pop from the scope of the current namespace. */
7243 pop_namespace (void)
7245 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
7247 gcc_assert (current_namespace
!= global_namespace
);
7248 current_namespace
= CP_DECL_CONTEXT (current_namespace
);
7249 /* The binding level is not popped, as it might be re-opened later. */
7252 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
7255 /* External entry points for do_{push_to/pop_from}_top_level. */
7258 push_to_top_level (void)
7260 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
7261 do_push_to_top_level ();
7262 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
7266 pop_from_top_level (void)
7268 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
7269 do_pop_from_top_level ();
7270 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
7273 /* External entry points for do_{push,pop}_nested_namespace. */
7276 push_nested_namespace (tree ns
)
7278 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
7279 do_push_nested_namespace (ns
);
7280 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
7284 pop_nested_namespace (tree ns
)
7286 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
7287 gcc_assert (current_namespace
== ns
);
7288 do_pop_nested_namespace (ns
);
7289 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
7292 /* Pop off extraneous binding levels left over due to syntax errors.
7293 We don't pop past namespaces, as they might be valid. */
7296 pop_everything (void)
7298 if (ENABLE_SCOPE_CHECKING
)
7299 verbatim ("XXX entering pop_everything ()\n");
7300 while (!namespace_bindings_p ())
7302 if (current_binding_level
->kind
== sk_class
)
7303 pop_nested_class ();
7307 if (ENABLE_SCOPE_CHECKING
)
7308 verbatim ("XXX leaving pop_everything ()\n");
7311 /* Emit debugging information for using declarations and directives.
7312 If input tree is overloaded fn then emit debug info for all
7316 cp_emit_debug_info_for_using (tree t
, tree context
)
7318 /* Don't try to emit any debug information if we have errors. */
7322 /* Ignore this FUNCTION_DECL if it refers to a builtin declaration
7323 of a builtin function. */
7324 if (TREE_CODE (t
) == FUNCTION_DECL
7325 && DECL_EXTERNAL (t
)
7326 && DECL_BUILT_IN (t
))
7329 /* Do not supply context to imported_module_or_decl, if
7330 it is a global namespace. */
7331 if (context
== global_namespace
)
7332 context
= NULL_TREE
;
7334 t
= MAYBE_BASELINK_FUNCTIONS (t
);
7336 /* FIXME: Handle TEMPLATE_DECLs. */
7337 for (lkp_iterator
iter (t
); iter
; ++iter
)
7340 if (TREE_CODE (fn
) != TEMPLATE_DECL
)
7342 if (building_stmt_list_p ())
7343 add_stmt (build_stmt (input_location
, USING_STMT
, fn
));
7345 debug_hooks
->imported_module_or_decl (fn
, NULL_TREE
, context
,
7351 #include "gt-cp-name-lookup.h"