1	/* Definitions for C++ name lookup routines.
2	Copyright (C) 2003-2024 Free Software Foundation, Inc.
3	Contributed by Gabriel Dos Reis <gdr@integrable-solutions.net>
4
5	This file is part of GCC.
6
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)
10	any later version.
11
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.
16
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/>. */
20
21	#include "config.h"
22	#define INCLUDE_MEMORY
23	#include "system.h"
24	#include "coretypes.h"
25	#include "cp-tree.h"
26	#include "timevar.h"
27	#include "stringpool.h"
28	#include "print-tree.h"
29	#include "attribs.h"
30	#include "debug.h"
31	#include "c-family/c-pragma.h"
32	#include "gcc-rich-location.h"
33	#include "spellcheck-tree.h"
34	#include "parser.h"
35	#include "c-family/name-hint.h"
36	#include "c-family/known-headers.h"
37	#include "c-family/c-spellcheck.h"
38	#include "bitmap.h"
39
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,
43	cp_binding_level *b);
44	static name_hint maybe_suggest_missing_std_header (location_t location,
45	tree name);
46	static name_hint suggest_alternatives_for_1 (location_t location, tree name,
47	bool suggest_misspellings);
48
49	/* Slots in BINDING_VECTOR. */
50	enum binding_slots
51	{
52	BINDING_SLOT_CURRENT, /* Slot for current TU. */
53	BINDING_SLOT_GLOBAL, /* Slot for merged global module. */
54	BINDING_SLOT_PARTITION, /* Slot for merged partition entities
55	(optional). */
56
57	/* Number of always-allocated slots. */
58	BINDING_SLOTS_FIXED = BINDING_SLOT_GLOBAL + 1
59	};
60
61	/* Create an overload suitable for recording an artificial TYPE_DECL
62	and another decl. We use this machanism to implement the struct
63	stat hack. */
64
65	#define STAT_HACK_P(N) ((N) && TREE_CODE (N) == OVERLOAD && OVL_LOOKUP_P (N))
66	#define STAT_TYPE_VISIBLE_P(N) TREE_USED (OVERLOAD_CHECK (N))
67	#define STAT_TYPE(N) TREE_TYPE (N)
68	#define STAT_DECL(N) OVL_FUNCTION (N)
69	#define STAT_VISIBLE(N) OVL_CHAIN (N)
70	#define MAYBE_STAT_DECL(N) (STAT_HACK_P (N) ? STAT_DECL (N) : N)
71	#define MAYBE_STAT_TYPE(N) (STAT_HACK_P (N) ? STAT_TYPE (N) : NULL_TREE)
72
73	/* When a STAT_HACK_P is true, OVL_USING_P and OVL_EXPORT_P are valid
74	and apply to the hacked type. */
75
76	/* For regular (maybe) overloaded functions, we have OVL_HIDDEN_P.
77	But we also need to indicate hiddenness on implicit type decls
78	(injected friend classes), and (coming soon) decls injected from
79	block-scope externs. It is too awkward to press the existing
80	overload marking for that. If we have a hidden non-function, we
81	always create a STAT_HACK, and use these two markers as needed. */
82	#define STAT_TYPE_HIDDEN_P(N) OVL_HIDDEN_P (N)
83	#define STAT_DECL_HIDDEN_P(N) OVL_DEDUP_P (N)
84
85	/* Create a STAT_HACK node with DECL as the value binding and TYPE as
86	the type binding. */
87
88	static tree
89	stat_hack (tree decl = NULL_TREE, tree type = NULL_TREE)
90	{
91	tree result = make_node (OVERLOAD);
92
93	/* Mark this as a lookup, so we can tell this is a stat hack. */
94	OVL_LOOKUP_P (result) = true;
95	STAT_DECL (result) = decl;
96	STAT_TYPE (result) = type;
97	return result;
98	}
99
100	/* Create a local binding level for NAME. */
101
102	static cxx_binding *
103	create_local_binding (cp_binding_level *level, tree name)
104	{
105	cxx_binding *binding = cxx_binding_make (NULL, NULL);
106
107	LOCAL_BINDING_P (binding) = true;
108	binding->scope = level;
109	binding->previous = IDENTIFIER_BINDING (name);
110
111	IDENTIFIER_BINDING (name) = binding;
112
113	return binding;
114	}
115
116	/* Find the binding for NAME in namespace NS. If CREATE_P is true,
117	make an empty binding if there wasn't one. */
118
119	static tree *
120	find_namespace_slot (tree ns, tree name, bool create_p = false)
121	{
122	tree *slot = DECL_NAMESPACE_BINDINGS (ns)
123	->find_slot_with_hash (comparable: name, hash: name ? IDENTIFIER_HASH_VALUE (name) : 0,
124	insert: create_p ? INSERT : NO_INSERT);
125	return slot;
126	}
127
128	static tree
129	find_namespace_value (tree ns, tree name)
130	{
131	tree *b = find_namespace_slot (ns, name);
132
133	return b ? MAYBE_STAT_DECL (*b) : NULL_TREE;
134	}
135
136	/* Look in *SLOT for a the binding of NAME in imported module IX.
137	Returns pointer to binding's slot, or NULL if not found. Does a
138	binary search, as this is mainly used for random access during
139	importing. Do not use for the fixed slots. */
140
141	static binding_slot *
142	search_imported_binding_slot (tree *slot, unsigned ix)
143	{
144	gcc_assert (ix);
145
146	if (!*slot)
147	return NULL;
148
149	if (TREE_CODE (*slot) != BINDING_VECTOR)
150	return NULL;
151
152	unsigned clusters = BINDING_VECTOR_NUM_CLUSTERS (*slot);
153	binding_cluster *cluster = BINDING_VECTOR_CLUSTER_BASE (*slot);
154
155	if (BINDING_VECTOR_SLOTS_PER_CLUSTER == BINDING_SLOTS_FIXED)
156	{
157	clusters--;
158	cluster++;
159	}
160
161	while (clusters > 1)
162	{
163	unsigned half = clusters / 2;
164	gcc_checking_assert (cluster[half].indices[0].span);
165	if (cluster[half].indices[0].base > ix)
166	clusters = half;
167	else
168	{
169	clusters -= half;
170	cluster += half;
171	}
172	}
173
174	if (clusters)
175	/* Is it in this cluster? */
176	for (unsigned off = 0; off != BINDING_VECTOR_SLOTS_PER_CLUSTER; off++)
177	{
178	if (!cluster->indices[off].span)
179	break;
180	if (cluster->indices[off].base > ix)
181	break;
182
183	if (cluster->indices[off].base + cluster->indices[off].span > ix)
184	return &cluster->slots[off];
185	}
186
187	return NULL;
188	}
189
190	static void
191	init_global_partition (binding_cluster *cluster, tree decl)
192	{
193	bool named = true;
194
195	if (header_module_p ())
196	named = false;
197	else if (TREE_PUBLIC (decl)
198	&& TREE_CODE (decl) == NAMESPACE_DECL
199	&& !DECL_NAMESPACE_ALIAS (decl))
200	named = false;
201	else if (!get_originating_module (decl))
202	named = false;
203
204	binding_slot *mslot;
205	if (named)
206	mslot = &cluster[BINDING_SLOT_PARTITION
207	/ BINDING_VECTOR_SLOTS_PER_CLUSTER]
208	.slots[BINDING_SLOT_PARTITION
209	% BINDING_VECTOR_SLOTS_PER_CLUSTER];
210	else
211	mslot = &cluster[0].slots[BINDING_SLOT_GLOBAL];
212
213	if (*mslot)
214	decl = ovl_make (fn: decl, next: *mslot);
215	*mslot = decl;
216
217	if (TREE_CODE (decl) == CONST_DECL)
218	{
219	tree type = TREE_TYPE (decl);
220	if (TREE_CODE (type) == ENUMERAL_TYPE
221	&& IDENTIFIER_ANON_P (DECL_NAME (TYPE_NAME (type)))
222	&& decl == TREE_VALUE (TYPE_VALUES (type)))
223	/* Anonymous enums are keyed by their first enumerator, put
224	the TYPE_DECL here too. */
225	*mslot = ovl_make (TYPE_NAME (type), next: *mslot);
226	}
227	}
228
229	/* Get the fixed binding slot IX. Creating the vector if CREATE is
230	non-zero. If CREATE is < 0, make sure there is at least 1 spare
231	slot for an import. (It is an error for CREATE < 0 and the slot to
232	already exist.) */
233
234	static tree *
235	get_fixed_binding_slot (tree *slot, tree name, unsigned ix, int create)
236	{
237	gcc_checking_assert (ix <= BINDING_SLOT_PARTITION);
238
239	/* An assumption is that the fixed slots all reside in one cluster. */
240	gcc_checking_assert (BINDING_VECTOR_SLOTS_PER_CLUSTER >= BINDING_SLOTS_FIXED);
241
242	if (!*slot || TREE_CODE (*slot) != BINDING_VECTOR)
243	{
244	if (ix == BINDING_SLOT_CURRENT)
245	/* The current TU can just use slot directly. */
246	return slot;
247
248	if (!create)
249	return NULL;
250
251	/* The partition slot is only needed when we're a named
252	module. */
253	bool partition_slot = named_module_p ();
254	unsigned want = ((BINDING_SLOTS_FIXED + partition_slot + (create < 0)
255	+ BINDING_VECTOR_SLOTS_PER_CLUSTER - 1)
256	/ BINDING_VECTOR_SLOTS_PER_CLUSTER);
257	tree new_vec = make_binding_vec (name, clusters: want);
258	BINDING_VECTOR_NUM_CLUSTERS (new_vec) = want;
259	binding_cluster *cluster = BINDING_VECTOR_CLUSTER_BASE (new_vec);
260
261	/* Initialize the fixed slots. */
262	for (unsigned jx = BINDING_SLOTS_FIXED; jx--;)
263	{
264	cluster[0].indices[jx].base = 0;
265	cluster[0].indices[jx].span = 1;
266	cluster[0].slots[jx] = NULL_TREE;
267	}
268
269	if (partition_slot)
270	{
271	unsigned off = BINDING_SLOT_PARTITION % BINDING_VECTOR_SLOTS_PER_CLUSTER;
272	unsigned ind = BINDING_SLOT_PARTITION / BINDING_VECTOR_SLOTS_PER_CLUSTER;
273	cluster[ind].indices[off].base = 0;
274	cluster[ind].indices[off].span = 1;
275	cluster[ind].slots[off] = NULL_TREE;
276	}
277
278	if (tree orig = *slot)
279	{
280	/* Propagate existing value to current slot. */
281
282	/* Propagate global & module entities to the global and
283	partition slots. */
284	if (tree type = MAYBE_STAT_TYPE (orig))
285	init_global_partition (cluster, decl: type);
286
287	for (ovl_iterator iter (MAYBE_STAT_DECL (orig)); iter; ++iter)
288	{
289	tree decl = *iter;
290
291	/* Internal linkage entities are in deduplicateable. */
292	init_global_partition (cluster, decl);
293	}
294
295	if (cluster[0].slots[BINDING_SLOT_GLOBAL]
296	&& !(TREE_CODE (orig) == NAMESPACE_DECL
297	&& !DECL_NAMESPACE_ALIAS (orig)))
298	{
299	/* Note that we had some GMF entries. */
300	if (!STAT_HACK_P (orig))
301	orig = stat_hack (decl: orig);
302
303	MODULE_BINDING_GLOBAL_P (orig) = true;
304	}
305
306	cluster[0].slots[BINDING_SLOT_CURRENT] = orig;
307	}
308
309	*slot = new_vec;
310	}
311	else
312	gcc_checking_assert (create >= 0);
313
314	unsigned off = ix % BINDING_VECTOR_SLOTS_PER_CLUSTER;
315	binding_cluster &cluster
316	= BINDING_VECTOR_CLUSTER (*slot, ix / BINDING_VECTOR_SLOTS_PER_CLUSTER);
317
318	/* There must always be slots for these indices */
319	gcc_checking_assert (cluster.indices[off].span == 1
320	&& !cluster.indices[off].base
321	&& !cluster.slots[off].is_lazy ());
322
323	return reinterpret_cast<tree *> (&cluster.slots[off]);
324	}
325
326	/* *SLOT is a namespace binding slot. Append a slot for imported
327	module IX. */
328
329	static binding_slot *
330	append_imported_binding_slot (tree *slot, tree name, unsigned ix)
331	{
332	gcc_checking_assert (ix);
333
334	if (!*slot || TREE_CODE (*slot) != BINDING_VECTOR)
335	/* Make an initial module vector. */
336	get_fixed_binding_slot (slot, name, ix: BINDING_SLOT_GLOBAL, create: -1);
337	else if (!BINDING_VECTOR_CLUSTER_LAST (*slot)
338	->indices[BINDING_VECTOR_SLOTS_PER_CLUSTER - 1].span)
339	/* There is space in the last cluster. */;
340	else if (BINDING_VECTOR_NUM_CLUSTERS (*slot)
341	!= BINDING_VECTOR_ALLOC_CLUSTERS (*slot))
342	/* There is space in the vector. */
343	BINDING_VECTOR_NUM_CLUSTERS (*slot)++;
344	else
345	{
346	/* Extend the vector. */
347	unsigned have = BINDING_VECTOR_NUM_CLUSTERS (*slot);
348	unsigned want = (have * 3 + 1) / 2;
349
350	if (want > (unsigned short)~0)
351	want = (unsigned short)~0;
352
353	tree new_vec = make_binding_vec (name, clusters: want);
354	BINDING_VECTOR_NUM_CLUSTERS (new_vec) = have + 1;
355	memcpy (BINDING_VECTOR_CLUSTER_BASE (new_vec),
356	BINDING_VECTOR_CLUSTER_BASE (*slot),
357	n: have * sizeof (binding_cluster));
358	*slot = new_vec;
359	}
360
361	binding_cluster *last = BINDING_VECTOR_CLUSTER_LAST (*slot);
362	for (unsigned off = 0; off != BINDING_VECTOR_SLOTS_PER_CLUSTER; off++)
363	if (!last->indices[off].span)
364	{
365	/* Fill the free slot of the cluster. */
366	last->indices[off].base = ix;
367	last->indices[off].span = 1;
368	last->slots[off] = NULL_TREE;
369	/* Check monotonicity. */
370	gcc_checking_assert (last[off ? 0 : -1]
371	.indices[off ? off - 1
372	: BINDING_VECTOR_SLOTS_PER_CLUSTER - 1]
373	.base < ix);
374	return &last->slots[off];
375	}
376
377	gcc_unreachable ();
378	}
379
380	/* Add DECL to the list of things declared in binding level B. */
381
382	static void
383	add_decl_to_level (cp_binding_level *b, tree decl)
384	{
385	gcc_assert (b->kind != sk_class);
386
387	/* Make sure we don't create a circular list. xref_tag can end
388	up pushing the same artificial decl more than once. We
389	should have already detected that in update_binding. (This isn't a
390	complete verification of non-circularity.) */
391	gcc_assert (b->names != decl);
392
393	/* We build up the list in reverse order, and reverse it later if
394	necessary. */
395	TREE_CHAIN (decl) = b->names;
396	b->names = decl;
397
398	/* If appropriate, add decl to separate list of statics. We include
399	extern variables because they might turn out to be static later.
400	It's OK for this list to contain a few false positives. */
401	if (b->kind == sk_namespace
402	&& ((VAR_P (decl) && (TREE_STATIC (decl) || DECL_EXTERNAL (decl)))
403	|| (TREE_CODE (decl) == FUNCTION_DECL
404	&& (!TREE_PUBLIC (decl)
405	|| decl_internal_context_p (decl)
406	|| DECL_DECLARED_INLINE_P (decl)))))
407	vec_safe_push (v&: static_decls, obj: decl);
408	}
409
410	/* Find the binding for NAME in the local binding level B. */
411
412	static cxx_binding *
413	find_local_binding (cp_binding_level *b, tree name)
414	{
415	if (cxx_binding *binding = IDENTIFIER_BINDING (name))
416	for (;; b = b->level_chain)
417	{
418	if (binding->scope == b)
419	return binding;
420
421	/* Cleanup contours are transparent to the language. */
422	if (b->kind != sk_cleanup)
423	break;
424	}
425	return NULL;
426	}
427
428	class name_lookup
429	{
430	public:
431	typedef std::pair<tree, tree> using_pair;
432	typedef auto_vec<using_pair, 16> using_queue;
433
434	public:
435	tree name; /* The identifier being looked for. */
436
437	/* Usually we just add things to the VALUE binding, but we record
438	(hidden) IMPLICIT_TYPEDEFs on the type binding, which is used for
439	using-decl resolution. */
440	tree value; /* A (possibly ambiguous) set of things found. */
441	tree type; /* A type that has been found. */
442
443	LOOK_want want; /* What kind of entity we want. */
444
445	bool deduping; /* Full deduping is needed because using declarations
446	are in play. */
447	vec<tree, va_heap, vl_embed> *scopes;
448	name_lookup *previous; /* Previously active lookup. */
449
450	protected:
451	/* Marked scope stack for outermost name lookup. */
452	static vec<tree, va_heap, vl_embed> *shared_scopes;
453	/* Currently active lookup. */
454	static name_lookup *active;
455
456	public:
457	name_lookup (tree n, LOOK_want w = LOOK_want::NORMAL)
458	: name (n), value (NULL_TREE), type (NULL_TREE),
459	want (w),
460	deduping (false), scopes (NULL), previous (NULL)
461	{
462	preserve_state ();
463	}
464	~name_lookup ()
465	{
466	gcc_checking_assert (!deduping);
467	restore_state ();
468	}
469
470	private: /* Uncopyable, unmovable, unassignable. I am a rock. */
471	name_lookup (const name_lookup &);
472	name_lookup &operator= (const name_lookup &);
473
474	public:
475	/* Turn on or off deduping mode. */
476	void dedup (bool state)
477	{
478	if (deduping != state)
479	{
480	deduping = state;
481	lookup_mark (lookup: value, val: state);
482	}
483	}
484
485	protected:
486	static bool seen_p (tree scope)
487	{
488	return LOOKUP_SEEN_P (scope);
489	}
490	static bool found_p (tree scope)
491	{
492	return LOOKUP_FOUND_P (scope);
493	}
494
495	void mark_seen (tree scope); /* Mark and add to scope vector. */
496	static void mark_found (tree scope)
497	{
498	gcc_checking_assert (seen_p (scope));
499	LOOKUP_FOUND_P (scope) = true;
500	}
501	bool see_and_mark (tree scope)
502	{
503	bool ret = seen_p (scope);
504	if (!ret)
505	mark_seen (scope);
506	return ret;
507	}
508	bool find_and_mark (tree scope);
509
510	private:
511	void preserve_state ();
512	void restore_state ();
513
514	public:
515	static tree ambiguous (tree thing, tree current);
516	void add_value (tree new_val);
517	private:
518	void add_overload (tree fns);
519	void add_type (tree new_type);
520	bool process_binding (tree val_bind, tree type_bind);
521	unsigned process_module_binding (tree val_bind, tree type_bind, unsigned);
522	/* Look in only namespace. */
523	bool search_namespace_only (tree scope);
524	/* Look in namespace and its (recursive) inlines. Ignore using
525	directives. Return true if something found (inc dups). */
526	bool search_namespace (tree scope);
527	/* Look in the using directives of namespace + inlines using
528	qualified lookup rules. */
529	bool search_usings (tree scope);
530
531	private:
532	void queue_namespace (using_queue& queue, int depth, tree scope);
533	void queue_usings (using_queue& queue, int depth, vec<tree, va_gc> *usings);
534
535	private:
536	void add_fns (tree);
537
538	private:
539	void adl_expr (tree);
540	void adl_type (tree);
541	void adl_template_arg (tree);
542	void adl_class (tree);
543	void adl_enum (tree);
544	void adl_bases (tree);
545	void adl_class_only (tree);
546	void adl_namespace (tree);
547	void adl_class_fns (tree);
548	void adl_namespace_fns (tree, bitmap);
549
550	public:
551	/* Search namespace + inlines + maybe usings as qualified lookup. */
552	bool search_qualified (tree scope, bool usings = true);
553
554	/* Search namespace + inlines + usings as unqualified lookup. */
555	bool search_unqualified (tree scope, cp_binding_level *);
556
557	/* ADL lookup of ARGS. */
558	tree search_adl (tree fns, vec<tree, va_gc> *args);
559	};
560
561	/* Scope stack shared by all outermost lookups. This avoids us
562	allocating and freeing on every single lookup. */
563	vec<tree, va_heap, vl_embed> *name_lookup::shared_scopes;
564
565	/* Currently active lookup. */
566	name_lookup *name_lookup::active;
567
568	/* Name lookup is recursive, becase ADL can cause template
569	instatiation. This is of course a rare event, so we optimize for
570	it not happening. When we discover an active name-lookup, which
571	must be an ADL lookup, we need to unmark the marked scopes and also
572	unmark the lookup we might have been accumulating. */
573
574	void
575	name_lookup::preserve_state ()
576	{
577	previous = active;
578	if (previous)
579	{
580	unsigned length = vec_safe_length (v: previous->scopes);
581	vec_safe_reserve (v&: previous->scopes, nelems: length * 2);
582	for (unsigned ix = length; ix--;)
583	{
584	tree decl = (*previous->scopes)[ix];
585
586	gcc_checking_assert (LOOKUP_SEEN_P (decl));
587	LOOKUP_SEEN_P (decl) = false;
588
589	/* Preserve the FOUND_P state on the interrupted lookup's
590	stack. */
591	if (LOOKUP_FOUND_P (decl))
592	{
593	LOOKUP_FOUND_P (decl) = false;
594	previous->scopes->quick_push (obj: decl);
595	}
596	}
597
598	/* Unmark the outer partial lookup. */
599	if (previous->deduping)
600	lookup_mark (lookup: previous->value, val: false);
601	}
602	else
603	scopes = shared_scopes;
604	active = this;
605	}
606
607	/* Restore the marking state of a lookup we interrupted. */
608
609	void
610	name_lookup::restore_state ()
611	{
612	gcc_checking_assert (!deduping);
613
614	/* Unmark and empty this lookup's scope stack. */
615	for (unsigned ix = vec_safe_length (v: scopes); ix--;)
616	{
617	tree decl = scopes->pop ();
618	gcc_checking_assert (LOOKUP_SEEN_P (decl));
619	LOOKUP_SEEN_P (decl) = false;
620	LOOKUP_FOUND_P (decl) = false;
621	}
622
623	active = previous;
624	if (previous)
625	{
626	free (ptr: scopes);
627
628	unsigned length = vec_safe_length (v: previous->scopes);
629	for (unsigned ix = 0; ix != length; ix++)
630	{
631	tree decl = (*previous->scopes)[ix];
632	if (LOOKUP_SEEN_P (decl))
633	{
634	/* The remainder of the scope stack must be recording
635	FOUND_P decls, which we want to pop off. */
636	do
637	{
638	tree decl = previous->scopes->pop ();
639	gcc_checking_assert (LOOKUP_SEEN_P (decl)
640	&& !LOOKUP_FOUND_P (decl));
641	LOOKUP_FOUND_P (decl) = true;
642	}
643	while (++ix != length);
644	break;
645	}
646
647	gcc_checking_assert (!LOOKUP_FOUND_P (decl));
648	LOOKUP_SEEN_P (decl) = true;
649	}
650
651	/* Remark the outer partial lookup. */
652	if (previous->deduping)
653	lookup_mark (lookup: previous->value, val: true);
654	}
655	else
656	shared_scopes = scopes;
657	}
658
659	void
660	name_lookup::mark_seen (tree scope)
661	{
662	gcc_checking_assert (!seen_p (scope));
663	LOOKUP_SEEN_P (scope) = true;
664	vec_safe_push (v&: scopes, obj: scope);
665	}
666
667	bool
668	name_lookup::find_and_mark (tree scope)
669	{
670	bool result = LOOKUP_FOUND_P (scope);
671	if (!result)
672	{
673	LOOKUP_FOUND_P (scope) = true;
674	if (!LOOKUP_SEEN_P (scope))
675	vec_safe_push (v&: scopes, obj: scope);
676	}
677
678	return result;
679	}
680
681	/* THING and CURRENT are ambiguous, concatenate them. */
682
683	tree
684	name_lookup::ambiguous (tree thing, tree current)
685	{
686	if (TREE_CODE (current) != TREE_LIST)
687	{
688	current = build_tree_list (NULL_TREE, current);
689	TREE_TYPE (current) = error_mark_node;
690	}
691	current = tree_cons (NULL_TREE, thing, current);
692	TREE_TYPE (current) = error_mark_node;
693
694	return current;
695	}
696
697	/* FNS is a new overload set to add to the exising set. */
698
699	void
700	name_lookup::add_overload (tree fns)
701	{
702	if (!deduping && TREE_CODE (fns) == OVERLOAD)
703	{
704	tree probe = fns;
705	if (!bool (want & LOOK_want::HIDDEN_FRIEND))
706	probe = ovl_skip_hidden (probe);
707	if (probe && TREE_CODE (probe) == OVERLOAD
708	&& OVL_DEDUP_P (probe))
709	/* We're about to add something found by multiple paths, so need to
710	engage deduping mode. */
711	dedup (state: true);
712	}
713
714	value = lookup_maybe_add (fns, lookup: value, deduping);
715	}
716
717	/* Add a NEW_VAL, a found value binding into the current value binding. */
718
719	void
720	name_lookup::add_value (tree new_val)
721	{
722	if (OVL_P (new_val) && (!value || OVL_P (value)))
723	add_overload (fns: new_val);
724	else if (!value)
725	value = new_val;
726	else if (value == new_val)
727	;
728	else if ((TREE_CODE (value) == TYPE_DECL
729	&& TREE_CODE (new_val) == TYPE_DECL
730	&& same_type_p (TREE_TYPE (value), TREE_TYPE (new_val))))
731	/* Typedefs to the same type. */;
732	else if (TREE_CODE (value) == NAMESPACE_DECL
733	&& TREE_CODE (new_val) == NAMESPACE_DECL
734	&& ORIGINAL_NAMESPACE (value) == ORIGINAL_NAMESPACE (new_val))
735	/* Namespace (possibly aliased) to the same namespace. Locate
736	the namespace*/
737	value = ORIGINAL_NAMESPACE (value);
738	else
739	{
740	/* Disengage deduping mode. */
741	dedup (state: false);
742	value = ambiguous (thing: new_val, current: value);
743	}
744	}
745
746	/* Add a NEW_TYPE, a found type binding into the current type binding. */
747
748	void
749	name_lookup::add_type (tree new_type)
750	{
751	if (!type)
752	type = new_type;
753	else if (TREE_CODE (type) == TREE_LIST
754	|| !same_type_p (TREE_TYPE (type), TREE_TYPE (new_type)))
755	type = ambiguous (thing: new_type, current: type);
756	}
757
758	/* Process a found binding containing NEW_VAL and NEW_TYPE. Returns
759	true if we actually found something noteworthy. Hiddenness has
760	already been handled in the caller. */
761
762	bool
763	name_lookup::process_binding (tree new_val, tree new_type)
764	{
765	/* Did we really see a type? */
766	if (new_type
767	&& (want & LOOK_want::TYPE_NAMESPACE) == LOOK_want::NAMESPACE)
768	new_type = NULL_TREE;
769
770	/* Do we really see a value? */
771	if (new_val)
772	switch (TREE_CODE (new_val))
773	{
774	case TEMPLATE_DECL:
775	/* If we expect types or namespaces, and not templates,
776	or this is not a template class. */
777	if (bool (want & LOOK_want::TYPE_NAMESPACE)
778	&& !DECL_TYPE_TEMPLATE_P (new_val))
779	new_val = NULL_TREE;
780	break;
781	case TYPE_DECL:
782	if ((want & LOOK_want::TYPE_NAMESPACE) == LOOK_want::NAMESPACE
783	|| (new_type && bool (want & LOOK_want::TYPE)))
784	new_val = NULL_TREE;
785	break;
786	case NAMESPACE_DECL:
787	if ((want & LOOK_want::TYPE_NAMESPACE) == LOOK_want::TYPE)
788	new_val = NULL_TREE;
789	break;
790	default:
791	if (bool (want & LOOK_want::TYPE_NAMESPACE))
792	new_val = NULL_TREE;
793	}
794
795	if (!new_val)
796	{
797	new_val = new_type;
798	new_type = NULL_TREE;
799	}
800
801	/* Merge into the lookup */
802	if (new_val)
803	add_value (new_val);
804	if (new_type)
805	add_type (new_type);
806
807	return new_val != NULL_TREE;
808	}
809
810	/* If we're importing a module containing this binding, add it to the
811	lookup set. The trickiness is with namespaces, we only want to
812	find it once. */
813
814	unsigned
815	name_lookup::process_module_binding (tree new_val, tree new_type,
816	unsigned marker)
817	{
818	/* Optimize for (re-)finding a public namespace. We only need to
819	look once. */
820	if (new_val && !new_type
821	&& TREE_CODE (new_val) == NAMESPACE_DECL
822	&& TREE_PUBLIC (new_val)
823	&& !DECL_NAMESPACE_ALIAS (new_val))
824	{
825	if (marker & 2)
826	return marker;
827	marker |= 2;
828	}
829
830	if (new_type || new_val)
831	marker |= process_binding (new_val, new_type);
832
833	return marker;
834	}
835
836	/* Look in exactly namespace SCOPE. */
837
838	bool
839	name_lookup::search_namespace_only (tree scope)
840	{
841	bool found = false;
842	if (tree *binding = find_namespace_slot (ns: scope, name))
843	{
844	tree val = *binding;
845	if (TREE_CODE (val) == BINDING_VECTOR)
846	{
847	/* I presume the binding list is going to be sparser than
848	the import bitmap. Hence iterate over the former
849	checking for bits set in the bitmap. */
850	bitmap imports = get_import_bitmap ();
851	binding_cluster *cluster = BINDING_VECTOR_CLUSTER_BASE (val);
852	int marker = 0;
853	int dup_detect = 0;
854
855	if (tree bind = cluster->slots[BINDING_SLOT_CURRENT])
856	{
857	if (!deduping)
858	{
859	if (named_module_purview_p ())
860	{
861	dup_detect |= 2;
862
863	if (STAT_HACK_P (bind) && MODULE_BINDING_GLOBAL_P (bind))
864	dup_detect |= 1;
865	}
866	else
867	dup_detect |= 1;
868	}
869	tree type = NULL_TREE;
870	tree value = bind;
871
872	if (STAT_HACK_P (bind))
873	{
874	type = STAT_TYPE (bind);
875	value = STAT_DECL (bind);
876
877	if (!bool (want & LOOK_want::HIDDEN_FRIEND))
878	{
879	if (STAT_TYPE_HIDDEN_P (bind))
880	type = NULL_TREE;
881	if (STAT_DECL_HIDDEN_P (bind))
882	value = NULL_TREE;
883	else
884	value = ovl_skip_hidden (value);
885	}
886	}
887	else if (!bool (want & LOOK_want::HIDDEN_FRIEND))
888	value = ovl_skip_hidden (value);
889
890	marker = process_module_binding (new_val: value, new_type: type, marker);
891	}
892
893	/* Scan the imported bindings. */
894	unsigned ix = BINDING_VECTOR_NUM_CLUSTERS (val);
895	if (BINDING_VECTOR_SLOTS_PER_CLUSTER == BINDING_SLOTS_FIXED)
896	{
897	ix--;
898	cluster++;
899	}
900
901	/* Do this in forward order, so we load modules in an order
902	the user expects. */
903	for (; ix--; cluster++)
904	for (unsigned jx = 0; jx != BINDING_VECTOR_SLOTS_PER_CLUSTER; jx++)
905	{
906	/* Are we importing this module? */
907	if (unsigned base = cluster->indices[jx].base)
908	if (unsigned span = cluster->indices[jx].span)
909	do
910	if (bitmap_bit_p (imports, base))
911	goto found;
912	while (++base, --span);
913	continue;
914
915	found:;
916	/* Is it loaded? */
917	if (cluster->slots[jx].is_lazy ())
918	{
919	gcc_assert (cluster->indices[jx].span == 1);
920	lazy_load_binding (mod: cluster->indices[jx].base,
921	ns: scope, id: name, bslot: &cluster->slots[jx]);
922	}
923	tree bind = cluster->slots[jx];
924	if (!bind)
925	/* Load errors could mean there's nothing here. */
926	continue;
927
928	/* Extract what we can see from here. If there's no
929	stat_hack, then everything was exported. */
930	tree type = NULL_TREE;
931
932
933	/* If STAT_HACK_P is false, everything is visible, and
934	there's no duplication possibilities. */
935	if (STAT_HACK_P (bind))
936	{
937	if (!deduping)
938	{
939	/* Do we need to engage deduplication? */
940	int dup = 0;
941	if (MODULE_BINDING_GLOBAL_P (bind))
942	dup = 1;
943	else if (MODULE_BINDING_PARTITION_P (bind))
944	dup = 2;
945	if (unsigned hit = dup_detect & dup)
946	{
947	if ((hit & 1 && BINDING_VECTOR_GLOBAL_DUPS_P (val))
948	|| (hit & 2
949	&& BINDING_VECTOR_PARTITION_DUPS_P (val)))
950	dedup (state: true);
951	}
952	dup_detect |= dup;
953	}
954
955	if (STAT_TYPE_VISIBLE_P (bind))
956	type = STAT_TYPE (bind);
957	bind = STAT_VISIBLE (bind);
958	}
959
960	/* And process it. */
961	marker = process_module_binding (new_val: bind, new_type: type, marker);
962	}
963	found |= marker & 1;
964	}
965	else
966	{
967	/* Only a current module binding, visible from the current module. */
968	tree bind = *binding;
969	tree value = bind, type = NULL_TREE;
970
971	if (STAT_HACK_P (bind))
972	{
973	type = STAT_TYPE (bind);
974	value = STAT_DECL (bind);
975
976	if (!bool (want & LOOK_want::HIDDEN_FRIEND))
977	{
978	if (STAT_TYPE_HIDDEN_P (bind))
979	type = NULL_TREE;
980	if (STAT_DECL_HIDDEN_P (bind))
981	value = NULL_TREE;
982	else
983	value = ovl_skip_hidden (value);
984	}
985	}
986	else if (!bool (want & LOOK_want::HIDDEN_FRIEND))
987	value = ovl_skip_hidden (value);
988
989	found |= process_binding (new_val: value, new_type: type);
990	}
991	}
992
993	return found;
994	}
995
996	/* Conditionally look in namespace SCOPE and inline children. */
997
998	bool
999	name_lookup::search_namespace (tree scope)
1000	{
1001	if (see_and_mark (scope))
1002	/* We've visited this scope before. Return what we found then. */
1003	return found_p (scope);
1004
1005	/* Look in exactly namespace. */
1006	bool found = search_namespace_only (scope);
1007
1008	/* Don't look into inline children, if we're looking for an
1009	anonymous name -- it must be in the current scope, if anywhere. */
1010	if (name)
1011	/* Recursively look in its inline children. */
1012	if (vec<tree, va_gc> *inlinees = DECL_NAMESPACE_INLINEES (scope))
1013	for (unsigned ix = inlinees->length (); ix--;)
1014	found |= search_namespace (scope: (*inlinees)[ix]);
1015
1016	if (found)
1017	mark_found (scope);
1018
1019	return found;
1020	}
1021
1022	/* Recursively follow using directives of SCOPE & its inline children.
1023	Such following is essentially a flood-fill algorithm. */
1024
1025	bool
1026	name_lookup::search_usings (tree scope)
1027	{
1028	/* We do not check seen_p here, as that was already set during the
1029	namespace_only walk. */
1030	if (found_p (scope))
1031	return true;
1032
1033	bool found = false;
1034	if (vec<tree, va_gc> *usings = NAMESPACE_LEVEL (scope)->using_directives)
1035	for (unsigned ix = usings->length (); ix--;)
1036	found |= search_qualified (scope: (*usings)[ix], usings: true);
1037
1038	/* Look in its inline children. */
1039	if (vec<tree, va_gc> *inlinees = DECL_NAMESPACE_INLINEES (scope))
1040	for (unsigned ix = inlinees->length (); ix--;)
1041	found |= search_usings (scope: (*inlinees)[ix]);
1042
1043	if (found)
1044	mark_found (scope);
1045
1046	return found;
1047	}
1048
1049	/* Qualified namespace lookup in SCOPE.
1050	1) Look in SCOPE (+inlines). If found, we're done.
1051	2) Otherwise, if USINGS is true,
1052	recurse for every using directive of SCOPE (+inlines).
1053
1054	Trickiness is (a) loops and (b) multiple paths to same namespace.
1055	In both cases we want to not repeat any lookups, and know whether
1056	to stop the caller's step #2. Do this via the FOUND_P marker. */
1057
1058	bool
1059	name_lookup::search_qualified (tree scope, bool usings)
1060	{
1061	bool found = false;
1062
1063	if (seen_p (scope))
1064	found = found_p (scope);
1065	else
1066	{
1067	found = search_namespace (scope);
1068	if (!found && usings)
1069	found = search_usings (scope);
1070	}
1071
1072	dedup (state: false);
1073
1074	return found;
1075	}
1076
1077	/* Add SCOPE to the unqualified search queue, recursively add its
1078	inlines and those via using directives. */
1079
1080	void
1081	name_lookup::queue_namespace (using_queue& queue, int depth, tree scope)
1082	{
1083	if (see_and_mark (scope))
1084	return;
1085
1086	/* Record it. */
1087	tree common = scope;
1088	while (SCOPE_DEPTH (common) > depth)
1089	common = CP_DECL_CONTEXT (common);
1090	queue.safe_push (obj: using_pair (common, scope));
1091
1092	/* Queue its inline children. */
1093	if (vec<tree, va_gc> *inlinees = DECL_NAMESPACE_INLINEES (scope))
1094	for (unsigned ix = inlinees->length (); ix--;)
1095	queue_namespace (queue, depth, scope: (*inlinees)[ix]);
1096
1097	/* Queue its using targets. */
1098	queue_usings (queue, depth, NAMESPACE_LEVEL (scope)->using_directives);
1099	}
1100
1101	/* Add the namespaces in USINGS to the unqualified search queue. */
1102
1103	void
1104	name_lookup::queue_usings (using_queue& queue, int depth, vec<tree, va_gc> *usings)
1105	{
1106	if (usings)
1107	for (unsigned ix = usings->length (); ix--;)
1108	queue_namespace (queue, depth, scope: (*usings)[ix]);
1109	}
1110
1111	/* Unqualified namespace lookup in SCOPE.
1112	1) add scope+inlins to worklist.
1113	2) recursively add target of every using directive
1114	3) for each worklist item where SCOPE is common ancestor, search it
1115	4) if nothing find, scope=parent, goto 1. */
1116
1117	bool
1118	name_lookup::search_unqualified (tree scope, cp_binding_level *level)
1119	{
1120	using_queue queue;
1121	bool found = false;
1122
1123	/* Queue local using-directives. */
1124	for (; level->kind != sk_namespace; level = level->level_chain)
1125	queue_usings (queue, SCOPE_DEPTH (scope), usings: level->using_directives);
1126
1127	for (; !found; scope = CP_DECL_CONTEXT (scope))
1128	{
1129	gcc_assert (!DECL_NAMESPACE_ALIAS (scope));
1130	int depth = SCOPE_DEPTH (scope);
1131
1132	/* Queue namespaces reachable from SCOPE. */
1133	queue_namespace (queue, depth, scope);
1134
1135	/* Search every queued namespace where SCOPE is the common
1136	ancestor. Adjust the others. */
1137	unsigned ix = 0;
1138	do
1139	{
1140	using_pair &pair = queue[ix];
1141	while (pair.first == scope)
1142	{
1143	found |= search_namespace_only (scope: pair.second);
1144	pair = queue.pop ();
1145	if (ix == queue.length ())
1146	goto done;
1147	}
1148	/* The depth is the same as SCOPE, find the parent scope. */
1149	if (SCOPE_DEPTH (pair.first) == depth)
1150	pair.first = CP_DECL_CONTEXT (pair.first);
1151	ix++;
1152	}
1153	while (ix < queue.length ());
1154	done:;
1155	if (scope == global_namespace)
1156	break;
1157
1158	/* If looking for hidden friends, we only look in the innermost
1159	namespace scope. [namespace.memdef]/3 If a friend
1160	declaration in a non-local class first declares a class,
1161	function, class template or function template the friend is a
1162	member of the innermost enclosing namespace. See also
1163	[basic.lookup.unqual]/7 */
1164	if (bool (want & LOOK_want::HIDDEN_FRIEND))
1165	break;
1166	}
1167
1168	dedup (state: false);
1169
1170	return found;
1171	}
1172
1173	/* FNS is a value binding. If it is a (set of overloaded) functions,
1174	add them into the current value. */
1175
1176	void
1177	name_lookup::add_fns (tree fns)
1178	{
1179	if (!fns)
1180	return;
1181	else if (TREE_CODE (fns) == OVERLOAD)
1182	{
1183	if (TREE_TYPE (fns) != unknown_type_node)
1184	fns = OVL_FUNCTION (fns);
1185	}
1186	else if (!DECL_DECLARES_FUNCTION_P (fns))
1187	return;
1188
1189	add_overload (fns);
1190	}
1191
1192	/* Add the overloaded fns of SCOPE. */
1193
1194	void
1195	name_lookup::adl_namespace_fns (tree scope, bitmap imports)
1196	{
1197	if (tree *binding = find_namespace_slot (ns: scope, name))
1198	{
1199	tree val = *binding;
1200	if (TREE_CODE (val) != BINDING_VECTOR)
1201	add_fns (fns: ovl_skip_hidden (MAYBE_STAT_DECL (val)));
1202	else
1203	{
1204	/* I presume the binding list is going to be sparser than
1205	the import bitmap. Hence iterate over the former
1206	checking for bits set in the bitmap. */
1207	binding_cluster *cluster = BINDING_VECTOR_CLUSTER_BASE (val);
1208	int dup_detect = 0;
1209
1210	if (tree bind = cluster->slots[BINDING_SLOT_CURRENT])
1211	{
1212	/* The current TU's bindings must be visible, we don't
1213	need to check the bitmaps. */
1214
1215	if (!deduping)
1216	{
1217	if (named_module_purview_p ())
1218	{
1219	dup_detect |= 2;
1220
1221	if (STAT_HACK_P (bind) && MODULE_BINDING_GLOBAL_P (bind))
1222	dup_detect |= 1;
1223	}
1224	else
1225	dup_detect |= 1;
1226	}
1227
1228	add_fns (fns: ovl_skip_hidden (MAYBE_STAT_DECL (bind)));
1229	}
1230
1231	/* Scan the imported bindings. */
1232	unsigned ix = BINDING_VECTOR_NUM_CLUSTERS (val);
1233	if (BINDING_VECTOR_SLOTS_PER_CLUSTER == BINDING_SLOTS_FIXED)
1234	{
1235	ix--;
1236	cluster++;
1237	}
1238
1239	/* Do this in forward order, so we load modules in an order
1240	the user expects. */
1241	for (; ix--; cluster++)
1242	for (unsigned jx = 0; jx != BINDING_VECTOR_SLOTS_PER_CLUSTER; jx++)
1243	{
1244	/* Functions are never on merged slots. */
1245	if (!cluster->indices[jx].base
1246	|| cluster->indices[jx].span != 1)
1247	continue;
1248
1249	/* Is this slot visible? */
1250	if (!bitmap_bit_p (imports, cluster->indices[jx].base))
1251	continue;
1252
1253	/* Is it loaded. */
1254	if (cluster->slots[jx].is_lazy ())
1255	lazy_load_binding (mod: cluster->indices[jx].base,
1256	ns: scope, id: name, bslot: &cluster->slots[jx]);
1257
1258	tree bind = cluster->slots[jx];
1259	if (!bind)
1260	/* Load errors could mean there's nothing here. */
1261	continue;
1262
1263	if (STAT_HACK_P (bind))
1264	{
1265	if (!deduping)
1266	{
1267	/* Do we need to engage deduplication? */
1268	int dup = 0;
1269	if (MODULE_BINDING_GLOBAL_P (bind))
1270	dup = 1;
1271	else if (MODULE_BINDING_PARTITION_P (bind))
1272	dup = 2;
1273	if (unsigned hit = dup_detect & dup)
1274	if ((hit & 1 && BINDING_VECTOR_GLOBAL_DUPS_P (val))
1275	|| (hit & 2
1276	&& BINDING_VECTOR_PARTITION_DUPS_P (val)))
1277	dedup (state: true);
1278	dup_detect |= dup;
1279	}
1280
1281	bind = STAT_VISIBLE (bind);
1282	}
1283
1284	add_fns (fns: bind);
1285	}
1286	}
1287	}
1288	}
1289
1290	/* Add the hidden friends of SCOPE. */
1291
1292	void
1293	name_lookup::adl_class_fns (tree type)
1294	{
1295	/* Add friends. */
1296	for (tree list = DECL_FRIENDLIST (TYPE_MAIN_DECL (type));
1297	list; list = TREE_CHAIN (list))
1298	if (name == FRIEND_NAME (list))
1299	{
1300	tree context = NULL_TREE; /* Lazily computed. */
1301	for (tree friends = FRIEND_DECLS (list); friends;
1302	friends = TREE_CHAIN (friends))
1303	{
1304	tree fn = TREE_VALUE (friends);
1305
1306	/* Only interested in global functions with potentially hidden
1307	(i.e. unqualified) declarations. */
1308	if (!context)
1309	context = decl_namespace_context (type);
1310	if (CP_DECL_CONTEXT (fn) != context)
1311	continue;
1312
1313	dedup (state: true);
1314
1315	/* Template specializations are never found by name lookup.
1316	(Templates themselves can be found, but not template
1317	specializations.) */
1318	if (TREE_CODE (fn) == FUNCTION_DECL && DECL_USE_TEMPLATE (fn))
1319	continue;
1320
1321	add_fns (fns: fn);
1322	}
1323	}
1324	}
1325
1326	/* Find the containing non-inlined namespace, add it and all its
1327	inlinees. */
1328
1329	void
1330	name_lookup::adl_namespace (tree scope)
1331	{
1332	if (see_and_mark (scope))
1333	return;
1334
1335	/* Look down into inline namespaces. */
1336	if (vec<tree, va_gc> *inlinees = DECL_NAMESPACE_INLINEES (scope))
1337	for (unsigned ix = inlinees->length (); ix--;)
1338	adl_namespace (scope: (*inlinees)[ix]);
1339
1340	if (DECL_NAMESPACE_INLINE_P (scope))
1341	/* Mark parent. */
1342	adl_namespace (CP_DECL_CONTEXT (scope));
1343	}
1344
1345	/* Adds the class and its friends to the lookup structure. */
1346
1347	void
1348	name_lookup::adl_class_only (tree type)
1349	{
1350	/* Backend-built structures, such as __builtin_va_list, aren't
1351	affected by all this. */
1352	if (!CLASS_TYPE_P (type))
1353	return;
1354
1355	type = TYPE_MAIN_VARIANT (type);
1356
1357	if (see_and_mark (scope: type))
1358	return;
1359
1360	tree context = decl_namespace_context (type);
1361	adl_namespace (scope: context);
1362	}
1363
1364	/* Adds the class and its bases to the lookup structure.
1365	Returns true on error. */
1366
1367	void
1368	name_lookup::adl_bases (tree type)
1369	{
1370	adl_class_only (type);
1371
1372	/* Process baseclasses. */
1373	if (tree binfo = TYPE_BINFO (type))
1374	{
1375	tree base_binfo;
1376	int i;
1377
1378	for (i = 0; BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
1379	adl_bases (BINFO_TYPE (base_binfo));
1380	}
1381	}
1382
1383	/* Adds everything associated with a class argument type to the lookup
1384	structure.
1385
1386	If T is a class type (including unions), its associated classes are: the
1387	class itself; the class of which it is a member, if any; and its direct
1388	and indirect base classes. Its associated namespaces are the namespaces
1389	of which its associated classes are members. Furthermore, if T is a
1390	class template specialization, its associated namespaces and classes
1391	also include: the namespaces and classes associated with the types of
1392	the template arguments provided for template type parameters (excluding
1393	template template parameters); the namespaces of which any template
1394	template arguments are members; and the classes of which any member
1395	templates used as template template arguments are members. [ Note:
1396	non-type template arguments do not contribute to the set of associated
1397	namespaces. --end note] */
1398
1399	void
1400	name_lookup::adl_class (tree type)
1401	{
1402	/* Backend build structures, such as __builtin_va_list, aren't
1403	affected by all this. */
1404	if (!CLASS_TYPE_P (type))
1405	return;
1406
1407	type = TYPE_MAIN_VARIANT (type);
1408
1409	/* We don't set found here because we have to have set seen first,
1410	which is done in the adl_bases walk. */
1411	if (found_p (scope: type))
1412	return;
1413
1414	complete_type (type);
1415	adl_bases (type);
1416	mark_found (scope: type);
1417
1418	if (TYPE_CLASS_SCOPE_P (type))
1419	adl_class_only (TYPE_CONTEXT (type));
1420
1421	/* Process template arguments. */
1422	if (CLASSTYPE_TEMPLATE_INFO (type)
1423	&& PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (type)))
1424	{
1425	tree list = INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (type));
1426	for (int i = 0; i < TREE_VEC_LENGTH (list); ++i)
1427	adl_template_arg (TREE_VEC_ELT (list, i));
1428	}
1429	}
1430
1431	void
1432	name_lookup::adl_enum (tree type)
1433	{
1434	type = TYPE_MAIN_VARIANT (type);
1435	if (see_and_mark (scope: type))
1436	return;
1437
1438	if (TYPE_CLASS_SCOPE_P (type))
1439	adl_class_only (TYPE_CONTEXT (type));
1440	else
1441	adl_namespace (scope: decl_namespace_context (type));
1442	}
1443
1444	void
1445	name_lookup::adl_expr (tree expr)
1446	{
1447	if (!expr)
1448	return;
1449
1450	gcc_assert (!TYPE_P (expr));
1451
1452	if (TREE_TYPE (expr) != unknown_type_node)
1453	{
1454	adl_type (unlowered_expr_type (expr));
1455	return;
1456	}
1457
1458	if (TREE_CODE (expr) == ADDR_EXPR)
1459	expr = TREE_OPERAND (expr, 0);
1460	if (TREE_CODE (expr) == COMPONENT_REF
1461	|| TREE_CODE (expr) == OFFSET_REF)
1462	expr = TREE_OPERAND (expr, 1);
1463	expr = MAYBE_BASELINK_FUNCTIONS (expr);
1464
1465	if (OVL_P (expr))
1466	for (lkp_iterator iter (expr); iter; ++iter)
1467	adl_type (TREE_TYPE (*iter));
1468	else if (TREE_CODE (expr) == TEMPLATE_ID_EXPR)
1469	{
1470	/* The working paper doesn't currently say how to handle
1471	template-id arguments. The sensible thing would seem to be
1472	to handle the list of template candidates like a normal
1473	overload set, and handle the template arguments like we do
1474	for class template specializations. */
1475
1476	/* First the templates. */
1477	adl_expr (TREE_OPERAND (expr, 0));
1478
1479	/* Now the arguments. */
1480	if (tree args = TREE_OPERAND (expr, 1))
1481	for (int ix = TREE_VEC_LENGTH (args); ix--;)
1482	adl_template_arg (TREE_VEC_ELT (args, ix));
1483	}
1484	}
1485
1486	void
1487	name_lookup::adl_type (tree type)
1488	{
1489	if (!type)
1490	return;
1491
1492	if (TYPE_PTRDATAMEM_P (type))
1493	{
1494	/* Pointer to member: associate class type and value type. */
1495	adl_type (TYPE_PTRMEM_CLASS_TYPE (type));
1496	adl_type (TYPE_PTRMEM_POINTED_TO_TYPE (type));
1497	return;
1498	}
1499
1500	switch (TREE_CODE (type))
1501	{
1502	case RECORD_TYPE:
1503	if (TYPE_PTRMEMFUNC_P (type))
1504	{
1505	adl_type (TYPE_PTRMEMFUNC_FN_TYPE (type));
1506	return;
1507	}
1508	/* FALLTHRU */
1509	case UNION_TYPE:
1510	adl_class (type);
1511	return;
1512
1513	case METHOD_TYPE:
1514	/* The basetype is referenced in the first arg type, so just
1515	fall through. */
1516	case FUNCTION_TYPE:
1517	/* Associate the parameter types. */
1518	for (tree args = TYPE_ARG_TYPES (type); args; args = TREE_CHAIN (args))
1519	adl_type (TREE_VALUE (args));
1520	/* FALLTHROUGH */
1521
1522	case POINTER_TYPE:
1523	case REFERENCE_TYPE:
1524	case ARRAY_TYPE:
1525	adl_type (TREE_TYPE (type));
1526	return;
1527
1528	case ENUMERAL_TYPE:
1529	adl_enum (type);
1530	return;
1531
1532	case LANG_TYPE:
1533	gcc_assert (type == unknown_type_node
1534	|| type == init_list_type_node);
1535	return;
1536
1537	case TYPE_PACK_EXPANSION:
1538	adl_type (PACK_EXPANSION_PATTERN (type));
1539	return;
1540
1541	default:
1542	break;
1543	}
1544	}
1545
1546	/* Adds everything associated with a template argument to the lookup
1547	structure. */
1548
1549	void
1550	name_lookup::adl_template_arg (tree arg)
1551	{
1552	/* [basic.lookup.koenig]
1553
1554	If T is a template-id, its associated namespaces and classes are
1555	... the namespaces and classes associated with the types of the
1556	template arguments provided for template type parameters
1557	(excluding template template parameters); the namespaces in which
1558	any template template arguments are defined; and the classes in
1559	which any member templates used as template template arguments
1560	are defined. [Note: non-type template arguments do not
1561	contribute to the set of associated namespaces. ] */
1562
1563	/* Consider first template template arguments. */
1564	if (TREE_CODE (arg) == TEMPLATE_TEMPLATE_PARM
1565	|| TREE_CODE (arg) == UNBOUND_CLASS_TEMPLATE)
1566	;
1567	else if (TREE_CODE (arg) == TEMPLATE_DECL)
1568	{
1569	tree ctx = CP_DECL_CONTEXT (arg);
1570
1571	/* It's not a member template. */
1572	if (TREE_CODE (ctx) == NAMESPACE_DECL)
1573	adl_namespace (scope: ctx);
1574	/* Otherwise, it must be member template. */
1575	else
1576	adl_class_only (type: ctx);
1577	}
1578	/* It's an argument pack; handle it recursively. */
1579	else if (ARGUMENT_PACK_P (arg))
1580	{
1581	tree args = ARGUMENT_PACK_ARGS (arg);
1582	int i, len = TREE_VEC_LENGTH (args);
1583	for (i = 0; i < len; ++i)
1584	adl_template_arg (TREE_VEC_ELT (args, i));
1585	}
1586	/* It's not a template template argument, but it is a type template
1587	argument. */
1588	else if (TYPE_P (arg))
1589	adl_type (type: arg);
1590	}
1591
1592	/* Perform ADL lookup. FNS is the existing lookup result and ARGS are
1593	the call arguments. */
1594
1595	tree
1596	name_lookup::search_adl (tree fns, vec<tree, va_gc> *args)
1597	{
1598	gcc_checking_assert (!vec_safe_length (scopes));
1599
1600	/* Gather each associated entity onto the lookup's scope list. */
1601	unsigned ix;
1602	tree arg;
1603
1604	FOR_EACH_VEC_ELT_REVERSE (*args, ix, arg)
1605	/* OMP reduction operators put an ADL-significant type as the
1606	first arg. */
1607	if (TYPE_P (arg))
1608	adl_type (type: arg);
1609	else
1610	adl_expr (expr: arg);
1611
1612	if (vec_safe_length (v: scopes))
1613	{
1614	/* Now do the lookups. */
1615	value = fns;
1616	if (fns)
1617	dedup (state: true);
1618
1619	/* INST_PATH will be NULL, if this is /not/ 2nd-phase ADL. */
1620	bitmap inst_path = NULL;
1621	/* VISIBLE is the regular import bitmap. */
1622	bitmap visible = visible_instantiation_path (&inst_path);
1623
1624	for (unsigned ix = scopes->length (); ix--;)
1625	{
1626	tree scope = (*scopes)[ix];
1627	if (TREE_CODE (scope) == NAMESPACE_DECL)
1628	adl_namespace_fns (scope, imports: visible);
1629	else
1630	{
1631	if (RECORD_OR_UNION_TYPE_P (scope))
1632	adl_class_fns (type: scope);
1633
1634	/* During 2nd phase ADL: Any exported declaration D in N
1635	declared within the purview of a named module M
1636	(10.2) is visible if there is an associated entity
1637	attached to M with the same innermost enclosing
1638	non-inline namespace as D.
1639	[basic.lookup.argdep]/4.4 */
1640
1641	if (!inst_path)
1642	/* Not 2nd phase. */
1643	continue;
1644
1645	tree ctx = CP_DECL_CONTEXT (TYPE_NAME (scope));
1646	if (TREE_CODE (ctx) != NAMESPACE_DECL)
1647	/* Not namespace-scope class. */
1648	continue;
1649
1650	tree origin = get_originating_module_decl (TYPE_NAME (scope));
1651	tree not_tmpl = STRIP_TEMPLATE (origin);
1652	if (!DECL_LANG_SPECIFIC (not_tmpl)
1653	|| !DECL_MODULE_IMPORT_P (not_tmpl))
1654	/* Not imported. */
1655	continue;
1656
1657	unsigned module = get_importing_module (origin);
1658
1659	if (!bitmap_bit_p (inst_path, module))
1660	/* Not on path of instantiation. */
1661	continue;
1662
1663	if (bitmap_bit_p (visible, module))
1664	/* If the module was in the visible set, we'll look at
1665	its namespace partition anyway. */
1666	continue;
1667
1668	if (tree *slot = find_namespace_slot (ns: ctx, name, create_p: false))
1669	if (binding_slot *mslot = search_imported_binding_slot (slot, ix: module))
1670	{
1671	if (mslot->is_lazy ())
1672	lazy_load_binding (mod: module, ns: ctx, id: name, bslot: mslot);
1673
1674	if (tree bind = *mslot)
1675	{
1676	/* We must turn on deduping, because some other class
1677	from this module might also be in this namespace. */
1678	dedup (state: true);
1679
1680	/* Add the exported fns */
1681	if (STAT_HACK_P (bind))
1682	add_fns (STAT_VISIBLE (bind));
1683	}
1684	}
1685	}
1686	}
1687
1688	fns = value;
1689	dedup (state: false);
1690	}
1691
1692	return fns;
1693	}
1694
1695	static bool qualified_namespace_lookup (tree, name_lookup *);
1696	static void consider_binding_level (tree name,
1697	best_match <tree, const char *> &bm,
1698	cp_binding_level *lvl,
1699	bool look_within_fields,
1700	enum lookup_name_fuzzy_kind kind);
1701
1702	/* ADL lookup of NAME. FNS is the result of regular lookup, and we
1703	don't add duplicates to it. ARGS is the vector of call
1704	arguments (which will not be empty). */
1705
1706	tree
1707	lookup_arg_dependent (tree name, tree fns, vec<tree, va_gc> *args)
1708	{
1709	auto_cond_timevar tv (TV_NAME_LOOKUP);
1710	name_lookup lookup (name);
1711	return lookup.search_adl (fns, args);
1712	}
1713
1714	/* FNS is an overload set of conversion functions. Return the
1715	overloads converting to TYPE. */
1716
1717	static tree
1718	extract_conversion_operator (tree fns, tree type)
1719	{
1720	tree convs = NULL_TREE;
1721	tree tpls = NULL_TREE;
1722
1723	for (ovl_iterator iter (fns); iter; ++iter)
1724	{
1725	if (same_type_p (DECL_CONV_FN_TYPE (*iter), type))
1726	convs = lookup_add (fns: *iter, lookup: convs);
1727
1728	if (TREE_CODE (*iter) == TEMPLATE_DECL)
1729	tpls = lookup_add (fns: *iter, lookup: tpls);
1730	}
1731
1732	if (!convs)
1733	convs = tpls;
1734
1735	return convs;
1736	}
1737
1738	/* Binary search of (ordered) MEMBER_VEC for NAME. */
1739
1740	static tree
1741	member_vec_binary_search (vec<tree, va_gc> *member_vec, tree name)
1742	{
1743	for (unsigned lo = 0, hi = member_vec->length (); lo < hi;)
1744	{
1745	unsigned mid = (lo + hi) / 2;
1746	tree binding = (*member_vec)[mid];
1747	tree binding_name = OVL_NAME (binding);
1748
1749	if (binding_name > name)
1750	hi = mid;
1751	else if (binding_name < name)
1752	lo = mid + 1;
1753	else
1754	return binding;
1755	}
1756
1757	return NULL_TREE;
1758	}
1759
1760	/* Linear search of (unordered) MEMBER_VEC for NAME. */
1761
1762	static tree
1763	member_vec_linear_search (vec<tree, va_gc> *member_vec, tree name)
1764	{
1765	for (int ix = member_vec->length (); ix--;)
1766	if (tree binding = (*member_vec)[ix])
1767	if (OVL_NAME (binding) == name)
1768	return binding;
1769
1770	return NULL_TREE;
1771	}
1772
1773	/* Linear search of (partially ordered) fields of KLASS for NAME. */
1774
1775	static tree
1776	fields_linear_search (tree klass, tree name, bool want_type)
1777	{
1778	for (tree fields = TYPE_FIELDS (klass); fields; fields = DECL_CHAIN (fields))
1779	{
1780	tree decl = fields;
1781
1782	if (TREE_CODE (decl) == FIELD_DECL
1783	&& ANON_AGGR_TYPE_P (TREE_TYPE (decl)))
1784	{
1785	if (tree temp = search_anon_aggr (TREE_TYPE (decl), name, want_type))
1786	return temp;
1787	}
1788
1789	if (DECL_NAME (decl) != name)
1790	continue;
1791
1792	if (TREE_CODE (decl) == USING_DECL)
1793	{
1794	decl = strip_using_decl (decl);
1795	if (is_overloaded_fn (decl))
1796	continue;
1797	}
1798
1799	if (DECL_DECLARES_FUNCTION_P (decl))
1800	/* Functions are found separately. */
1801	continue;
1802
1803	if (!want_type || DECL_DECLARES_TYPE_P (decl))
1804	return decl;
1805	}
1806
1807	return NULL_TREE;
1808	}
1809
1810	/* Like fields_linear_search, but specific for "_" name. There can be multiple
1811	name-independent non-static data members and in that case a TREE_LIST with the
1812	ambiguous decls should be returned. */
1813
1814	static tree
1815	name_independent_linear_search (tree val, tree klass, tree name)
1816	{
1817	for (tree fields = TYPE_FIELDS (klass); fields; fields = DECL_CHAIN (fields))
1818	{
1819	tree decl = fields;
1820
1821	if (TREE_CODE (decl) == FIELD_DECL
1822	&& ANON_AGGR_TYPE_P (TREE_TYPE (decl)))
1823	{
1824	if (tree temp = search_anon_aggr (TREE_TYPE (decl), name, false))
1825	{
1826	decl = temp;
1827	goto add;
1828	}
1829	}
1830
1831	if (DECL_NAME (decl) != name)
1832	continue;
1833
1834	if (TREE_CODE (decl) == USING_DECL)
1835	{
1836	decl = strip_using_decl (decl);
1837	if (is_overloaded_fn (decl))
1838	continue;
1839	}
1840
1841	if (DECL_DECLARES_FUNCTION_P (decl))
1842	/* Functions are found separately. */
1843	continue;
1844
1845	add:
1846	if (val == NULL_TREE)
1847	val = decl;
1848	else
1849	{
1850	if (TREE_CODE (val) != TREE_LIST)
1851	{
1852	if (TREE_CODE (val) == OVERLOAD
1853	&& OVL_DEDUP_P (val)
1854	&& TREE_CODE (decl) == USING_DECL)
1855	{
1856	val = ovl_make (fn: decl, next: val);
1857	continue;
1858	}
1859	val = tree_cons (NULL_TREE, val, NULL_TREE);
1860	TREE_TYPE (val) = error_mark_node;
1861	}
1862	if (TREE_CODE (decl) == TREE_LIST)
1863	val = chainon (decl, val);
1864	else
1865	{
1866	val = tree_cons (NULL_TREE, decl, val);
1867	TREE_TYPE (val) = error_mark_node;
1868	}
1869	}
1870	}
1871
1872	return val;
1873	}
1874
1875	/* Look for NAME member inside of anonymous aggregate ANON. Although
1876	such things should only contain FIELD_DECLs, we check that too
1877	late, and would give very confusing errors if we weren't
1878	permissive here. */
1879
1880	tree
1881	search_anon_aggr (tree anon, tree name, bool want_type)
1882	{
1883	gcc_assert (COMPLETE_TYPE_P (anon));
1884	tree ret = get_class_binding_direct (anon, name, want_type);
1885	return ret;
1886	}
1887
1888	/* Look for NAME as an immediate member of KLASS (including
1889	anon-members or unscoped enum member). TYPE_OR_FNS is zero for
1890	regular search. >0 to get a type binding (if there is one) and <0
1891	if you want (just) the member function binding.
1892
1893	Use this if you do not want lazy member creation. */
1894
1895	tree
1896	get_class_binding_direct (tree klass, tree name, bool want_type)
1897	{
1898	gcc_checking_assert (RECORD_OR_UNION_TYPE_P (klass));
1899
1900	/* Conversion operators can only be found by the marker conversion
1901	operator name. */
1902	bool conv_op = IDENTIFIER_CONV_OP_P (name);
1903	tree lookup = conv_op ? conv_op_identifier : name;
1904	tree val = NULL_TREE;
1905	vec<tree, va_gc> *member_vec = CLASSTYPE_MEMBER_VEC (klass);
1906
1907	if (COMPLETE_TYPE_P (klass) && member_vec)
1908	{
1909	val = member_vec_binary_search (member_vec, name: lookup);
1910	if (!val)
1911	;
1912	else if (TREE_CODE (val) == OVERLOAD
1913	&& OVL_NAME_INDEPENDENT_DECL_P (val))
1914	{
1915	if (want_type)
1916	{
1917	while (TREE_CODE (val) == OVERLOAD
1918	&& OVL_NAME_INDEPENDENT_DECL_P (val))
1919	val = OVL_CHAIN (val);
1920	if (STAT_HACK_P (val))
1921	val = STAT_TYPE (val);
1922	else if (!DECL_DECLARES_TYPE_P (val))
1923	val = NULL_TREE;
1924	}
1925	else
1926	{
1927	/* OVERLOAD with a special OVL_NAME_INDEPENDENT_DECL_P
1928	flag is used under the hood to represent lookup
1929	results which include name-independent declarations,
1930	and get_class_binding_direct is turning that into
1931	TREE_LIST representation (which the callers expect for
1932	ambiguous lookups) instead.
1933	There are 2 reasons for that:
1934	1) in order to keep the member_vec binary search fast, I
1935	think it is better to keep OVL_NAME usable on all elements
1936	because having to special case TREE_LIST would slow
1937	everything down;
1938	2) the callers need to be able to chain the results anyway
1939	and so need an unshared TREE_LIST they can tweak/destroy. */
1940	tree ovl = val;
1941	val = NULL_TREE;
1942	while (TREE_CODE (ovl) == OVERLOAD
1943	&& OVL_NAME_INDEPENDENT_DECL_P (ovl))
1944	{
1945	val = tree_cons (NULL_TREE, OVL_FUNCTION (ovl), val);
1946	TREE_TYPE (val) = error_mark_node;
1947	ovl = OVL_CHAIN (ovl);
1948	}
1949	if (STAT_HACK_P (ovl))
1950	val = tree_cons (NULL_TREE, STAT_DECL (ovl), val);
1951	else
1952	val = tree_cons (NULL_TREE, ovl, val);
1953	TREE_TYPE (val) = error_mark_node;
1954	}
1955	}
1956	else if (STAT_HACK_P (val))
1957	val = want_type ? STAT_TYPE (val) : STAT_DECL (val);
1958	else if (want_type && !DECL_DECLARES_TYPE_P (val))
1959	val = NULL_TREE;
1960	}
1961	else
1962	{
1963	if (member_vec && !want_type)
1964	val = member_vec_linear_search (member_vec, name: lookup);
1965
1966	if (id_equal (id: lookup, str: "_") && !want_type)
1967	val = name_independent_linear_search (val, klass, name: lookup);
1968	else if (!val || (TREE_CODE (val) == OVERLOAD && OVL_DEDUP_P (val)))
1969	/* Dependent using declarations are a 'field', make sure we
1970	return that even if we saw an overload already. */
1971	if (tree field_val = fields_linear_search (klass, name: lookup, want_type))
1972	{
1973	if (!val)
1974	val = field_val;
1975	else if (TREE_CODE (field_val) == USING_DECL)
1976	val = ovl_make (fn: field_val, next: val);
1977	}
1978	}
1979
1980	/* Extract the conversion operators asked for, unless the general
1981	conversion operator was requested. */
1982	if (val && conv_op)
1983	{
1984	gcc_checking_assert (OVL_FUNCTION (val) == conv_op_marker);
1985	val = OVL_CHAIN (val);
1986	if (tree type = TREE_TYPE (name))
1987	val = extract_conversion_operator (fns: val, type);
1988	}
1989
1990	return val;
1991	}
1992
1993	/* We're about to lookup NAME in KLASS. Make sure any lazily declared
1994	members are now declared. */
1995
1996	static void
1997	maybe_lazily_declare (tree klass, tree name)
1998	{
1999	/* See big comment anout module_state::write_pendings regarding adding a check
2000	bit. */
2001	if (modules_p ())
2002	lazy_load_pendings (TYPE_NAME (klass));
2003
2004	/* Lazily declare functions, if we're going to search these. */
2005	if (IDENTIFIER_CTOR_P (name))
2006	{
2007	if (CLASSTYPE_LAZY_DEFAULT_CTOR (klass))
2008	lazily_declare_fn (sfk_constructor, klass);
2009	if (CLASSTYPE_LAZY_COPY_CTOR (klass))
2010	lazily_declare_fn (sfk_copy_constructor, klass);
2011	if (CLASSTYPE_LAZY_MOVE_CTOR (klass))
2012	lazily_declare_fn (sfk_move_constructor, klass);
2013	}
2014	else if (IDENTIFIER_DTOR_P (name))
2015	{
2016	if (CLASSTYPE_LAZY_DESTRUCTOR (klass))
2017	lazily_declare_fn (sfk_destructor, klass);
2018	}
2019	else if (name == assign_op_identifier)
2020	{
2021	if (CLASSTYPE_LAZY_COPY_ASSIGN (klass))
2022	lazily_declare_fn (sfk_copy_assignment, klass);
2023	if (CLASSTYPE_LAZY_MOVE_ASSIGN (klass))
2024	lazily_declare_fn (sfk_move_assignment, klass);
2025	}
2026	}
2027
2028	/* Look for NAME's binding in exactly KLASS. See
2029	get_class_binding_direct for argument description. Does lazy
2030	special function creation as necessary. */
2031
2032	tree
2033	get_class_binding (tree klass, tree name, bool want_type /*=false*/)
2034	{
2035	klass = complete_type (klass);
2036
2037	if (COMPLETE_TYPE_P (klass))
2038	maybe_lazily_declare (klass, name);
2039
2040	return get_class_binding_direct (klass, name, want_type);
2041	}
2042
2043	/* Find the slot containing overloads called 'NAME'. If there is no
2044	such slot and the class is complete, create an empty one, at the
2045	correct point in the sorted member vector. Otherwise return NULL.
2046	Deals with conv_op marker handling. */
2047
2048	tree *
2049	find_member_slot (tree klass, tree name)
2050	{
2051	bool complete_p = COMPLETE_TYPE_P (klass);
2052
2053	vec<tree, va_gc> *member_vec = CLASSTYPE_MEMBER_VEC (klass);
2054	if (!member_vec)
2055	{
2056	vec_alloc (v&: member_vec, nelems: 8);
2057	CLASSTYPE_MEMBER_VEC (klass) = member_vec;
2058	if (complete_p)
2059	/* If the class is complete but had no member_vec, we need to
2060	add the TYPE_FIELDS into it. We're also most likely to be
2061	adding ctors & dtors, so ask for 6 spare slots (the
2062	abstract cdtors and their clones). */
2063	member_vec = set_class_bindings (klass, extra: 6);
2064	}
2065
2066	if (IDENTIFIER_CONV_OP_P (name))
2067	name = conv_op_identifier;
2068
2069	unsigned ix, length = member_vec->length ();
2070	for (ix = 0; ix < length; ix++)
2071	{
2072	tree *slot = &(*member_vec)[ix];
2073	tree fn_name = OVL_NAME (*slot);
2074
2075	if (fn_name == name)
2076	{
2077	/* If we found an existing slot, it must be a function set.
2078	Even with insertion after completion, because those only
2079	happen with artificial fns that have unspellable names.
2080	This means we do not have to deal with the stat hack
2081	either. */
2082	gcc_checking_assert (OVL_P (*slot));
2083	if (name == conv_op_identifier)
2084	{
2085	gcc_checking_assert (OVL_FUNCTION (*slot) == conv_op_marker);
2086	/* Skip the conv-op marker. */
2087	slot = &OVL_CHAIN (*slot);
2088	}
2089	return slot;
2090	}
2091
2092	if (complete_p && fn_name > name)
2093	break;
2094	}
2095
2096	/* No slot found, add one if the class is complete. */
2097	if (complete_p)
2098	{
2099	/* Do exact allocation, as we don't expect to add many. */
2100	gcc_assert (name != conv_op_identifier);
2101	vec_safe_reserve_exact (v&: member_vec, nelems: 1);
2102	CLASSTYPE_MEMBER_VEC (klass) = member_vec;
2103	member_vec->quick_insert (ix, NULL_TREE);
2104	return &(*member_vec)[ix];
2105	}
2106
2107	return NULL;
2108	}
2109
2110	/* KLASS is an incomplete class to which we're adding a method NAME.
2111	Add a slot and deal with conv_op marker handling. */
2112
2113	tree *
2114	add_member_slot (tree klass, tree name)
2115	{
2116	gcc_assert (!COMPLETE_TYPE_P (klass));
2117
2118	vec<tree, va_gc> *member_vec = CLASSTYPE_MEMBER_VEC (klass);
2119	vec_safe_push (v&: member_vec, NULL_TREE);
2120	CLASSTYPE_MEMBER_VEC (klass) = member_vec;
2121
2122	tree *slot = &member_vec->last ();
2123	if (IDENTIFIER_CONV_OP_P (name))
2124	{
2125	/* Install the marker prefix. */
2126	*slot = ovl_make (conv_op_marker, NULL_TREE);
2127	slot = &OVL_CHAIN (*slot);
2128	}
2129
2130	return slot;
2131	}
2132
2133	/* Comparison function to compare two MEMBER_VEC entries by name.
2134	Because we can have duplicates during insertion of TYPE_FIELDS, we
2135	do extra checking so deduping doesn't have to deal with so many
2136	cases. */
2137
2138	static int
2139	member_name_cmp (const void *a_p, const void *b_p)
2140	{
2141	tree a = *(const tree *)a_p;
2142	tree b = *(const tree *)b_p;
2143	tree name_a = DECL_NAME (TREE_CODE (a) == OVERLOAD ? OVL_FUNCTION (a) : a);
2144	tree name_b = DECL_NAME (TREE_CODE (b) == OVERLOAD ? OVL_FUNCTION (b) : b);
2145
2146	gcc_checking_assert (name_a && name_b);
2147	if (name_a != name_b)
2148	return name_a < name_b ? -1 : +1;
2149
2150	if (name_a == conv_op_identifier)
2151	{
2152	/* Strip the conv-op markers. */
2153	gcc_checking_assert (OVL_FUNCTION (a) == conv_op_marker
2154	&& OVL_FUNCTION (b) == conv_op_marker);
2155	a = OVL_CHAIN (a);
2156	b = OVL_CHAIN (b);
2157	}
2158
2159	if (TREE_CODE (a) == OVERLOAD)
2160	a = OVL_FUNCTION (a);
2161	if (TREE_CODE (b) == OVERLOAD)
2162	b = OVL_FUNCTION (b);
2163
2164	if (id_equal (id: name_a, str: "_"))
2165	{
2166	/* Sort name-independent members first. */
2167	if (name_independent_decl_p (decl: a))
2168	{
2169	if (name_independent_decl_p (decl: b))
2170	{
2171	if (DECL_UID (a) != DECL_UID (b))
2172	return DECL_UID (a) < DECL_UID (b) ? -1 : +1;
2173	gcc_assert (a == b);
2174	return 0;
2175	}
2176	else
2177	return -1;
2178	}
2179	else if (name_independent_decl_p (decl: b))
2180	return +1;
2181	}
2182
2183	/* We're in STAT_HACK or USING_DECL territory (or possibly error-land). */
2184	if (TREE_CODE (a) != TREE_CODE (b))
2185	{
2186	/* If one of them is a TYPE_DECL, it loses. */
2187	if (TREE_CODE (a) == TYPE_DECL)
2188	return +1;
2189	else if (TREE_CODE (b) == TYPE_DECL)
2190	return -1;
2191
2192	/* If one of them is a USING_DECL, it loses. */
2193	if (TREE_CODE (a) == USING_DECL)
2194	return +1;
2195	else if (TREE_CODE (b) == USING_DECL)
2196	return -1;
2197
2198	/* There are no other cases with different kinds of decls, as
2199	duplicate detection should have kicked in earlier. However,
2200	some erroneous cases get though. */
2201	gcc_assert (errorcount);
2202	}
2203
2204	/* Using source location would be the best thing here, but we can
2205	get identically-located decls in the following circumstances:
2206
2207	1) duplicate artificial type-decls for the same type.
2208
2209	2) pack expansions of using-decls.
2210
2211	We should not be doing #1, but in either case it doesn't matter
2212	how we order these. Use UID as a proxy for source ordering, so
2213	that identically-located decls still have a well-defined stable
2214	ordering. */
2215	if (DECL_UID (a) != DECL_UID (b))
2216	return DECL_UID (a) < DECL_UID (b) ? -1 : +1;
2217	gcc_assert (a == b);
2218	return 0;
2219	}
2220
2221	static struct {
2222	gt_pointer_operator new_value;
2223	void *cookie;
2224	} resort_data;
2225
2226	/* This routine compares two fields like member_name_cmp but using the
2227	pointer operator in resort_field_decl_data. We don't have to deal
2228	with duplicates here. */
2229
2230	static int
2231	resort_member_name_cmp (const void *a_p, const void *b_p)
2232	{
2233	tree a = *(const tree *)a_p;
2234	tree b = *(const tree *)b_p;
2235	tree name_a = OVL_NAME (a);
2236	tree name_b = OVL_NAME (b);
2237
2238	resort_data.new_value (&name_a, &name_a, resort_data.cookie);
2239	resort_data.new_value (&name_b, &name_b, resort_data.cookie);
2240
2241	gcc_checking_assert (name_a != name_b);
2242
2243	return name_a < name_b ? -1 : +1;
2244	}
2245
2246	/* Resort CLASSTYPE_MEMBER_VEC because pointers have been reordered. */
2247
2248	void
2249	resort_type_member_vec (void *obj, void */*orig_obj*/,
2250	gt_pointer_operator new_value, void* cookie)
2251	{
2252	if (vec<tree, va_gc> *member_vec = (vec<tree, va_gc> *) obj)
2253	{
2254	resort_data.new_value = new_value;
2255	resort_data.cookie = cookie;
2256	member_vec->qsort (resort_member_name_cmp);
2257	}
2258	}
2259
2260	/* Recursively count the number of fields in KLASS, including anonymous
2261	union members. */
2262
2263	static unsigned
2264	count_class_fields (tree klass)
2265	{
2266	unsigned n_fields = 0;
2267
2268	for (tree fields = TYPE_FIELDS (klass); fields; fields = DECL_CHAIN (fields))
2269	if (DECL_DECLARES_FUNCTION_P (fields))
2270	/* Functions are dealt with separately. */;
2271	else if (TREE_CODE (fields) == FIELD_DECL
2272	&& ANON_AGGR_TYPE_P (TREE_TYPE (fields)))
2273	n_fields += count_class_fields (TREE_TYPE (fields));
2274	else if (DECL_NAME (fields))
2275	n_fields += 1;
2276
2277	return n_fields;
2278	}
2279
2280	/* Append all the nonfunction members fields of KLASS to MEMBER_VEC.
2281	Recurse for anonymous members. MEMBER_VEC must have space. */
2282
2283	static void
2284	member_vec_append_class_fields (vec<tree, va_gc> *member_vec, tree klass)
2285	{
2286	for (tree fields = TYPE_FIELDS (klass); fields; fields = DECL_CHAIN (fields))
2287	if (DECL_DECLARES_FUNCTION_P (fields))
2288	/* Functions are handled separately. */;
2289	else if (TREE_CODE (fields) == FIELD_DECL
2290	&& ANON_AGGR_TYPE_P (TREE_TYPE (fields)))
2291	member_vec_append_class_fields (member_vec, TREE_TYPE (fields));
2292	else if (DECL_NAME (fields))
2293	{
2294	tree field = fields;
2295	/* Mark a conv-op USING_DECL with the conv-op-marker. */
2296	if (TREE_CODE (field) == USING_DECL
2297	&& IDENTIFIER_CONV_OP_P (DECL_NAME (field)))
2298	field = ovl_make (conv_op_marker, next: field);
2299	member_vec->quick_push (obj: field);
2300	}
2301	}
2302
2303	/* Append all of the enum values of ENUMTYPE to MEMBER_VEC.
2304	MEMBER_VEC must have space. */
2305
2306	static void
2307	member_vec_append_enum_values (vec<tree, va_gc> *member_vec, tree enumtype)
2308	{
2309	for (tree values = TYPE_VALUES (enumtype);
2310	values; values = TREE_CHAIN (values))
2311	member_vec->quick_push (TREE_VALUE (values));
2312	}
2313
2314	/* MEMBER_VEC has just had new DECLs added to it, but is sorted.
2315	DeDup adjacent DECLS of the same name. We already dealt with
2316	conflict resolution when adding the fields or methods themselves.
2317	There are four cases (which could all be combined):
2318	1) a TYPE_DECL and non TYPE_DECL. Deploy STAT_HACK as appropriate.
2319	2) a USING_DECL and an overload. If the USING_DECL is dependent,
2320	it wins. Otherwise the OVERLOAD does.
2321	3) two USING_DECLS.
2322	4) name-independent members plus others. ...
2323
2324	member_name_cmp will have ordered duplicates as
2325	<name_independent><fns><using><type> */
2326
2327	static void
2328	member_vec_dedup (vec<tree, va_gc> *member_vec)
2329	{
2330	unsigned len = member_vec->length ();
2331	unsigned store = 0;
2332
2333	if (!len)
2334	return;
2335
2336	tree name = OVL_NAME ((*member_vec)[0]);
2337	for (unsigned jx, ix = 0; ix < len; ix = jx)
2338	{
2339	tree current = NULL_TREE;
2340	tree to_type = NULL_TREE;
2341	tree to_using = NULL_TREE;
2342	tree marker = NULL_TREE;
2343	unsigned name_independent = ix;
2344
2345	for (jx = ix; jx < len; jx++)
2346	{
2347	tree next = (*member_vec)[jx];
2348	if (jx != ix)
2349	{
2350	tree next_name = OVL_NAME (next);
2351	if (next_name != name)
2352	{
2353	name = next_name;
2354	break;
2355	}
2356	}
2357
2358	if (IDENTIFIER_CONV_OP_P (name))
2359	{
2360	marker = next;
2361	next = OVL_CHAIN (next);
2362	}
2363
2364	if (TREE_CODE (next) == USING_DECL)
2365	{
2366	if (IDENTIFIER_CTOR_P (name))
2367	/* Dependent inherited ctor. */
2368	continue;
2369
2370	next = strip_using_decl (next);
2371	if (TREE_CODE (next) == USING_DECL)
2372	{
2373	to_using = next;
2374	continue;
2375	}
2376
2377	if (is_overloaded_fn (next))
2378	continue;
2379	}
2380
2381	if (DECL_DECLARES_TYPE_P (next))
2382	{
2383	to_type = next;
2384	continue;
2385	}
2386
2387	if (name_independent_decl_p (decl: next))
2388	name_independent = jx + 1;
2389	else if (!current)
2390	current = next;
2391	}
2392
2393	if (to_using)
2394	{
2395	if (!current)
2396	current = to_using;
2397	else
2398	current = ovl_make (fn: to_using, next: current);
2399	}
2400
2401	if (to_type)
2402	{
2403	if (!current)
2404	current = to_type;
2405	else
2406	current = stat_hack (decl: current, type: to_type);
2407	}
2408
2409	for (unsigned kx = name_independent; kx > ix; --kx)
2410	if (!current)
2411	current = (*member_vec)[kx - 1];
2412	else if (current == to_type)
2413	current = stat_hack (decl: (*member_vec)[kx - 1], type: to_type);
2414	else
2415	{
2416	current = ovl_make (fn: (*member_vec)[kx - 1], next: current);
2417	OVL_NAME_INDEPENDENT_DECL_P (current) = 1;
2418	}
2419
2420	if (current)
2421	{
2422	if (marker)
2423	{
2424	OVL_CHAIN (marker) = current;
2425	current = marker;
2426	}
2427	(*member_vec)[store++] = current;
2428	}
2429	}
2430
2431	while (store++ < len)
2432	member_vec->pop ();
2433	}
2434
2435	/* Add the non-function members to CLASSTYPE_MEMBER_VEC. If there is
2436	no existing MEMBER_VEC and fewer than 8 fields, do nothing. We
2437	know there must be at least 1 field -- the self-reference
2438	TYPE_DECL, except for anon aggregates, which will have at least
2439	one field anyway. If EXTRA < 0, always create the vector. */
2440
2441	vec<tree, va_gc> *
2442	set_class_bindings (tree klass, int extra)
2443	{
2444	unsigned n_fields = count_class_fields (klass);
2445	vec<tree, va_gc> *member_vec = CLASSTYPE_MEMBER_VEC (klass);
2446
2447	if (member_vec || n_fields >= 8 || extra < 0)
2448	{
2449	/* Append the new fields. */
2450	vec_safe_reserve_exact (v&: member_vec, nelems: n_fields + (extra >= 0 ? extra : 0));
2451	member_vec_append_class_fields (member_vec, klass);
2452	}
2453
2454	if (member_vec)
2455	{
2456	CLASSTYPE_MEMBER_VEC (klass) = member_vec;
2457	member_vec->qsort (member_name_cmp);
2458	member_vec_dedup (member_vec);
2459	}
2460
2461	return member_vec;
2462	}
2463
2464	/* Insert lately defined enum ENUMTYPE into KLASS for the sorted case. */
2465
2466	void
2467	insert_late_enum_def_bindings (tree klass, tree enumtype)
2468	{
2469	int n_fields;
2470	vec<tree, va_gc> *member_vec = CLASSTYPE_MEMBER_VEC (klass);
2471
2472	/* The enum bindings will already be on the TYPE_FIELDS, so don't
2473	count them twice. */
2474	if (!member_vec)
2475	n_fields = count_class_fields (klass);
2476	else
2477	n_fields = list_length (TYPE_VALUES (enumtype));
2478
2479	if (member_vec || n_fields >= 8)
2480	{
2481	vec_safe_reserve_exact (v&: member_vec, nelems: n_fields);
2482	if (CLASSTYPE_MEMBER_VEC (klass))
2483	member_vec_append_enum_values (member_vec, enumtype);
2484	else
2485	member_vec_append_class_fields (member_vec, klass);
2486	CLASSTYPE_MEMBER_VEC (klass) = member_vec;
2487	member_vec->qsort (member_name_cmp);
2488	member_vec_dedup (member_vec);
2489	}
2490	}
2491
2492	/* The binding oracle; see cp-tree.h. */
2493
2494	cp_binding_oracle_function *cp_binding_oracle;
2495
2496	/* If we have a binding oracle, ask it for all namespace-scoped
2497	definitions of NAME. */
2498
2499	static inline void
2500	query_oracle (tree name)
2501	{
2502	if (!cp_binding_oracle)
2503	return;
2504
2505	/* LOOKED_UP holds the set of identifiers that we have already
2506	looked up with the oracle. */
2507	static hash_set<tree> looked_up;
2508	if (looked_up.add (k: name))
2509	return;
2510
2511	cp_binding_oracle (CP_ORACLE_IDENTIFIER, name);
2512	}
2513
2514	#ifndef ENABLE_SCOPE_CHECKING
2515	# define ENABLE_SCOPE_CHECKING 0
2516	#else
2517	# define ENABLE_SCOPE_CHECKING 1
2518	#endif
2519
2520	/* A free list of "cxx_binding"s, connected by their PREVIOUS. */
2521
2522	static GTY((deletable)) cxx_binding *free_bindings;
2523
2524	/* Initialize VALUE and TYPE field for BINDING, and set the PREVIOUS
2525	field to NULL. */
2526
2527	static inline void
2528	cxx_binding_init (cxx_binding *binding, tree value, tree type)
2529	{
2530	binding->value = value;
2531	binding->type = type;
2532	binding->previous = NULL;
2533	}
2534
2535	/* (GC)-allocate a binding object with VALUE and TYPE member initialized. */
2536
2537	static cxx_binding *
2538	cxx_binding_make (tree value, tree type)
2539	{
2540	cxx_binding *binding = free_bindings;
2541
2542	if (binding)
2543	free_bindings = binding->previous;
2544	else
2545	binding = ggc_alloc<cxx_binding> ();
2546
2547	/* Clear flags by default. */
2548	LOCAL_BINDING_P (binding) = false;
2549	INHERITED_VALUE_BINDING_P (binding) = false;
2550	HIDDEN_TYPE_BINDING_P (binding) = false;
2551
2552	cxx_binding_init (binding, value, type);
2553
2554	return binding;
2555	}
2556
2557	/* Put BINDING back on the free list. */
2558
2559	static inline void
2560	cxx_binding_free (cxx_binding *binding)
2561	{
2562	binding->scope = NULL;
2563	binding->previous = free_bindings;
2564	free_bindings = binding;
2565	}
2566
2567	/* Create a new binding for NAME (with the indicated VALUE and TYPE
2568	bindings) in the class scope indicated by SCOPE. */
2569
2570	static cxx_binding *
2571	new_class_binding (tree name, tree value, tree type, cp_binding_level *scope)
2572	{
2573	cp_class_binding cb = {.base: cxx_binding_make (value, type), .identifier: name};
2574	cxx_binding *binding = cb.base;
2575	vec_safe_push (v&: scope->class_shadowed, obj: cb);
2576	binding->scope = scope;
2577	return binding;
2578	}
2579
2580	/* Make DECL the innermost binding for ID. The LEVEL is the binding
2581	level at which this declaration is being bound. */
2582
2583	void
2584	push_binding (tree id, tree decl, cp_binding_level* level)
2585	{
2586	cxx_binding *binding;
2587
2588	if (level != class_binding_level)
2589	{
2590	binding = cxx_binding_make (value: decl, NULL_TREE);
2591	binding->scope = level;
2592	}
2593	else
2594	binding = new_class_binding (name: id, value: decl, /*type=*/NULL_TREE, scope: level);
2595
2596	/* Now, fill in the binding information. */
2597	binding->previous = IDENTIFIER_BINDING (id);
2598	LOCAL_BINDING_P (binding) = (level != class_binding_level);
2599
2600	/* And put it on the front of the list of bindings for ID. */
2601	IDENTIFIER_BINDING (id) = binding;
2602	}
2603
2604	/* Remove the binding for DECL which should be the innermost binding
2605	for ID. */
2606
2607	void
2608	pop_local_binding (tree id, tree decl)
2609	{
2610	if (!id || IDENTIFIER_ANON_P (id))
2611	/* It's easiest to write the loops that call this function without
2612	checking whether or not the entities involved have names. We
2613	get here for such an entity. */
2614	return;
2615
2616	/* Get the innermost binding for ID. */
2617	cxx_binding *binding = IDENTIFIER_BINDING (id);
2618
2619	/* The name should be bound. */
2620	gcc_assert (binding != NULL);
2621
2622	/* The DECL will be either the ordinary binding or the type binding
2623	for this identifier. Remove that binding. We don't have to
2624	clear HIDDEN_TYPE_BINDING_P, as the whole binding will be going
2625	away. */
2626	if (binding->value == decl)
2627	binding->value = NULL_TREE;
2628	else if (binding->type == decl)
2629	binding->type = NULL_TREE;
2630	else
2631	{
2632	/* Name-independent variable was found after at least one declaration
2633	with the same name. */
2634	gcc_assert (TREE_CODE (binding->value) == TREE_LIST);
2635	if (TREE_VALUE (binding->value) != decl)
2636	{
2637	binding->value = nreverse (binding->value);
2638	/* Skip over TREE_LISTs added in pushdecl for check_local_shadow
2639	detected declarations, formerly at the tail, now at the start
2640	of the list. */
2641	while (TREE_PURPOSE (binding->value) == error_mark_node)
2642	binding->value = TREE_CHAIN (binding->value);
2643	}
2644	gcc_assert (TREE_VALUE (binding->value) == decl);
2645	binding->value = TREE_CHAIN (binding->value);
2646	while (binding->value
2647	&& TREE_PURPOSE (binding->value) == error_mark_node)
2648	binding->value = TREE_CHAIN (binding->value);
2649	}
2650
2651	if (!binding->value && !binding->type)
2652	{
2653	/* We're completely done with the innermost binding for this
2654	identifier. Unhook it from the list of bindings. */
2655	IDENTIFIER_BINDING (id) = binding->previous;
2656
2657	/* Add it to the free list. */
2658	cxx_binding_free (binding);
2659	}
2660	}
2661
2662	/* Remove the bindings for the decls of the current level and leave
2663	the current scope. */
2664
2665	void
2666	pop_bindings_and_leave_scope (void)
2667	{
2668	for (tree t = get_local_decls (); t; t = DECL_CHAIN (t))
2669	{
2670	tree decl = TREE_CODE (t) == TREE_LIST ? TREE_VALUE (t) : t;
2671	tree name = OVL_NAME (decl);
2672
2673	pop_local_binding (id: name, decl);
2674	}
2675
2676	leave_scope ();
2677	}
2678
2679	/* Strip non dependent using declarations. If DECL is dependent,
2680	surreptitiously create a typename_type and return it. */
2681
2682	tree
2683	strip_using_decl (tree decl)
2684	{
2685	if (decl == NULL_TREE)
2686	return NULL_TREE;
2687
2688	while (TREE_CODE (decl) == USING_DECL && !DECL_DEPENDENT_P (decl))
2689	decl = USING_DECL_DECLS (decl);
2690
2691	if (TREE_CODE (decl) == USING_DECL && DECL_DEPENDENT_P (decl)
2692	&& USING_DECL_TYPENAME_P (decl))
2693	{
2694	/* We have found a type introduced by a using
2695	declaration at class scope that refers to a dependent
2696	type.
2697
2698	using typename :: [opt] nested-name-specifier unqualified-id ;
2699	*/
2700	decl = make_typename_type (USING_DECL_SCOPE (decl),
2701	DECL_NAME (decl),
2702	typename_type, tf_error);
2703	if (decl != error_mark_node)
2704	decl = TYPE_NAME (decl);
2705	}
2706
2707	return decl;
2708	}
2709
2710	/* Return true if OVL is an overload for an anticipated builtin. */
2711
2712	static bool
2713	anticipated_builtin_p (tree ovl)
2714	{
2715	return (TREE_CODE (ovl) == OVERLOAD
2716	&& OVL_HIDDEN_P (ovl)
2717	&& DECL_IS_UNDECLARED_BUILTIN (OVL_FUNCTION (ovl)));
2718	}
2719
2720	/* BINDING records an existing declaration for a name in the current scope.
2721	But, DECL is another declaration for that same identifier in the
2722	same scope. This is the `struct stat' hack whereby a non-typedef
2723	class name or enum-name can be bound at the same level as some other
2724	kind of entity.
2725	3.3.7/1
2726
2727	A class name (9.1) or enumeration name (7.2) can be hidden by the
2728	name of an object, function, or enumerator declared in the same scope.
2729	If a class or enumeration name and an object, function, or enumerator
2730	are declared in the same scope (in any order) with the same name, the
2731	class or enumeration name is hidden wherever the object, function, or
2732	enumerator name is visible.
2733
2734	It's the responsibility of the caller to check that
2735	inserting this name is valid here. Returns nonzero if the new binding
2736	was successful. */
2737
2738	static bool
2739	supplement_binding (cxx_binding *binding, tree decl)
2740	{
2741	auto_cond_timevar tv (TV_NAME_LOOKUP);
2742
2743	tree bval = binding->value;
2744	bool ok = true;
2745	if (bval
2746	&& TREE_CODE (bval) == TREE_LIST
2747	&& name_independent_decl_p (TREE_VALUE (bval)))
2748	bval = TREE_VALUE (bval);
2749	tree target_bval = strip_using_decl (decl: bval);
2750	tree target_decl = strip_using_decl (decl);
2751
2752	if (TREE_CODE (target_decl) == TYPE_DECL && DECL_ARTIFICIAL (target_decl)
2753	&& target_decl != target_bval
2754	&& (TREE_CODE (target_bval) != TYPE_DECL
2755	/* We allow pushing an enum multiple times in a class
2756	template in order to handle late matching of underlying
2757	type on an opaque-enum-declaration followed by an
2758	enum-specifier. */
2759	|| (processing_template_decl
2760	&& TREE_CODE (TREE_TYPE (target_decl)) == ENUMERAL_TYPE
2761	&& TREE_CODE (TREE_TYPE (target_bval)) == ENUMERAL_TYPE
2762	&& (dependent_type_p (ENUM_UNDERLYING_TYPE
2763	(TREE_TYPE (target_decl)))
2764	|| dependent_type_p (ENUM_UNDERLYING_TYPE
2765	(TREE_TYPE (target_bval)))))))
2766	/* The new name is the type name. */
2767	binding->type = decl;
2768	else if (/* TARGET_BVAL is null when push_class_level_binding moves
2769	an inherited type-binding out of the way to make room
2770	for a new value binding. */
2771	!target_bval
2772	/* TARGET_BVAL is error_mark_node when TARGET_DECL's name
2773	has been used in a non-class scope prior declaration.
2774	In that case, we should have already issued a
2775	diagnostic; for graceful error recovery purpose, pretend
2776	this was the intended declaration for that name. */
2777	|| target_bval == error_mark_node
2778	/* If TARGET_BVAL is anticipated but has not yet been
2779	declared, pretend it is not there at all. */
2780	|| anticipated_builtin_p (ovl: target_bval))
2781	binding->value = decl;
2782	else if (TREE_CODE (target_bval) == TYPE_DECL
2783	&& DECL_ARTIFICIAL (target_bval)
2784	&& target_decl != target_bval
2785	&& (TREE_CODE (target_decl) != TYPE_DECL
2786	|| same_type_p (TREE_TYPE (target_decl),
2787	TREE_TYPE (target_bval))))
2788	{
2789	/* The old binding was a type name. It was placed in
2790	VALUE field because it was thought, at the point it was
2791	declared, to be the only entity with such a name. Move the
2792	type name into the type slot; it is now hidden by the new
2793	binding. */
2794	binding->type = bval;
2795	binding->value = decl;
2796	binding->value_is_inherited = false;
2797	}
2798	else if (TREE_CODE (target_bval) == TYPE_DECL
2799	&& TREE_CODE (target_decl) == TYPE_DECL
2800	&& DECL_NAME (target_decl) == DECL_NAME (target_bval)
2801	&& binding->scope->kind != sk_class
2802	&& (same_type_p (TREE_TYPE (target_decl), TREE_TYPE (target_bval))
2803	/* If either type involves template parameters, we must
2804	wait until instantiation. */
2805	|| uses_template_parms (TREE_TYPE (target_decl))
2806	|| uses_template_parms (TREE_TYPE (target_bval))))
2807	/* We have two typedef-names, both naming the same type to have
2808	the same name. In general, this is OK because of:
2809
2810	[dcl.typedef]
2811
2812	In a given scope, a typedef specifier can be used to redefine
2813	the name of any type declared in that scope to refer to the
2814	type to which it already refers.
2815
2816	However, in class scopes, this rule does not apply due to the
2817	stricter language in [class.mem] prohibiting redeclarations of
2818	members. */
2819	ok = false;
2820	/* There can be two block-scope declarations of the same variable,
2821	so long as they are `extern' declarations. However, there cannot
2822	be two declarations of the same static data member:
2823
2824	[class.mem]
2825
2826	A member shall not be declared twice in the
2827	member-specification. */
2828	else if (VAR_P (target_decl)
2829	&& VAR_P (target_bval)
2830	&& DECL_EXTERNAL (target_decl) && DECL_EXTERNAL (target_bval)
2831	&& !DECL_CLASS_SCOPE_P (target_decl))
2832	{
2833	duplicate_decls (decl, binding->value);
2834	ok = false;
2835	}
2836	else if (TREE_CODE (decl) == NAMESPACE_DECL
2837	&& TREE_CODE (bval) == NAMESPACE_DECL
2838	&& DECL_NAMESPACE_ALIAS (decl)
2839	&& DECL_NAMESPACE_ALIAS (bval)
2840	&& ORIGINAL_NAMESPACE (bval) == ORIGINAL_NAMESPACE (decl))
2841	/* [namespace.alias]
2842
2843	In a declarative region, a namespace-alias-definition can be
2844	used to redefine a namespace-alias declared in that declarative
2845	region to refer only to the namespace to which it already
2846	refers. */
2847	ok = false;
2848	else if (TREE_CODE (bval) == USING_DECL
2849	&& CONST_DECL_USING_P (decl))
2850	/* Let the clone hide the using-decl that introduced it. */
2851	binding->value = decl;
2852	else if (name_independent_decl_p (decl))
2853	{
2854	if (cxx_dialect < cxx26)
2855	pedwarn (DECL_SOURCE_LOCATION (decl), OPT_Wc__26_extensions,
2856	"name-independent declarations only available with "
2857	"%<-std=c++2c%> or %<-std=gnu++2c%>");
2858	binding->value = name_lookup::ambiguous (thing: decl, current: binding->value);
2859	}
2860	else
2861	{
2862	if (!error_operand_p (t: bval))
2863	diagnose_name_conflict (decl, bval);
2864	ok = false;
2865	}
2866
2867	return ok;
2868	}
2869
2870	/* Diagnose a name conflict between DECL and BVAL.
2871
2872	This is non-static so maybe_push_used_methods can use it and avoid changing
2873	the diagnostic for inherit/using4.C; otherwise it should not be used from
2874	outside this file. */
2875
2876	void
2877	diagnose_name_conflict (tree decl, tree bval)
2878	{
2879	if (TREE_CODE (decl) == TREE_CODE (bval)
2880	&& TREE_CODE (decl) != NAMESPACE_DECL
2881	&& !DECL_DECLARES_FUNCTION_P (decl)
2882	&& (TREE_CODE (decl) != TYPE_DECL
2883	|| DECL_ARTIFICIAL (decl) == DECL_ARTIFICIAL (bval))
2884	&& CP_DECL_CONTEXT (decl) == CP_DECL_CONTEXT (bval))
2885	{
2886	if (concept_definition_p (t: decl))
2887	error ("redeclaration of %q#D with different template parameters",
2888	decl);
2889	else
2890	error ("redeclaration of %q#D", decl);
2891	}
2892	else
2893	error ("%q#D conflicts with a previous declaration", decl);
2894
2895	inform (location_of (bval), "previous declaration %q#D", bval);
2896	}
2897
2898	/* Replace BINDING's current value on its scope's name list with
2899	NEWVAL. */
2900
2901	static void
2902	update_local_overload (cxx_binding *binding, tree newval)
2903	{
2904	tree *d;
2905
2906	for (d = &binding->scope->names; ; d = &TREE_CHAIN (*d))
2907	if (*d == binding->value)
2908	{
2909	/* Stitch new list node in. */
2910	*d = tree_cons (DECL_NAME (*d), NULL_TREE, TREE_CHAIN (*d));
2911	break;
2912	}
2913	else if (TREE_CODE (*d) == TREE_LIST && TREE_VALUE (*d) == binding->value)
2914	break;
2915
2916	TREE_VALUE (*d) = newval;
2917	}
2918
2919	/* Compares the parameter-type-lists of ONE and TWO and
2920	returns false if they are different. If the DECLs are template
2921	functions, the return types and the template parameter lists are
2922	compared too (DR 565). */
2923
2924	static bool
2925	matching_fn_p (tree one, tree two)
2926	{
2927	if (TREE_CODE (one) != TREE_CODE (two))
2928	return false;
2929
2930	if (!compparms (TYPE_ARG_TYPES (TREE_TYPE (one)),
2931	TYPE_ARG_TYPES (TREE_TYPE (two))))
2932	return false;
2933
2934	if (TREE_CODE (one) == TEMPLATE_DECL)
2935	{
2936	/* Compare template parms. */
2937	if (!comp_template_parms (DECL_TEMPLATE_PARMS (one),
2938	DECL_TEMPLATE_PARMS (two)))
2939	return false;
2940
2941	/* And return type. */
2942	if (!same_type_p (TREE_TYPE (TREE_TYPE (one)),
2943	TREE_TYPE (TREE_TYPE (two))))
2944	return false;
2945	}
2946
2947	if (!equivalently_constrained (one, two))
2948	return false;
2949
2950	return true;
2951	}
2952
2953	/* Push DECL into nonclass LEVEL BINDING or SLOT. OLD is the current
2954	binding value (possibly with anticipated builtins stripped).
2955	Diagnose conflicts and return updated decl. */
2956
2957	static tree
2958	update_binding (cp_binding_level *level, cxx_binding *binding, tree *slot,
2959	tree old, tree decl, bool hiding = false)
2960	{
2961	tree old_type = NULL_TREE;
2962	bool hide_type = false;
2963	bool hide_value = false;
2964	bool name_independent_p = false;
2965
2966	if (!slot)
2967	{
2968	old_type = binding->type;
2969	hide_type = HIDDEN_TYPE_BINDING_P (binding);
2970	if (!old_type)
2971	hide_value = hide_type, hide_type = false;
2972	name_independent_p = name_independent_decl_p (decl);
2973	}
2974	else if (STAT_HACK_P (*slot))
2975	{
2976	old_type = STAT_TYPE (*slot);
2977	hide_type = STAT_TYPE_HIDDEN_P (*slot);
2978	hide_value = STAT_DECL_HIDDEN_P (*slot);
2979	}
2980
2981	tree to_val = decl;
2982	tree to_type = old_type;
2983	bool local_overload = false;
2984
2985	gcc_assert (!level || level->kind == sk_namespace ? !binding
2986	: level->kind != sk_class && !slot);
2987
2988	if (old == error_mark_node)
2989	old = NULL_TREE;
2990
2991	if (DECL_IMPLICIT_TYPEDEF_P (decl))
2992	{
2993	/* Pushing an artificial decl. We should not find another
2994	artificial decl here already -- lookup_elaborated_type will
2995	have already found it. */
2996	gcc_checking_assert (!to_type
2997	&& !(old && DECL_IMPLICIT_TYPEDEF_P (old)));
2998
2999	if (old)
3000	{
3001	/* Put DECL into the type slot. */
3002	gcc_checking_assert (!to_type);
3003	hide_type = hiding;
3004	to_type = decl;
3005	to_val = old;
3006	}
3007	else
3008	hide_value = hiding;
3009
3010	goto done;
3011	}
3012
3013	if (old && DECL_IMPLICIT_TYPEDEF_P (old))
3014	{
3015	/* OLD is an implicit typedef. Move it to to_type. */
3016	gcc_checking_assert (!to_type);
3017
3018	to_type = old;
3019	hide_type = hide_value;
3020	old = NULL_TREE;
3021	hide_value = false;
3022	}
3023
3024	if (DECL_DECLARES_FUNCTION_P (decl))
3025	{
3026	if (!old)
3027	;
3028	else if (OVL_P (old))
3029	{
3030	for (ovl_iterator iter (old); iter; ++iter)
3031	{
3032	tree fn = *iter;
3033
3034	if (iter.using_p () && matching_fn_p (one: fn, two: decl))
3035	{
3036	gcc_checking_assert (!iter.hidden_p ());
3037	/* If a function declaration in namespace scope or
3038	block scope has the same name and the same
3039	parameter-type- list (8.3.5) as a function
3040	introduced by a using-declaration, and the
3041	declarations do not declare the same function,
3042	the program is ill-formed. [namespace.udecl]/14 */
3043	if (tree match = duplicate_decls (decl, fn, hiding))
3044	return match;
3045	else
3046	/* FIXME: To preserve existing error behavior, we
3047	still push the decl. This might change. */
3048	diagnose_name_conflict (decl, bval: fn);
3049	}
3050	}
3051	}
3052	else
3053	goto conflict;
3054
3055	if (to_type != old_type
3056	&& warn_shadow
3057	&& MAYBE_CLASS_TYPE_P (TREE_TYPE (to_type))
3058	&& !(DECL_IN_SYSTEM_HEADER (decl)
3059	&& DECL_IN_SYSTEM_HEADER (to_type)))
3060	warning (OPT_Wshadow, "%q#D hides constructor for %q#D",
3061	decl, to_type);
3062
3063	local_overload = old && level && level->kind != sk_namespace;
3064	to_val = ovl_insert (fn: decl, maybe_ovl: old, using_or_hidden: -int (hiding));
3065	}
3066	else if (old)
3067	{
3068	if (name_independent_p)
3069	to_val = name_lookup::ambiguous (thing: decl, current: old);
3070	else if (TREE_CODE (old) != TREE_CODE (decl))
3071	/* Different kinds of decls conflict. */
3072	goto conflict;
3073	else if (TREE_CODE (old) == TYPE_DECL)
3074	{
3075	if (same_type_p (TREE_TYPE (old), TREE_TYPE (decl)))
3076	/* Two type decls to the same type. Do nothing. */
3077	return old;
3078	else
3079	goto conflict;
3080	}
3081	else if (TREE_CODE (old) == NAMESPACE_DECL)
3082	{
3083	/* Two maybe-aliased namespaces. If they're to the same target
3084	namespace, that's ok. */
3085	if (ORIGINAL_NAMESPACE (old) != ORIGINAL_NAMESPACE (decl))
3086	goto conflict;
3087
3088	/* The new one must be an alias at this point. */
3089	gcc_assert (DECL_NAMESPACE_ALIAS (decl));
3090	return old;
3091	}
3092	else if (TREE_CODE (old) == VAR_DECL)
3093	{
3094	/* There can be two block-scope declarations of the same
3095	variable, so long as they are `extern' declarations. */
3096	if (!DECL_EXTERNAL (old) || !DECL_EXTERNAL (decl))
3097	goto conflict;
3098	else if (tree match = duplicate_decls (decl, old))
3099	{
3100	gcc_checking_assert (!hide_value && !hiding);
3101	return match;
3102	}
3103	else
3104	goto conflict;
3105	}
3106	else
3107	{
3108	conflict:
3109	diagnose_name_conflict (decl, bval: old);
3110	to_val = NULL_TREE;
3111	}
3112	}
3113	else if (hiding)
3114	hide_value = true;
3115
3116	done:
3117	if (to_val)
3118	{
3119	if (local_overload)
3120	{
3121	gcc_checking_assert (binding->value && OVL_P (binding->value));
3122	update_local_overload (binding, newval: to_val);
3123	}
3124	else if (level
3125	&& !(TREE_CODE (decl) == NAMESPACE_DECL
3126	&& !DECL_NAMESPACE_ALIAS (decl)))
3127	/* Don't add namespaces here. They're done in
3128	push_namespace. */
3129	add_decl_to_level (b: level, decl);
3130
3131	if (slot)
3132	{
3133	if (STAT_HACK_P (*slot))
3134	{
3135	STAT_TYPE (*slot) = to_type;
3136	STAT_DECL (*slot) = to_val;
3137	STAT_TYPE_HIDDEN_P (*slot) = hide_type;
3138	STAT_DECL_HIDDEN_P (*slot) = hide_value;
3139	}
3140	else if (to_type || hide_value)
3141	{
3142	*slot = stat_hack (decl: to_val, type: to_type);
3143	STAT_TYPE_HIDDEN_P (*slot) = hide_type;
3144	STAT_DECL_HIDDEN_P (*slot) = hide_value;
3145	}
3146	else
3147	{
3148	gcc_checking_assert (!hide_type);
3149	*slot = to_val;
3150	}
3151	}
3152	else
3153	{
3154	binding->type = to_type;
3155	binding->value = to_val;
3156	HIDDEN_TYPE_BINDING_P (binding) = hide_type || hide_value;
3157	}
3158	}
3159
3160	return decl;
3161	}
3162
3163	/* Table of identifiers to extern C declarations (or LISTS thereof). */
3164
3165	static GTY(()) hash_table<named_decl_hash> *extern_c_decls;
3166
3167	/* DECL has C linkage. If we have an existing instance, make sure the
3168	new one is compatible. Make sure it has the same exception
3169	specification [7.5, 7.6]. Add DECL to the map. */
3170
3171	static void
3172	check_extern_c_conflict (tree decl)
3173	{
3174	/* Ignore artificial or system header decls. */
3175	if (DECL_ARTIFICIAL (decl) || DECL_IN_SYSTEM_HEADER (decl))
3176	return;
3177
3178	/* This only applies to decls at namespace scope. */
3179	if (!DECL_NAMESPACE_SCOPE_P (decl))
3180	return;
3181
3182	if (!extern_c_decls)
3183	extern_c_decls = hash_table<named_decl_hash>::create_ggc (n: 127);
3184
3185	tree *slot = extern_c_decls
3186	->find_slot_with_hash (DECL_NAME (decl),
3187	IDENTIFIER_HASH_VALUE (DECL_NAME (decl)), insert: INSERT);
3188	if (tree old = *slot)
3189	{
3190	if (TREE_CODE (old) == OVERLOAD)
3191	old = OVL_FUNCTION (old);
3192
3193	int mismatch = 0;
3194	if (DECL_CONTEXT (old) == DECL_CONTEXT (decl))
3195	; /* If they're in the same context, we'll have already complained
3196	about a (possible) mismatch, when inserting the decl. */
3197	else if (!decls_match (decl, old))
3198	mismatch = 1;
3199	else if (TREE_CODE (decl) == FUNCTION_DECL
3200	&& !comp_except_specs (TYPE_RAISES_EXCEPTIONS (TREE_TYPE (old)),
3201	TYPE_RAISES_EXCEPTIONS (TREE_TYPE (decl)),
3202	ce_normal))
3203	mismatch = -1;
3204	else if (DECL_ASSEMBLER_NAME_SET_P (old))
3205	SET_DECL_ASSEMBLER_NAME (decl, DECL_ASSEMBLER_NAME (old));
3206
3207	if (mismatch)
3208	{
3209	auto_diagnostic_group d;
3210	pedwarn (DECL_SOURCE_LOCATION (decl), 0,
3211	"conflicting C language linkage declaration %q#D", decl);
3212	inform (DECL_SOURCE_LOCATION (old),
3213	"previous declaration %q#D", old);
3214	if (mismatch < 0)
3215	inform (DECL_SOURCE_LOCATION (decl),
3216	"due to different exception specifications");
3217	}
3218	else
3219	{
3220	if (old == *slot)
3221	/* The hash table expects OVERLOADS, so construct one with
3222	OLD as both the function and the chain. This allocate
3223	an excess OVERLOAD node, but it's rare to have multiple
3224	extern "C" decls of the same name. And we save
3225	complicating the hash table logic (which is used
3226	elsewhere). */
3227	*slot = ovl_make (fn: old, next: old);
3228
3229	slot = &OVL_CHAIN (*slot);
3230
3231	/* Chain it on for c_linkage_binding's use. */
3232	*slot = tree_cons (NULL_TREE, decl, *slot);
3233	}
3234	}
3235	else
3236	*slot = decl;
3237	}
3238
3239	/* Returns a list of C-linkage decls with the name NAME. Used in
3240	c-family/c-pragma.cc to implement redefine_extname pragma. */
3241
3242	tree
3243	c_linkage_bindings (tree name)
3244	{
3245	if (extern_c_decls)
3246	if (tree *slot = extern_c_decls
3247	->find_slot_with_hash (comparable: name, IDENTIFIER_HASH_VALUE (name), insert: NO_INSERT))
3248	{
3249	tree result = *slot;
3250	if (TREE_CODE (result) == OVERLOAD)
3251	result = OVL_CHAIN (result);
3252	return result;
3253	}
3254
3255	return NULL_TREE;
3256	}
3257
3258	/* Subroutine of check_local_shadow. */
3259
3260	static void
3261	inform_shadowed (tree shadowed)
3262	{
3263	inform (DECL_SOURCE_LOCATION (shadowed),
3264	"shadowed declaration is here");
3265	}
3266
3267	/* DECL is being declared at a local scope. Emit suitable shadow
3268	warnings. */
3269
3270	static tree
3271	check_local_shadow (tree decl)
3272	{
3273	/* Don't complain about the parms we push and then pop
3274	while tentatively parsing a function declarator. */
3275	if (TREE_CODE (decl) == PARM_DECL && !DECL_CONTEXT (decl))
3276	return NULL_TREE;
3277
3278	if (DECL_FUNCTION_SCOPE_P (decl))
3279	{
3280	tree ctx = DECL_CONTEXT (decl);
3281	if (DECL_CLONED_FUNCTION_P (ctx)
3282	|| DECL_TEMPLATE_INSTANTIATED (ctx)
3283	|| (DECL_LANG_SPECIFIC (ctx)
3284	&& DECL_DEFAULTED_FN (ctx))
3285	|| (LAMBDA_FUNCTION_P (ctx)
3286	&& LAMBDA_EXPR_REGEN_INFO (CLASSTYPE_LAMBDA_EXPR
3287	(DECL_CONTEXT (ctx)))))
3288	/* It suffices to check shadowing only when actually parsing.
3289	So punt for clones, instantiations, defaulted functions and
3290	regenerated lambdas. This optimization helps reduce lazy
3291	loading cascades with modules. */
3292	return NULL_TREE;
3293	}
3294
3295	tree old = NULL_TREE;
3296	cp_binding_level *old_scope = NULL;
3297	if (cxx_binding *binding = outer_binding (DECL_NAME (decl), NULL, true))
3298	{
3299	old = binding->value;
3300	old_scope = binding->scope;
3301	}
3302
3303	if (old
3304	&& (TREE_CODE (old) == PARM_DECL
3305	|| VAR_P (old)
3306	|| (TREE_CODE (old) == TYPE_DECL
3307	&& (!DECL_ARTIFICIAL (old)
3308	|| TREE_CODE (decl) == TYPE_DECL)))
3309	&& DECL_FUNCTION_SCOPE_P (old)
3310	&& (!DECL_ARTIFICIAL (decl)
3311	|| is_capture_proxy (decl)
3312	|| DECL_IMPLICIT_TYPEDEF_P (decl)
3313	|| (VAR_P (decl) && DECL_ANON_UNION_VAR_P (decl))))
3314	{
3315	/* DECL shadows a local thing possibly of interest. */
3316
3317	/* DR 2211: check that captures and parameters
3318	do not have the same name. */
3319	if (is_capture_proxy (decl))
3320	{
3321	if (current_lambda_expr ()
3322	&& DECL_CONTEXT (old) == lambda_function (current_lambda_expr ())
3323	&& TREE_CODE (old) == PARM_DECL
3324	&& DECL_NAME (decl) != this_identifier)
3325	error_at (DECL_SOURCE_LOCATION (old),
3326	"lambda parameter %qD "
3327	"previously declared as a capture", old);
3328	return NULL_TREE;
3329	}
3330	/* Don't complain if it's from an enclosing function. */
3331	else if (DECL_CONTEXT (old) == current_function_decl
3332	&& TREE_CODE (decl) != PARM_DECL
3333	&& TREE_CODE (old) == PARM_DECL)
3334	{
3335	/* Go to where the parms should be and see if we find
3336	them there. */
3337	cp_binding_level *b = current_binding_level->level_chain;
3338
3339	if (in_function_try_handler && b->kind == sk_catch)
3340	b = b->level_chain;
3341
3342	/* Skip artificially added scopes which aren't present
3343	in the C++ standard, e.g. for function-try-block or
3344	ctor/dtor cleanups. */
3345	while (b->artificial)
3346	b = b->level_chain;
3347
3348	/* [basic.scope.param] A parameter name shall not be redeclared
3349	in the outermost block of the function definition. */
3350	if (b->kind == sk_function_parms)
3351	{
3352	if (name_independent_decl_p (decl))
3353	return old;
3354
3355	auto_diagnostic_group d;
3356	bool emit = true;
3357	if (DECL_EXTERNAL (decl))
3358	emit = pedwarn (DECL_SOURCE_LOCATION (decl), OPT_Wpedantic,
3359	"declaration of %q#D shadows a parameter",
3360	decl);
3361	else
3362	error_at (DECL_SOURCE_LOCATION (decl),
3363	"declaration of %q#D shadows a parameter", decl);
3364	if (emit)
3365	inform (DECL_SOURCE_LOCATION (old),
3366	"%q#D previously declared here", old);
3367	return NULL_TREE;
3368	}
3369	}
3370
3371	/* The local structure or class can't use parameters of
3372	the containing function anyway. */
3373	if (DECL_CONTEXT (old) != current_function_decl)
3374	{
3375	for (cp_binding_level *scope = current_binding_level;
3376	scope != old_scope; scope = scope->level_chain)
3377	if (scope->kind == sk_class
3378	&& !LAMBDA_TYPE_P (scope->this_entity))
3379	return NULL_TREE;
3380	}
3381	/* Error if redeclaring a local declared in a
3382	init-statement or in the condition of an if or
3383	switch statement when the new declaration is in the
3384	outermost block of the controlled statement.
3385	Redeclaring a variable from a for or while condition is
3386	detected elsewhere. */
3387	else if (VAR_P (old)
3388	&& old_scope == current_binding_level->level_chain
3389	&& (old_scope->kind == sk_cond || old_scope->kind == sk_for))
3390	{
3391	if (name_independent_decl_p (decl))
3392	return old;
3393
3394	auto_diagnostic_group d;
3395	bool emit = true;
3396	if (DECL_EXTERNAL (decl))
3397	emit = pedwarn (DECL_SOURCE_LOCATION (decl), OPT_Wpedantic,
3398	"redeclaration of %q#D", decl);
3399	else
3400	error_at (DECL_SOURCE_LOCATION (decl),
3401	"redeclaration of %q#D", decl);
3402	if (emit)
3403	inform (DECL_SOURCE_LOCATION (old),
3404	"%q#D previously declared here", old);
3405	return NULL_TREE;
3406	}
3407	/* C++11:
3408	3.3.3/3: The name declared in an exception-declaration (...)
3409	shall not be redeclared in the outermost block of the handler.
3410	3.3.3/2: A parameter name shall not be redeclared (...) in
3411	the outermost block of any handler associated with a
3412	function-try-block. */
3413	else if (TREE_CODE (old) == VAR_DECL
3414	&& old_scope == current_binding_level->level_chain
3415	&& old_scope->kind == sk_catch)
3416	{
3417	if (name_independent_decl_p (decl))
3418	return old;
3419
3420	auto_diagnostic_group d;
3421	bool emit;
3422	if (DECL_EXTERNAL (decl))
3423	emit = pedwarn (DECL_SOURCE_LOCATION (decl), OPT_Wpedantic,
3424	"redeclaration of %q#D", decl);
3425	else
3426	emit = permerror (DECL_SOURCE_LOCATION (decl),
3427	"redeclaration of %q#D", decl);
3428	if (emit)
3429	inform (DECL_SOURCE_LOCATION (old),
3430	"%q#D previously declared here", old);
3431	return NULL_TREE;
3432	}
3433
3434	/* Don't emit -Wshadow* warnings for name-independent decls. */
3435	if (name_independent_decl_p (decl) || name_independent_decl_p (decl: old))
3436	return NULL_TREE;
3437
3438	/* If '-Wshadow=compatible-local' is specified without other
3439	-Wshadow= flags, we will warn only when the type of the
3440	shadowing variable (DECL) can be converted to that of the
3441	shadowed parameter (OLD_LOCAL). The reason why we only check
3442	if DECL's type can be converted to OLD_LOCAL's type (but not the
3443	other way around) is because when users accidentally shadow a
3444	parameter, more than often they would use the variable
3445	thinking (mistakenly) it's still the parameter. It would be
3446	rare that users would use the variable in the place that
3447	expects the parameter but thinking it's a new decl.
3448	If either object is a TYPE_DECL, '-Wshadow=compatible-local'
3449	warns regardless of whether one of the types involved
3450	is a subclass of the other, since that is never okay. */
3451
3452	enum opt_code warning_code;
3453	if (warn_shadow)
3454	warning_code = OPT_Wshadow;
3455	else if ((TREE_CODE (decl) == TYPE_DECL)
3456	^ (TREE_CODE (old) == TYPE_DECL))
3457	/* If exactly one is a type, they aren't compatible. */
3458	warning_code = OPT_Wshadow_local;
3459	else if ((TREE_TYPE (old)
3460	&& TREE_TYPE (decl)
3461	&& same_type_p (TREE_TYPE (old), TREE_TYPE (decl)))
3462	|| TREE_CODE (decl) == TYPE_DECL
3463	|| TREE_CODE (old) == TYPE_DECL
3464	|| (!dependent_type_p (TREE_TYPE (decl))
3465	&& !dependent_type_p (TREE_TYPE (old))
3466	/* If the new decl uses auto, we don't yet know
3467	its type (the old type cannot be using auto
3468	at this point, without also being
3469	dependent). This is an indication we're
3470	(now) doing the shadow checking too
3471	early. */
3472	&& !type_uses_auto (TREE_TYPE (decl))
3473	&& can_convert_arg (TREE_TYPE (old), TREE_TYPE (decl),
3474	decl, LOOKUP_IMPLICIT, tf_none)))
3475	warning_code = OPT_Wshadow_compatible_local;
3476	else
3477	warning_code = OPT_Wshadow_local;
3478
3479	const char *msg;
3480	if (TREE_CODE (old) == PARM_DECL)
3481	msg = "declaration of %q#D shadows a parameter";
3482	else if (is_capture_proxy (old))
3483	msg = "declaration of %qD shadows a lambda capture";
3484	else
3485	msg = "declaration of %qD shadows a previous local";
3486
3487	auto_diagnostic_group d;
3488	if (warning_at (DECL_SOURCE_LOCATION (decl), warning_code, msg, decl))
3489	inform_shadowed (shadowed: old);
3490	return NULL_TREE;
3491	}
3492
3493	if (!warn_shadow)
3494	return NULL_TREE;
3495
3496	/* Don't emit -Wshadow for name-independent decls. */
3497	if (name_independent_decl_p (decl))
3498	return NULL_TREE;
3499
3500	/* Don't warn for artificial things that are not implicit typedefs. */
3501	if (DECL_ARTIFICIAL (decl) && !DECL_IMPLICIT_TYPEDEF_P (decl))
3502	return NULL_TREE;
3503
3504	if (nonlambda_method_basetype ())
3505	if (tree member = lookup_member (current_nonlambda_class_type (),
3506	DECL_NAME (decl), /*protect=*/0,
3507	/*want_type=*/false, tf_warning_or_error))
3508	{
3509	member = MAYBE_BASELINK_FUNCTIONS (member);
3510
3511	/* Warn if a variable shadows a non-function, or the variable
3512	is a function or a pointer-to-function. */
3513	if ((!OVL_P (member)
3514	|| TREE_CODE (decl) == FUNCTION_DECL
3515	|| (TREE_TYPE (decl)
3516	&& (TYPE_PTRFN_P (TREE_TYPE (decl))
3517	|| TYPE_PTRMEMFUNC_P (TREE_TYPE (decl)))))
3518	&& !warning_suppressed_p (decl, OPT_Wshadow))
3519	{
3520	auto_diagnostic_group d;
3521	if (warning_at (DECL_SOURCE_LOCATION (decl), OPT_Wshadow,
3522	"declaration of %qD shadows a member of %qT",
3523	decl, current_nonlambda_class_type ())
3524	&& DECL_P (member))
3525	{
3526	inform_shadowed (shadowed: member);
3527	suppress_warning (decl, OPT_Wshadow);
3528	}
3529	}
3530	return NULL_TREE;
3531	}
3532
3533	/* Now look for a namespace shadow. */
3534	old = find_namespace_value (current_namespace, DECL_NAME (decl));
3535	if (old
3536	&& (VAR_P (old)
3537	|| (TREE_CODE (old) == TYPE_DECL
3538	&& (!DECL_ARTIFICIAL (old)
3539	|| TREE_CODE (decl) == TYPE_DECL)))
3540	&& !DECL_EXTERNAL (decl)
3541	&& !instantiating_current_function_p ()
3542	&& !warning_suppressed_p (decl, OPT_Wshadow))
3543	/* XXX shadow warnings in outer-more namespaces */
3544	{
3545	auto_diagnostic_group d;
3546	if (warning_at (DECL_SOURCE_LOCATION (decl), OPT_Wshadow,
3547	"declaration of %qD shadows a global declaration",
3548	decl))
3549	{
3550	inform_shadowed (shadowed: old);
3551	suppress_warning (decl, OPT_Wshadow);
3552	}
3553	return NULL_TREE;
3554	}
3555
3556	return NULL_TREE;
3557	}
3558
3559	/* DECL is being pushed inside function CTX. Set its context, if
3560	needed. */
3561
3562	static void
3563	set_decl_context_in_fn (tree ctx, tree decl)
3564	{
3565	if (TREE_CODE (decl) == FUNCTION_DECL
3566	|| (VAR_P (decl) && DECL_EXTERNAL (decl)))
3567	/* Make sure local externs are marked as such. OMP UDRs really
3568	are nested functions. */
3569	gcc_checking_assert (DECL_LOCAL_DECL_P (decl)
3570	&& (DECL_NAMESPACE_SCOPE_P (decl)
3571	|| (TREE_CODE (decl) == FUNCTION_DECL
3572	&& DECL_OMP_DECLARE_REDUCTION_P (decl))));
3573
3574	if (!DECL_CONTEXT (decl)
3575	/* When parsing the parameter list of a function declarator,
3576	don't set DECL_CONTEXT to an enclosing function. */
3577	&& !(TREE_CODE (decl) == PARM_DECL
3578	&& parsing_function_declarator ()))
3579	DECL_CONTEXT (decl) = ctx;
3580	}
3581
3582	/* DECL is a local extern decl. Find or create the namespace-scope
3583	decl that it aliases. Also, determines the linkage of DECL. */
3584
3585	void
3586	push_local_extern_decl_alias (tree decl)
3587	{
3588	if (dependent_type_p (TREE_TYPE (decl))
3589	|| (processing_template_decl
3590	&& VAR_P (decl)
3591	&& CP_DECL_THREAD_LOCAL_P (decl)))
3592	return;
3593	/* EH specs were not part of the function type prior to c++17, but
3594	we still can't go pushing dependent eh specs into the namespace. */
3595	if (cxx_dialect < cxx17
3596	&& TREE_CODE (decl) == FUNCTION_DECL
3597	&& (value_dependent_expression_p
3598	(TYPE_RAISES_EXCEPTIONS (TREE_TYPE (decl)))))
3599	return;
3600
3601	gcc_checking_assert (!DECL_LANG_SPECIFIC (decl)
3602	|| !DECL_TEMPLATE_INFO (decl));
3603	if (DECL_LANG_SPECIFIC (decl) && DECL_LOCAL_DECL_ALIAS (decl))
3604	/* We're instantiating a non-dependent local decl, it already
3605	knows the alias. */
3606	return;
3607
3608	tree alias = NULL_TREE;
3609
3610	if (DECL_SIZE (decl) && !TREE_CONSTANT (DECL_SIZE (decl)))
3611	/* Do not let a VLA creep into a namespace. Diagnostic will be
3612	emitted in layout_var_decl later. */
3613	alias = error_mark_node;
3614	else
3615	{
3616	/* First look for a decl that matches. */
3617	tree ns = CP_DECL_CONTEXT (decl);
3618	tree binding = find_namespace_value (ns, DECL_NAME (decl));
3619
3620	if (binding && TREE_CODE (binding) != TREE_LIST)
3621	for (ovl_iterator iter (binding); iter; ++iter)
3622	if (decls_match (decl, *iter, /*record_versions*/false))
3623	{
3624	alias = *iter;
3625	break;
3626	}
3627
3628	if (!alias)
3629	{
3630	/* No existing namespace-scope decl. Make one. */
3631	alias = copy_decl (decl);
3632	if (TREE_CODE (alias) == FUNCTION_DECL)
3633	{
3634	/* Recontextualize the parms. */
3635	for (tree *chain = &DECL_ARGUMENTS (alias);
3636	*chain; chain = &DECL_CHAIN (*chain))
3637	{
3638	*chain = copy_decl (*chain);
3639	DECL_CONTEXT (*chain) = alias;
3640	}
3641
3642	tree type = TREE_TYPE (alias);
3643	for (tree args = TYPE_ARG_TYPES (type);
3644	args; args = TREE_CHAIN (args))
3645	if (TREE_PURPOSE (args))
3646	{
3647	/* There are default args. Lose them. */
3648	tree nargs = NULL_TREE;
3649	tree *chain = &nargs;
3650	for (args = TYPE_ARG_TYPES (type);
3651	args; args = TREE_CHAIN (args))
3652	if (args == void_list_node)
3653	{
3654	*chain = args;
3655	break;
3656	}
3657	else
3658	{
3659	*chain
3660	= build_tree_list (NULL_TREE, TREE_VALUE (args));
3661	chain = &TREE_CHAIN (*chain);
3662	}
3663
3664	tree fn_type = build_function_type (TREE_TYPE (type), nargs);
3665
3666	fn_type = apply_memfn_quals
3667	(fn_type, type_memfn_quals (type));
3668
3669	fn_type = build_cp_fntype_variant
3670	(fn_type, type_memfn_rqual (type),
3671	TYPE_RAISES_EXCEPTIONS (type),
3672	TYPE_HAS_LATE_RETURN_TYPE (type));
3673
3674	TREE_TYPE (alias) = fn_type;
3675	break;
3676	}
3677	}
3678
3679	/* This is the real thing. */
3680	DECL_LOCAL_DECL_P (alias) = false;
3681
3682	/* Expected default linkage is from the namespace. */
3683	TREE_PUBLIC (alias) = TREE_PUBLIC (ns);
3684	push_nested_namespace (ns);
3685	alias = pushdecl (alias, /* hiding= */true);
3686	pop_nested_namespace (ns);
3687	if (VAR_P (decl)
3688	&& CP_DECL_THREAD_LOCAL_P (decl)
3689	&& alias != error_mark_node)
3690	set_decl_tls_model (alias, DECL_TLS_MODEL (decl));
3691
3692	/* Adjust visibility. */
3693	determine_visibility (alias);
3694	}
3695	}
3696
3697	retrofit_lang_decl (decl);
3698	DECL_LOCAL_DECL_ALIAS (decl) = alias;
3699	}
3700
3701	/* If DECL has non-internal linkage, and we have a module vector,
3702	record it in the appropriate slot. We have already checked for
3703	duplicates. */
3704
3705	static void
3706	maybe_record_mergeable_decl (tree *slot, tree name, tree decl)
3707	{
3708	if (TREE_CODE (*slot) != BINDING_VECTOR)
3709	return;
3710
3711	if (!TREE_PUBLIC (CP_DECL_CONTEXT (decl)))
3712	/* Member of internal namespace. */
3713	return;
3714
3715	tree not_tmpl = STRIP_TEMPLATE (decl);
3716	if ((TREE_CODE (not_tmpl) == FUNCTION_DECL
3717	|| VAR_P (not_tmpl))
3718	&& DECL_THIS_STATIC (not_tmpl))
3719	/* Internal linkage. */
3720	return;
3721
3722	bool is_attached = (DECL_LANG_SPECIFIC (not_tmpl)
3723	&& DECL_MODULE_ATTACH_P (not_tmpl));
3724	tree *gslot = get_fixed_binding_slot
3725	(slot, name, ix: is_attached ? BINDING_SLOT_PARTITION : BINDING_SLOT_GLOBAL,
3726	create: true);
3727
3728	if (!is_attached)
3729	{
3730	binding_slot &orig
3731	= BINDING_VECTOR_CLUSTER (*slot, 0).slots[BINDING_SLOT_CURRENT];
3732
3733	if (!STAT_HACK_P (tree (orig)))
3734	orig = stat_hack (decl: tree (orig));
3735
3736	MODULE_BINDING_GLOBAL_P (tree (orig)) = true;
3737	}
3738
3739	add_mergeable_namespace_entity (slot: gslot, decl);
3740	}
3741
3742	/* DECL is being pushed. Check whether it hides or ambiguates
3743	something seen as an import. This include decls seen in our own
3744	interface, which is OK. Also, check for merging a
3745	global/partition decl. */
3746
3747	static tree
3748	check_module_override (tree decl, tree mvec, bool hiding,
3749	tree scope, tree name)
3750	{
3751	tree match = NULL_TREE;
3752	bitmap imports = get_import_bitmap ();
3753	binding_cluster *cluster = BINDING_VECTOR_CLUSTER_BASE (mvec);
3754	unsigned ix = BINDING_VECTOR_NUM_CLUSTERS (mvec);
3755
3756	if (BINDING_VECTOR_SLOTS_PER_CLUSTER == BINDING_SLOTS_FIXED)
3757	{
3758	cluster++;
3759	ix--;
3760	}
3761
3762	for (; ix--; cluster++)
3763	for (unsigned jx = 0; jx != BINDING_VECTOR_SLOTS_PER_CLUSTER; jx++)
3764	{
3765	/* Are we importing this module? */
3766	if (cluster->indices[jx].span != 1)
3767	continue;
3768	if (!cluster->indices[jx].base)
3769	continue;
3770	if (!bitmap_bit_p (imports, cluster->indices[jx].base))
3771	continue;
3772	/* Is it loaded? */
3773	if (cluster->slots[jx].is_lazy ())
3774	{
3775	gcc_assert (cluster->indices[jx].span == 1);
3776	lazy_load_binding (mod: cluster->indices[jx].base,
3777	ns: scope, id: name, bslot: &cluster->slots[jx]);
3778	}
3779	tree bind = cluster->slots[jx];
3780	if (!bind)
3781	/* Errors could cause there to be nothing. */
3782	continue;
3783
3784	if (STAT_HACK_P (bind))
3785	/* We do not have to check STAT_TYPE here, the xref_tag
3786	machinery deals with that problem. */
3787	bind = STAT_VISIBLE (bind);
3788
3789	for (ovl_iterator iter (bind); iter; ++iter)
3790	if (!iter.using_p ())
3791	{
3792	match = duplicate_decls (decl, *iter, hiding);
3793	if (match)
3794	goto matched;
3795	}
3796	}
3797
3798	if (TREE_PUBLIC (scope) && TREE_PUBLIC (STRIP_TEMPLATE (decl))
3799	/* Namespaces are dealt with specially in
3800	make_namespace_finish. */
3801	&& !(TREE_CODE (decl) == NAMESPACE_DECL && !DECL_NAMESPACE_ALIAS (decl)))
3802	{
3803	/* Look in the appropriate mergeable decl slot. */
3804	tree mergeable = NULL_TREE;
3805	if (named_module_p ())
3806	mergeable = BINDING_VECTOR_CLUSTER (mvec, BINDING_SLOT_PARTITION
3807	/ BINDING_VECTOR_SLOTS_PER_CLUSTER)
3808	.slots[BINDING_SLOT_PARTITION % BINDING_VECTOR_SLOTS_PER_CLUSTER];
3809	else
3810	mergeable = BINDING_VECTOR_CLUSTER (mvec, 0).slots[BINDING_SLOT_GLOBAL];
3811
3812	for (ovl_iterator iter (mergeable); iter; ++iter)
3813	{
3814	match = duplicate_decls (decl, *iter, hiding);
3815	if (match)
3816	goto matched;
3817	}
3818	}
3819
3820	return NULL_TREE;
3821
3822	matched:
3823	if (match != error_mark_node)
3824	{
3825	if (named_module_p ())
3826	BINDING_VECTOR_PARTITION_DUPS_P (mvec) = true;
3827	else
3828	BINDING_VECTOR_GLOBAL_DUPS_P (mvec) = true;
3829	}
3830
3831	return match;
3832
3833
3834	}
3835
3836	/* Record DECL as belonging to the current lexical scope. Check for
3837	errors (such as an incompatible declaration for the same name
3838	already seen in the same scope).
3839
3840	The new binding is hidden if HIDING is true (an anticipated builtin
3841	or hidden friend).
3842
3843	Returns either DECL or an old decl for the same name. If an old
3844	decl is returned, it may have been smashed to agree with what DECL
3845	says. */
3846
3847	tree
3848	pushdecl (tree decl, bool hiding)
3849	{
3850	auto_cond_timevar tv (TV_NAME_LOOKUP);
3851
3852	if (decl == error_mark_node)
3853	return error_mark_node;
3854
3855	if (!DECL_TEMPLATE_PARM_P (decl) && current_function_decl && !hiding)
3856	set_decl_context_in_fn (ctx: current_function_decl, decl);
3857
3858	/* The binding level we will be pushing into. During local class
3859	pushing, we want to push to the containing scope. */
3860	cp_binding_level *level = current_binding_level;
3861	while (level->kind == sk_class
3862	|| level->kind == sk_cleanup)
3863	level = level->level_chain;
3864
3865	/* An anonymous namespace has a NULL DECL_NAME, but we still want to
3866	insert it. Other NULL-named decls, not so much. */
3867	tree name = DECL_NAME (decl);
3868	if (name ? !IDENTIFIER_ANON_P (name) : TREE_CODE (decl) == NAMESPACE_DECL)
3869	{
3870	cxx_binding *binding = NULL; /* Local scope binding. */
3871	tree ns = NULL_TREE; /* Searched namespace. */
3872	tree *slot = NULL; /* Binding slot in namespace. */
3873	tree *mslot = NULL; /* Current module slot in namespace. */
3874	tree old = NULL_TREE;
3875	bool name_independent_p = false;
3876	bool name_independent_diagnosed_p = false;
3877
3878	if (level->kind == sk_namespace)
3879	{
3880	/* We look in the decl's namespace for an existing
3881	declaration, even though we push into the current
3882	namespace. */
3883	ns = (DECL_NAMESPACE_SCOPE_P (decl)
3884	? CP_DECL_CONTEXT (decl) : current_namespace);
3885	/* Create the binding, if this is current namespace, because
3886	that's where we'll be pushing anyway. */
3887	slot = find_namespace_slot (ns, name, create_p: ns == current_namespace);
3888	if (slot)
3889	{
3890	mslot = get_fixed_binding_slot (slot, name, ix: BINDING_SLOT_CURRENT,
3891	create: ns == current_namespace);
3892	old = MAYBE_STAT_DECL (*mslot);
3893	}
3894	}
3895	else
3896	{
3897	binding = find_local_binding (b: level, name);
3898	if (binding)
3899	old = binding->value;
3900	name_independent_p = name_independent_decl_p (decl);
3901	}
3902
3903	if (old == error_mark_node)
3904	old = NULL_TREE;
3905
3906	tree oldi, oldn;
3907	for (oldi = old; oldi; oldi = oldn)
3908	{
3909	if (TREE_CODE (oldi) == TREE_LIST)
3910	{
3911	gcc_checking_assert (level->kind != sk_namespace
3912	&& name_independent_decl_p
3913	(TREE_VALUE (old)));
3914	oldn = TREE_CHAIN (oldi);
3915	oldi = TREE_VALUE (oldi);
3916	}
3917	else
3918	oldn = NULL_TREE;
3919	for (ovl_iterator iter (oldi); iter; ++iter)
3920	if (iter.using_p ())
3921	; /* Ignore using decls here. */
3922	else if (iter.hidden_p ()
3923	&& TREE_CODE (*iter) == FUNCTION_DECL
3924	&& DECL_LANG_SPECIFIC (*iter)
3925	&& DECL_MODULE_IMPORT_P (*iter))
3926	; /* An undeclared builtin imported from elsewhere. */
3927	else if (name_independent_p)
3928	{
3929	/* Ignore name-independent declarations. */
3930	if (cxx_dialect < cxx26 && !name_independent_diagnosed_p)
3931	pedwarn (DECL_SOURCE_LOCATION (decl), OPT_Wc__26_extensions,
3932	"name-independent declarations only available with "
3933	"%<-std=c++2c%> or %<-std=gnu++2c%>");
3934	name_independent_diagnosed_p = true;
3935	}
3936	else if (tree match
3937	= duplicate_decls (decl, *iter, hiding, was_hidden: iter.hidden_p ()))
3938	{
3939	if (match == error_mark_node)
3940	;
3941	else if (TREE_CODE (match) == TYPE_DECL)
3942	gcc_checking_assert (REAL_IDENTIFIER_TYPE_VALUE (name)
3943	== (level->kind == sk_namespace
3944	? NULL_TREE : TREE_TYPE (match)));
3945	else if (iter.hidden_p () && !hiding)
3946	{
3947	/* Unhiding a previously hidden decl. */
3948	tree head = iter.reveal_node (head: oldi);
3949	if (head != oldi)
3950	{
3951	gcc_checking_assert (ns);
3952	if (STAT_HACK_P (*slot))
3953	STAT_DECL (*slot) = head;
3954	else
3955	*slot = head;
3956	}
3957	if (DECL_EXTERN_C_P (match))
3958	/* We need to check and register the decl now. */
3959	check_extern_c_conflict (decl: match);
3960	}
3961	else if (slot
3962	&& !hiding
3963	&& STAT_HACK_P (*slot)
3964	&& STAT_DECL_HIDDEN_P (*slot))
3965	{
3966	/* Unhide the non-function. */
3967	gcc_checking_assert (oldi == match);
3968	if (!STAT_TYPE (*slot))
3969	*slot = match;
3970	else
3971	STAT_DECL (*slot) = match;
3972	}
3973	return match;
3974	}
3975	}
3976
3977	/* Check for redeclaring an import. */
3978	if (slot && *slot && TREE_CODE (*slot) == BINDING_VECTOR)
3979	if (tree match
3980	= check_module_override (decl, mvec: *slot, hiding, scope: ns, name))
3981	{
3982	if (match == error_mark_node)
3983	return match;
3984
3985	/* We found a decl in an interface, push it into this
3986	binding. */
3987	decl = update_binding (NULL, binding, slot: mslot, old,
3988	decl: match, hiding);
3989
3990	return decl;
3991	}
3992
3993	/* We are pushing a new decl. */
3994
3995	/* Skip a hidden builtin we failed to match already. There can
3996	only be one. */
3997	if (old && anticipated_builtin_p (ovl: old))
3998	old = OVL_CHAIN (old);
3999
4000	check_template_shadow (decl);
4001
4002	if (DECL_DECLARES_FUNCTION_P (decl))
4003	{
4004	check_default_args (decl);
4005
4006	if (hiding)
4007	{
4008	if (level->kind != sk_namespace)
4009	{
4010	/* In a local class, a friend function declaration must
4011	find a matching decl in the innermost non-class scope.
4012	[class.friend/11] */
4013	error_at (DECL_SOURCE_LOCATION (decl),
4014	"friend declaration %qD in local class without "
4015	"prior local declaration", decl);
4016	/* Don't attempt to push it. */
4017	return error_mark_node;
4018	}
4019	}
4020	}
4021
4022	if (level->kind != sk_namespace)
4023	{
4024	tree local_shadow = check_local_shadow (decl);
4025	if (name_independent_p && local_shadow)
4026	{
4027	if (cxx_dialect < cxx26 && !name_independent_diagnosed_p)
4028	pedwarn (DECL_SOURCE_LOCATION (decl), OPT_Wc__26_extensions,
4029	"name-independent declarations only available with "
4030	"%<-std=c++2c%> or %<-std=gnu++2c%>");
4031	name_independent_diagnosed_p = true;
4032	/* When a name-independent declaration is pushed into a scope
4033	which itself does not contain a _ named declaration yet (so
4034	_ name lookups wouldn't be normally ambiguous), but it
4035	shadows a _ declaration in some outer scope in cases
4036	described in [basic.scope.block]/2 where if the names of
4037	the shadowed and shadowing declarations were different it
4038	would be ill-formed program, arrange for _ name lookups
4039	in this scope to be ambiguous. */
4040	if (old == NULL_TREE)
4041	{
4042	old = build_tree_list (error_mark_node, local_shadow);
4043	TREE_TYPE (old) = error_mark_node;
4044	}
4045	}
4046
4047	if (TREE_CODE (decl) == NAMESPACE_DECL)
4048	/* A local namespace alias. */
4049	set_identifier_type_value_with_scope (id: name, NULL_TREE, b: level);
4050
4051	if (!binding)
4052	binding = create_local_binding (level, name);
4053	}
4054	else if (!slot)
4055	{
4056	ns = current_namespace;
4057	slot = find_namespace_slot (ns, name, create_p: true);
4058	mslot = get_fixed_binding_slot (slot, name, ix: BINDING_SLOT_CURRENT, create: true);
4059	/* Update OLD to reflect the namespace we're going to be
4060	pushing into. */
4061	old = MAYBE_STAT_DECL (*mslot);
4062	}
4063
4064	old = update_binding (level, binding, slot: mslot, old, decl, hiding);
4065
4066	if (old != decl)
4067	/* An existing decl matched, use it. */
4068	decl = old;
4069	else
4070	{
4071	if (TREE_CODE (decl) == TYPE_DECL)
4072	{
4073	tree type = TREE_TYPE (decl);
4074
4075	if (type != error_mark_node)
4076	{
4077	if (TYPE_NAME (type) != decl)
4078	set_underlying_type (decl);
4079
4080	set_identifier_type_value_with_scope (id: name, decl, b: level);
4081
4082	if (level->kind != sk_namespace
4083	&& !instantiating_current_function_p ())
4084	/* This is a locally defined typedef in a function that
4085	is not a template instantation, record it to implement
4086	-Wunused-local-typedefs. */
4087	record_locally_defined_typedef (decl);
4088	}
4089	}
4090	else if (VAR_OR_FUNCTION_DECL_P (decl))
4091	{
4092	if (DECL_EXTERN_C_P (decl))
4093	check_extern_c_conflict (decl);
4094
4095	if (!DECL_LOCAL_DECL_P (decl)
4096	&& VAR_P (decl))
4097	maybe_register_incomplete_var (decl);
4098
4099	if (DECL_LOCAL_DECL_P (decl)
4100	&& NAMESPACE_SCOPE_P (decl))
4101	push_local_extern_decl_alias (decl);
4102	}
4103
4104	if (level->kind == sk_namespace
4105	&& TREE_PUBLIC (level->this_entity)
4106	&& module_p ())
4107	maybe_record_mergeable_decl (slot, name, decl);
4108	}
4109	}
4110	else
4111	add_decl_to_level (b: level, decl);
4112
4113	return decl;
4114	}
4115
4116	/* A mergeable entity is being loaded into namespace NS slot NAME.
4117	Create and return the appropriate vector slot for that. Either a
4118	GMF slot or a module-specific one. */
4119
4120	tree *
4121	mergeable_namespace_slots (tree ns, tree name, bool is_attached, tree *vec)
4122	{
4123	tree *mslot = find_namespace_slot (ns, name, create_p: true);
4124	tree *vslot = get_fixed_binding_slot
4125	(slot: mslot, name, ix: is_attached ? BINDING_SLOT_PARTITION : BINDING_SLOT_GLOBAL,
4126	create: true);
4127
4128	gcc_checking_assert (TREE_CODE (*mslot) == BINDING_VECTOR);
4129	*vec = *mslot;
4130
4131	return vslot;
4132	}
4133
4134	/* DECL is a new mergeable namespace-scope decl. Add it to the
4135	mergeable entities on GSLOT. */
4136
4137	void
4138	add_mergeable_namespace_entity (tree *gslot, tree decl)
4139	{
4140	*gslot = ovl_make (fn: decl, next: *gslot);
4141	}
4142
4143	/* A mergeable entity of KLASS called NAME is being loaded. Return
4144	the set of things it could be. All such non-as_base classes have
4145	been given a member vec. */
4146
4147	tree
4148	lookup_class_binding (tree klass, tree name)
4149	{
4150	tree found = NULL_TREE;
4151
4152	if (!COMPLETE_TYPE_P (klass))
4153	;
4154	else if (TYPE_LANG_SPECIFIC (klass))
4155	{
4156	vec<tree, va_gc> *member_vec = CLASSTYPE_MEMBER_VEC (klass);
4157
4158	found = member_vec_binary_search (member_vec, name);
4159	if (!found)
4160	;
4161	else if (STAT_HACK_P (found))
4162	/* Rearrange the stat hack so that we don't need to expose that
4163	internal detail. */
4164	found = ovl_make (STAT_TYPE (found), STAT_DECL (found));
4165	else if (IDENTIFIER_CONV_OP_P (name))
4166	{
4167	gcc_checking_assert (name == conv_op_identifier);
4168	found = OVL_CHAIN (found);
4169	}
4170	}
4171	else
4172	{
4173	gcc_checking_assert (IS_FAKE_BASE_TYPE (klass)
4174	|| TYPE_PTRMEMFUNC_P (klass));
4175	found = fields_linear_search (klass, name, want_type: false);
4176	}
4177
4178	return found;
4179	}
4180
4181	/* Given a namespace-level binding BINDING, walk it, calling CALLBACK
4182	for all decls of the current module. When partitions are involved,
4183	decls might be mentioned more than once. Return the accumulation of
4184	CALLBACK results. */
4185
4186	unsigned
4187	walk_module_binding (tree binding, bitmap partitions,
4188	bool (*callback) (tree decl, WMB_Flags, void *data),
4189	void *data)
4190	{
4191	// FIXME: We don't quite deal with using decls naming stat hack
4192	// type.
4193	tree current = binding;
4194	unsigned count = 0;
4195
4196	if (TREE_CODE (binding) == BINDING_VECTOR)
4197	current = BINDING_VECTOR_CLUSTER (binding, 0).slots[BINDING_SLOT_CURRENT];
4198
4199	bool decl_hidden = false;
4200	if (tree type = MAYBE_STAT_TYPE (current))
4201	{
4202	WMB_Flags flags = WMB_None;
4203	if (STAT_TYPE_HIDDEN_P (current))
4204	flags = WMB_Flags (flags | WMB_Hidden);
4205	count += callback (type, flags, data);
4206	decl_hidden = STAT_DECL_HIDDEN_P (current);
4207	}
4208
4209	for (ovl_iterator iter (MAYBE_STAT_DECL (current)); iter; ++iter)
4210	{
4211	if (iter.hidden_p ())
4212	decl_hidden = true;
4213	if (!(decl_hidden && DECL_IS_UNDECLARED_BUILTIN (*iter)))
4214	{
4215	WMB_Flags flags = WMB_None;
4216	if (decl_hidden)
4217	flags = WMB_Flags (flags | WMB_Hidden);
4218	if (iter.using_p ())
4219	{
4220	flags = WMB_Flags (flags | WMB_Using);
4221	if (iter.exporting_p ())
4222	flags = WMB_Flags (flags | WMB_Export);
4223	}
4224	count += callback (*iter, flags, data);
4225	}
4226	decl_hidden = false;
4227	}
4228
4229	if (partitions && TREE_CODE (binding) == BINDING_VECTOR)
4230	{
4231	/* Process partition slots. */
4232	binding_cluster *cluster = BINDING_VECTOR_CLUSTER_BASE (binding);
4233	unsigned ix = BINDING_VECTOR_NUM_CLUSTERS (binding);
4234	if (BINDING_VECTOR_SLOTS_PER_CLUSTER == BINDING_SLOTS_FIXED)
4235	{
4236	ix--;
4237	cluster++;
4238	}
4239
4240	bool maybe_dups = BINDING_VECTOR_PARTITION_DUPS_P (binding);
4241
4242	for (; ix--; cluster++)
4243	for (unsigned jx = 0; jx != BINDING_VECTOR_SLOTS_PER_CLUSTER; jx++)
4244	if (!cluster->slots[jx].is_lazy ())
4245	if (tree bind = cluster->slots[jx])
4246	{
4247	if (TREE_CODE (bind) == NAMESPACE_DECL
4248	&& !DECL_NAMESPACE_ALIAS (bind))
4249	{
4250	if (unsigned base = cluster->indices[jx].base)
4251	if (unsigned span = cluster->indices[jx].span)
4252	do
4253	if (bitmap_bit_p (partitions, base))
4254	goto found;
4255	while (++base, --span);
4256	/* Not a partition's namespace. */
4257	continue;
4258	found:
4259
4260	WMB_Flags flags = WMB_None;
4261	if (maybe_dups)
4262	flags = WMB_Flags (flags | WMB_Dups);
4263	count += callback (bind, flags, data);
4264	}
4265	else if (STAT_HACK_P (bind) && MODULE_BINDING_PARTITION_P (bind))
4266	{
4267	if (tree btype = STAT_TYPE (bind))
4268	{
4269	WMB_Flags flags = WMB_None;
4270	if (maybe_dups)
4271	flags = WMB_Flags (flags | WMB_Dups);
4272	if (STAT_TYPE_HIDDEN_P (bind))
4273	flags = WMB_Flags (flags | WMB_Hidden);
4274
4275	count += callback (btype, flags, data);
4276	}
4277	bool hidden = STAT_DECL_HIDDEN_P (bind);
4278	for (ovl_iterator iter (MAYBE_STAT_DECL (STAT_DECL (bind)));
4279	iter; ++iter)
4280	{
4281	if (iter.hidden_p ())
4282	hidden = true;
4283	gcc_checking_assert
4284	(!(hidden && DECL_IS_UNDECLARED_BUILTIN (*iter)));
4285
4286	WMB_Flags flags = WMB_None;
4287	if (maybe_dups)
4288	flags = WMB_Flags (flags | WMB_Dups);
4289	if (decl_hidden)
4290	flags = WMB_Flags (flags | WMB_Hidden);
4291	if (iter.using_p ())
4292	{
4293	flags = WMB_Flags (flags | WMB_Using);
4294	if (iter.exporting_p ())
4295	flags = WMB_Flags (flags | WMB_Export);
4296	}
4297	count += callback (*iter, flags, data);
4298	hidden = false;
4299	}
4300	}
4301	}
4302	}
4303
4304	return count;
4305	}
4306
4307	/* Imported module MOD has a binding to NS::NAME, stored in section
4308	SNUM. */
4309
4310	bool
4311	import_module_binding (tree ns, tree name, unsigned mod, unsigned snum)
4312	{
4313	tree *slot = find_namespace_slot (ns, name, create_p: true);
4314	binding_slot *mslot = append_imported_binding_slot (slot, name, ix: mod);
4315
4316	if (mslot->is_lazy () || *mslot)
4317	/* Oops, something was already there. */
4318	return false;
4319
4320	mslot->set_lazy (snum);
4321	return true;
4322	}
4323
4324	/* An import of MODULE is binding NS::NAME. There should be no
4325	existing binding for >= MODULE. MOD_GLOB indicates whether MODULE
4326	is a header_unit (-1) or part of the current module (+1). VALUE
4327	and TYPE are the value and type bindings. VISIBLE are the value
4328	bindings being exported. */
4329
4330	bool
4331	set_module_binding (tree ns, tree name, unsigned mod, int mod_glob,
4332	tree value, tree type, tree visible)
4333	{
4334	if (!value)
4335	/* Bogus BMIs could give rise to nothing to bind. */
4336	return false;
4337
4338	gcc_assert (TREE_CODE (value) != NAMESPACE_DECL
4339	|| DECL_NAMESPACE_ALIAS (value));
4340	gcc_checking_assert (mod);
4341
4342	tree *slot = find_namespace_slot (ns, name, create_p: true);
4343	binding_slot *mslot = search_imported_binding_slot (slot, ix: mod);
4344
4345	if (!mslot || !mslot->is_lazy ())
4346	/* Again, bogus BMI could give find to missing or already loaded slot. */
4347	return false;
4348
4349	tree bind = value;
4350	if (type || visible != bind || mod_glob)
4351	{
4352	bind = stat_hack (decl: bind, type);
4353	STAT_VISIBLE (bind) = visible;
4354	if ((mod_glob > 0 && TREE_PUBLIC (ns))
4355	|| (type && DECL_MODULE_EXPORT_P (type)))
4356	STAT_TYPE_VISIBLE_P (bind) = true;
4357	}
4358
4359	/* Note if this is this-module or global binding. */
4360	if (mod_glob > 0)
4361	MODULE_BINDING_PARTITION_P (bind) = true;
4362	else if (mod_glob < 0)
4363	MODULE_BINDING_GLOBAL_P (bind) = true;
4364
4365	*mslot = bind;
4366
4367	return true;
4368	}
4369
4370	void
4371	add_module_namespace_decl (tree ns, tree decl)
4372	{
4373	gcc_assert (!DECL_CHAIN (decl));
4374	gcc_checking_assert (!(VAR_OR_FUNCTION_DECL_P (decl)
4375	&& DECL_LOCAL_DECL_P (decl)));
4376	if (CHECKING_P)
4377	/* Expensive already-there? check. */
4378	for (auto probe = NAMESPACE_LEVEL (ns)->names; probe;
4379	probe = DECL_CHAIN (probe))
4380	gcc_assert (decl != probe);
4381
4382	add_decl_to_level (NAMESPACE_LEVEL (ns), decl);
4383
4384	if (VAR_P (decl))
4385	maybe_register_incomplete_var (decl);
4386
4387	if (VAR_OR_FUNCTION_DECL_P (decl)
4388	&& DECL_EXTERN_C_P (decl))
4389	check_extern_c_conflict (decl);
4390	}
4391
4392	/* Enter DECL into the symbol table, if that's appropriate. Returns
4393	DECL, or a modified version thereof. */
4394
4395	tree
4396	maybe_push_decl (tree decl)
4397	{
4398	tree type = TREE_TYPE (decl);
4399
4400	/* Add this decl to the current binding level, but not if it comes
4401	from another scope, e.g. a static member variable. TEM may equal
4402	DECL or it may be a previous decl of the same name. */
4403	if (decl == error_mark_node
4404	|| (TREE_CODE (decl) != PARM_DECL
4405	&& DECL_CONTEXT (decl) != NULL_TREE
4406	/* Definitions of namespace members outside their namespace are
4407	possible. */
4408	&& !DECL_NAMESPACE_SCOPE_P (decl))
4409	|| (TREE_CODE (decl) == TEMPLATE_DECL && !namespace_bindings_p ())
4410	|| type == unknown_type_node
4411	/* The declaration of a template specialization does not affect
4412	the functions available for overload resolution, so we do not
4413	call pushdecl. */
4414	|| (TREE_CODE (decl) == FUNCTION_DECL
4415	&& DECL_TEMPLATE_SPECIALIZATION (decl)))
4416	return decl;
4417	else
4418	return pushdecl (decl);
4419	}
4420
4421	/* Bind DECL to ID in the current_binding_level, assumed to be a local
4422	binding level. If IS_USING is true, DECL got here through a
4423	using-declaration. */
4424
4425	static void
4426	push_local_binding (tree id, tree decl, bool is_using)
4427	{
4428	/* Skip over any local classes. This makes sense if we call
4429	push_local_binding with a friend decl of a local class. */
4430	cp_binding_level *b = innermost_nonclass_level ();
4431
4432	gcc_assert (b->kind != sk_namespace);
4433	if (find_local_binding (b, name: id))
4434	{
4435	/* Supplement the existing binding. */
4436	if (!supplement_binding (IDENTIFIER_BINDING (id), decl))
4437	/* It didn't work. Something else must be bound at this
4438	level. Do not add DECL to the list of things to pop
4439	later. */
4440	return;
4441	}
4442	else
4443	/* Create a new binding. */
4444	push_binding (id, decl, level: b);
4445
4446	if (TREE_CODE (decl) == OVERLOAD || is_using)
4447	/* We must put the OVERLOAD or using into a TREE_LIST since we
4448	cannot use the decl's chain itself. */
4449	decl = build_tree_list (id, decl);
4450
4451	/* And put DECL on the list of things declared by the current
4452	binding level. */
4453	add_decl_to_level (b, decl);
4454	}
4455
4456
4457	/* true means unconditionally make a BLOCK for the next level pushed. */
4458
4459	static bool keep_next_level_flag;
4460
4461	static int binding_depth = 0;
4462
4463	static void
4464	indent (int depth)
4465	{
4466	int i;
4467
4468	for (i = 0; i < depth * 2; i++)
4469	putc (c: ' ', stderr);
4470	}
4471
4472	/* Return a string describing the kind of SCOPE we have. */
4473	static const char *
4474	cp_binding_level_descriptor (cp_binding_level *scope)
4475	{
4476	/* The order of this table must match the "scope_kind"
4477	enumerators. */
4478	static const char* scope_kind_names[] = {
4479	"block-scope",
4480	"cleanup-scope",
4481	"try-scope",
4482	"catch-scope",
4483	"for-scope",
4484	"cond-init-scope",
4485	"stmt-expr-scope",
4486	"function-parameter-scope",
4487	"class-scope",
4488	"enum-scope",
4489	"namespace-scope",
4490	"template-parameter-scope",
4491	"template-explicit-spec-scope",
4492	"transaction-scope",
4493	"openmp-scope"
4494	};
4495	static_assert (ARRAY_SIZE (scope_kind_names) == sk_count,
4496	"must keep names aligned with scope_kind enum");
4497
4498	scope_kind kind = scope->kind;
4499	if (kind == sk_template_parms && scope->explicit_spec_p)
4500	kind = sk_template_spec;
4501
4502	return scope_kind_names[kind];
4503	}
4504
4505	/* Output a debugging information about SCOPE when performing
4506	ACTION at LINE. */
4507	static void
4508	cp_binding_level_debug (cp_binding_level *scope, int line, const char *action)
4509	{
4510	const char *desc = cp_binding_level_descriptor (scope);
4511	if (scope->this_entity)
4512	verbatim ("%s %<%s(%E)%> %p %d", action, desc,
4513	scope->this_entity, (void *) scope, line);
4514	else
4515	verbatim ("%s %s %p %d", action, desc, (void *) scope, line);
4516	}
4517
4518	/* A chain of binding_level structures awaiting reuse. */
4519
4520	static GTY((deletable)) cp_binding_level *free_binding_level;
4521
4522	/* Insert SCOPE as the innermost binding level. */
4523
4524	void
4525	push_binding_level (cp_binding_level *scope)
4526	{
4527	/* Add it to the front of currently active scopes stack. */
4528	scope->level_chain = current_binding_level;
4529	current_binding_level = scope;
4530	keep_next_level_flag = false;
4531
4532	if (ENABLE_SCOPE_CHECKING)
4533	{
4534	scope->binding_depth = binding_depth;
4535	indent (depth: binding_depth);
4536	cp_binding_level_debug (scope, LOCATION_LINE (input_location),
4537	action: "push");
4538	binding_depth++;
4539	}
4540	}
4541
4542	/* Create a new KIND scope and make it the top of the active scopes stack.
4543	ENTITY is the scope of the associated C++ entity (namespace, class,
4544	function, C++0x enumeration); it is NULL otherwise. */
4545
4546	cp_binding_level *
4547	begin_scope (scope_kind kind, tree entity)
4548	{
4549	cp_binding_level *scope;
4550
4551	/* Reuse or create a struct for this binding level. */
4552	if (!ENABLE_SCOPE_CHECKING && free_binding_level)
4553	{
4554	scope = free_binding_level;
4555	free_binding_level = scope->level_chain;
4556	memset (s: scope, c: 0, n: sizeof (cp_binding_level));
4557	}
4558	else
4559	scope = ggc_cleared_alloc<cp_binding_level> ();
4560
4561	scope->this_entity = entity;
4562	scope->more_cleanups_ok = true;
4563	switch (kind)
4564	{
4565	case sk_cleanup:
4566	scope->keep = true;
4567	break;
4568
4569	case sk_template_spec:
4570	scope->explicit_spec_p = true;
4571	kind = sk_template_parms;
4572	/* Fall through. */
4573	case sk_template_parms:
4574	case sk_block:
4575	case sk_try:
4576	case sk_catch:
4577	case sk_for:
4578	case sk_cond:
4579	case sk_class:
4580	case sk_scoped_enum:
4581	case sk_transaction:
4582	case sk_omp:
4583	case sk_stmt_expr:
4584	scope->keep = keep_next_level_flag;
4585	break;
4586
4587	case sk_function_parms:
4588	scope->keep = keep_next_level_flag;
4589	break;
4590
4591	case sk_namespace:
4592	NAMESPACE_LEVEL (entity) = scope;
4593	break;
4594
4595	default:
4596	/* Should not happen. */
4597	gcc_unreachable ();
4598	break;
4599	}
4600	scope->kind = kind;
4601
4602	push_binding_level (scope);
4603
4604	return scope;
4605	}
4606
4607	/* We're about to leave current scope. Pop the top of the stack of
4608	currently active scopes. Return the enclosing scope, now active. */
4609
4610	cp_binding_level *
4611	leave_scope (void)
4612	{
4613	cp_binding_level *scope = current_binding_level;
4614
4615	if (scope->kind == sk_namespace && class_binding_level)
4616	current_binding_level = class_binding_level;
4617
4618	/* We cannot leave a scope, if there are none left. */
4619	if (NAMESPACE_LEVEL (global_namespace))
4620	gcc_assert (!global_scope_p (scope));
4621
4622	if (ENABLE_SCOPE_CHECKING)
4623	{
4624	indent (depth: --binding_depth);
4625	cp_binding_level_debug (scope, LOCATION_LINE (input_location),
4626	action: "leave");
4627	}
4628
4629	/* Move one nesting level up. */
4630	current_binding_level = scope->level_chain;
4631
4632	/* Namespace-scopes are left most probably temporarily, not
4633	completely; they can be reopened later, e.g. in namespace-extension
4634	or any name binding activity that requires us to resume a
4635	namespace. For classes, we cache some binding levels. For other
4636	scopes, we just make the structure available for reuse. */
4637	if (scope->kind != sk_namespace
4638	&& scope != previous_class_level)
4639	{
4640	scope->level_chain = free_binding_level;
4641	gcc_assert (!ENABLE_SCOPE_CHECKING
4642	|| scope->binding_depth == binding_depth);
4643	free_binding_level = scope;
4644	}
4645
4646	if (scope->kind == sk_class)
4647	{
4648	/* Reset DEFINING_CLASS_P to allow for reuse of a
4649	class-defining scope in a non-defining context. */
4650	scope->defining_class_p = 0;
4651
4652	/* Find the innermost enclosing class scope, and reset
4653	CLASS_BINDING_LEVEL appropriately. */
4654	class_binding_level = NULL;
4655	for (scope = current_binding_level; scope; scope = scope->level_chain)
4656	if (scope->kind == sk_class)
4657	{
4658	class_binding_level = scope;
4659	break;
4660	}
4661	}
4662
4663	return current_binding_level;
4664	}
4665
4666	/* When we exit a toplevel class scope, we save its binding level so
4667	that we can restore it quickly. Here, we've entered some other
4668	class, so we must invalidate our cache. */
4669
4670	void
4671	invalidate_class_lookup_cache (void)
4672	{
4673	previous_class_level->level_chain = free_binding_level;
4674	free_binding_level = previous_class_level;
4675	previous_class_level = NULL;
4676	}
4677
4678	static void
4679	resume_scope (cp_binding_level* b)
4680	{
4681	/* Resuming binding levels is meant only for namespaces,
4682	and those cannot nest into classes. */
4683	gcc_assert (!class_binding_level);
4684	/* Also, resuming a non-directly nested namespace is a no-no. */
4685	gcc_assert (b->level_chain == current_binding_level);
4686	current_binding_level = b;
4687	if (ENABLE_SCOPE_CHECKING)
4688	{
4689	b->binding_depth = binding_depth;
4690	indent (depth: binding_depth);
4691	cp_binding_level_debug (scope: b, LOCATION_LINE (input_location), action: "resume");
4692	binding_depth++;
4693	}
4694	}
4695
4696	/* Return the innermost binding level that is not for a class scope. */
4697
4698	static cp_binding_level *
4699	innermost_nonclass_level (void)
4700	{
4701	cp_binding_level *b;
4702
4703	b = current_binding_level;
4704	while (b->kind == sk_class)
4705	b = b->level_chain;
4706
4707	return b;
4708	}
4709
4710	/* We're defining an object of type TYPE. If it needs a cleanup, but
4711	we're not allowed to add any more objects with cleanups to the current
4712	scope, create a new binding level. */
4713
4714	void
4715	maybe_push_cleanup_level (tree type)
4716	{
4717	if (type != error_mark_node
4718	&& TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type)
4719	&& current_binding_level->more_cleanups_ok == 0)
4720	{
4721	begin_scope (kind: sk_cleanup, NULL);
4722	current_binding_level->statement_list = push_stmt_list ();
4723	}
4724	}
4725
4726	/* Return true if we are in the global binding level. */
4727
4728	bool
4729	global_bindings_p (void)
4730	{
4731	return global_scope_p (current_binding_level);
4732	}
4733
4734	/* True if we are currently in a toplevel binding level. This
4735	means either the global binding level or a namespace in a toplevel
4736	binding level. Since there are no non-toplevel namespace levels,
4737	this really means any namespace or template parameter level. We
4738	also include a class whose context is toplevel. */
4739
4740	bool
4741	toplevel_bindings_p (void)
4742	{
4743	cp_binding_level *b = innermost_nonclass_level ();
4744
4745	return b->kind == sk_namespace || b->kind == sk_template_parms;
4746	}
4747
4748	/* True if this is a namespace scope, or if we are defining a class
4749	which is itself at namespace scope, or whose enclosing class is
4750	such a class, etc. */
4751
4752	bool
4753	namespace_bindings_p (void)
4754	{
4755	cp_binding_level *b = innermost_nonclass_level ();
4756
4757	return b->kind == sk_namespace;
4758	}
4759
4760	/* True if the innermost non-class scope is a block scope. */
4761
4762	bool
4763	local_bindings_p (void)
4764	{
4765	cp_binding_level *b = innermost_nonclass_level ();
4766	return b->kind < sk_function_parms || b->kind == sk_omp;
4767	}
4768
4769	/* True if the current level needs to have a BLOCK made. */
4770
4771	bool
4772	kept_level_p (void)
4773	{
4774	return (current_binding_level->blocks != NULL_TREE
4775	|| current_binding_level->keep
4776	|| current_binding_level->kind == sk_cleanup
4777	|| current_binding_level->names != NULL_TREE
4778	|| current_binding_level->using_directives);
4779	}
4780
4781	/* Returns the kind of the innermost scope. */
4782
4783	scope_kind
4784	innermost_scope_kind (void)
4785	{
4786	return current_binding_level->kind;
4787	}
4788
4789	/* Returns true if this scope was created to store template parameters. */
4790
4791	bool
4792	template_parm_scope_p (void)
4793	{
4794	return innermost_scope_kind () == sk_template_parms;
4795	}
4796
4797	/* If KEEP is true, make a BLOCK node for the next binding level,
4798	unconditionally. Otherwise, use the normal logic to decide whether
4799	or not to create a BLOCK. */
4800
4801	void
4802	keep_next_level (bool keep)
4803	{
4804	keep_next_level_flag = keep;
4805	}
4806
4807	/* Return the list of declarations of the current local scope. */
4808
4809	tree
4810	get_local_decls (void)
4811	{
4812	gcc_assert (current_binding_level->kind != sk_namespace
4813	&& current_binding_level->kind != sk_class);
4814	return current_binding_level->names;
4815	}
4816
4817	/* Return how many function prototypes we are currently nested inside. */
4818
4819	int
4820	function_parm_depth (void)
4821	{
4822	int level = 0;
4823	cp_binding_level *b;
4824
4825	for (b = current_binding_level;
4826	b->kind == sk_function_parms;
4827	b = b->level_chain)
4828	++level;
4829
4830	return level;
4831	}
4832
4833	/* For debugging. */
4834	static int no_print_functions = 0;
4835	static int no_print_builtins = 0;
4836
4837	static void
4838	print_binding_level (cp_binding_level* lvl)
4839	{
4840	tree t;
4841	int i = 0, len;
4842	if (lvl->this_entity)
4843	print_node_brief (stderr, "entity=", lvl->this_entity, 1);
4844	fprintf (stderr, format: " blocks=%p", (void *) lvl->blocks);
4845	if (lvl->more_cleanups_ok)
4846	fprintf (stderr, format: " more-cleanups-ok");
4847	if (lvl->have_cleanups)
4848	fprintf (stderr, format: " have-cleanups");
4849	fprintf (stderr, format: "\n");
4850	if (lvl->names)
4851	{
4852	fprintf (stderr, format: " names:\t");
4853	/* We can probably fit 3 names to a line? */
4854	for (t = lvl->names; t; t = TREE_CHAIN (t))
4855	{
4856	if (no_print_functions && (TREE_CODE (t) == FUNCTION_DECL))
4857	continue;
4858	if (no_print_builtins
4859	&& (TREE_CODE (t) == TYPE_DECL)
4860	&& DECL_IS_UNDECLARED_BUILTIN (t))
4861	continue;
4862
4863	/* Function decls tend to have longer names. */
4864	if (TREE_CODE (t) == FUNCTION_DECL)
4865	len = 3;
4866	else
4867	len = 2;
4868	i += len;
4869	if (i > 6)
4870	{
4871	fprintf (stderr, format: "\n\t");
4872	i = len;
4873	}
4874	print_node_brief (stderr, "", t, 0);
4875	if (t == error_mark_node)
4876	break;
4877	}
4878	if (i)
4879	fprintf (stderr, format: "\n");
4880	}
4881	if (vec_safe_length (v: lvl->class_shadowed))
4882	{
4883	size_t i;
4884	cp_class_binding *b;
4885	fprintf (stderr, format: " class-shadowed:");
4886	FOR_EACH_VEC_ELT (*lvl->class_shadowed, i, b)
4887	fprintf (stderr, format: " %s ", IDENTIFIER_POINTER (b->identifier));
4888	fprintf (stderr, format: "\n");
4889	}
4890	if (lvl->type_shadowed)
4891	{
4892	fprintf (stderr, format: " type-shadowed:");
4893	for (t = lvl->type_shadowed; t; t = TREE_CHAIN (t))
4894	{
4895	fprintf (stderr, format: " %s ", IDENTIFIER_POINTER (TREE_PURPOSE (t)));
4896	}
4897	fprintf (stderr, format: "\n");
4898	}
4899	}
4900
4901	DEBUG_FUNCTION void
4902	debug (cp_binding_level &ref)
4903	{
4904	print_binding_level (lvl: &ref);
4905	}
4906
4907	DEBUG_FUNCTION void
4908	debug (cp_binding_level *ptr)
4909	{
4910	if (ptr)
4911	debug (ref&: *ptr);
4912	else
4913	fprintf (stderr, format: "<nil>\n");
4914	}
4915
4916	static void
4917	print_other_binding_stack (cp_binding_level *stack)
4918	{
4919	cp_binding_level *level;
4920	for (level = stack; !global_scope_p (level); level = level->level_chain)
4921	{
4922	fprintf (stderr, format: "binding level %p\n", (void *) level);
4923	print_binding_level (lvl: level);
4924	}
4925	}
4926
4927	DEBUG_FUNCTION void
4928	print_binding_stack (void)
4929	{
4930	cp_binding_level *b;
4931	fprintf (stderr, format: "current_binding_level=%p\n"
4932	"class_binding_level=%p\n"
4933	"NAMESPACE_LEVEL (global_namespace)=%p\n",
4934	(void *) current_binding_level, (void *) class_binding_level,
4935	(void *) NAMESPACE_LEVEL (global_namespace));
4936	if (class_binding_level)
4937	{
4938	for (b = class_binding_level; b; b = b->level_chain)
4939	if (b == current_binding_level)
4940	break;
4941	if (b)
4942	b = class_binding_level;
4943	else
4944	b = current_binding_level;
4945	}
4946	else
4947	b = current_binding_level;
4948	print_other_binding_stack (stack: b);
4949	fprintf (stderr, format: "global:\n");
4950	print_binding_level (NAMESPACE_LEVEL (global_namespace));
4951	}
4952
4953	/* Push a definition of struct, union or enum tag named ID. into
4954	binding_level B. DECL is a TYPE_DECL for the type. DECL has
4955	already been pushed into its binding level. This is bookkeeping to
4956	find it easily. */
4957
4958	static void
4959	set_identifier_type_value_with_scope (tree id, tree decl, cp_binding_level *b)
4960	{
4961	if (b->kind == sk_namespace)
4962	/* At namespace scope we should not see an identifier type value. */
4963	gcc_checking_assert (!REAL_IDENTIFIER_TYPE_VALUE (id)
4964	/* We could be pushing a friend underneath a template
4965	parm (ill-formed). */
4966	|| (TEMPLATE_PARM_P
4967	(TYPE_NAME (REAL_IDENTIFIER_TYPE_VALUE (id)))));
4968	else
4969	{
4970	/* Push the current type value, so we can restore it later */
4971	tree old = REAL_IDENTIFIER_TYPE_VALUE (id);
4972	b->type_shadowed = tree_cons (id, old, b->type_shadowed);
4973	tree type = decl ? TREE_TYPE (decl) : NULL_TREE;
4974	TREE_TYPE (b->type_shadowed) = type;
4975	SET_IDENTIFIER_TYPE_VALUE (id, type);
4976	}
4977	}
4978
4979	/* As set_identifier_type_value_with_scope, but using
4980	current_binding_level. */
4981
4982	void
4983	set_identifier_type_value (tree id, tree decl)
4984	{
4985	set_identifier_type_value_with_scope (id, decl, current_binding_level);
4986	}
4987
4988	/* Return the name for the constructor (or destructor) for the
4989	specified class. */
4990
4991	tree
4992	constructor_name (tree type)
4993	{
4994	tree decl = TYPE_NAME (TYPE_MAIN_VARIANT (type));
4995
4996	return decl ? DECL_NAME (decl) : NULL_TREE;
4997	}
4998
4999	/* Returns TRUE if NAME is the name for the constructor for TYPE,
5000	which must be a class type. */
5001
5002	bool
5003	constructor_name_p (tree name, tree type)
5004	{
5005	gcc_assert (MAYBE_CLASS_TYPE_P (type));
5006
5007	/* These don't have names. */
5008	if (TREE_CODE (type) == DECLTYPE_TYPE
5009	|| TREE_CODE (type) == TYPEOF_TYPE)
5010	return false;
5011
5012	if (name && name == constructor_name (type))
5013	return true;
5014
5015	return false;
5016	}
5017
5018	/* Same as pushdecl, but define X in binding-level LEVEL. We rely on the
5019	caller to set DECL_CONTEXT properly.
5020
5021	Warning: For class and block-scope this must only be used when X
5022	will be the new innermost binding for its name, as we tack it onto
5023	the front of IDENTIFIER_BINDING without checking to see if the
5024	current IDENTIFIER_BINDING comes from a closer binding level than
5025	LEVEL.
5026
5027	Warning: For namespace scope, this will look in LEVEL for an
5028	existing binding to match, but if not found will push the decl into
5029	CURRENT_NAMESPACE. Use push_nested_namespace/pushdecl/
5030	pop_nested_namespace if you really need to push it into a foreign
5031	namespace. */
5032
5033	static tree
5034	do_pushdecl_with_scope (tree x, cp_binding_level *level, bool hiding = false)
5035	{
5036	cp_binding_level *b;
5037
5038	if (level->kind == sk_class)
5039	{
5040	gcc_checking_assert (!hiding);
5041	b = class_binding_level;
5042	class_binding_level = level;
5043	pushdecl_class_level (x);
5044	class_binding_level = b;
5045	}
5046	else
5047	{
5048	tree function_decl = current_function_decl;
5049	if (level->kind == sk_namespace)
5050	current_function_decl = NULL_TREE;
5051	b = current_binding_level;
5052	current_binding_level = level;
5053	x = pushdecl (decl: x, hiding);
5054	current_binding_level = b;
5055	current_function_decl = function_decl;
5056	}
5057	return x;
5058	}
5059
5060	/* Inject X into the local scope just before the function parms. */
5061
5062	tree
5063	pushdecl_outermost_localscope (tree x)
5064	{
5065	cp_binding_level *b = NULL;
5066	auto_cond_timevar tv (TV_NAME_LOOKUP);
5067
5068	/* Find the scope just inside the function parms. */
5069	for (cp_binding_level *n = current_binding_level;
5070	n->kind != sk_function_parms; n = b->level_chain)
5071	b = n;
5072
5073	return b ? do_pushdecl_with_scope (x, level: b) : error_mark_node;
5074	}
5075
5076	/* Checks if BINDING is a binding that we can export. */
5077
5078	static bool
5079	check_can_export_using_decl (tree binding)
5080	{
5081	tree decl = STRIP_TEMPLATE (binding);
5082
5083	/* Linkage is determined by the owner of an enumerator. */
5084	if (TREE_CODE (decl) == CONST_DECL)
5085	decl = TYPE_NAME (DECL_CONTEXT (decl));
5086
5087	/* If the using decl is exported, the things it refers
5088	to must also be exported (or not have module attachment). */
5089	if (!DECL_MODULE_EXPORT_P (decl)
5090	&& (DECL_LANG_SPECIFIC (decl)
5091	&& DECL_MODULE_ATTACH_P (decl)))
5092	{
5093	bool internal_p = !TREE_PUBLIC (decl);
5094
5095	/* A template in an anonymous namespace doesn't constrain TREE_PUBLIC
5096	until it's instantiated, so double-check its context. */
5097	if (!internal_p && TREE_CODE (binding) == TEMPLATE_DECL)
5098	internal_p = decl_internal_context_p (decl);
5099
5100	auto_diagnostic_group d;
5101	error ("exporting %q#D that does not have external linkage",
5102	binding);
5103	if (TREE_CODE (decl) == TYPE_DECL && !DECL_IMPLICIT_TYPEDEF_P (decl))
5104	/* An un-exported explicit type alias has no linkage. */
5105	inform (DECL_SOURCE_LOCATION (binding),
5106	"%q#D declared here with no linkage", binding);
5107	else if (internal_p)
5108	inform (DECL_SOURCE_LOCATION (binding),
5109	"%q#D declared here with internal linkage", binding);
5110	else
5111	inform (DECL_SOURCE_LOCATION (binding),
5112	"%q#D declared here with module linkage", binding);
5113	return false;
5114	}
5115
5116	return true;
5117	}
5118
5119	/* Process a local-scope or namespace-scope using declaration. LOOKUP
5120	is the result of qualified lookup (both value & type are
5121	significant). FN_SCOPE_P indicates if we're at function-scope (as
5122	opposed to namespace-scope). *VALUE_P and *TYPE_P are the current
5123	bindings, which are altered to reflect the newly brought in
5124	declarations. */
5125
5126	static bool
5127	do_nonmember_using_decl (name_lookup &lookup, bool fn_scope_p,
5128	bool insert_p, tree *value_p, tree *type_p)
5129	{
5130	tree value = *value_p;
5131	tree type = *type_p;
5132	bool failed = false;
5133
5134	/* Shift the old and new bindings around so we're comparing class and
5135	enumeration names to each other. */
5136	if (value && DECL_IMPLICIT_TYPEDEF_P (value))
5137	{
5138	type = value;
5139	value = NULL_TREE;
5140	}
5141
5142	if (lookup.value && DECL_IMPLICIT_TYPEDEF_P (lookup.value))
5143	{
5144	lookup.type = lookup.value;
5145	lookup.value = NULL_TREE;
5146	}
5147
5148	/* Only process exporting if we're going to be inserting. */
5149	bool revealing_p = insert_p && !fn_scope_p && module_has_cmi_p ();
5150
5151	/* First do the value binding. */
5152	if (!lookup.value)
5153	/* Nothing (only implicit typedef found). */
5154	gcc_checking_assert (lookup.type);
5155	else if (OVL_P (lookup.value) && (!value || OVL_P (value)))
5156	{
5157	for (lkp_iterator usings (lookup.value); usings; ++usings)
5158	{
5159	tree new_fn = *usings;
5160	bool exporting = revealing_p && module_exporting_p ();
5161	if (exporting)
5162	exporting = check_can_export_using_decl (binding: new_fn);
5163
5164	/* [namespace.udecl]
5165
5166	If a function declaration in namespace scope or block
5167	scope has the same name and the same parameter types as a
5168	function introduced by a using declaration the program is
5169	ill-formed. */
5170	/* This seems overreaching, asking core -- why do we care
5171	about decls in the namespace that we cannot name (because
5172	they are not transitively imported. We just check the
5173	decls that are in this TU. */
5174	bool found = false;
5175	for (ovl_iterator old (value); !found && old; ++old)
5176	{
5177	tree old_fn = *old;
5178
5179	if (new_fn == old_fn)
5180	{
5181	/* The function already exists in the current
5182	namespace. We will still want to insert it if
5183	it is revealing a not-revealed thing. */
5184	found = true;
5185	if (!revealing_p)
5186	;
5187	else if (old.using_p ())
5188	{
5189	if (exporting)
5190	/* Update in place. 'tis ok. */
5191	OVL_EXPORT_P (old.get_using ()) = true;
5192	;
5193	}
5194	else if (DECL_MODULE_EXPORT_P (new_fn))
5195	;
5196	else
5197	{
5198	value = old.remove_node (head: value);
5199	found = false;
5200	}
5201	break;
5202	}
5203	else if (old.using_p ())
5204	continue; /* This is a using decl. */
5205	else if (old.hidden_p () && DECL_IS_UNDECLARED_BUILTIN (old_fn))
5206	continue; /* This is an anticipated builtin. */
5207	else if (!matching_fn_p (one: new_fn, two: old_fn))
5208	continue; /* Parameters do not match. */
5209	else if (decls_match (new_fn, old_fn))
5210	{
5211	/* Extern "C" in different namespaces. */
5212	found = true;
5213	break;
5214	}
5215	else
5216	{
5217	diagnose_name_conflict (decl: new_fn, bval: old_fn);
5218	failed = true;
5219	found = true;
5220	break;
5221	}
5222	}
5223
5224	if (!found && insert_p)
5225	/* Unlike the decl-pushing case we don't drop anticipated
5226	builtins here. They don't cause a problem, and we'd
5227	like to match them with a future declaration. */
5228	value = ovl_insert (fn: new_fn, maybe_ovl: value, using_or_hidden: 1 + exporting);
5229	}
5230	}
5231	else if (value
5232	/* Ignore anticipated builtins. */
5233	&& !anticipated_builtin_p (ovl: value)
5234	&& (fn_scope_p || !decls_match (lookup.value, value)))
5235	{
5236	diagnose_name_conflict (decl: lookup.value, bval: value);
5237	failed = true;
5238	}
5239	else if (insert_p)
5240	{
5241	if (revealing_p
5242	&& module_exporting_p ()
5243	&& check_can_export_using_decl (binding: lookup.value)
5244	&& lookup.value == value
5245	&& !DECL_MODULE_EXPORT_P (value))
5246	{
5247	/* We're redeclaring the same value, but this time as
5248	newly exported: make sure to mark it as such. */
5249	if (TREE_CODE (value) == TEMPLATE_DECL)
5250	{
5251	DECL_MODULE_EXPORT_P (value) = true;
5252
5253	tree result = DECL_TEMPLATE_RESULT (value);
5254	retrofit_lang_decl (result);
5255	DECL_MODULE_PURVIEW_P (result) = true;
5256	DECL_MODULE_EXPORT_P (result) = true;
5257	}
5258	else
5259	{
5260	retrofit_lang_decl (value);
5261	DECL_MODULE_PURVIEW_P (value) = true;
5262	DECL_MODULE_EXPORT_P (value) = true;
5263	}
5264	}
5265	else
5266	value = lookup.value;
5267	}
5268
5269	/* Now the type binding. */
5270	if (lookup.type)
5271	{
5272	if (type && !decls_match (lookup.type, type))
5273	{
5274	diagnose_name_conflict (decl: lookup.type, bval: type);
5275	failed = true;
5276	}
5277	else if (insert_p)
5278	{
5279	if (revealing_p
5280	&& module_exporting_p ()
5281	&& check_can_export_using_decl (binding: lookup.type)
5282	&& lookup.type == type
5283	&& !DECL_MODULE_EXPORT_P (type))
5284	{
5285	/* We're redeclaring the same type, but this time as
5286	newly exported: make sure to mark it as such. */
5287	retrofit_lang_decl (type);
5288	DECL_MODULE_PURVIEW_P (type) = true;
5289	DECL_MODULE_EXPORT_P (type) = true;
5290	}
5291	else
5292	type = lookup.type;
5293	}
5294	}
5295
5296	if (insert_p)
5297	{
5298	/* If value is empty, shift any class or enumeration name back. */
5299	if (!value)
5300	{
5301	value = type;
5302	type = NULL_TREE;
5303	}
5304	*value_p = value;
5305	*type_p = type;
5306	}
5307
5308	return failed;
5309	}
5310
5311	/* Returns true if ANCESTOR encloses DESCENDANT, including matching.
5312	Both are namespaces. */
5313
5314	bool
5315	is_nested_namespace (tree ancestor, tree descendant, bool inline_only)
5316	{
5317	int depth = SCOPE_DEPTH (ancestor);
5318
5319	if (!depth && !inline_only)
5320	/* The global namespace encloses everything. */
5321	return true;
5322
5323	while (SCOPE_DEPTH (descendant) > depth
5324	&& (!inline_only || DECL_NAMESPACE_INLINE_P (descendant)))
5325	descendant = CP_DECL_CONTEXT (descendant);
5326
5327	return ancestor == descendant;
5328	}
5329
5330	/* Returns true if ROOT (a non-alias namespace, class, or function)
5331	encloses CHILD. CHILD may be either a class type or a namespace
5332	(maybe alias). */
5333
5334	bool
5335	is_ancestor (tree root, tree child)
5336	{
5337	gcc_checking_assert ((TREE_CODE (root) == NAMESPACE_DECL
5338	&& !DECL_NAMESPACE_ALIAS (root))
5339	|| TREE_CODE (root) == FUNCTION_DECL
5340	|| CLASS_TYPE_P (root));
5341	gcc_checking_assert (TREE_CODE (child) == NAMESPACE_DECL
5342	|| CLASS_TYPE_P (child));
5343
5344	/* The global namespace encloses everything. Early-out for the
5345	common case. */
5346	if (root == global_namespace)
5347	return true;
5348
5349	/* Search CHILD until we reach namespace scope. */
5350	while (TREE_CODE (child) != NAMESPACE_DECL)
5351	{
5352	/* If we've reached the ROOT, it encloses CHILD. */
5353	if (root == child)
5354	return true;
5355
5356	/* Go out one level. */
5357	if (TYPE_P (child))
5358	child = TYPE_NAME (child);
5359	child = CP_DECL_CONTEXT (child);
5360	}
5361
5362	if (TREE_CODE (root) != NAMESPACE_DECL)
5363	/* Failed to meet the non-namespace we were looking for. */
5364	return false;
5365
5366	if (tree alias = DECL_NAMESPACE_ALIAS (child))
5367	child = alias;
5368
5369	return is_nested_namespace (ancestor: root, descendant: child);
5370	}
5371
5372	/* Enter the class or namespace scope indicated by T suitable for name
5373	lookup. T can be arbitrary scope, not necessary nested inside the
5374	current scope. Returns a non-null scope to pop iff pop_scope
5375	should be called later to exit this scope. */
5376
5377	tree
5378	push_scope (tree t)
5379	{
5380	if (TREE_CODE (t) == NAMESPACE_DECL)
5381	push_decl_namespace (t);
5382	else if (CLASS_TYPE_P (t))
5383	{
5384	if (!at_class_scope_p ()
5385	|| !same_type_p (current_class_type, t))
5386	push_nested_class (t);
5387	else
5388	/* T is the same as the current scope. There is therefore no
5389	need to re-enter the scope. Since we are not actually
5390	pushing a new scope, our caller should not call
5391	pop_scope. */
5392	t = NULL_TREE;
5393	}
5394
5395	return t;
5396	}
5397
5398	/* Leave scope pushed by push_scope. */
5399
5400	void
5401	pop_scope (tree t)
5402	{
5403	if (t == NULL_TREE)
5404	return;
5405	if (TREE_CODE (t) == NAMESPACE_DECL)
5406	pop_decl_namespace ();
5407	else if CLASS_TYPE_P (t)
5408	pop_nested_class ();
5409	}
5410
5411	/* Subroutine of push_inner_scope. */
5412
5413	static void
5414	push_inner_scope_r (tree outer, tree inner)
5415	{
5416	tree prev;
5417
5418	if (outer == inner
5419	|| (TREE_CODE (inner) != NAMESPACE_DECL && !CLASS_TYPE_P (inner)))
5420	return;
5421
5422	prev = CP_DECL_CONTEXT (TREE_CODE (inner) == NAMESPACE_DECL ? inner : TYPE_NAME (inner));
5423	if (outer != prev)
5424	push_inner_scope_r (outer, inner: prev);
5425	if (TREE_CODE (inner) == NAMESPACE_DECL)
5426	{
5427	cp_binding_level *save_template_parm = 0;
5428	/* Temporary take out template parameter scopes. They are saved
5429	in reversed order in save_template_parm. */
5430	while (current_binding_level->kind == sk_template_parms)
5431	{
5432	cp_binding_level *b = current_binding_level;
5433	current_binding_level = b->level_chain;
5434	b->level_chain = save_template_parm;
5435	save_template_parm = b;
5436	}
5437
5438	resume_scope (NAMESPACE_LEVEL (inner));
5439	current_namespace = inner;
5440
5441	/* Restore template parameter scopes. */
5442	while (save_template_parm)
5443	{
5444	cp_binding_level *b = save_template_parm;
5445	save_template_parm = b->level_chain;
5446	b->level_chain = current_binding_level;
5447	current_binding_level = b;
5448	}
5449	}
5450	else
5451	pushclass (inner);
5452	}
5453
5454	/* Enter the scope INNER from current scope. INNER must be a scope
5455	nested inside current scope. This works with both name lookup and
5456	pushing name into scope. In case a template parameter scope is present,
5457	namespace is pushed under the template parameter scope according to
5458	name lookup rule in 14.6.1/6.
5459
5460	Return the former current scope suitable for pop_inner_scope. */
5461
5462	tree
5463	push_inner_scope (tree inner)
5464	{
5465	tree outer = current_scope ();
5466	if (!outer)
5467	outer = current_namespace;
5468
5469	push_inner_scope_r (outer, inner);
5470	return outer;
5471	}
5472
5473	/* Exit the current scope INNER back to scope OUTER. */
5474
5475	void
5476	pop_inner_scope (tree outer, tree inner)
5477	{
5478	if (outer == inner
5479	|| (TREE_CODE (inner) != NAMESPACE_DECL && !CLASS_TYPE_P (inner)))
5480	return;
5481
5482	while (outer != inner)
5483	{
5484	if (TREE_CODE (inner) == NAMESPACE_DECL)
5485	{
5486	cp_binding_level *save_template_parm = 0;
5487	/* Temporary take out template parameter scopes. They are saved
5488	in reversed order in save_template_parm. */
5489	while (current_binding_level->kind == sk_template_parms)
5490	{
5491	cp_binding_level *b = current_binding_level;
5492	current_binding_level = b->level_chain;
5493	b->level_chain = save_template_parm;
5494	save_template_parm = b;
5495	}
5496
5497	pop_namespace ();
5498
5499	/* Restore template parameter scopes. */
5500	while (save_template_parm)
5501	{
5502	cp_binding_level *b = save_template_parm;
5503	save_template_parm = b->level_chain;
5504	b->level_chain = current_binding_level;
5505	current_binding_level = b;
5506	}
5507	}
5508	else
5509	popclass ();
5510
5511	inner = CP_DECL_CONTEXT (TREE_CODE (inner) == NAMESPACE_DECL ? inner : TYPE_NAME (inner));
5512	}
5513	}
5514
5515	/* Do a pushlevel for class declarations. */
5516
5517	void
5518	pushlevel_class (void)
5519	{
5520	class_binding_level = begin_scope (kind: sk_class, current_class_type);
5521	}
5522
5523	/* ...and a poplevel for class declarations. */
5524
5525	void
5526	poplevel_class (void)
5527	{
5528	cp_binding_level *level = class_binding_level;
5529	cp_class_binding *cb;
5530	size_t i;
5531	tree shadowed;
5532
5533	auto_cond_timevar tv (TV_NAME_LOOKUP);
5534	gcc_assert (level != 0);
5535
5536	/* If we're leaving a toplevel class, cache its binding level. */
5537	if (current_class_depth == 1)
5538	previous_class_level = level;
5539	for (shadowed = level->type_shadowed;
5540	shadowed;
5541	shadowed = TREE_CHAIN (shadowed))
5542	SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (shadowed), TREE_VALUE (shadowed));
5543
5544	/* Remove the bindings for all of the class-level declarations. */
5545	if (level->class_shadowed)
5546	{
5547	FOR_EACH_VEC_ELT (*level->class_shadowed, i, cb)
5548	{
5549	IDENTIFIER_BINDING (cb->identifier) = cb->base->previous;
5550	cxx_binding_free (binding: cb->base);
5551	}
5552	ggc_free (level->class_shadowed);
5553	level->class_shadowed = NULL;
5554	}
5555
5556	/* Now, pop out of the binding level which we created up in the
5557	`pushlevel_class' routine. */
5558	gcc_assert (current_binding_level == level);
5559	leave_scope ();
5560	}
5561
5562	/* Set INHERITED_VALUE_BINDING_P on BINDING to true or false, as
5563	appropriate. DECL is the value to which a name has just been
5564	bound. CLASS_TYPE is the class in which the lookup occurred. */
5565
5566	static void
5567	set_inherited_value_binding_p (cxx_binding *binding, tree decl,
5568	tree class_type)
5569	{
5570	if (binding->value == decl && TREE_CODE (decl) != TREE_LIST)
5571	{
5572	tree context;
5573
5574	if (is_overloaded_fn (decl))
5575	context = ovl_scope (decl);
5576	else
5577	{
5578	gcc_assert (DECL_P (decl));
5579	context = context_for_name_lookup (decl);
5580	}
5581
5582	if (is_properly_derived_from (class_type, context))
5583	INHERITED_VALUE_BINDING_P (binding) = 1;
5584	else
5585	INHERITED_VALUE_BINDING_P (binding) = 0;
5586	}
5587	else if (binding->value == decl)
5588	/* We only encounter a TREE_LIST when there is an ambiguity in the
5589	base classes. Such an ambiguity can be overridden by a
5590	definition in this class. */
5591	INHERITED_VALUE_BINDING_P (binding) = 1;
5592	else
5593	INHERITED_VALUE_BINDING_P (binding) = 0;
5594	}
5595
5596	/* Make the declaration of X appear in CLASS scope. */
5597
5598	bool
5599	pushdecl_class_level (tree x)
5600	{
5601	bool is_valid = true;
5602
5603	/* Do nothing if we're adding to an outer lambda closure type,
5604	outer_binding will add it later if it's needed. */
5605	if (current_class_type != class_binding_level->this_entity)
5606	return true;
5607
5608	auto_cond_timevar tv (TV_NAME_LOOKUP);
5609	/* Get the name of X. */
5610	tree name = OVL_NAME (x);
5611
5612	if (name)
5613	{
5614	is_valid = push_class_level_binding (name, x);
5615	if (TREE_CODE (x) == TYPE_DECL)
5616	set_identifier_type_value (id: name, decl: x);
5617	}
5618	else if (ANON_AGGR_TYPE_P (TREE_TYPE (x)))
5619	{
5620	/* If X is an anonymous aggregate, all of its members are
5621	treated as if they were members of the class containing the
5622	aggregate, for naming purposes. */
5623	location_t save_location = input_location;
5624	tree anon = TREE_TYPE (x);
5625	if (vec<tree, va_gc> *member_vec = CLASSTYPE_MEMBER_VEC (anon))
5626	for (unsigned ix = member_vec->length (); ix--;)
5627	{
5628	tree binding = (*member_vec)[ix];
5629	if (STAT_HACK_P (binding))
5630	{
5631	if (!pushdecl_class_level (STAT_TYPE (binding)))
5632	is_valid = false;
5633	binding = STAT_DECL (binding);
5634	}
5635	if (!pushdecl_class_level (x: binding))
5636	is_valid = false;
5637	}
5638	else
5639	for (tree f = TYPE_FIELDS (anon); f; f = DECL_CHAIN (f))
5640	if (TREE_CODE (f) == FIELD_DECL)
5641	{
5642	input_location = DECL_SOURCE_LOCATION (f);
5643	if (!pushdecl_class_level (x: f))
5644	is_valid = false;
5645	}
5646	input_location = save_location;
5647	}
5648	return is_valid;
5649	}
5650
5651	/* Return the BINDING (if any) for NAME in SCOPE, which is a class
5652	scope. If the value returned is non-NULL, and the PREVIOUS field
5653	is not set, callers must set the PREVIOUS field explicitly. */
5654
5655	static cxx_binding *
5656	get_class_binding (tree name, cp_binding_level *scope)
5657	{
5658	tree class_type;
5659	tree type_binding;
5660	tree value_binding;
5661	cxx_binding *binding;
5662
5663	class_type = scope->this_entity;
5664
5665	/* Get the type binding. */
5666	type_binding = lookup_member (class_type, name,
5667	/*protect=*/2, /*want_type=*/true,
5668	tf_warning_or_error);
5669	/* Get the value binding. */
5670	value_binding = lookup_member (class_type, name,
5671	/*protect=*/2, /*want_type=*/false,
5672	tf_warning_or_error);
5673
5674	/* If we found either a type binding or a value binding, create a
5675	new binding object. */
5676	if (type_binding || value_binding)
5677	{
5678	binding = new_class_binding (name,
5679	value: value_binding,
5680	type: type_binding,
5681	scope);
5682	set_inherited_value_binding_p (binding, decl: value_binding, class_type);
5683	}
5684	else
5685	binding = NULL;
5686
5687	return binding;
5688	}
5689
5690	/* Make the declaration(s) of X appear in CLASS scope under the name
5691	NAME. Returns true if the binding is valid. */
5692
5693	bool
5694	push_class_level_binding (tree name, tree x)
5695	{
5696	cxx_binding *binding;
5697	tree decl = x;
5698	bool ok;
5699
5700	auto_cond_timevar tv (TV_NAME_LOOKUP);
5701
5702	/* The class_binding_level will be NULL if x is a template
5703	parameter name in a member template. */
5704	if (!class_binding_level)
5705	return true;
5706
5707	if (name == error_mark_node)
5708	return false;
5709
5710	/* Can happen for an erroneous declaration (c++/60384). */
5711	if (!identifier_p (t: name))
5712	{
5713	gcc_assert (errorcount || sorrycount);
5714	return false;
5715	}
5716
5717	/* Check for invalid member names. But don't worry about a default
5718	argument-scope lambda being pushed after the class is complete. */
5719	gcc_assert (TYPE_BEING_DEFINED (current_class_type)
5720	|| LAMBDA_TYPE_P (TREE_TYPE (decl)));
5721	/* Check that we're pushing into the right binding level. */
5722	gcc_assert (current_class_type == class_binding_level->this_entity);
5723
5724	/* We could have been passed a tree list if this is an ambiguous
5725	declaration. If so, pull the declaration out because
5726	check_template_shadow will not handle a TREE_LIST. */
5727	if (TREE_CODE (decl) == TREE_LIST
5728	&& TREE_TYPE (decl) == error_mark_node)
5729	decl = TREE_VALUE (decl);
5730
5731	if (!check_template_shadow (decl))
5732	return false;
5733
5734	/* [class.mem]
5735
5736	If T is the name of a class, then each of the following shall
5737	have a name different from T:
5738
5739	-- every static data member of class T;
5740
5741	-- every member of class T that is itself a type;
5742
5743	-- every enumerator of every member of class T that is an
5744	enumerated type;
5745
5746	-- every member of every anonymous union that is a member of
5747	class T.
5748
5749	(Non-static data members were also forbidden to have the same
5750	name as T until TC1.) */
5751	if ((VAR_P (x)
5752	|| TREE_CODE (x) == CONST_DECL
5753	|| (TREE_CODE (x) == TYPE_DECL
5754	&& !DECL_SELF_REFERENCE_P (x))
5755	/* A data member of an anonymous union. */
5756	|| (TREE_CODE (x) == FIELD_DECL
5757	&& DECL_CONTEXT (x) != current_class_type))
5758	&& DECL_NAME (x) == DECL_NAME (TYPE_NAME (current_class_type)))
5759	{
5760	tree scope = context_for_name_lookup (x);
5761	if (TYPE_P (scope) && same_type_p (scope, current_class_type))
5762	{
5763	error_at (DECL_SOURCE_LOCATION (x),
5764	"%qD has the same name as the class in which it is "
5765	"declared", x);
5766	return false;
5767	}
5768	}
5769
5770	/* Get the current binding for NAME in this class, if any. */
5771	binding = IDENTIFIER_BINDING (name);
5772	if (!binding || binding->scope != class_binding_level)
5773	{
5774	binding = get_class_binding (name, class_binding_level);
5775	/* If a new binding was created, put it at the front of the
5776	IDENTIFIER_BINDING list. */
5777	if (binding)
5778	{
5779	binding->previous = IDENTIFIER_BINDING (name);
5780	IDENTIFIER_BINDING (name) = binding;
5781	}
5782	}
5783
5784	/* If there is already a binding, then we may need to update the
5785	current value. */
5786	if (binding && binding->value)
5787	{
5788	tree bval = binding->value;
5789	tree old_decl = NULL_TREE;
5790	tree target_decl = strip_using_decl (decl);
5791	tree target_bval = strip_using_decl (decl: bval);
5792
5793	if (INHERITED_VALUE_BINDING_P (binding))
5794	{
5795	/* If the old binding was from a base class, and was for a
5796	tag name, slide it over to make room for the new binding.
5797	The old binding is still visible if explicitly qualified
5798	with a class-key. */
5799	if (TREE_CODE (target_bval) == TYPE_DECL
5800	&& DECL_ARTIFICIAL (target_bval)
5801	&& !(TREE_CODE (target_decl) == TYPE_DECL
5802	&& DECL_ARTIFICIAL (target_decl)))
5803	{
5804	old_decl = binding->type;
5805	binding->type = bval;
5806	binding->value = NULL_TREE;
5807	INHERITED_VALUE_BINDING_P (binding) = 0;
5808	}
5809	else
5810	{
5811	old_decl = bval;
5812	/* Any inherited type declaration is hidden by the type
5813	declaration in the derived class. */
5814	if (TREE_CODE (target_decl) == TYPE_DECL
5815	&& DECL_ARTIFICIAL (target_decl))
5816	binding->type = NULL_TREE;
5817	}
5818	}
5819	else if (TREE_CODE (decl) == USING_DECL
5820	&& TREE_CODE (bval) == USING_DECL
5821	&& same_type_p (USING_DECL_SCOPE (decl),
5822	USING_DECL_SCOPE (bval)))
5823	/* This is a using redeclaration that will be diagnosed later
5824	in supplement_binding */
5825	;
5826	else if (TREE_CODE (decl) == USING_DECL
5827	&& TREE_CODE (bval) == USING_DECL
5828	&& DECL_DEPENDENT_P (decl)
5829	&& DECL_DEPENDENT_P (bval))
5830	return true;
5831	else if (TREE_CODE (decl) == USING_DECL
5832	&& DECL_DEPENDENT_P (decl)
5833	&& OVL_P (target_bval))
5834	/* The new dependent using beats an old overload. */
5835	old_decl = bval;
5836	else if (TREE_CODE (bval) == USING_DECL
5837	&& DECL_DEPENDENT_P (bval)
5838	&& OVL_P (target_decl))
5839	/* The old dependent using beats a new overload. */
5840	return true;
5841	else if (OVL_P (target_decl)
5842	&& OVL_P (target_bval))
5843	/* The new overload set contains the old one. */
5844	old_decl = bval;
5845
5846	if (old_decl && binding->scope == class_binding_level)
5847	{
5848	binding->value = x;
5849	/* It is always safe to clear INHERITED_VALUE_BINDING_P
5850	here. This function is only used to register bindings
5851	from with the class definition itself. */
5852	INHERITED_VALUE_BINDING_P (binding) = 0;
5853	return true;
5854	}
5855	}
5856
5857	/* Note that we declared this value so that we can issue an error if
5858	this is an invalid redeclaration of a name already used for some
5859	other purpose. */
5860	note_name_declared_in_class (name, decl);
5861
5862	/* If we didn't replace an existing binding, put the binding on the
5863	stack of bindings for the identifier, and update the shadowed
5864	list. */
5865	if (binding && binding->scope == class_binding_level)
5866	/* Supplement the existing binding. */
5867	ok = supplement_binding (binding, decl);
5868	else
5869	{
5870	/* Create a new binding. */
5871	push_binding (id: name, decl, class_binding_level);
5872	ok = true;
5873	}
5874
5875	return ok;
5876	}
5877
5878	/* Process and lookup a using decl SCOPE::lookup.name, filling in
5879	lookup.values & lookup.type. Return a USING_DECL, or NULL_TREE on
5880	failure. */
5881
5882	static tree
5883	lookup_using_decl (tree scope, name_lookup &lookup)
5884	{
5885	tree current = current_scope ();
5886	bool dependent_p = false;
5887	tree binfo = NULL_TREE;
5888	base_kind b_kind = bk_not_base;
5889
5890	/* Because C++20 breaks the invariant that only member using-decls
5891	refer to members and only non-member using-decls refer to
5892	non-members, we first do the lookups, and then do validation that
5893	what we found is ok. */
5894
5895	if (TREE_CODE (scope) == ENUMERAL_TYPE
5896	&& cxx_dialect < cxx20
5897	&& UNSCOPED_ENUM_P (scope)
5898	&& !TYPE_FUNCTION_SCOPE_P (scope))
5899	{
5900	/* PR c++/60265 argued that since C++11 added explicit enum scope, we
5901	should allow it as meaning the enclosing scope. I don't see any
5902	justification for this in C++11, but let's keep allowing it. */
5903	tree ctx = CP_TYPE_CONTEXT (scope);
5904	if (CLASS_TYPE_P (ctx) == CLASS_TYPE_P (current))
5905	scope = ctx;
5906	}
5907
5908	/* You cannot using-decl a destructor. */
5909	if (TREE_CODE (lookup.name) == BIT_NOT_EXPR)
5910	{
5911	error ("%<%T%s%D%> names destructor", scope,
5912	&"::"[scope == global_namespace ? 2 : 0], lookup.name);
5913	return NULL_TREE;
5914	}
5915
5916	if (TREE_CODE (scope) == NAMESPACE_DECL)
5917	{
5918	/* Naming a namespace member. */
5919	qualified_namespace_lookup (scope, &lookup);
5920
5921	if (TYPE_P (current)
5922	&& (!lookup.value
5923	|| lookup.type
5924	|| cxx_dialect < cxx20
5925	|| TREE_CODE (lookup.value) != CONST_DECL))
5926	{
5927	error ("using-declaration for non-member at class scope");
5928	return NULL_TREE;
5929	}
5930	}
5931	else if (TREE_CODE (scope) == ENUMERAL_TYPE)
5932	{
5933	/* Naming an enumeration member. */
5934	if (cxx_dialect < cxx20)
5935	error ("%<using%> with enumeration scope %q#T "
5936	"only available with %<-std=c++20%> or %<-std=gnu++20%>",
5937	scope);
5938	lookup.value = lookup_enumerator (scope, lookup.name);
5939	}
5940	else
5941	{
5942	/* Naming a class member. This is awkward in C++20, because we
5943	might be naming an enumerator of an unrelated class. */
5944
5945	tree npscope = scope;
5946	if (PACK_EXPANSION_P (scope))
5947	npscope = PACK_EXPANSION_PATTERN (scope);
5948
5949	if (!MAYBE_CLASS_TYPE_P (npscope))
5950	{
5951	error ("%qT is not a class, namespace, or enumeration", npscope);
5952	return NULL_TREE;
5953	}
5954
5955	/* Using T::T declares inheriting ctors, even if T is a typedef. */
5956	if (lookup.name == TYPE_IDENTIFIER (npscope)
5957	|| constructor_name_p (name: lookup.name, type: npscope))
5958	{
5959	if (!TYPE_P (current))
5960	{
5961	error ("non-member using-declaration names constructor of %qT",
5962	npscope);
5963	return NULL_TREE;
5964	}
5965	maybe_warn_cpp0x (str: CPP0X_INHERITING_CTORS);
5966	lookup.name = ctor_identifier;
5967	CLASSTYPE_NON_AGGREGATE (current) = true;
5968	}
5969
5970	if (!TYPE_P (current) && cxx_dialect < cxx20)
5971	{
5972	error ("using-declaration for member at non-class scope");
5973	return NULL_TREE;
5974	}
5975
5976	bool depscope = dependent_scope_p (scope);
5977
5978	if (depscope)
5979	/* Leave binfo null. */;
5980	else if (TYPE_P (current))
5981	{
5982	binfo = lookup_base (current, scope, ba_any, &b_kind, tf_none);
5983	gcc_checking_assert (b_kind >= bk_not_base);
5984
5985	if (b_kind == bk_not_base && any_dependent_bases_p ())
5986	/* Treat as-if dependent. */
5987	depscope = true;
5988	else if (lookup.name == ctor_identifier
5989	&& (b_kind < bk_proper_base || !binfo_direct_p (binfo)))
5990	{
5991	if (any_dependent_bases_p ())
5992	depscope = true;
5993	else
5994	{
5995	error ("%qT is not a direct base of %qT", scope, current);
5996	return NULL_TREE;
5997	}
5998	}
5999
6000	if (b_kind < bk_proper_base)
6001	binfo = TYPE_BINFO (scope);
6002	}
6003	else
6004	binfo = TYPE_BINFO (scope);
6005
6006	dependent_p = (depscope
6007	|| (IDENTIFIER_CONV_OP_P (lookup.name)
6008	&& dependent_type_p (TREE_TYPE (lookup.name))));
6009
6010	if (!dependent_p)
6011	lookup.value = lookup_member (binfo, lookup.name, /*protect=*/2,
6012	/*want_type=*/false, tf_none);
6013
6014	/* If the lookup in the base contains a dependent using, this
6015	using is also dependent. */
6016	if (!dependent_p && lookup.value && dependent_type_p (scope))
6017	{
6018	tree val = lookup.value;
6019	if (tree fns = maybe_get_fns (val))
6020	val = fns;
6021	for (tree f: lkp_range (val))
6022	if (TREE_CODE (f) == USING_DECL && DECL_DEPENDENT_P (f))
6023	{
6024	dependent_p = true;
6025	break;
6026	}
6027	}
6028
6029	if (!depscope && b_kind < bk_proper_base)
6030	{
6031	if (cxx_dialect >= cxx20 && lookup.value
6032	&& TREE_CODE (lookup.value) == CONST_DECL)
6033	{
6034	/* Using an unrelated enum; check access here rather
6035	than separately for class and non-class using. */
6036	perform_or_defer_access_check
6037	(binfo, lookup.value, lookup.value, tf_warning_or_error);
6038	/* And then if this is a copy from handle_using_decl, look
6039	through to the original enumerator. */
6040	if (CONST_DECL_USING_P (lookup.value))
6041	lookup.value = DECL_ABSTRACT_ORIGIN (lookup.value);
6042	}
6043	else if (!TYPE_P (current))
6044	{
6045	error ("using-declaration for member at non-class scope");
6046	return NULL_TREE;
6047	}
6048	else
6049	{
6050	auto_diagnostic_group g;
6051	error_not_base_type (scope, current);
6052	if (lookup.value && DECL_IMPLICIT_TYPEDEF_P (lookup.value)
6053	&& TREE_CODE (TREE_TYPE (lookup.value)) == ENUMERAL_TYPE)
6054	inform (input_location,
6055	"did you mean %<using enum %T::%D%>?",
6056	scope, lookup.name);
6057	return NULL_TREE;
6058	}
6059	}
6060	}
6061
6062	/* Did we find anything sane? */
6063	if (dependent_p)
6064	;
6065	else if (!lookup.value)
6066	{
6067	error ("%qD has not been declared in %qD", lookup.name, scope);
6068	return NULL_TREE;
6069	}
6070	else if (TREE_CODE (lookup.value) == TREE_LIST
6071	/* We can (independently) have ambiguous implicit typedefs. */
6072	|| (lookup.type && TREE_CODE (lookup.type) == TREE_LIST))
6073	{
6074	error ("reference to %qD is ambiguous", lookup.name);
6075	print_candidates (TREE_CODE (lookup.value) == TREE_LIST
6076	? lookup.value : lookup.type);
6077	return NULL_TREE;
6078	}
6079	else if (TREE_CODE (lookup.value) == NAMESPACE_DECL)
6080	{
6081	error ("using-declaration may not name namespace %qD", lookup.value);
6082	return NULL_TREE;
6083	}
6084
6085	if (TYPE_P (current))
6086	{
6087	/* In class scope. */
6088
6089	/* Cannot introduce a constructor name. */
6090	if (constructor_name_p (name: lookup.name, type: current))
6091	{
6092	error ("%<%T::%D%> names constructor in %qT",
6093	scope, lookup.name, current);
6094	return NULL_TREE;
6095	}
6096
6097	if (lookup.value && BASELINK_P (lookup.value))
6098	/* The binfo from which the functions came does not matter. */
6099	lookup.value = BASELINK_FUNCTIONS (lookup.value);
6100	}
6101
6102	tree using_decl = build_lang_decl (USING_DECL, lookup.name, NULL_TREE);
6103	USING_DECL_SCOPE (using_decl) = scope;
6104	USING_DECL_DECLS (using_decl) = lookup.value;
6105	DECL_DEPENDENT_P (using_decl) = dependent_p;
6106	DECL_CONTEXT (using_decl) = current;
6107	if (TYPE_P (current) && b_kind == bk_not_base)
6108	USING_DECL_UNRELATED_P (using_decl) = true;
6109
6110	return using_decl;
6111	}
6112
6113	/* Process "using SCOPE::NAME" in a class scope. Return the
6114	USING_DECL created. */
6115
6116	tree
6117	do_class_using_decl (tree scope, tree name)
6118	{
6119	if (name == error_mark_node
6120	|| scope == error_mark_node)
6121	return NULL_TREE;
6122
6123	name_lookup lookup (name);
6124	return lookup_using_decl (scope, lookup);
6125	}
6126
6127
6128	/* Return the binding for NAME in NS in the current TU. If NS is
6129	NULL, look in global_namespace. We will not find declarations
6130	from imports. Users of this who, having found nothing, push a new
6131	decl must be prepared for that pushing to match an existing decl. */
6132
6133	tree
6134	get_namespace_binding (tree ns, tree name)
6135	{
6136	auto_cond_timevar tv (TV_NAME_LOOKUP);
6137	if (!ns)
6138	ns = global_namespace;
6139	gcc_checking_assert (!DECL_NAMESPACE_ALIAS (ns));
6140	tree ret = NULL_TREE;
6141
6142	if (tree *b = find_namespace_slot (ns, name))
6143	{
6144	ret = *b;
6145
6146	if (TREE_CODE (ret) == BINDING_VECTOR)
6147	ret = BINDING_VECTOR_CLUSTER (ret, 0).slots[0];
6148	if (ret)
6149	ret = MAYBE_STAT_DECL (ret);
6150	}
6151
6152	return ret;
6153	}
6154
6155	/* Push internal DECL into the global namespace. Does not do the
6156	full overload fn handling and does not add it to the list of things
6157	in the namespace. */
6158
6159	void
6160	set_global_binding (tree decl)
6161	{
6162	auto_cond_timevar tv (TV_NAME_LOOKUP);
6163
6164	tree *slot = find_namespace_slot (global_namespace, DECL_NAME (decl), create_p: true);
6165
6166	if (*slot)
6167	/* The user's placed something in the implementor's namespace. */
6168	diagnose_name_conflict (decl, MAYBE_STAT_DECL (*slot));
6169
6170	/* Force the binding, so compiler internals continue to work. */
6171	*slot = decl;
6172	}
6173
6174	/* Set the context of a declaration to scope. Complain if we are not
6175	outside scope. */
6176
6177	void
6178	set_decl_namespace (tree decl, tree scope, bool friendp)
6179	{
6180	/* Get rid of namespace aliases. */
6181	scope = ORIGINAL_NAMESPACE (scope);
6182
6183	/* It is ok for friends to be qualified in parallel space. */
6184	if (!friendp && !is_nested_namespace (current_namespace, descendant: scope))
6185	error ("declaration of %qD not in a namespace surrounding %qD",
6186	decl, scope);
6187	DECL_CONTEXT (decl) = FROB_CONTEXT (scope);
6188
6189	/* See whether this has been declared in the namespace or inline
6190	children. */
6191	tree old = NULL_TREE;
6192	{
6193	name_lookup lookup (DECL_NAME (decl),
6194	LOOK_want::NORMAL | LOOK_want::HIDDEN_FRIEND);
6195	if (!lookup.search_qualified (scope, /*usings=*/false))
6196	/* No old declaration at all. */
6197	goto not_found;
6198	old = lookup.value;
6199	}
6200
6201	/* If it's a TREE_LIST, the result of the lookup was ambiguous. */
6202	if (TREE_CODE (old) == TREE_LIST)
6203	{
6204	ambiguous:
6205	DECL_CONTEXT (decl) = FROB_CONTEXT (scope);
6206	error ("reference to %qD is ambiguous", decl);
6207	print_candidates (old);
6208	return;
6209	}
6210
6211	if (!DECL_DECLARES_FUNCTION_P (decl))
6212	{
6213	/* Don't compare non-function decls with decls_match here, since
6214	it can't check for the correct constness at this
6215	point. pushdecl will find those errors later. */
6216
6217	/* We might have found it in an inline namespace child of SCOPE. */
6218	if (TREE_CODE (decl) == TREE_CODE (old))
6219	DECL_CONTEXT (decl) = DECL_CONTEXT (old);
6220
6221	found:
6222	/* Writing "N::i" to declare something directly in "N" is invalid. */
6223	if (CP_DECL_CONTEXT (decl) == current_namespace
6224	&& at_namespace_scope_p ())
6225	error_at (DECL_SOURCE_LOCATION (decl),
6226	"explicit qualification in declaration of %qD", decl);
6227	return;
6228	}
6229
6230	/* Since decl is a function, old should contain a function decl. */
6231	if (!OVL_P (old))
6232	{
6233	not_found:
6234	/* It didn't work, go back to the explicit scope. */
6235	DECL_CONTEXT (decl) = FROB_CONTEXT (scope);
6236	error ("%qD should have been declared inside %qD", decl, scope);
6237
6238	return;
6239	}
6240
6241	/* We handle these in check_explicit_instantiation_namespace. */
6242	if (processing_explicit_instantiation)
6243	return;
6244	if (processing_template_decl || processing_specialization)
6245	/* We have not yet called push_template_decl to turn a
6246	FUNCTION_DECL into a TEMPLATE_DECL, so the declarations won't
6247	match. But, we'll check later, when we construct the
6248	template. */
6249	return;
6250
6251	/* Instantiations or specializations of templates may be declared as
6252	friends in any namespace. */
6253	if (friendp && DECL_USE_TEMPLATE (decl))
6254	return;
6255
6256	tree found = NULL_TREE;
6257	bool hidden_p = false;
6258	bool saw_template = false;
6259
6260	for (lkp_iterator iter (old); iter; ++iter)
6261	{
6262	if (iter.using_p ())
6263	continue;
6264
6265	tree ofn = *iter;
6266
6267	/* Adjust DECL_CONTEXT first so decls_match will return true
6268	if DECL will match a declaration in an inline namespace. */
6269	DECL_CONTEXT (decl) = DECL_CONTEXT (ofn);
6270	if (decls_match (decl, ofn))
6271	{
6272	if (found)
6273	{
6274	/* We found more than one matching declaration. This
6275	can happen if we have two inline namespace children,
6276	each containing a suitable declaration. */
6277	DECL_CONTEXT (decl) = FROB_CONTEXT (scope);
6278	goto ambiguous;
6279	}
6280	found = ofn;
6281	hidden_p = iter.hidden_p ();
6282	}
6283	else if (TREE_CODE (decl) == FUNCTION_DECL
6284	&& TREE_CODE (ofn) == TEMPLATE_DECL)
6285	saw_template = true;
6286	}
6287
6288	if (!found && friendp && saw_template)
6289	{
6290	/* "[if no non-template match is found,] each remaining function template
6291	is replaced with the specialization chosen by deduction from the
6292	friend declaration or discarded if deduction fails."
6293
6294	So tell check_explicit_specialization to look for a match. */
6295	SET_DECL_IMPLICIT_INSTANTIATION (decl);
6296	DECL_TEMPLATE_INFO (decl) = build_template_info (old, NULL_TREE);
6297	return;
6298	}
6299
6300	if (found)
6301	{
6302	if (hidden_p)
6303	{
6304	pedwarn (DECL_SOURCE_LOCATION (decl), 0,
6305	"%qD has not been declared within %qD", decl, scope);
6306	inform (DECL_SOURCE_LOCATION (found),
6307	"only here as a %<friend%>");
6308	}
6309	DECL_CONTEXT (decl) = DECL_CONTEXT (found);
6310	goto found;
6311	}
6312
6313	goto not_found;
6314	}
6315
6316	/* Return the namespace where the current declaration is declared. */
6317
6318	tree
6319	current_decl_namespace (void)
6320	{
6321	tree result;
6322	/* If we have been pushed into a different namespace, use it. */
6323	if (!vec_safe_is_empty (decl_namespace_list))
6324	return decl_namespace_list->last ();
6325
6326	if (current_class_type)
6327	result = decl_namespace_context (current_class_type);
6328	else if (current_function_decl)
6329	result = decl_namespace_context (current_function_decl);
6330	else
6331	result = current_namespace;
6332	return result;
6333	}
6334
6335	/* Process any ATTRIBUTES on a namespace definition. Returns true if
6336	attribute visibility is seen. */
6337
6338	bool
6339	handle_namespace_attrs (tree ns, tree attributes)
6340	{
6341	tree d;
6342	bool saw_vis = false;
6343
6344	if (attributes == error_mark_node)
6345	return false;
6346
6347	for (d = attributes; d; d = TREE_CHAIN (d))
6348	{
6349	tree name = get_attribute_name (d);
6350	tree args = TREE_VALUE (d);
6351
6352	if (is_attribute_p (attr_name: "visibility", ident: name))
6353	{
6354	/* attribute visibility is a property of the syntactic block
6355	rather than the namespace as a whole, so we don't touch the
6356	NAMESPACE_DECL at all. */
6357	tree x = args ? TREE_VALUE (args) : NULL_TREE;
6358	if (x == NULL_TREE || TREE_CODE (x) != STRING_CST || TREE_CHAIN (args))
6359	{
6360	warning (OPT_Wattributes,
6361	"%qD attribute requires a single NTBS argument",
6362	name);
6363	continue;
6364	}
6365
6366	if (!TREE_PUBLIC (ns))
6367	warning (OPT_Wattributes,
6368	"%qD attribute is meaningless since members of the "
6369	"anonymous namespace get local symbols", name);
6370
6371	push_visibility (TREE_STRING_POINTER (x), 1);
6372	saw_vis = true;
6373	}
6374	else if (is_attribute_p (attr_name: "abi_tag", ident: name))
6375	{
6376	if (!DECL_NAME (ns))
6377	{
6378	warning (OPT_Wattributes, "ignoring %qD attribute on anonymous "
6379	"namespace", name);
6380	continue;
6381	}
6382	if (!DECL_NAMESPACE_INLINE_P (ns))
6383	{
6384	warning (OPT_Wattributes, "ignoring %qD attribute on non-inline "
6385	"namespace", name);
6386	continue;
6387	}
6388	if (!args)
6389	{
6390	tree dn = DECL_NAME (ns);
6391	args = build_string (IDENTIFIER_LENGTH (dn) + 1,
6392	IDENTIFIER_POINTER (dn));
6393	TREE_TYPE (args) = char_array_type_node;
6394	args = fix_string_type (args);
6395	args = build_tree_list (NULL_TREE, args);
6396	}
6397	if (check_abi_tag_args (args, name))
6398	DECL_ATTRIBUTES (ns) = tree_cons (name, args,
6399	DECL_ATTRIBUTES (ns));
6400	}
6401	else if (is_attribute_p (attr_name: "deprecated", ident: name))
6402	{
6403	if (!DECL_NAME (ns))
6404	{
6405	warning (OPT_Wattributes, "ignoring %qD attribute on anonymous "
6406	"namespace", name);
6407	continue;
6408	}
6409	if (args && TREE_CODE (TREE_VALUE (args)) != STRING_CST)
6410	{
6411	error ("deprecated message is not a string");
6412	continue;
6413	}
6414	TREE_DEPRECATED (ns) = 1;
6415	if (args)
6416	DECL_ATTRIBUTES (ns) = tree_cons (name, args,
6417	DECL_ATTRIBUTES (ns));
6418	}
6419	else if (!attribute_ignored_p (d))
6420	{
6421	warning (OPT_Wattributes, "%qD attribute directive ignored",
6422	name);
6423	continue;
6424	}
6425	}
6426
6427	return saw_vis;
6428	}
6429
6430	/* Temporarily set the namespace for the current declaration. */
6431
6432	void
6433	push_decl_namespace (tree decl)
6434	{
6435	if (TREE_CODE (decl) != NAMESPACE_DECL)
6436	decl = decl_namespace_context (decl);
6437	vec_safe_push (decl_namespace_list, ORIGINAL_NAMESPACE (decl));
6438	}
6439
6440	/* [namespace.memdef]/2 */
6441
6442	void
6443	pop_decl_namespace (void)
6444	{
6445	decl_namespace_list->pop ();
6446	}
6447
6448	/* Process a namespace-alias declaration. */
6449
6450	void
6451	do_namespace_alias (tree alias, tree name_space)
6452	{
6453	if (name_space == error_mark_node)
6454	return;
6455
6456	gcc_assert (TREE_CODE (name_space) == NAMESPACE_DECL);
6457
6458	name_space = ORIGINAL_NAMESPACE (name_space);
6459
6460	/* Build the alias. */
6461	alias = build_lang_decl (NAMESPACE_DECL, alias, void_type_node);
6462	DECL_NAMESPACE_ALIAS (alias) = name_space;
6463	DECL_EXTERNAL (alias) = 1;
6464	DECL_CONTEXT (alias) = FROB_CONTEXT (current_scope ());
6465	set_originating_module (alias);
6466
6467	pushdecl (decl: alias);
6468
6469	/* Emit debug info for namespace alias. */
6470	if (!building_stmt_list_p ())
6471	(*debug_hooks->early_global_decl) (alias);
6472	}
6473
6474	/* Like pushdecl, only it places DECL in the current namespace,
6475	if appropriate. */
6476
6477	tree
6478	pushdecl_namespace_level (tree decl, bool hiding)
6479	{
6480	auto_cond_timevar tv (TV_NAME_LOOKUP);
6481	return do_pushdecl_with_scope (x: decl, NAMESPACE_LEVEL (current_namespace),
6482	hiding);
6483	}
6484
6485	/* Wrapper around push_local_binding to push the bindings for
6486	a non-member USING_DECL with NAME and VALUE. LOOKUP, if non-null,
6487	is the result of name lookup during template parsing. */
6488
6489	static void
6490	push_using_decl_bindings (name_lookup *lookup, tree name, tree value)
6491	{
6492	tree type = NULL_TREE;
6493
6494	cxx_binding *binding = find_local_binding (current_binding_level, name);
6495	if (binding)
6496	{
6497	value = binding->value;
6498	type = binding->type;
6499	}
6500
6501	/* DR 36 questions why using-decls at function scope may not be
6502	duplicates. Disallow it, as C++11 claimed and PR 20420
6503	implemented. */
6504	if (lookup)
6505	do_nonmember_using_decl (lookup&: *lookup, fn_scope_p: true, insert_p: true, value_p: &value, type_p: &type);
6506
6507	if (!value)
6508	;
6509	else if (binding && value == binding->value)
6510	/* Redeclaration of this USING_DECL. */;
6511	else if (binding && binding->value && TREE_CODE (value) == OVERLOAD)
6512	{
6513	/* We already have this binding, so replace it. */
6514	update_local_overload (IDENTIFIER_BINDING (name), newval: value);
6515	IDENTIFIER_BINDING (name)->value = value;
6516	}
6517	else
6518	/* Install the new binding. */
6519	push_local_binding (id: name, decl: value, /*using=*/is_using: true);
6520
6521	if (!type)
6522	;
6523	else if (binding && type == binding->type)
6524	;
6525	else
6526	{
6527	push_local_binding (id: name, decl: type, /*using=*/is_using: true);
6528	set_identifier_type_value (id: name, decl: type);
6529	}
6530	}
6531
6532	/* Overload for push_using_decl_bindings that doesn't take a name_lookup. */
6533
6534	void
6535	push_using_decl_bindings (tree name, tree value)
6536	{
6537	push_using_decl_bindings (lookup: nullptr, name, value);
6538	}
6539
6540	/* Process a using declaration in non-class scope. */
6541
6542	void
6543	finish_nonmember_using_decl (tree scope, tree name)
6544	{
6545	gcc_checking_assert (current_binding_level->kind != sk_class);
6546
6547	if (scope == error_mark_node || name == error_mark_node)
6548	return;
6549
6550	name_lookup lookup (name);
6551
6552	tree using_decl = lookup_using_decl (scope, lookup);
6553	if (!using_decl)
6554	return;
6555
6556	/* Emit debug info. */
6557	if (!processing_template_decl)
6558	cp_emit_debug_info_for_using (lookup.value,
6559	current_binding_level->this_entity);
6560
6561	if (current_binding_level->kind == sk_namespace)
6562	{
6563	tree *slot = find_namespace_slot (current_namespace, name, create_p: true);
6564	tree *mslot = get_fixed_binding_slot (slot, name,
6565	ix: BINDING_SLOT_CURRENT, create: true);
6566	bool failed = false;
6567
6568	if (mslot != slot)
6569	{
6570	/* A module vector. I presume the binding list is going to
6571	be sparser than the import bitmap. Hence iterate over
6572	the former checking for bits set in the bitmap. */
6573	bitmap imports = get_import_bitmap ();
6574	binding_cluster *cluster = BINDING_VECTOR_CLUSTER_BASE (*slot);
6575
6576	/* Scan the imported bindings. */
6577	unsigned ix = BINDING_VECTOR_NUM_CLUSTERS (*slot);
6578	if (BINDING_VECTOR_SLOTS_PER_CLUSTER == BINDING_SLOTS_FIXED)
6579	{
6580	ix--;
6581	cluster++;
6582	}
6583
6584	/* Do this in forward order, so we load modules in an order
6585	the user expects. */
6586	for (; ix--; cluster++)
6587	for (unsigned jx = 0; jx != BINDING_VECTOR_SLOTS_PER_CLUSTER; jx++)
6588	{
6589	/* Are we importing this module? */
6590	if (unsigned base = cluster->indices[jx].base)
6591	if (unsigned span = cluster->indices[jx].span)
6592	do
6593	if (bitmap_bit_p (imports, base))
6594	goto found;
6595	while (++base, --span);
6596	continue;
6597
6598	found:;
6599	/* Is it loaded? */
6600	if (cluster->slots[jx].is_lazy ())
6601	{
6602	gcc_assert (cluster->indices[jx].span == 1);
6603	lazy_load_binding (mod: cluster->indices[jx].base,
6604	ns: scope, id: name, bslot: &cluster->slots[jx]);
6605	}
6606
6607	tree value = cluster->slots[jx];
6608	if (!value)
6609	/* Load errors could mean there's nothing here. */
6610	continue;
6611
6612	/* Extract what we can see from here. If there's no
6613	stat_hack, then everything was exported. */
6614	tree type = NULL_TREE;
6615
6616	/* If no stat hack, everything is visible. */
6617	if (STAT_HACK_P (value))
6618	{
6619	if (STAT_TYPE_VISIBLE_P (value))
6620	type = STAT_TYPE (value);
6621	value = STAT_VISIBLE (value);
6622	}
6623
6624	if (do_nonmember_using_decl (lookup, fn_scope_p: false, insert_p: false,
6625	value_p: &value, type_p: &type))
6626	{
6627	failed = true;
6628	break;
6629	}
6630	}
6631	}
6632
6633	if (!failed)
6634	{
6635	/* Now do the current slot. */
6636	tree value = MAYBE_STAT_DECL (*mslot);
6637	tree type = MAYBE_STAT_TYPE (*mslot);
6638
6639	do_nonmember_using_decl (lookup, fn_scope_p: false, insert_p: true, value_p: &value, type_p: &type);
6640
6641	// FIXME: Partition mergeableness?
6642	if (STAT_HACK_P (*mslot))
6643	{
6644	STAT_DECL (*mslot) = value;
6645	STAT_TYPE (*mslot) = type;
6646	}
6647	else if (type)
6648	*mslot = stat_hack (decl: value, type);
6649	else
6650	*mslot = value;
6651	}
6652	}
6653	else
6654	{
6655	add_decl_expr (using_decl);
6656	if (DECL_DEPENDENT_P (using_decl))
6657	lookup.value = using_decl;
6658	push_using_decl_bindings (lookup: &lookup, name, NULL_TREE);
6659	}
6660	}
6661
6662	/* Return the declarations that are members of the namespace NS. */
6663
6664	tree
6665	cp_namespace_decls (tree ns)
6666	{
6667	return NAMESPACE_LEVEL (ns)->names;
6668	}
6669
6670	/* Given a lookup that returned VAL, use FLAGS to decide if we want to
6671	ignore it or not. Subroutine of lookup_name_1 and lookup_type_scope. */
6672
6673	static bool
6674	qualify_lookup (tree val, LOOK_want want)
6675	{
6676	if (val == NULL_TREE)
6677	return false;
6678
6679	if (bool (want & LOOK_want::TYPE))
6680	{
6681	tree target_val = strip_using_decl (decl: val);
6682
6683	if (TREE_CODE (STRIP_TEMPLATE (target_val)) == TYPE_DECL)
6684	return true;
6685	}
6686
6687	if (bool (want & LOOK_want::TYPE_NAMESPACE))
6688	return TREE_CODE (val) == NAMESPACE_DECL;
6689
6690	return true;
6691	}
6692
6693	/* Is there a "using namespace std;" directive within USINGS? */
6694
6695	static bool
6696	using_directives_contain_std_p (vec<tree, va_gc> *usings)
6697	{
6698	if (!usings)
6699	return false;
6700
6701	for (unsigned ix = usings->length (); ix--;)
6702	if ((*usings)[ix] == std_node)
6703	return true;
6704
6705	return false;
6706	}
6707
6708	/* Is there a "using namespace std;" directive within the current
6709	namespace (or its ancestors)?
6710	Compare with name_lookup::search_unqualified. */
6711
6712	static bool
6713	has_using_namespace_std_directive_p ()
6714	{
6715	for (cp_binding_level *level = current_binding_level;
6716	level;
6717	level = level->level_chain)
6718	if (using_directives_contain_std_p (usings: level->using_directives))
6719	return true;
6720
6721	return false;
6722	}
6723
6724	/* Subclass of deferred_diagnostic, for issuing a note when
6725	--param cxx-max-namespaces-for-diagnostic-help is reached.
6726
6727	The note should be issued after the error, but before any other
6728	deferred diagnostics. This is handled by decorating a wrapped
6729	deferred_diagnostic, and emitting a note before that wrapped note is
6730	deleted. */
6731
6732	class namespace_limit_reached : public deferred_diagnostic
6733	{
6734	public:
6735	namespace_limit_reached (location_t loc, unsigned limit, tree name,
6736	std::unique_ptr<deferred_diagnostic> wrapped)
6737	: deferred_diagnostic (loc),
6738	m_limit (limit), m_name (name),
6739	m_wrapped (std::move (wrapped))
6740	{
6741	}
6742
6743	~namespace_limit_reached ()
6744	{
6745	/* Unconditionally warn that the search was truncated. */
6746	inform (get_location (),
6747	"maximum limit of %d namespaces searched for %qE",
6748	m_limit, m_name);
6749	/* m_wrapped will be implicitly deleted after this, emitting any followup
6750	diagnostic after the above note. */
6751	}
6752
6753	private:
6754	unsigned m_limit;
6755	tree m_name;
6756	std::unique_ptr<deferred_diagnostic> m_wrapped;
6757	};
6758
6759	/* Subclass of deferred_diagnostic, for use when issuing a single suggestion.
6760	Emit a note showing the location of the declaration of the suggestion. */
6761
6762	class show_candidate_location : public deferred_diagnostic
6763	{
6764	public:
6765	show_candidate_location (location_t loc, tree candidate)
6766	: deferred_diagnostic (loc),
6767	m_candidate (candidate)
6768	{
6769	}
6770
6771	~show_candidate_location ()
6772	{
6773	inform (location_of (m_candidate), "%qE declared here", m_candidate);
6774	}
6775
6776	private:
6777	tree m_candidate;
6778	};
6779
6780	/* Subclass of deferred_diagnostic, for use when there are multiple candidates
6781	to be suggested by suggest_alternatives_for.
6782
6783	Emit a series of notes showing the various suggestions. */
6784
6785	class suggest_alternatives : public deferred_diagnostic
6786	{
6787	public:
6788	suggest_alternatives (location_t loc, vec<tree> candidates)
6789	: deferred_diagnostic (loc),
6790	m_candidates (candidates)
6791	{
6792	}
6793
6794	~suggest_alternatives ()
6795	{
6796	if (m_candidates.length ())
6797	{
6798	inform_n (get_location (), m_candidates.length (),
6799	"suggested alternative:",
6800	"suggested alternatives:");
6801	for (unsigned ix = 0; ix != m_candidates.length (); ix++)
6802	{
6803	tree val = m_candidates[ix];
6804
6805	inform (location_of (val), " %qE", val);
6806	}
6807	}
6808	m_candidates.release ();
6809	}
6810
6811	private:
6812	vec<tree> m_candidates;
6813	};
6814
6815	/* A class for encapsulating the result of a search across
6816	multiple namespaces (and scoped enums within them) for an
6817	unrecognized name seen at a given source location. */
6818
6819	class namespace_hints
6820	{
6821	public:
6822	namespace_hints (location_t loc, tree name);
6823
6824	name_hint convert_candidates_to_name_hint ();
6825	name_hint maybe_decorate_with_limit (name_hint);
6826
6827	private:
6828	void maybe_add_candidate_for_scoped_enum (tree scoped_enum, tree name);
6829
6830	location_t m_loc;
6831	tree m_name;
6832	vec<tree> m_candidates;
6833
6834	/* Value of "--param cxx-max-namespaces-for-diagnostic-help". */
6835	unsigned m_limit;
6836
6837	/* Was the limit reached? */
6838	bool m_limited;
6839	};
6840
6841	/* Constructor for namespace_hints. Search namespaces and scoped enums,
6842	looking for an exact match for unrecognized NAME seen at LOC. */
6843
6844	namespace_hints::namespace_hints (location_t loc, tree name)
6845	: m_loc(loc), m_name (name)
6846	{
6847	auto_vec<tree> worklist;
6848
6849	m_candidates = vNULL;
6850	m_limited = false;
6851	m_limit = param_cxx_max_namespaces_for_diagnostic_help;
6852
6853	/* Breadth-first search of namespaces. Up to limit namespaces
6854	searched (limit zero == unlimited). */
6855	worklist.safe_push (global_namespace);
6856	for (unsigned ix = 0; ix != worklist.length (); ix++)
6857	{
6858	tree ns = worklist[ix];
6859	name_lookup lookup (name);
6860
6861	if (lookup.search_qualified (scope: ns, usings: false))
6862	m_candidates.safe_push (obj: lookup.value);
6863
6864	if (!m_limited)
6865	{
6866	/* Look for child namespaces. We have to do this
6867	indirectly because they are chained in reverse order,
6868	which is confusing to the user. */
6869	auto_vec<tree> children;
6870
6871	for (tree decl = NAMESPACE_LEVEL (ns)->names;
6872	decl; decl = TREE_CHAIN (decl))
6873	{
6874	if (TREE_CODE (decl) == NAMESPACE_DECL
6875	&& !DECL_NAMESPACE_ALIAS (decl)
6876	&& !DECL_NAMESPACE_INLINE_P (decl))
6877	children.safe_push (obj: decl);
6878
6879	/* Look for exact matches for NAME within scoped enums.
6880	These aren't added to the worklist, and so don't count
6881	against the search limit. */
6882	if (TREE_CODE (decl) == TYPE_DECL)
6883	{
6884	tree type = TREE_TYPE (decl);
6885	if (SCOPED_ENUM_P (type))
6886	maybe_add_candidate_for_scoped_enum (scoped_enum: type, name);
6887	}
6888	}
6889
6890	while (!m_limited && !children.is_empty ())
6891	{
6892	if (worklist.length () == m_limit)
6893	m_limited = true;
6894	else
6895	worklist.safe_push (obj: children.pop ());
6896	}
6897	}
6898	}
6899	}
6900
6901	/* Drop ownership of m_candidates, using it to generate a name_hint at m_loc
6902	for m_name, an IDENTIFIER_NODE for which name lookup failed.
6903
6904	If m_candidates is non-empty, use it to generate a suggestion and/or
6905	a deferred diagnostic that lists the possible candidate(s).
6906	*/
6907
6908	name_hint
6909	namespace_hints::convert_candidates_to_name_hint ()
6910	{
6911	/* How many candidates do we have? */
6912
6913	/* If we have just one candidate, issue a name_hint with it as a suggestion
6914	(so that consumers are able to suggest it within the error message and emit
6915	it as a fix-it hint), and with a note showing the candidate's location. */
6916	if (m_candidates.length () == 1)
6917	{
6918	tree candidate = m_candidates[0];
6919	/* Clean up CANDIDATES. */
6920	m_candidates.release ();
6921	return name_hint (expr_to_string (candidate),
6922	new show_candidate_location (m_loc, candidate));
6923	}
6924	else if (m_candidates.length () > 1)
6925	/* If we have more than one candidate, issue a name_hint without a single
6926	"suggestion", but with a deferred diagnostic that lists the
6927	various candidates. This takes ownership of m_candidates. */
6928	return name_hint (NULL, new suggest_alternatives (m_loc, m_candidates));
6929
6930	/* Otherwise, m_candidates ought to be empty, so no cleanup is necessary. */
6931	gcc_assert (m_candidates.length () == 0);
6932	gcc_assert (m_candidates == vNULL);
6933
6934	return name_hint ();
6935	}
6936
6937	/* If --param cxx-max-namespaces-for-diagnostic-help was reached,
6938	then we want to emit a note about after the error, but before
6939	any other deferred diagnostics.
6940
6941	Handle this by figuring out what hint is needed, then optionally
6942	decorating HINT with a namespace_limit_reached wrapper. */
6943
6944	name_hint
6945	namespace_hints::maybe_decorate_with_limit (name_hint hint)
6946	{
6947	if (m_limited)
6948	return name_hint (hint.suggestion (),
6949	new namespace_limit_reached (m_loc, m_limit,
6950	m_name,
6951	hint.take_deferred ()));
6952	else
6953	return hint;
6954	}
6955
6956	/* Look inside SCOPED_ENUM for exact matches for NAME.
6957	If one is found, add its CONST_DECL to m_candidates. */
6958
6959	void
6960	namespace_hints::maybe_add_candidate_for_scoped_enum (tree scoped_enum,
6961	tree name)
6962	{
6963	gcc_assert (SCOPED_ENUM_P (scoped_enum));
6964
6965	for (tree iter = TYPE_VALUES (scoped_enum); iter; iter = TREE_CHAIN (iter))
6966	{
6967	tree id = TREE_PURPOSE (iter);
6968	if (id == name)
6969	{
6970	m_candidates.safe_push (TREE_VALUE (iter));
6971	return;
6972	}
6973	}
6974	}
6975
6976	/* Generate a name_hint at LOCATION for NAME, an IDENTIFIER_NODE for which
6977	name lookup failed.
6978
6979	Search through all available namespaces and any scoped enums within them
6980	and generate a suggestion and/or a deferred diagnostic that lists possible
6981	candidate(s).
6982
6983	If no exact matches are found, and SUGGEST_MISSPELLINGS is true, then also
6984	look for near-matches and suggest the best near-match, if there is one.
6985
6986	If nothing is found, then an empty name_hint is returned. */
6987
6988	name_hint
6989	suggest_alternatives_for (location_t location, tree name,
6990	bool suggest_misspellings)
6991	{
6992	/* First, search for exact matches in other namespaces. */
6993	namespace_hints ns_hints (location, name);
6994	name_hint result = ns_hints.convert_candidates_to_name_hint ();
6995
6996	/* Otherwise, try other approaches. */
6997	if (!result)
6998	result = suggest_alternatives_for_1 (location, name, suggest_misspellings);
6999
7000	return ns_hints.maybe_decorate_with_limit (hint: std::move (result));
7001	}
7002
7003	/* The second half of suggest_alternatives_for, for when no exact matches
7004	were found in other namespaces. */
7005
7006	static name_hint
7007	suggest_alternatives_for_1 (location_t location, tree name,
7008	bool suggest_misspellings)
7009	{
7010	/* No candidates were found in the available namespaces. */
7011
7012	/* If there's a "using namespace std;" active, and this
7013	is one of the most common "std::" names, then it's probably a
7014	missing #include. */
7015	if (has_using_namespace_std_directive_p ())
7016	{
7017	name_hint hint = maybe_suggest_missing_std_header (location, name);
7018	if (hint)
7019	return hint;
7020	}
7021
7022	/* Otherwise, consider misspellings. */
7023	if (!suggest_misspellings)
7024	return name_hint ();
7025
7026	return lookup_name_fuzzy (name, FUZZY_LOOKUP_NAME, location);
7027	}
7028
7029	/* Generate a name_hint at LOCATION for NAME, an IDENTIFIER_NODE for which
7030	name lookup failed.
7031
7032	Search through all available namespaces and generate a suggestion and/or
7033	a deferred diagnostic that lists possible candidate(s).
7034
7035	This is similiar to suggest_alternatives_for, but doesn't fallback to
7036	the other approaches used by that function. */
7037
7038	name_hint
7039	suggest_alternatives_in_other_namespaces (location_t location, tree name)
7040	{
7041	namespace_hints ns_hints (location, name);
7042
7043	name_hint result = ns_hints.convert_candidates_to_name_hint ();
7044
7045	return ns_hints.maybe_decorate_with_limit (hint: std::move (result));
7046	}
7047
7048	/* A well-known name within the C++ standard library, returned by
7049	get_std_name_hint.
7050
7051	The gperf-generated file contains the definition of the class
7052	"std_name_hint_lookup" with a static member function which
7053	returns the pointer to a structure "std_name_hint" which
7054	is also defined in that file. */
7055
7056	#include "std-name-hint.h"
7057
7058	/* Subroutine of maybe_suggest_missing_header for handling unrecognized names
7059	for some of the most common names within "std::".
7060	Given non-NULL NAME, return the std_name_hint for it, or NULL. */
7061
7062	static const std_name_hint *
7063	get_std_name_hint (const char *name)
7064	{
7065	return std_name_hint_lookup::find(str: name, len: strlen(s: name));
7066	}
7067
7068	/* Describe DIALECT. */
7069
7070	const char *
7071	get_cxx_dialect_name (enum cxx_dialect dialect)
7072	{
7073	switch (dialect)
7074	{
7075	default:
7076	gcc_unreachable ();
7077	case cxx98:
7078	return "C++98";
7079	case cxx11:
7080	return "C++11";
7081	case cxx14:
7082	return "C++14";
7083	case cxx17:
7084	return "C++17";
7085	case cxx20:
7086	return "C++20";
7087	case cxx23:
7088	return "C++23";
7089	case cxx26:
7090	return "C++26";
7091	}
7092	}
7093
7094	/* Subclass of deferred_diagnostic for use for names in the "std" namespace
7095	that weren't recognized, but for which we know which header it ought to be
7096	in.
7097
7098	Emit a note either suggesting the header to be included, or noting that
7099	the current dialect is too early for the given name. */
7100
7101	class missing_std_header : public deferred_diagnostic
7102	{
7103	public:
7104	missing_std_header (location_t loc,
7105	const char *name_str,
7106	const std_name_hint *header_hint)
7107	: deferred_diagnostic (loc),
7108	m_name_str (name_str),
7109	m_header_hint (header_hint)
7110	{}
7111	~missing_std_header ()
7112	{
7113	gcc_rich_location richloc (get_location ());
7114	if (cxx_dialect >= m_header_hint->min_dialect)
7115	{
7116	const char *header = m_header_hint->header;
7117	maybe_add_include_fixit (&richloc, header, true);
7118	inform (&richloc,
7119	"%<std::%s%> is defined in header %qs;"
7120	" this is probably fixable by adding %<#include %s%>",
7121	m_name_str, header, header);
7122	}
7123	else
7124	inform (&richloc,
7125	"%<std::%s%> is only available from %s onwards",
7126	m_name_str, get_cxx_dialect_name (dialect: m_header_hint->min_dialect));
7127	}
7128
7129	private:
7130	const char *m_name_str;
7131	const std_name_hint *m_header_hint;
7132	};
7133
7134	/* Attempt to generate a name_hint that suggests pertinent header files
7135	for NAME at LOCATION, for common names within the "std" namespace,
7136	or an empty name_hint if this isn't applicable. */
7137
7138	static name_hint
7139	maybe_suggest_missing_std_header (location_t location, tree name)
7140	{
7141	gcc_assert (TREE_CODE (name) == IDENTIFIER_NODE);
7142
7143	const char *name_str = IDENTIFIER_POINTER (name);
7144	const std_name_hint *header_hint = get_std_name_hint (name: name_str);
7145	if (!header_hint)
7146	return name_hint ();
7147
7148	return name_hint (NULL, new missing_std_header (location, name_str,
7149	header_hint));
7150	}
7151
7152	/* Attempt to generate a name_hint that suggests a missing header file
7153	for NAME within SCOPE at LOCATION, or an empty name_hint if this isn't
7154	applicable. */
7155
7156	name_hint
7157	maybe_suggest_missing_header (location_t location, tree name, tree scope)
7158	{
7159	if (scope == NULL_TREE)
7160	return name_hint ();
7161	if (TREE_CODE (scope) != NAMESPACE_DECL)
7162	return name_hint ();
7163	/* We only offer suggestions for the "std" namespace. */
7164	if (scope != std_node)
7165	return name_hint ();
7166	return maybe_suggest_missing_std_header (location, name);
7167	}
7168
7169	/* Generate a name_hint at LOCATION for NAME, an IDENTIFIER_NODE for which name
7170	lookup failed within the explicitly provided SCOPE.
7171
7172	Suggest the best meaningful candidates (if any), otherwise
7173	an empty name_hint is returned. */
7174
7175	name_hint
7176	suggest_alternative_in_explicit_scope (location_t location, tree name,
7177	tree scope)
7178	{
7179	/* Something went very wrong; don't suggest anything. */
7180	if (name == error_mark_node)
7181	return name_hint ();
7182
7183	/* Resolve any namespace aliases. */
7184	scope = ORIGINAL_NAMESPACE (scope);
7185
7186	name_hint hint = maybe_suggest_missing_header (location, name, scope);
7187	if (hint)
7188	return hint;
7189
7190	cp_binding_level *level = NAMESPACE_LEVEL (scope);
7191
7192	best_match <tree, const char *> bm (name);
7193	consider_binding_level (name, bm, lvl: level, look_within_fields: false, kind: FUZZY_LOOKUP_NAME);
7194
7195	/* See if we have a good suggesion for the user. */
7196	const char *fuzzy_name = bm.get_best_meaningful_candidate ();
7197	if (fuzzy_name)
7198	return name_hint (fuzzy_name, NULL);
7199
7200	return name_hint ();
7201	}
7202
7203	/* Given NAME, look within SCOPED_ENUM for possible spell-correction
7204	candidates. */
7205
7206	name_hint
7207	suggest_alternative_in_scoped_enum (tree name, tree scoped_enum)
7208	{
7209	gcc_assert (SCOPED_ENUM_P (scoped_enum));
7210
7211	best_match <tree, const char *> bm (name);
7212	for (tree iter = TYPE_VALUES (scoped_enum); iter; iter = TREE_CHAIN (iter))
7213	{
7214	tree id = TREE_PURPOSE (iter);
7215	bm.consider (IDENTIFIER_POINTER (id));
7216	}
7217	return name_hint (bm.get_best_meaningful_candidate (), NULL);
7218	}
7219
7220	/* Look up NAME (an IDENTIFIER_NODE) in SCOPE (either a NAMESPACE_DECL
7221	or a class TYPE).
7222
7223	WANT as for lookup_name_1.
7224
7225	Returns a DECL (or OVERLOAD, or BASELINK) representing the
7226	declaration found. If no suitable declaration can be found,
7227	ERROR_MARK_NODE is returned. If COMPLAIN is true and SCOPE is
7228	neither a class-type nor a namespace a diagnostic is issued. */
7229
7230	tree
7231	lookup_qualified_name (tree scope, tree name, LOOK_want want, bool complain)
7232	{
7233	tree t = NULL_TREE;
7234
7235	if (TREE_CODE (scope) == NAMESPACE_DECL)
7236	{
7237	name_lookup lookup (name, want);
7238
7239	if (qualified_namespace_lookup (scope, &lookup))
7240	{
7241	t = lookup.value;
7242
7243	/* If we have a known type overload, pull it out. This can happen
7244	for using decls. */
7245	if (TREE_CODE (t) == OVERLOAD && TREE_TYPE (t) != unknown_type_node)
7246	t = OVL_FUNCTION (t);
7247	}
7248	}
7249	else if (cxx_dialect != cxx98 && TREE_CODE (scope) == ENUMERAL_TYPE)
7250	t = lookup_enumerator (scope, name);
7251	else if (is_class_type (scope, complain))
7252	t = lookup_member (scope, name, 2, bool (want & LOOK_want::TYPE),
7253	tf_warning_or_error);
7254
7255	if (!t)
7256	return error_mark_node;
7257	return t;
7258	}
7259
7260	/* Wrapper for the above that takes a string argument. The function name is
7261	not at the beginning of the line to keep this wrapper out of etags. */
7262
7263	tree lookup_qualified_name (tree t, const char *p, LOOK_want w, bool c)
7264	{
7265	return lookup_qualified_name (scope: t, get_identifier (p), want: w, complain: c);
7266	}
7267
7268	/* [namespace.qual]
7269	Accepts the NAME to lookup and its qualifying SCOPE.
7270	Returns the name/type pair found into the cxx_binding *RESULT,
7271	or false on error. */
7272
7273	static bool
7274	qualified_namespace_lookup (tree scope, name_lookup *lookup)
7275	{
7276	timevar_start (TV_NAME_LOOKUP);
7277	query_oracle (name: lookup->name);
7278	bool found = lookup->search_qualified (ORIGINAL_NAMESPACE (scope));
7279	timevar_stop (TV_NAME_LOOKUP);
7280	return found;
7281	}
7282
7283	/* If DECL is suitably visible to the user, consider its name for
7284	spelling correction. */
7285
7286	static void
7287	consider_decl (tree decl, best_match <tree, const char *> &bm,
7288	bool consider_impl_names)
7289	{
7290	/* Skip compiler-generated variables (e.g. __for_begin/__for_end
7291	within range for). */
7292	if (VAR_P (decl) && DECL_ARTIFICIAL (decl))
7293	return;
7294
7295	tree suggestion = DECL_NAME (decl);
7296	if (!suggestion)
7297	return;
7298
7299	/* Don't suggest names that are for anonymous aggregate types, as
7300	they are an implementation detail generated by the compiler. */
7301	if (IDENTIFIER_ANON_P (suggestion))
7302	return;
7303
7304	const char *suggestion_str = IDENTIFIER_POINTER (suggestion);
7305
7306	/* Ignore internal names with spaces in them. */
7307	if (strchr (s: suggestion_str, c: ' '))
7308	return;
7309
7310	/* Don't suggest names that are reserved for use by the
7311	implementation, unless NAME began with an underscore. */
7312	if (!consider_impl_names
7313	&& name_reserved_for_implementation_p (str: suggestion_str))
7314	return;
7315
7316	bm.consider (candidate: suggestion_str);
7317	}
7318
7319	/* If DECL is suitably visible to the user, add its name to VEC and
7320	return true. Otherwise return false. */
7321
7322	static bool
7323	maybe_add_fuzzy_decl (auto_vec<tree> &vec, tree decl)
7324	{
7325	/* Skip compiler-generated variables (e.g. __for_begin/__for_end
7326	within range for). */
7327	if (VAR_P (decl) && DECL_ARTIFICIAL (decl))
7328	return false;
7329
7330	tree suggestion = DECL_NAME (decl);
7331	if (!suggestion)
7332	return false;
7333
7334	/* Don't suggest names that are for anonymous aggregate types, as
7335	they are an implementation detail generated by the compiler. */
7336	if (IDENTIFIER_ANON_P (suggestion))
7337	return false;
7338
7339	vec.safe_push (obj: suggestion);
7340
7341	return true;
7342	}
7343
7344	/* Examing the namespace binding BINDING, and add at most one instance
7345	of the name, if it contains a visible entity of interest. Return
7346	true if we added something. */
7347
7348	bool
7349	maybe_add_fuzzy_binding (auto_vec<tree> &vec, tree binding,
7350	lookup_name_fuzzy_kind kind)
7351	{
7352	tree value = NULL_TREE;
7353
7354	if (STAT_HACK_P (binding))
7355	{
7356	if (!STAT_TYPE_HIDDEN_P (binding)
7357	&& STAT_TYPE (binding))
7358	{
7359	if (maybe_add_fuzzy_decl (vec, STAT_TYPE (binding)))
7360	return true;
7361	}
7362	else if (!STAT_DECL_HIDDEN_P (binding))
7363	value = STAT_DECL (binding);
7364	}
7365	else
7366	value = binding;
7367
7368	value = ovl_skip_hidden (value);
7369	if (value)
7370	{
7371	value = OVL_FIRST (value);
7372	if (kind != FUZZY_LOOKUP_TYPENAME
7373	|| TREE_CODE (STRIP_TEMPLATE (value)) == TYPE_DECL)
7374	if (maybe_add_fuzzy_decl (vec, decl: value))
7375	return true;
7376	}
7377
7378	/* Nothing found. */
7379	return false;
7380	}
7381
7382	/* Helper function for lookup_name_fuzzy.
7383	Traverse binding level LVL, looking for good name matches for NAME
7384	(and BM). */
7385	static void
7386	consider_binding_level (tree name, best_match <tree, const char *> &bm,
7387	cp_binding_level *lvl, bool look_within_fields,
7388	enum lookup_name_fuzzy_kind kind)
7389	{
7390	if (look_within_fields)
7391	if (lvl->this_entity && TREE_CODE (lvl->this_entity) == RECORD_TYPE)
7392	{
7393	tree type = lvl->this_entity;
7394	bool want_type_p = (kind == FUZZY_LOOKUP_TYPENAME);
7395	tree best_matching_field
7396	= lookup_member_fuzzy (type, name, want_type_p);
7397	if (best_matching_field)
7398	bm.consider (IDENTIFIER_POINTER (best_matching_field));
7399	}
7400
7401	/* Only suggest names reserved for the implementation if NAME begins
7402	with an underscore. */
7403	bool consider_implementation_names = (IDENTIFIER_POINTER (name)[0] == '_');
7404
7405	if (lvl->kind != sk_namespace)
7406	for (tree t = lvl->names; t; t = TREE_CHAIN (t))
7407	{
7408	tree d = t;
7409
7410	/* OVERLOADs or decls from using declaration are wrapped into
7411	TREE_LIST. */
7412	if (TREE_CODE (d) == TREE_LIST)
7413	d = OVL_FIRST (TREE_VALUE (d));
7414
7415	/* Don't use bindings from implicitly declared functions,
7416	as they were likely misspellings themselves. */
7417	if (TREE_TYPE (d) == error_mark_node)
7418	continue;
7419
7420	/* If we want a typename, ignore non-types. */
7421	if (kind == FUZZY_LOOKUP_TYPENAME
7422	&& TREE_CODE (STRIP_TEMPLATE (d)) != TYPE_DECL)
7423	continue;
7424
7425	consider_decl (decl: d, bm, consider_impl_names: consider_implementation_names);
7426	}
7427	else
7428	{
7429	/* We need to iterate over the namespace hash table, in order to
7430	not mention hidden entities. But hash table iteration is
7431	(essentially) unpredictable, our correction-distance measure
7432	is very granular, and we pick the first of equal distances.
7433	Hence, we need to call the distance-measurer in a predictable
7434	order. So, iterate over the namespace hash, inserting
7435	visible names into a vector. Then sort the vector. Then
7436	determine spelling distance. */
7437
7438	tree ns = lvl->this_entity;
7439	auto_vec<tree> vec;
7440
7441	hash_table<named_decl_hash>::iterator end
7442	(DECL_NAMESPACE_BINDINGS (ns)->end ());
7443	for (hash_table<named_decl_hash>::iterator iter
7444	(DECL_NAMESPACE_BINDINGS (ns)->begin ()); iter != end; ++iter)
7445	{
7446	tree binding = *iter;
7447
7448	if (TREE_CODE (binding) == BINDING_VECTOR)
7449	{
7450	bitmap imports = get_import_bitmap ();
7451	binding_cluster *cluster = BINDING_VECTOR_CLUSTER_BASE (binding);
7452
7453	if (tree bind = cluster->slots[BINDING_SLOT_CURRENT])
7454	if (maybe_add_fuzzy_binding (vec, binding: bind, kind))
7455	continue;
7456
7457	/* Scan the imported bindings. */
7458	unsigned ix = BINDING_VECTOR_NUM_CLUSTERS (binding);
7459	if (BINDING_VECTOR_SLOTS_PER_CLUSTER == BINDING_SLOTS_FIXED)
7460	{
7461	ix--;
7462	cluster++;
7463	}
7464
7465	for (; ix--; cluster++)
7466	for (unsigned jx = 0; jx != BINDING_VECTOR_SLOTS_PER_CLUSTER;
7467	jx++)
7468	{
7469	/* Are we importing this module? */
7470	if (unsigned base = cluster->indices[jx].base)
7471	if (unsigned span = cluster->indices[jx].span)
7472	do
7473	if (bitmap_bit_p (imports, base))
7474	goto found;
7475	while (++base, --span);
7476	continue;
7477
7478	found:;
7479	/* Is it loaded? */
7480	if (cluster->slots[jx].is_lazy ())
7481	/* Let's not read in everything on the first
7482	spello! **/
7483	continue;
7484	if (tree bind = cluster->slots[jx])
7485	if (maybe_add_fuzzy_binding (vec, binding: bind, kind))
7486	break;
7487	}
7488	}
7489	else
7490	maybe_add_fuzzy_binding (vec, binding, kind);
7491	}
7492
7493	vec.qsort ([] (const void *a_, const void *b_)
7494	{
7495	return strcmp (IDENTIFIER_POINTER (*(const tree *)a_),
7496	IDENTIFIER_POINTER (*(const tree *)b_));
7497	});
7498
7499	/* Examine longest to shortest. */
7500	for (unsigned ix = vec.length (); ix--;)
7501	{
7502	const char *str = IDENTIFIER_POINTER (vec[ix]);
7503
7504	/* Ignore internal names with spaces in them. */
7505	if (strchr (s: str, c: ' '))
7506	continue;
7507
7508	/* Don't suggest names that are reserved for use by the
7509	implementation, unless NAME began with an underscore. */
7510	if (!consider_implementation_names
7511	&& name_reserved_for_implementation_p (str))
7512	continue;
7513
7514	bm.consider (candidate: str);
7515	}
7516	}
7517	}
7518
7519	/* Subclass of deferred_diagnostic. Notify the user that the
7520	given macro was used before it was defined.
7521	This can be done in the C++ frontend since tokenization happens
7522	upfront. */
7523
7524	class macro_use_before_def : public deferred_diagnostic
7525	{
7526	public:
7527	/* Factory function. Return a new macro_use_before_def instance if
7528	appropriate, or return NULL. */
7529	static macro_use_before_def *
7530	maybe_make (location_t use_loc, cpp_hashnode *macro)
7531	{
7532	location_t def_loc = cpp_macro_definition_location (node: macro);
7533	if (def_loc == UNKNOWN_LOCATION)
7534	return NULL;
7535
7536	/* We only want to issue a note if the macro was used *before* it was
7537	defined.
7538	We don't want to issue a note for cases where a macro was incorrectly
7539	used, leaving it unexpanded (e.g. by using the wrong argument
7540	count). */
7541	if (!linemap_location_before_p (set: line_table, loc_a: use_loc, loc_b: def_loc))
7542	return NULL;
7543
7544	return new macro_use_before_def (use_loc, macro);
7545	}
7546
7547	private:
7548	/* Ctor. LOC is the location of the usage. MACRO is the
7549	macro that was used. */
7550	macro_use_before_def (location_t loc, cpp_hashnode *macro)
7551	: deferred_diagnostic (loc), m_macro (macro)
7552	{
7553	gcc_assert (macro);
7554	}
7555
7556	~macro_use_before_def ()
7557	{
7558	if (is_suppressed_p ())
7559	return;
7560
7561	inform (get_location (), "the macro %qs had not yet been defined",
7562	(const char *)m_macro->ident.str);
7563	inform (cpp_macro_definition_location (node: m_macro),
7564	"it was later defined here");
7565	}
7566
7567	private:
7568	cpp_hashnode *m_macro;
7569	};
7570
7571	/* Determine if it can ever make sense to offer RID as a suggestion for
7572	a misspelling.
7573
7574	Subroutine of lookup_name_fuzzy. */
7575
7576	static bool
7577	suggest_rid_p (enum rid rid)
7578	{
7579	switch (rid)
7580	{
7581	/* Support suggesting function-like keywords. */
7582	case RID_STATIC_ASSERT:
7583	return true;
7584
7585	default:
7586	/* Support suggesting the various decl-specifier words, to handle
7587	e.g. "singed" vs "signed" typos. */
7588	if (cp_keyword_starts_decl_specifier_p (keyword: rid))
7589	return true;
7590
7591	/* Otherwise, don't offer it. This avoids suggesting e.g. "if"
7592	and "do" for short misspellings, which are likely to lead to
7593	nonsensical results. */
7594	return false;
7595	}
7596	}
7597
7598	/* Search for near-matches for NAME within the current bindings, and within
7599	macro names, returning the best match as a const char *, or NULL if
7600	no reasonable match is found.
7601
7602	Use LOC for any deferred diagnostics. */
7603
7604	name_hint
7605	lookup_name_fuzzy (tree name, enum lookup_name_fuzzy_kind kind, location_t loc)
7606	{
7607	gcc_assert (TREE_CODE (name) == IDENTIFIER_NODE);
7608
7609	/* First, try some well-known names in the C++ standard library, in case
7610	the user forgot a #include. */
7611	const char *header_hint
7612	= get_cp_stdlib_header_for_name (IDENTIFIER_POINTER (name));
7613	if (header_hint)
7614	return name_hint (NULL,
7615	new suggest_missing_header (loc,
7616	IDENTIFIER_POINTER (name),
7617	header_hint));
7618
7619	best_match <tree, const char *> bm (name);
7620
7621	cp_binding_level *lvl;
7622	for (lvl = scope_chain->class_bindings; lvl; lvl = lvl->level_chain)
7623	consider_binding_level (name, bm, lvl, look_within_fields: true, kind);
7624
7625	for (lvl = current_binding_level; lvl; lvl = lvl->level_chain)
7626	consider_binding_level (name, bm, lvl, look_within_fields: false, kind);
7627
7628	/* Consider macros: if the user misspelled a macro name e.g. "SOME_MACRO"
7629	as:
7630	x = SOME_OTHER_MACRO (y);
7631	then "SOME_OTHER_MACRO" will survive to the frontend and show up
7632	as a misspelled identifier.
7633
7634	Use the best distance so far so that a candidate is only set if
7635	a macro is better than anything so far. This allows early rejection
7636	(without calculating the edit distance) of macro names that must have
7637	distance >= bm.get_best_distance (), and means that we only get a
7638	non-NULL result for best_macro_match if it's better than any of
7639	the identifiers already checked. */
7640	best_macro_match bmm (name, bm.get_best_distance (), parse_in);
7641	cpp_hashnode *best_macro = bmm.get_best_meaningful_candidate ();
7642	/* If a macro is the closest so far to NAME, consider it. */
7643	if (best_macro)
7644	bm.consider (candidate: (const char *)best_macro->ident.str);
7645	else if (bmm.get_best_distance () == 0)
7646	{
7647	/* If we have an exact match for a macro name, then either the
7648	macro was used with the wrong argument count, or the macro
7649	has been used before it was defined. */
7650	if (cpp_hashnode *macro = bmm.blithely_get_best_candidate ())
7651	if (cpp_user_macro_p (node: macro))
7652	return name_hint (NULL,
7653	macro_use_before_def::maybe_make (use_loc: loc, macro));
7654	}
7655
7656	/* Try the "starts_decl_specifier_p" keywords to detect
7657	"singed" vs "signed" typos. */
7658	for (unsigned i = 0; i < num_c_common_reswords; i++)
7659	{
7660	const c_common_resword *resword = &c_common_reswords[i];
7661
7662	if (!suggest_rid_p (rid: resword->rid))
7663	continue;
7664
7665	tree resword_identifier = ridpointers [resword->rid];
7666	if (!resword_identifier)
7667	continue;
7668	gcc_assert (TREE_CODE (resword_identifier) == IDENTIFIER_NODE);
7669
7670	/* Only consider reserved words that survived the
7671	filtering in init_reswords (e.g. for -std). */
7672	if (!IDENTIFIER_KEYWORD_P (resword_identifier))
7673	continue;
7674
7675	bm.consider (IDENTIFIER_POINTER (resword_identifier));
7676	}
7677
7678	return name_hint (bm.get_best_meaningful_candidate (), NULL);
7679	}
7680
7681	/* Subroutine of outer_binding.
7682
7683	Returns TRUE if BINDING is a binding to a template parameter of
7684	SCOPE. In that case SCOPE is the scope of a primary template
7685	parameter -- in the sense of G++, i.e, a template that has its own
7686	template header.
7687
7688	Returns FALSE otherwise. */
7689
7690	static bool
7691	binding_to_template_parms_of_scope_p (cxx_binding *binding,
7692	cp_binding_level *scope)
7693	{
7694	tree binding_value, tmpl, tinfo;
7695	int level;
7696
7697	if (!binding || !scope || !scope->this_entity)
7698	return false;
7699
7700	binding_value = binding->value ? binding->value : binding->type;
7701	tinfo = get_template_info (scope->this_entity);
7702
7703	/* BINDING_VALUE must be a template parm. */
7704	if (binding_value == NULL_TREE
7705	|| (!DECL_P (binding_value)
7706	|| !DECL_TEMPLATE_PARM_P (binding_value)))
7707	return false;
7708
7709	/* The level of BINDING_VALUE. */
7710	level =
7711	template_type_parameter_p (binding_value)
7712	? TEMPLATE_PARM_LEVEL (TEMPLATE_TYPE_PARM_INDEX
7713	(TREE_TYPE (binding_value)))
7714	: TEMPLATE_PARM_LEVEL (DECL_INITIAL (binding_value));
7715
7716	/* The template of the current scope, iff said scope is a primary
7717	template. */
7718	tmpl = (tinfo
7719	&& PRIMARY_TEMPLATE_P (TI_TEMPLATE (tinfo))
7720	? TI_TEMPLATE (tinfo)
7721	: NULL_TREE);
7722
7723	/* If the level of the parm BINDING_VALUE equals the depth of TMPL,
7724	then BINDING_VALUE is a parameter of TMPL. */
7725	return (tmpl && level == TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (tmpl)));
7726	}
7727
7728	/* Return the innermost non-namespace binding for NAME from a scope
7729	containing BINDING, or, if BINDING is NULL, the current scope.
7730	Please note that for a given template, the template parameters are
7731	considered to be in the scope containing the current scope.
7732	If CLASS_P is false, then class bindings are ignored. */
7733
7734	cxx_binding *
7735	outer_binding (tree name,
7736	cxx_binding *binding,
7737	bool class_p)
7738	{
7739	cxx_binding *outer;
7740	cp_binding_level *scope;
7741	cp_binding_level *outer_scope;
7742
7743	if (binding)
7744	{
7745	scope = binding->scope->level_chain;
7746	outer = binding->previous;
7747	}
7748	else
7749	{
7750	scope = current_binding_level;
7751	outer = IDENTIFIER_BINDING (name);
7752	}
7753	outer_scope = outer ? outer->scope : NULL;
7754
7755	/* Because we create class bindings lazily, we might be missing a
7756	class binding for NAME. If there are any class binding levels
7757	between the LAST_BINDING_LEVEL and the scope in which OUTER was
7758	declared, we must lookup NAME in those class scopes. */
7759	if (class_p)
7760	while (scope && scope != outer_scope && scope->kind != sk_namespace)
7761	{
7762	if (scope->kind == sk_class)
7763	{
7764	cxx_binding *class_binding;
7765
7766	class_binding = get_class_binding (name, scope);
7767	if (class_binding)
7768	{
7769	/* Thread this new class-scope binding onto the
7770	IDENTIFIER_BINDING list so that future lookups
7771	find it quickly. */
7772	if (BASELINK_P (class_binding->value))
7773	/* Don't put a BASELINK in IDENTIFIER_BINDING. */
7774	class_binding->value
7775	= BASELINK_FUNCTIONS (class_binding->value);
7776	class_binding->previous = outer;
7777	if (binding)
7778	binding->previous = class_binding;
7779	else
7780	IDENTIFIER_BINDING (name) = class_binding;
7781	return class_binding;
7782	}
7783	}
7784	/* If we are in a member template, the template parms of the member
7785	template are considered to be inside the scope of the containing
7786	class, but within G++ the class bindings are all pushed between the
7787	template parms and the function body. So if the outer binding is
7788	a template parm for the current scope, return it now rather than
7789	look for a class binding. */
7790	if (outer_scope && outer_scope->kind == sk_template_parms
7791	&& binding_to_template_parms_of_scope_p (binding: outer, scope))
7792	return outer;
7793
7794	scope = scope->level_chain;
7795	}
7796
7797	return outer;
7798	}
7799
7800	/* Return the innermost block-scope or class-scope value binding for
7801	NAME, or NULL_TREE if there is no such binding. */
7802
7803	tree
7804	innermost_non_namespace_value (tree name)
7805	{
7806	cxx_binding *binding;
7807	binding = outer_binding (name, /*binding=*/NULL, /*class_p=*/true);
7808	return binding ? binding->value : NULL_TREE;
7809	}
7810
7811	/* True iff current_binding_level is within the potential scope of local
7812	variable DECL. */
7813
7814	bool
7815	decl_in_scope_p (tree decl)
7816	{
7817	gcc_checking_assert (DECL_FUNCTION_SCOPE_P (decl));
7818
7819	tree name = DECL_NAME (decl);
7820
7821	for (cxx_binding *iter = NULL;
7822	(iter = outer_binding (name, binding: iter, /*class_p=*/false)); )
7823	{
7824	if (!LOCAL_BINDING_P (iter))
7825	return false;
7826	if (iter->value == decl)
7827	return true;
7828	}
7829
7830	return false;
7831	}
7832
7833	/* Look up NAME in the current binding level and its superiors in the
7834	namespace of variables, functions and typedefs. Return a ..._DECL
7835	node of some kind representing its definition if there is only one
7836	such declaration, or return a TREE_LIST with all the overloaded
7837	definitions if there are many, or return NULL_TREE if it is undefined.
7838	Hidden name, either friend declaration or built-in function, are
7839	not ignored.
7840
7841	WHERE controls which scopes are considered. It is a bit mask of
7842	LOOK_where::BLOCK (look in block scope), LOOK_where::CLASS
7843	(look in class scopes) & LOOK_where::NAMESPACE (look in namespace
7844	scopes). It is an error for no bits to be set. These scopes are
7845	searched from innermost to outermost.
7846
7847	WANT controls what kind of entity we'd happy with.
7848	LOOK_want::NORMAL for normal lookup (implicit typedefs can be
7849	hidden). LOOK_want::TYPE for only TYPE_DECLS, LOOK_want::NAMESPACE
7850	for only NAMESPACE_DECLS. These two can be bit-ored to find
7851	namespace or type.
7852
7853	WANT can also have LOOK_want::HIDDEN_FRIEND or
7854	LOOK_want::HIDDEN_LAMBDa added to it. */
7855
7856	tree
7857	lookup_name (tree name, LOOK_where where, LOOK_want want)
7858	{
7859	tree val = NULL_TREE;
7860
7861	auto_cond_timevar tv (TV_NAME_LOOKUP);
7862
7863	gcc_checking_assert (unsigned (where) != 0);
7864	/* If we're looking for hidden lambda things, we shouldn't be
7865	looking in namespace scope. */
7866	gcc_checking_assert (!bool (want & LOOK_want::HIDDEN_LAMBDA)
7867	|| !bool (where & LOOK_where::NAMESPACE));
7868	query_oracle (name);
7869
7870	/* Conversion operators are handled specially because ordinary
7871	unqualified name lookup will not find template conversion
7872	operators. */
7873	if (IDENTIFIER_CONV_OP_P (name))
7874	{
7875	cp_binding_level *level;
7876
7877	for (level = current_binding_level;
7878	level && level->kind != sk_namespace;
7879	level = level->level_chain)
7880	{
7881	tree class_type;
7882	tree operators;
7883
7884	/* A conversion operator can only be declared in a class
7885	scope. */
7886	if (level->kind != sk_class)
7887	continue;
7888
7889	/* Lookup the conversion operator in the class. */
7890	class_type = level->this_entity;
7891	operators = lookup_fnfields (class_type, name, /*protect=*/0,
7892	tf_warning_or_error);
7893	if (operators)
7894	return operators;
7895	}
7896
7897	return NULL_TREE;
7898	}
7899
7900	/* First, look in non-namespace scopes. */
7901
7902	if (current_class_type == NULL_TREE)
7903	/* Maybe avoid searching the binding stack at all. */
7904	where = LOOK_where (unsigned (where) & ~unsigned (LOOK_where::CLASS));
7905
7906	if (bool (where & (LOOK_where::BLOCK | LOOK_where::CLASS)))
7907	for (cxx_binding *iter = nullptr;
7908	(iter = outer_binding (name, binding: iter, class_p: bool (where & LOOK_where::CLASS)));)
7909	{
7910	/* Skip entities we don't want. */
7911	if (!bool (where & (LOCAL_BINDING_P (iter)
7912	? LOOK_where::BLOCK : LOOK_where::CLASS)))
7913	continue;
7914
7915	/* If this is the kind of thing we're looking for, we're done. */
7916	if (iter->value)
7917	{
7918	tree binding = NULL_TREE;
7919
7920	if (!(!iter->type && HIDDEN_TYPE_BINDING_P (iter))
7921	&& (bool (want & LOOK_want::HIDDEN_LAMBDA)
7922	|| !is_lambda_ignored_entity (iter->value))
7923	&& qualify_lookup (val: iter->value, want))
7924	binding = iter->value;
7925	else if (bool (want & LOOK_want::TYPE)
7926	&& !HIDDEN_TYPE_BINDING_P (iter)
7927	&& iter->type)
7928	binding = iter->type;
7929
7930	if (binding)
7931	{
7932	val = binding;
7933	break;
7934	}
7935	}
7936	}
7937
7938	/* Now lookup in namespace scopes. */
7939	if (!val && bool (where & LOOK_where::NAMESPACE))
7940	{
7941	name_lookup lookup (name, want);
7942	if (lookup.search_unqualified
7943	(scope: current_decl_namespace (), current_binding_level))
7944	val = lookup.value;
7945	}
7946
7947	/* If we have a known type overload, pull it out. This can happen
7948	for both using decls and unhidden functions. */
7949	if (val && TREE_CODE (val) == OVERLOAD && TREE_TYPE (val) != unknown_type_node)
7950	val = OVL_FUNCTION (val);
7951
7952	return val;
7953	}
7954
7955	tree
7956	lookup_name (tree name)
7957	{
7958	return lookup_name (name, where: LOOK_where::ALL, want: LOOK_want::NORMAL);
7959	}
7960
7961	/* Look up NAME for type used in elaborated name specifier in
7962	the scopes given by HOW.
7963
7964	Unlike lookup_name_1, we make sure that NAME is actually
7965	declared in the desired scope, not from inheritance, nor using
7966	directive. For using declaration, there is DR138 still waiting
7967	to be resolved. Hidden name coming from an earlier friend
7968	declaration is also returned, and will be made visible unless HOW
7969	is TAG_how::HIDDEN_FRIEND.
7970
7971	A TYPE_DECL best matching the NAME is returned. Catching error
7972	and issuing diagnostics are caller's responsibility. */
7973
7974	tree
7975	lookup_elaborated_type (tree name, TAG_how how)
7976	{
7977	auto_cond_timevar tv (TV_NAME_LOOKUP);
7978
7979	cp_binding_level *b = current_binding_level;
7980
7981	if (b->kind != sk_namespace)
7982	/* Look in non-namespace scopes. */
7983	for (cxx_binding *iter = NULL;
7984	(iter = outer_binding (name, binding: iter, /*class_p=*/ true)); )
7985	{
7986	/* First check we're supposed to be looking in this scope --
7987	if we're not, we're done. */
7988	for (; b != iter->scope; b = b->level_chain)
7989	if (!(b->kind == sk_cleanup
7990	|| b->kind == sk_template_parms
7991	|| b->kind == sk_function_parms
7992	|| (b->kind == sk_class && how != TAG_how::CURRENT_ONLY)))
7993	return NULL_TREE;
7994
7995	/* Check if this is the kind of thing we're looking for. If
7996	HOW is TAG_how::CURRENT_ONLY, also make sure it doesn't
7997	come from base class. For ITER->VALUE, we can simply use
7998	INHERITED_VALUE_BINDING_P. For ITER->TYPE, we have to use
7999	our own check.
8000
8001	We check ITER->TYPE before ITER->VALUE in order to handle
8002	typedef struct C {} C;
8003	correctly. */
8004
8005	if (tree type = iter->type)
8006	{
8007	if (qualify_lookup (val: type, want: LOOK_want::TYPE)
8008	&& (how != TAG_how::CURRENT_ONLY
8009	|| LOCAL_BINDING_P (iter)
8010	|| DECL_CONTEXT (type) == iter->scope->this_entity))
8011	{
8012	if (how != TAG_how::HIDDEN_FRIEND)
8013	/* It is no longer a hidden binding. */
8014	HIDDEN_TYPE_BINDING_P (iter) = false;
8015
8016	return type;
8017	}
8018	}
8019	else
8020	{
8021	if (qualify_lookup (val: iter->value, want: LOOK_want::TYPE)
8022	&& (how != TAG_how::CURRENT_ONLY
8023	|| !INHERITED_VALUE_BINDING_P (iter)))
8024	{
8025	if (how != TAG_how::HIDDEN_FRIEND && !iter->type)
8026	/* It is no longer a hidden binding. */
8027	HIDDEN_TYPE_BINDING_P (iter) = false;
8028
8029	return iter->value;
8030	}
8031	}
8032	}
8033
8034	/* Now check if we can look in namespace scope. */
8035	for (; b->kind != sk_namespace; b = b->level_chain)
8036	if (!(b->kind == sk_cleanup
8037	|| b->kind == sk_template_parms
8038	|| b->kind == sk_function_parms
8039	|| (b->kind == sk_class && how != TAG_how::CURRENT_ONLY)))
8040	return NULL_TREE;
8041
8042	/* Look in the innermost namespace. */
8043	tree ns = b->this_entity;
8044	if (tree *slot = find_namespace_slot (ns, name))
8045	{
8046	tree bind = *slot;
8047	if (TREE_CODE (bind) == BINDING_VECTOR)
8048	bind = BINDING_VECTOR_CLUSTER (bind, 0).slots[BINDING_SLOT_CURRENT];
8049
8050	if (bind)
8051	{
8052	/* If this is the kind of thing we're looking for, we're done. */
8053	if (tree type = MAYBE_STAT_TYPE (bind))
8054	{
8055	if (how != TAG_how::HIDDEN_FRIEND)
8056	/* No longer hidden. */
8057	STAT_TYPE_HIDDEN_P (*slot) = false;
8058
8059	return type;
8060	}
8061	else if (tree decl = MAYBE_STAT_DECL (bind))
8062	{
8063	if (qualify_lookup (val: decl, want: LOOK_want::TYPE))
8064	{
8065	if (how != TAG_how::HIDDEN_FRIEND && STAT_HACK_P (bind)
8066	&& STAT_DECL_HIDDEN_P (bind))
8067	{
8068	if (STAT_TYPE (bind))
8069	STAT_DECL_HIDDEN_P (bind) = false;
8070	else
8071	{
8072	/* There is no type, just remove the stat
8073	hack. */
8074	if (*slot == bind)
8075	*slot = decl;
8076	else
8077	BINDING_VECTOR_CLUSTER (*slot, 0)
8078	.slots[BINDING_SLOT_CURRENT] = decl;
8079	}
8080	}
8081	return decl;
8082	}
8083	}
8084	}
8085
8086	if (TREE_CODE (*slot) == BINDING_VECTOR)
8087	{
8088	/* We could be redeclaring a global module entity, (from GMF
8089	or header unit), or from another partition, or
8090	specializing an imported template. */
8091	bitmap imports = get_import_bitmap ();
8092	binding_cluster *cluster = BINDING_VECTOR_CLUSTER_BASE (*slot);
8093
8094	/* Scan the imported bindings. */
8095	unsigned ix = BINDING_VECTOR_NUM_CLUSTERS (*slot);
8096	if (BINDING_VECTOR_SLOTS_PER_CLUSTER == BINDING_SLOTS_FIXED)
8097	{
8098	ix--;
8099	cluster++;
8100	}
8101
8102	/* Do this in forward order, so we load modules in an order
8103	the user expects. */
8104	for (; ix--; cluster++)
8105	for (unsigned jx = 0; jx != BINDING_VECTOR_SLOTS_PER_CLUSTER; jx++)
8106	{
8107	/* Are we importing this module? */
8108	if (unsigned base = cluster->indices[jx].base)
8109	if (unsigned span = cluster->indices[jx].span)
8110	do
8111	if (bitmap_bit_p (imports, base))
8112	goto found;
8113	while (++base, --span);
8114	continue;
8115
8116	found:;
8117	/* Is it loaded? */
8118	if (cluster->slots[jx].is_lazy ())
8119	{
8120	gcc_assert (cluster->indices[jx].span == 1);
8121	lazy_load_binding (mod: cluster->indices[jx].base,
8122	ns, id: name, bslot: &cluster->slots[jx]);
8123	}
8124	tree bind = cluster->slots[jx];
8125	if (!bind)
8126	/* Load errors could mean there's nothing here. */
8127	continue;
8128
8129	/* Extract what we can see from here. If there's no
8130	stat_hack, then everything was exported. */
8131	tree type = NULL_TREE;
8132
8133	/* If no stat hack, everything is visible. */
8134	if (STAT_HACK_P (bind))
8135	{
8136	if (STAT_TYPE_VISIBLE_P (bind))
8137	type = STAT_TYPE (bind);
8138	bind = STAT_VISIBLE (bind);
8139	}
8140
8141	if (type && qualify_lookup (val: type, want: LOOK_want::TYPE))
8142	return type;
8143
8144	if (bind && qualify_lookup (val: bind, want: LOOK_want::TYPE))
8145	return bind;
8146	}
8147
8148	if (!module_purview_p ())
8149	{
8150	/* We're in the global module, perhaps there's a tag
8151	there? */
8152
8153	/* FIXME: In general we should probably merge global module
8154	classes in check_module_override rather than here, but for
8155	GCC14 let's just fix lazy declarations of __class_type_info in
8156	build_dynamic_cast_1. */
8157	if (current_namespace == abi_node)
8158	{
8159	tree g = (BINDING_VECTOR_CLUSTER (*slot, 0)
8160	.slots[BINDING_SLOT_GLOBAL]);
8161	for (ovl_iterator iter (g); iter; ++iter)
8162	if (qualify_lookup (val: *iter, want: LOOK_want::TYPE))
8163	return *iter;
8164	}
8165	}
8166	}
8167	}
8168
8169	return NULL_TREE;
8170	}
8171
8172	/* The type TYPE is being declared. If it is a class template, or a
8173	specialization of a class template, do any processing required and
8174	perform error-checking. If IS_FRIEND is nonzero, this TYPE is
8175	being declared a friend. B is the binding level at which this TYPE
8176	should be bound.
8177
8178	Returns the TYPE_DECL for TYPE, which may have been altered by this
8179	processing. */
8180
8181	static tree
8182	maybe_process_template_type_declaration (tree type, int is_friend,
8183	cp_binding_level *b)
8184	{
8185	tree decl = TYPE_NAME (type);
8186
8187	if (processing_template_parmlist)
8188	/* You can't declare a new template type in a template parameter
8189	list. But, you can declare a non-template type:
8190
8191	template <class A*> struct S;
8192
8193	is a forward-declaration of `A'. */
8194	;
8195	else if (b->kind == sk_namespace
8196	&& current_binding_level->kind != sk_namespace)
8197	/* If this new type is being injected into a containing scope,
8198	then it's not a template type. */
8199	;
8200	else
8201	{
8202	gcc_assert (MAYBE_CLASS_TYPE_P (type)
8203	|| TREE_CODE (type) == ENUMERAL_TYPE);
8204
8205	if (processing_template_decl)
8206	{
8207	decl = push_template_decl (decl, is_friend);
8208	if (decl == error_mark_node)
8209	return error_mark_node;
8210
8211	/* If the current binding level is the binding level for the
8212	template parameters (see the comment in
8213	begin_template_parm_list) and the enclosing level is a class
8214	scope, and we're not looking at a friend, push the
8215	declaration of the member class into the class scope. In the
8216	friend case, push_template_decl will already have put the
8217	friend into global scope, if appropriate. */
8218	if (TREE_CODE (type) != ENUMERAL_TYPE
8219	&& !is_friend && b->kind == sk_template_parms
8220	&& b->level_chain->kind == sk_class)
8221	{
8222	finish_member_declaration (CLASSTYPE_TI_TEMPLATE (type));
8223
8224	if (!COMPLETE_TYPE_P (current_class_type))
8225	maybe_add_class_template_decl_list (current_class_type,
8226	type, /*friend_p=*/0);
8227	}
8228	}
8229	}
8230
8231	return decl;
8232	}
8233
8234	/* Push a tag name NAME for struct/class/union/enum type TYPE. In case
8235	that the NAME is a class template, the tag is processed but not pushed.
8236
8237	The pushed scope depend on the SCOPE parameter:
8238	- When SCOPE is TS_CURRENT, put it into the inner-most non-sk_cleanup
8239	scope.
8240	- When SCOPE is TS_GLOBAL, put it in the inner-most non-class and
8241	non-template-parameter scope. This case is needed for forward
8242	declarations.
8243	- When SCOPE is TS_WITHIN_ENCLOSING_NON_CLASS, this is similar to
8244	TS_GLOBAL case except that names within template-parameter scopes
8245	are not pushed at all.
8246
8247	Returns TYPE upon success and ERROR_MARK_NODE otherwise. */
8248
8249	tree
8250	pushtag (tree name, tree type, TAG_how how)
8251	{
8252	tree decl;
8253
8254	gcc_assert (identifier_p (name));
8255
8256	auto_cond_timevar tv (TV_NAME_LOOKUP);
8257
8258	cp_binding_level *b = current_binding_level;
8259	while (true)
8260	{
8261	if (/* Cleanup scopes are not scopes from the point of view of
8262	the language. */
8263	b->kind == sk_cleanup
8264	/* Neither are function parameter scopes. */
8265	|| b->kind == sk_function_parms
8266	/* Neither are the scopes used to hold template parameters
8267	for an explicit specialization. For an ordinary template
8268	declaration, these scopes are not scopes from the point of
8269	view of the language. */
8270	|| (b->kind == sk_template_parms
8271	&& (b->explicit_spec_p || how == TAG_how::GLOBAL)))
8272	b = b->level_chain;
8273	else if (b->kind == sk_class && how != TAG_how::CURRENT_ONLY)
8274	{
8275	b = b->level_chain;
8276	if (b->kind == sk_template_parms)
8277	b = b->level_chain;
8278	}
8279	else
8280	break;
8281	}
8282
8283	/* Do C++ gratuitous typedefing. */
8284	if (REAL_IDENTIFIER_TYPE_VALUE (name) != type)
8285	{
8286	tree tdef;
8287	tree context = TYPE_CONTEXT (type);
8288
8289	if (! context)
8290	{
8291	cp_binding_level *cb = b;
8292	while (cb->kind != sk_namespace
8293	&& cb->kind != sk_class
8294	&& (cb->kind != sk_function_parms
8295	|| !cb->this_entity))
8296	cb = cb->level_chain;
8297	tree cs = cb->this_entity;
8298
8299	gcc_checking_assert (TREE_CODE (cs) == FUNCTION_DECL
8300	? cs == current_function_decl
8301	: TYPE_P (cs) ? cs == current_class_type
8302	: cs == current_namespace);
8303
8304	if (how == TAG_how::CURRENT_ONLY
8305	|| (cs && TREE_CODE (cs) == FUNCTION_DECL))
8306	context = cs;
8307	else if (cs && TYPE_P (cs))
8308	/* When declaring a friend class of a local class, we want
8309	to inject the newly named class into the scope
8310	containing the local class, not the namespace
8311	scope. */
8312	context = decl_function_context (get_type_decl (cs));
8313	}
8314	if (!context)
8315	context = current_namespace;
8316
8317	tdef = create_implicit_typedef (name, type);
8318	DECL_CONTEXT (tdef) = FROB_CONTEXT (context);
8319	set_originating_module (tdef);
8320
8321	decl = maybe_process_template_type_declaration
8322	(type, is_friend: how == TAG_how::HIDDEN_FRIEND, b);
8323	if (decl == error_mark_node)
8324	return decl;
8325
8326	if (b->kind == sk_class)
8327	{
8328	if (!TYPE_BEING_DEFINED (current_class_type))
8329	/* Don't push anywhere if the class is complete; a lambda in an
8330	NSDMI is not a member of the class. */
8331	;
8332	else if (!PROCESSING_REAL_TEMPLATE_DECL_P ())
8333	/* Put this TYPE_DECL on the TYPE_FIELDS list for the
8334	class. But if it's a member template class, we want
8335	the TEMPLATE_DECL, not the TYPE_DECL, so this is done
8336	later. */
8337	finish_member_declaration (decl);
8338	else
8339	pushdecl_class_level (x: decl);
8340	}
8341	else if (b->kind == sk_template_parms)
8342	{
8343	/* Do not push the tag here -- we'll want to push the
8344	TEMPLATE_DECL. */
8345	if (b->level_chain->kind != sk_class)
8346	set_identifier_type_value_with_scope (id: name, decl: tdef, b: b->level_chain);
8347	}
8348	else
8349	{
8350	decl = do_pushdecl_with_scope
8351	(x: decl, level: b, /*hiding=*/(how == TAG_how::HIDDEN_FRIEND));
8352	if (decl == error_mark_node)
8353	return decl;
8354
8355	if (DECL_CONTEXT (decl) == std_node
8356	&& init_list_identifier == DECL_NAME (TYPE_NAME (type))
8357	&& !CLASSTYPE_TEMPLATE_INFO (type))
8358	{
8359	error ("declaration of %<std::initializer_list%> does not match "
8360	"%<#include <initializer_list>%>, isn%'t a template");
8361	return error_mark_node;
8362	}
8363	}
8364
8365	TYPE_CONTEXT (type) = DECL_CONTEXT (decl);
8366
8367	/* If this is a local class, keep track of it. We need this
8368	information for name-mangling, and so that it is possible to
8369	find all function definitions in a translation unit in a
8370	convenient way. (It's otherwise tricky to find a member
8371	function definition it's only pointed to from within a local
8372	class.) */
8373	if (TYPE_FUNCTION_SCOPE_P (type))
8374	{
8375	if (processing_template_decl)
8376	{
8377	/* Push a DECL_EXPR so we call pushtag at the right time in
8378	template instantiation rather than in some nested context. */
8379	add_decl_expr (decl);
8380	}
8381	/* Lambdas use LAMBDA_EXPR_DISCRIMINATOR instead. */
8382	else if (!LAMBDA_TYPE_P (type))
8383	determine_local_discriminator (TYPE_NAME (type));
8384	}
8385	}
8386
8387	if (b->kind == sk_class
8388	&& !COMPLETE_TYPE_P (current_class_type))
8389	maybe_add_class_template_decl_list (current_class_type,
8390	type, /*friend_p=*/0);
8391
8392	decl = TYPE_NAME (type);
8393	gcc_assert (TREE_CODE (decl) == TYPE_DECL);
8394
8395	/* Set type visibility now if this is a forward declaration. */
8396	TREE_PUBLIC (decl) = 1;
8397	determine_visibility (decl);
8398
8399	return type;
8400	}
8401
8402	/* Subroutines for reverting temporarily to top-level for instantiation
8403	of templates and such. We actually need to clear out the class- and
8404	local-value slots of all identifiers, so that only the global values
8405	are at all visible. Simply setting current_binding_level to the global
8406	scope isn't enough, because more binding levels may be pushed. */
8407	struct saved_scope *scope_chain;
8408
8409	/* Return true if ID has not already been marked. */
8410
8411	static inline bool
8412	store_binding_p (tree id)
8413	{
8414	if (!id || !IDENTIFIER_BINDING (id))
8415	return false;
8416
8417	if (IDENTIFIER_MARKED (id))
8418	return false;
8419
8420	return true;
8421	}
8422
8423	/* Add an appropriate binding to *OLD_BINDINGS which needs to already
8424	have enough space reserved. */
8425
8426	static void
8427	store_binding (tree id, vec<cxx_saved_binding, va_gc> **old_bindings)
8428	{
8429	cxx_saved_binding saved;
8430
8431	gcc_checking_assert (store_binding_p (id));
8432
8433	IDENTIFIER_MARKED (id) = 1;
8434
8435	saved.identifier = id;
8436	saved.binding = IDENTIFIER_BINDING (id);
8437	saved.real_type_value = REAL_IDENTIFIER_TYPE_VALUE (id);
8438	(*old_bindings)->quick_push (obj: saved);
8439	IDENTIFIER_BINDING (id) = NULL;
8440	}
8441
8442	static void
8443	store_bindings (tree names, vec<cxx_saved_binding, va_gc> **old_bindings)
8444	{
8445	static vec<tree> bindings_need_stored;
8446	tree t, id;
8447	size_t i;
8448
8449	auto_cond_timevar tv (TV_NAME_LOOKUP);
8450	for (t = names; t; t = TREE_CHAIN (t))
8451	{
8452	if (TREE_CODE (t) == TREE_LIST)
8453	id = TREE_PURPOSE (t);
8454	else
8455	id = DECL_NAME (t);
8456
8457	if (store_binding_p (id))
8458	bindings_need_stored.safe_push (obj: id);
8459	}
8460	if (!bindings_need_stored.is_empty ())
8461	{
8462	vec_safe_reserve_exact (v&: *old_bindings, nelems: bindings_need_stored.length ());
8463	for (i = 0; bindings_need_stored.iterate (ix: i, ptr: &id); ++i)
8464	{
8465	/* We can apparently have duplicates in NAMES. */
8466	if (store_binding_p (id))
8467	store_binding (id, old_bindings);
8468	}
8469	bindings_need_stored.truncate (size: 0);
8470	}
8471	}
8472
8473	/* Like store_bindings, but NAMES is a vector of cp_class_binding
8474	objects, rather than a TREE_LIST. */
8475
8476	static void
8477	store_class_bindings (vec<cp_class_binding, va_gc> *names,
8478	vec<cxx_saved_binding, va_gc> **old_bindings)
8479	{
8480	static vec<tree> bindings_need_stored;
8481	size_t i;
8482	cp_class_binding *cb;
8483
8484	for (i = 0; vec_safe_iterate (v: names, ix: i, ptr: &cb); ++i)
8485	if (store_binding_p (id: cb->identifier))
8486	bindings_need_stored.safe_push (obj: cb->identifier);
8487	if (!bindings_need_stored.is_empty ())
8488	{
8489	tree id;
8490	vec_safe_reserve_exact (v&: *old_bindings, nelems: bindings_need_stored.length ());
8491	for (i = 0; bindings_need_stored.iterate (ix: i, ptr: &id); ++i)
8492	store_binding (id, old_bindings);
8493	bindings_need_stored.truncate (size: 0);
8494	}
8495	}
8496
8497	/* A chain of saved_scope structures awaiting reuse. */
8498
8499	static GTY((deletable)) struct saved_scope *free_saved_scope;
8500
8501	void
8502	push_to_top_level (void)
8503	{
8504	struct saved_scope *s;
8505	cp_binding_level *b;
8506	cxx_saved_binding *sb;
8507	size_t i;
8508	bool need_pop;
8509
8510	auto_cond_timevar tv (TV_NAME_LOOKUP);
8511
8512	/* Reuse or create a new structure for this saved scope. */
8513	if (free_saved_scope != NULL)
8514	{
8515	s = free_saved_scope;
8516	free_saved_scope = s->prev;
8517
8518	vec<cxx_saved_binding, va_gc> *old_bindings = s->old_bindings;
8519	memset (s: s, c: 0, n: sizeof (*s));
8520	/* Also reuse the structure's old_bindings vector. */
8521	vec_safe_truncate (v: old_bindings, size: 0);
8522	s->old_bindings = old_bindings;
8523	}
8524	else
8525	s = ggc_cleared_alloc<saved_scope> ();
8526
8527	b = scope_chain ? current_binding_level : 0;
8528
8529	/* If we're in the middle of some function, save our state. */
8530	if (cfun)
8531	{
8532	need_pop = true;
8533	push_function_context ();
8534	}
8535	else
8536	need_pop = false;
8537
8538	if (scope_chain && previous_class_level)
8539	store_class_bindings (previous_class_level->class_shadowed,
8540	old_bindings: &s->old_bindings);
8541
8542	/* Have to include the global scope, because class-scope decls
8543	aren't listed anywhere useful. */
8544	for (; b; b = b->level_chain)
8545	{
8546	tree t;
8547
8548	/* Template IDs are inserted into the global level. If they were
8549	inserted into namespace level, finish_file wouldn't find them
8550	when doing pending instantiations. Therefore, don't stop at
8551	namespace level, but continue until :: . */
8552	if (global_scope_p (b))
8553	break;
8554
8555	store_bindings (names: b->names, old_bindings: &s->old_bindings);
8556	/* We also need to check class_shadowed to save class-level type
8557	bindings, since pushclass doesn't fill in b->names. */
8558	if (b->kind == sk_class)
8559	store_class_bindings (names: b->class_shadowed, old_bindings: &s->old_bindings);
8560
8561	/* Unwind type-value slots back to top level. */
8562	for (t = b->type_shadowed; t; t = TREE_CHAIN (t))
8563	SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (t), TREE_VALUE (t));
8564	}
8565
8566	FOR_EACH_VEC_SAFE_ELT (s->old_bindings, i, sb)
8567	IDENTIFIER_MARKED (sb->identifier) = 0;
8568
8569	s->prev = scope_chain;
8570	s->bindings = b;
8571	s->need_pop_function_context = need_pop;
8572	s->function_decl = current_function_decl;
8573	s->unevaluated_operand = cp_unevaluated_operand;
8574	s->inhibit_evaluation_warnings = c_inhibit_evaluation_warnings;
8575	s->suppress_location_wrappers = suppress_location_wrappers;
8576	s->x_stmt_tree.stmts_are_full_exprs_p = true;
8577
8578	scope_chain = s;
8579	current_function_decl = NULL_TREE;
8580	current_lang_base = NULL;
8581	current_lang_name = lang_name_cplusplus;
8582	current_namespace = global_namespace;
8583	push_class_stack ();
8584	cp_unevaluated_operand = 0;
8585	c_inhibit_evaluation_warnings = 0;
8586	suppress_location_wrappers = 0;
8587	}
8588
8589	void
8590	pop_from_top_level (void)
8591	{
8592	struct saved_scope *s = scope_chain;
8593	cxx_saved_binding *saved;
8594	size_t i;
8595
8596	auto_cond_timevar tv (TV_NAME_LOOKUP);
8597
8598	pop_class_stack ();
8599
8600	release_tree_vector (current_lang_base);
8601
8602	scope_chain = s->prev;
8603	FOR_EACH_VEC_SAFE_ELT (s->old_bindings, i, saved)
8604	{
8605	tree id = saved->identifier;
8606
8607	IDENTIFIER_BINDING (id) = saved->binding;
8608	SET_IDENTIFIER_TYPE_VALUE (id, saved->real_type_value);
8609	}
8610
8611	/* If we were in the middle of compiling a function, restore our
8612	state. */
8613	if (s->need_pop_function_context)
8614	pop_function_context ();
8615	current_function_decl = s->function_decl;
8616	cp_unevaluated_operand = s->unevaluated_operand;
8617	c_inhibit_evaluation_warnings = s->inhibit_evaluation_warnings;
8618	suppress_location_wrappers = s->suppress_location_wrappers;
8619
8620	/* Make this saved_scope structure available for reuse by
8621	push_to_top_level. */
8622	s->prev = free_saved_scope;
8623	free_saved_scope = s;
8624	}
8625
8626	namespace {
8627
8628	/* Helper class for saving/restoring relevant global flags for the
8629	function-local case of maybe_push_to_top_level. */
8630
8631	struct local_state_t
8632	{
8633	int cp_unevaluated_operand;
8634	int c_inhibit_evaluation_warnings;
8635
8636	static local_state_t
8637	save_and_clear ()
8638	{
8639	local_state_t s;
8640	s.cp_unevaluated_operand = ::cp_unevaluated_operand;
8641	::cp_unevaluated_operand = 0;
8642	s.c_inhibit_evaluation_warnings = ::c_inhibit_evaluation_warnings;
8643	::c_inhibit_evaluation_warnings = 0;
8644	return s;
8645	}
8646
8647	void
8648	restore () const
8649	{
8650	::cp_unevaluated_operand = this->cp_unevaluated_operand;
8651	::c_inhibit_evaluation_warnings = this->c_inhibit_evaluation_warnings;
8652	}
8653	};
8654
8655	vec<local_state_t> local_state_stack;
8656
8657	} // anon namespace
8658
8659	/* Like push_to_top_level, but not if D is function-local. Returns whether we
8660	did push to top. */
8661
8662	bool
8663	maybe_push_to_top_level (tree d)
8664	{
8665	/* Push if D isn't function-local, or is a lambda function, for which name
8666	resolution is already done. */
8667	const bool push_to_top
8668	= (LAMBDA_FUNCTION_P (d)
8669	|| (TREE_CODE (d) == TYPE_DECL
8670	&& TREE_TYPE (d)
8671	&& LAMBDA_TYPE_P (TREE_TYPE (d)))
8672	|| !current_function_decl
8673	|| !decl_function_context (d));
8674
8675	if (push_to_top)
8676	push_to_top_level ();
8677	else
8678	{
8679	gcc_assert (!processing_template_decl);
8680	push_function_context ();
8681	local_state_stack.safe_push (obj: local_state_t::save_and_clear ());
8682	}
8683
8684	return push_to_top;
8685	}
8686
8687	/* Return from whatever maybe_push_to_top_level did. */
8688
8689	void
8690	maybe_pop_from_top_level (bool push_to_top)
8691	{
8692	if (push_to_top)
8693	pop_from_top_level ();
8694	else
8695	{
8696	local_state_stack.pop ().restore ();
8697	pop_function_context ();
8698	}
8699	}
8700
8701	/* Push into the scope of the namespace NS, even if it is deeply
8702	nested within another namespace. */
8703
8704	void
8705	push_nested_namespace (tree ns)
8706	{
8707	auto_cond_timevar tv (TV_NAME_LOOKUP);
8708	if (ns == global_namespace)
8709	push_to_top_level ();
8710	else
8711	{
8712	push_nested_namespace (CP_DECL_CONTEXT (ns));
8713	resume_scope (NAMESPACE_LEVEL (ns));
8714	current_namespace = ns;
8715	}
8716	}
8717
8718	/* Pop back from the scope of the namespace NS, which was previously
8719	entered with push_nested_namespace. */
8720
8721	void
8722	pop_nested_namespace (tree ns)
8723	{
8724	auto_cond_timevar tv (TV_NAME_LOOKUP);
8725	while (ns != global_namespace)
8726	{
8727	ns = CP_DECL_CONTEXT (ns);
8728	current_namespace = ns;
8729	leave_scope ();
8730	}
8731
8732	pop_from_top_level ();
8733	}
8734
8735	/* Add TARGET to USINGS, if it does not already exist there. We used
8736	to build the complete graph of usings at this point, from the POV
8737	of the source namespaces. Now we build that as we perform the
8738	unqualified search. */
8739
8740	static void
8741	add_using_namespace (vec<tree, va_gc> *&usings, tree target)
8742	{
8743	if (usings)
8744	for (unsigned ix = usings->length (); ix--;)
8745	if ((*usings)[ix] == target)
8746	return;
8747
8748	vec_safe_push (v&: usings, obj: target);
8749	}
8750
8751	/* Tell the debug system of a using directive. */
8752
8753	static void
8754	emit_debug_info_using_namespace (tree from, tree target, bool implicit)
8755	{
8756	/* Emit debugging info. */
8757	tree context = from != global_namespace ? from : NULL_TREE;
8758	debug_hooks->imported_module_or_decl (target, NULL_TREE, context, false,
8759	implicit);
8760	}
8761
8762	/* Process a using directive. */
8763
8764	void
8765	finish_using_directive (tree target, tree attribs)
8766	{
8767	if (target == error_mark_node)
8768	return;
8769
8770	if (current_binding_level->kind != sk_namespace)
8771	add_stmt (build_stmt (input_location, USING_STMT, target));
8772	else
8773	emit_debug_info_using_namespace (current_binding_level->this_entity,
8774	ORIGINAL_NAMESPACE (target), implicit: false);
8775
8776	add_using_namespace (current_binding_level->using_directives,
8777	ORIGINAL_NAMESPACE (target));
8778
8779	bool diagnosed = false;
8780	if (attribs != error_mark_node)
8781	for (tree a = attribs; a; a = TREE_CHAIN (a))
8782	{
8783	tree name = get_attribute_name (a);
8784	if (current_binding_level->kind == sk_namespace
8785	&& is_attribute_p (attr_name: "strong", ident: name))
8786	{
8787	if (warning (0, "%<strong%> using directive no longer supported")
8788	&& CP_DECL_CONTEXT (target) == current_namespace)
8789	inform (DECL_SOURCE_LOCATION (target),
8790	"you can use an inline namespace instead");
8791	}
8792	else if ((flag_openmp || flag_openmp_simd)
8793	&& get_attribute_namespace (a) == omp_identifier
8794	&& (is_attribute_p (attr_name: "directive", ident: name)
8795	|| is_attribute_p (attr_name: "sequence", ident: name)
8796	|| is_attribute_p (attr_name: "decl", ident: name)))
8797	{
8798	if (!diagnosed)
8799	{
8800	if (tree ar = TREE_VALUE (a))
8801	{
8802	tree d = TREE_VALUE (ar);
8803	gcc_assert (TREE_CODE (d) == DEFERRED_PARSE);
8804	error ("%<omp::%s%> not allowed to be specified in "
8805	"this context",
8806	TREE_PUBLIC (d) ? "decl" : "directive");
8807	}
8808	else
8809	error ("%<omp::%E%> not allowed to be specified in this "
8810	"context", name);
8811	diagnosed = true;
8812	}
8813	}
8814	else if (!attribute_ignored_p (a))
8815	warning (OPT_Wattributes, "%qD attribute directive ignored", name);
8816	}
8817	}
8818
8819	/* Pushes X into the global namespace. */
8820
8821	tree
8822	pushdecl_top_level (tree x)
8823	{
8824	auto_cond_timevar tv (TV_NAME_LOOKUP);
8825	push_to_top_level ();
8826	gcc_checking_assert (!DECL_CONTEXT (x));
8827	DECL_CONTEXT (x) = FROB_CONTEXT (global_namespace);
8828	x = pushdecl_namespace_level (decl: x);
8829	pop_from_top_level ();
8830	return x;
8831	}
8832
8833	/* Pushes X into the global namespace and calls cp_finish_decl to
8834	register the variable, initializing it with INIT. */
8835
8836	tree
8837	pushdecl_top_level_and_finish (tree x, tree init)
8838	{
8839	auto_cond_timevar tv (TV_NAME_LOOKUP);
8840	push_to_top_level ();
8841	gcc_checking_assert (!DECL_CONTEXT (x));
8842	DECL_CONTEXT (x) = FROB_CONTEXT (global_namespace);
8843	x = pushdecl_namespace_level (decl: x);
8844	cp_finish_decl (x, init, false, NULL_TREE, 0);
8845	pop_from_top_level ();
8846	return x;
8847	}
8848
8849	/* Enter the namespaces from current_namerspace to NS. */
8850
8851	static int
8852	push_inline_namespaces (tree ns)
8853	{
8854	int count = 0;
8855	if (ns != current_namespace)
8856	{
8857	gcc_assert (ns != global_namespace);
8858	count += push_inline_namespaces (CP_DECL_CONTEXT (ns));
8859	resume_scope (NAMESPACE_LEVEL (ns));
8860	current_namespace = ns;
8861	count++;
8862	}
8863	return count;
8864	}
8865
8866	/* SLOT is the (possibly empty) binding slot for NAME in CTX.
8867	Reuse or create a namespace NAME. NAME is null for the anonymous
8868	namespace. */
8869
8870	static tree
8871	reuse_namespace (tree *slot, tree ctx, tree name)
8872	{
8873	if (modules_p () && *slot && TREE_PUBLIC (ctx) && name)
8874	{
8875	/* Public namespace. Shared. */
8876	tree *global_slot = slot;
8877	if (TREE_CODE (*slot) == BINDING_VECTOR)
8878	global_slot = get_fixed_binding_slot (slot, name,
8879	ix: BINDING_SLOT_GLOBAL, create: false);
8880
8881	for (ovl_iterator iter (*global_slot); iter; ++iter)
8882	{
8883	tree decl = *iter;
8884
8885	if (TREE_CODE (decl) == NAMESPACE_DECL && !DECL_NAMESPACE_ALIAS (decl))
8886	return decl;
8887	}
8888	}
8889	return NULL_TREE;
8890	}
8891
8892	static tree
8893	make_namespace (tree ctx, tree name, location_t loc, bool inline_p)
8894	{
8895	/* Create the namespace. */
8896	tree ns = build_lang_decl (NAMESPACE_DECL, name, void_type_node);
8897	DECL_SOURCE_LOCATION (ns) = loc;
8898	SCOPE_DEPTH (ns) = SCOPE_DEPTH (ctx) + 1;
8899	if (!SCOPE_DEPTH (ns))
8900	/* We only allow depth 255. */
8901	sorry ("cannot nest more than %d namespaces", SCOPE_DEPTH (ctx));
8902	DECL_CONTEXT (ns) = FROB_CONTEXT (ctx);
8903
8904	if (!name)
8905	/* Anon-namespaces in different header-unit imports are distinct.
8906	But that's ok as their contents all have internal linkage.
8907	(This is different to how they'd behave as textual includes,
8908	but doing this at all is really odd source.) */
8909	SET_DECL_ASSEMBLER_NAME (ns, anon_identifier);
8910	else if (TREE_PUBLIC (ctx))
8911	TREE_PUBLIC (ns) = true;
8912
8913	if (inline_p)
8914	DECL_NAMESPACE_INLINE_P (ns) = true;
8915
8916	return ns;
8917	}
8918
8919	/* NS was newly created, finish off making it. */
8920
8921	static void
8922	make_namespace_finish (tree ns, tree *slot, bool from_import = false)
8923	{
8924	if (modules_p () && TREE_PUBLIC (ns) && (from_import || *slot != ns))
8925	{
8926	/* Merge into global slot. */
8927	tree *gslot = get_fixed_binding_slot (slot, DECL_NAME (ns),
8928	ix: BINDING_SLOT_GLOBAL, create: true);
8929	*gslot = ns;
8930	}
8931
8932	tree ctx = CP_DECL_CONTEXT (ns);
8933	cp_binding_level *scope = ggc_cleared_alloc<cp_binding_level> ();
8934	scope->this_entity = ns;
8935	scope->more_cleanups_ok = true;
8936	scope->kind = sk_namespace;
8937	scope->level_chain = NAMESPACE_LEVEL (ctx);
8938	NAMESPACE_LEVEL (ns) = scope;
8939
8940	if (DECL_NAMESPACE_INLINE_P (ns))
8941	vec_safe_push (DECL_NAMESPACE_INLINEES (ctx), obj: ns);
8942
8943	if (DECL_NAMESPACE_INLINE_P (ns) || !DECL_NAME (ns))
8944	emit_debug_info_using_namespace (from: ctx, target: ns, implicit: true);
8945	}
8946
8947	/* Push into the scope of the NAME namespace. If NAME is NULL_TREE,
8948	then we enter an anonymous namespace. If MAKE_INLINE is true, then
8949	we create an inline namespace (it is up to the caller to check upon
8950	redefinition). Return the number of namespaces entered. */
8951
8952	int
8953	push_namespace (tree name, bool make_inline)
8954	{
8955	auto_cond_timevar tv (TV_NAME_LOOKUP);
8956	int count = 0;
8957
8958	/* We should not get here if the global_namespace is not yet constructed
8959	nor if NAME designates the global namespace: The global scope is
8960	constructed elsewhere. */
8961	gcc_checking_assert (global_namespace != NULL && name != global_identifier);
8962
8963	tree ns = NULL_TREE;
8964	{
8965	name_lookup lookup (name);
8966	if (!lookup.search_qualified (current_namespace, /*usings=*/false))
8967	;
8968	else if (TREE_CODE (lookup.value) == TREE_LIST)
8969	{
8970	/* An ambiguous lookup. If exactly one is a namespace, we
8971	want that. If more than one is a namespace, error, but
8972	pick one of them. */
8973	/* DR2061 can cause us to find multiple namespaces of the same
8974	name. We must treat that carefully and avoid thinking we
8975	need to push a new (possibly) duplicate namespace. Hey,
8976	if you want to use the same identifier within an inline
8977	nest, knock yourself out. */
8978	for (tree *chain = &lookup.value, next; (next = *chain);)
8979	{
8980	tree decl = TREE_VALUE (next);
8981	if (TREE_CODE (decl) == NAMESPACE_DECL)
8982	{
8983	if (!ns)
8984	ns = decl;
8985	else if (SCOPE_DEPTH (ns) >= SCOPE_DEPTH (decl))
8986	ns = decl;
8987
8988	/* Advance. */
8989	chain = &TREE_CHAIN (next);
8990	}
8991	else
8992	/* Stitch out. */
8993	*chain = TREE_CHAIN (next);
8994	}
8995
8996	if (TREE_CHAIN (lookup.value))
8997	{
8998	error ("%<namespace %E%> is ambiguous", name);
8999	print_candidates (lookup.value);
9000	}
9001	}
9002	else if (TREE_CODE (lookup.value) == NAMESPACE_DECL)
9003	ns = lookup.value;
9004
9005	if (ns)
9006	if (tree dna = DECL_NAMESPACE_ALIAS (ns))
9007	{
9008	/* A namespace alias is not allowed here, but if the alias
9009	is for a namespace also inside the current scope,
9010	accept it with a diagnostic. That's better than dying
9011	horribly. */
9012	if (is_nested_namespace (current_namespace, CP_DECL_CONTEXT (dna)))
9013	{
9014	error ("namespace alias %qD not allowed here, "
9015	"assuming %qD", ns, dna);
9016	ns = dna;
9017	}
9018	else
9019	ns = NULL_TREE;
9020	}
9021	}
9022
9023	if (ns)
9024	{
9025	/* DR2061. NS might be a member of an inline namespace. We
9026	need to push into those namespaces. */
9027	if (modules_p ())
9028	{
9029	for (tree parent, ctx = ns; ctx != current_namespace;
9030	ctx = parent)
9031	{
9032	parent = CP_DECL_CONTEXT (ctx);
9033
9034	tree bind = *find_namespace_slot (ns: parent, DECL_NAME (ctx), create_p: false);
9035	if (bind != ctx)
9036	{
9037	auto &cluster = BINDING_VECTOR_CLUSTER (bind, 0);
9038	binding_slot &slot = cluster.slots[BINDING_SLOT_CURRENT];
9039	gcc_checking_assert (!(tree)slot || (tree)slot == ctx);
9040	slot = ctx;
9041	}
9042	}
9043	}
9044
9045	count += push_inline_namespaces (CP_DECL_CONTEXT (ns));
9046	if (DECL_SOURCE_LOCATION (ns) == BUILTINS_LOCATION)
9047	/* It's not builtin now. */
9048	DECL_SOURCE_LOCATION (ns) = input_location;
9049	}
9050	else
9051	{
9052	/* Before making a new namespace, see if we already have one in
9053	the existing partitions of the current namespace. */
9054	tree *slot = find_namespace_slot (current_namespace, name, create_p: false);
9055	if (slot)
9056	ns = reuse_namespace (slot, current_namespace, name);
9057	if (!ns)
9058	ns = make_namespace (current_namespace, name,
9059	loc: input_location, inline_p: make_inline);
9060
9061	if (pushdecl (decl: ns) == error_mark_node)
9062	ns = NULL_TREE;
9063	else
9064	{
9065	/* Finish up making the namespace. */
9066	add_decl_to_level (NAMESPACE_LEVEL (current_namespace), decl: ns);
9067	if (!slot)
9068	{
9069	slot = find_namespace_slot (current_namespace, name);
9070	/* This should find the slot created by pushdecl. */
9071	gcc_checking_assert (slot && *slot == ns);
9072	}
9073	else
9074	{
9075	/* pushdecl could have expanded the hash table, so
9076	slot might be invalid. */
9077	slot = find_namespace_slot (current_namespace, name);
9078	gcc_checking_assert (slot);
9079	}
9080	make_namespace_finish (ns, slot);
9081
9082	/* Add the anon using-directive here, we don't do it in
9083	make_namespace_finish. */
9084	if (!DECL_NAMESPACE_INLINE_P (ns) && !name)
9085	add_using_namespace (current_binding_level->using_directives, target: ns);
9086	}
9087	}
9088
9089	if (ns)
9090	{
9091	/* A public namespace is exported only if explicitly marked, or
9092	it contains exported entities. */
9093	if (TREE_PUBLIC (ns) && module_exporting_p ())
9094	DECL_MODULE_EXPORT_P (ns) = true;
9095	if (module_purview_p ())
9096	DECL_MODULE_PURVIEW_P (ns) = true;
9097
9098	if (make_inline && !DECL_NAMESPACE_INLINE_P (ns))
9099	{
9100	error_at (input_location,
9101	"inline namespace must be specified at initial definition");
9102	inform (DECL_SOURCE_LOCATION (ns), "%qD defined here", ns);
9103	}
9104	resume_scope (NAMESPACE_LEVEL (ns));
9105	current_namespace = ns;
9106	count++;
9107	}
9108
9109	return count;
9110	}
9111
9112	/* Pop from the scope of the current namespace. */
9113
9114	void
9115	pop_namespace (void)
9116	{
9117	auto_cond_timevar tv (TV_NAME_LOOKUP);
9118
9119	gcc_assert (current_namespace != global_namespace);
9120	current_namespace = CP_DECL_CONTEXT (current_namespace);
9121	/* The binding level is not popped, as it might be re-opened later. */
9122	leave_scope ();
9123	}
9124
9125	/* An IMPORT is an import that is defining namespace NAME inside CTX. Find or
9126	create that namespace and add it to the container's binding-vector. */
9127
9128	tree
9129	add_imported_namespace (tree ctx, tree name, location_t loc, unsigned import,
9130	bool inline_p, bool visible_p)
9131	{
9132	// FIXME: Something is not correct about the VISIBLE_P handling. We
9133	// need to insert this namespace into
9134	// (a) the GLOBAL or PARTITION slot, if it is TREE_PUBLIC
9135	// (b) The importing module's slot (always)
9136	// (c) Do we need to put it in the CURRENT slot? This is the
9137	// confused piece.
9138
9139	tree *slot = find_namespace_slot (ns: ctx, name, create_p: true);
9140	tree decl = reuse_namespace (slot, ctx, name);
9141
9142	/* Creating and binding. */
9143	if (!decl)
9144	{
9145	decl = make_namespace (ctx, name, loc, inline_p);
9146	make_namespace_finish (ns: decl, slot, from_import: true);
9147	}
9148	else if (DECL_NAMESPACE_INLINE_P (decl) != inline_p)
9149	{
9150	error_at (loc, "%s namespace %qD conflicts with reachable definition",
9151	inline_p ? "inline" : "non-inline", decl);
9152	inform (DECL_SOURCE_LOCATION (decl), "reachable %s definition here",
9153	inline_p ? "non-inline" : "inline");
9154	}
9155
9156	if (TREE_PUBLIC (decl) && TREE_CODE (*slot) == BINDING_VECTOR)
9157	{
9158	/* See if we can extend the final slot. */
9159	binding_cluster *last = BINDING_VECTOR_CLUSTER_LAST (*slot);
9160	gcc_checking_assert (last->indices[0].span);
9161	unsigned jx = BINDING_VECTOR_SLOTS_PER_CLUSTER;
9162
9163	while (--jx)
9164	if (last->indices[jx].span)
9165	break;
9166	tree final = last->slots[jx];
9167	if (visible_p == !STAT_HACK_P (final)
9168	&& MAYBE_STAT_DECL (final) == decl
9169	&& last->indices[jx].base + last->indices[jx].span == import
9170	&& (BINDING_VECTOR_NUM_CLUSTERS (*slot) > 1
9171	|| (BINDING_VECTOR_SLOTS_PER_CLUSTER > BINDING_SLOTS_FIXED
9172	&& jx >= BINDING_SLOTS_FIXED)))
9173	{
9174	last->indices[jx].span++;
9175	return decl;
9176	}
9177	}
9178
9179	/* Append a new slot. */
9180	tree *mslot = &(tree &)*append_imported_binding_slot (slot, name, ix: import);
9181
9182	gcc_assert (!*mslot);
9183	*mslot = visible_p ? decl : stat_hack (decl, NULL_TREE);
9184
9185	return decl;
9186	}
9187
9188	/* Pop off extraneous binding levels left over due to syntax errors.
9189	We don't pop past namespaces, as they might be valid. */
9190
9191	void
9192	pop_everything (void)
9193	{
9194	if (ENABLE_SCOPE_CHECKING)
9195	verbatim ("XXX entering %<pop_everything ()%>");
9196	while (!namespace_bindings_p ())
9197	{
9198	if (current_binding_level->kind == sk_class)
9199	pop_nested_class ();
9200	else
9201	poplevel (0, 0, 0);
9202	}
9203	if (ENABLE_SCOPE_CHECKING)
9204	verbatim ("XXX leaving %<pop_everything ()%>");
9205	}
9206
9207	/* Emit debugging information for using declarations and directives.
9208	If input tree is overloaded fn then emit debug info for all
9209	candidates. */
9210
9211	void
9212	cp_emit_debug_info_for_using (tree t, tree context)
9213	{
9214	/* Don't try to emit any debug information if we have errors. */
9215	if (seen_error ())
9216	return;
9217
9218	/* Do not supply context to imported_module_or_decl, if
9219	it is a global namespace. */
9220	if (context == global_namespace)
9221	context = NULL_TREE;
9222
9223	t = MAYBE_BASELINK_FUNCTIONS (t);
9224
9225	for (lkp_iterator iter (t); iter; ++iter)
9226	{
9227	tree fn = *iter;
9228
9229	if (TREE_CODE (fn) == TEMPLATE_DECL)
9230	/* FIXME: Handle TEMPLATE_DECLs. */
9231	continue;
9232
9233	/* Ignore this FUNCTION_DECL if it refers to a builtin declaration
9234	of a builtin function. */
9235	if (TREE_CODE (fn) == FUNCTION_DECL
9236	&& DECL_EXTERNAL (fn)
9237	&& fndecl_built_in_p (node: fn))
9238	continue;
9239
9240	if (building_stmt_list_p ())
9241	add_stmt (build_stmt (input_location, USING_STMT, fn));
9242	else
9243	debug_hooks->imported_module_or_decl (fn, NULL_TREE, context,
9244	false, false);
9245	}
9246	}
9247
9248	/* True if D is a local declaration in dependent scope. Assumes that it is
9249	(part of) the current lookup result for its name. */
9250
9251	bool
9252	dependent_local_decl_p (tree d)
9253	{
9254	if (!DECL_LOCAL_DECL_P (d))
9255	return false;
9256
9257	cxx_binding *b = IDENTIFIER_BINDING (DECL_NAME (d));
9258	cp_binding_level *l = b->scope;
9259	while (!l->this_entity)
9260	l = l->level_chain;
9261	return uses_template_parms (l->this_entity);
9262	}
9263
9264
9265
9266	#include "gt-cp-name-lookup.h"
9267