Re: [PATCH] c++: merge tsubst_copy into tsubst_copy_and_build

[Patrick Palka <ppalka@redhat.com>]

On Mon, 2 Oct 2023, Patrick Palka wrote:

> Bootstrapped and regtested on x86_64-pc-linux-gnu, does this look
> OK for trunk?
> 
> -- >8 --
> 
> The relationship between tsubst_copy_and_build and tsubst_copy (two of
> the main template argument substitution routines for expression trees)
> is rather hazy.  The former is mostly a superset of the latter, with
> some differences.
> 
> The main difference is that they handle many tree codes differently, but
> much of the tree code handling in tsubst_copy appears to be dead code[1].
> This is because tsubst_copy only gets directly called in a few places
> and mostly on id-expressions.  The interesting exceptions are PARM_DECL,
> VAR_DECL, BIT_NOT_EXPR, SCOPE_REF, TEMPLATE_ID_EXPR and IDENTIFIER_NODE:
> 
>  * for PARM_DECL and VAR_DECL, tsubst_copy_and_build calls tsubst_copy
>    followed by doing some extra handling of its own
>  * for BIT_NOT_EXPR tsubst_copy implicitly handles unresolved destructor
>    calls (i.e. the first operand is an identifier or a type)
>  * for SCOPE_REF, TEMPLATE_ID_EXPR and IDENTIFIER_NODE tsubst_copy
>    refrains from doing name lookup of the terminal name
> 
> Other more minor differences are that tsubst_copy exits early when
> 'args' is null, and it calls maybe_dependent_member_ref, and finally
> it dispatches to tsubst for type trees.
> 
> Thus tsubst_copy is (at this point) similar enough to tsubst_copy_and_build
> that it makes sense to merge the two functions, with the main difference
> being the name lookup behavior[2].  So this patch merges tsubst_copy into
> tsubst_copy_and_build via a new tsubst tf_no_name_lookup which controls
> name lookup and resolution of a (top-level) id-expression.
> 
> [1]: http://thrifty.mooo.com:8008/gcc-lcov/gcc/cp/pt.cc.gcov.html#17231
> [2]: I don't know the history of tsubst_copy but I would guess it was
> added before we settled on using processing_template_decl to control
> whether our AST building routines perform semantic checking and return
> non-templated trees, and so we needed a separate tsubst routine that
> avoids semantic checking and always returns a templated tree for e.g.
> partial substitution.

Oops, this is wrong -- tsubst_copy_and_build came after tsubst_copy,
and was introduced as an optimization with the intent of getting rid
of tsubst_copy eventually:
https://gcc.gnu.org/pipermail/gcc-patches/2003-January/093659.html

> 
> gcc/cp/ChangeLog:
> 
> 	* cp-tree.h (enum tsubst_flags): Add tf_no_name_lookup.
> 	* pt.cc (tsubst_copy):
> 	(tsubst_pack_expansion): Use tsubst for substituting BASES_TYPE.
> 	(tsubst_decl) <case USING_DECL>: Use tsubst_copy_and_build with
> 	tf_no_name_lookup instead of tsubst_copy.
> 	(tsubst) <case TEMPLATE_TYPE_PARM>: Use tsubst_copy_and_build
> 	instead of tsubst_copy for substituting
> 	CLASS_PLACEHOLDER_TEMPLATE.
> 	<case TYPENAME_TYPE>: Use tsubst_copy_and_build with
> 	tf_no_name_lookup instead of tsubst_copy for substituting
> 	TYPENAME_TYPE_FULLNAME.
> 	(tsubst_qualified_id): Likewise for substituting the component
> 	name of a SCOPE_REF.
> 	(tsubst_copy): Remove.
> 	(tsubst_copy_and_build): Clear tf_no_name_lookup at the start,
> 	and remember if it was set.  Call maybe_dependent_member_ref.
> 	<case IDENTIFIER_NODE>: Don't do name lookup if tf_no_name_lookup
> 	was set.
> 	<case TEMLPATE_ID_EXPR>: Don't finish a template-id if
> 	tf_no_name_lookup was set.
> 	<case BIT_NOT_EXPR>: Handle identifier and type operand (if
> 	tf_no_name_lookup was set).
> 	<case SCOPE_REF>: Avoid trying to resolve a SCOPE_REF if
> 	tf_no_name_lookup by calling build_qualified_name directly
> 	instead of tsubst_qualified_id.
> 	<case SIZEOF_EXPR>: Handling of sizeof...  copied from tsubst_copy.
> 	<case CALL_EXPR>: Use tsubst_copy_and_build with
> 	tf_no_name_lookup instead of tsubst_copy to substitute
> 	a TEMPLATE_ID_EXPR callee naming an unresolved template.
> 	<case COMPONENT_REF>: Likewise to substitute the member.
> 	<case FUNCTION_DECL>: Copied from tsubst_copy and merged with ...
> 	<case VAR_DECL, PARM_DECL>: ... these.  Initial handling copied
> 	from tsubst_copy.  Optimize local variable substitution by
> 	trying retrieve_local_specialization before checking
> 	uses_template_parms.
> 	<case CONST_DECL>: Copied from tsubst_copy.
> 	<case FIELD_DECL>: Likewise.
> 	<case NAMESPACE_DECL>: Likewise.
> 	<case OVERLOAD>: Likewise.
> 	<case TEMPLATE_DECL>: Likewise.
> 	<case TEMPLATE_PARM_INDEX>: Likewise.
> 	<case TYPE_DECL>: Likewise.
> 	<case CLEANUP_POINT_EXPR>: Likewise.
> 	<case OFFSET_REF>: Likewise.
> 	<case EXPR_PACK_EXPANSION>: Likewise.
> 	<case NONTYPE_ARGUMENT_PACK>: Likewise.
> 	<case *_CST>: Likewise.
> 	<case *_*_FOLD_EXPR>: Likewise.
> 	<case DEBUG_BEGIN_STMT>: Likewise.
> 	<case CO_AWAIT_EXPR>: Likewise.
> 	<case TRAIT_EXPR>: Use tsubst and tsubst_copy_and_build instead
> 	of tsubst_copy.
> 	<default>: Copied from tsubst_copy.
> 	(tsubst_initializer_list): Use tsubst and tsubst_copy_and_build
> 	instead of tsubst_copy.
> ---
>  gcc/cp/cp-tree.h |    3 +
>  gcc/cp/pt.cc     | 1742 +++++++++++++++++++---------------------------
>  2 files changed, 719 insertions(+), 1026 deletions(-)
> 
> diff --git a/gcc/cp/cp-tree.h b/gcc/cp/cp-tree.h
> index 8b9a7d58462..919eab34803 100644
> --- a/gcc/cp/cp-tree.h
> +++ b/gcc/cp/cp-tree.h
> @@ -5619,6 +5619,9 @@ enum tsubst_flags {
>    tf_qualifying_scope = 1 << 14, /* Substituting the LHS of the :: operator.
>  				    Affects TYPENAME_TYPE resolution from
>  				    make_typename_type.  */
> +  tf_no_name_lookup = 1 << 15, /* Don't look up the terminal name of an
> +				  outermost id-expression, or resolve its
> +				  constituent template-ids or qualified-ids.  */
>    /* Convenient substitution flags combinations.  */
>    tf_warning_or_error = tf_warning | tf_error
>  };
> diff --git a/gcc/cp/pt.cc b/gcc/cp/pt.cc
> index 4400d429b6f..e1fb20994e3 100644
> --- a/gcc/cp/pt.cc
> +++ b/gcc/cp/pt.cc
> @@ -204,7 +204,6 @@ static void copy_default_args_to_explicit_spec (tree);
>  static bool invalid_nontype_parm_type_p (tree, tsubst_flags_t);
>  static bool dependent_template_arg_p (tree);
>  static bool dependent_type_p_r (tree);
> -static tree tsubst_copy	(tree, tree, tsubst_flags_t, tree);
>  static tree tsubst_decl (tree, tree, tsubst_flags_t, bool = true);
>  static tree tsubst_scope (tree, tree, tsubst_flags_t, tree);
>  static void perform_instantiation_time_access_checks (tree, tree);
> @@ -13373,15 +13372,11 @@ tsubst_pack_expansion (tree t, tree args, tsubst_flags_t complain,
>        if (TREE_CODE (parm_pack) == BASES)
>  	{
>  	  gcc_assert (parm_pack == pattern);
> +	  tree type = tsubst (BASES_TYPE (parm_pack), args, complain, in_decl);
>  	  if (BASES_DIRECT (parm_pack))
> -	    return calculate_direct_bases (tsubst_expr (BASES_TYPE (parm_pack),
> -							args, complain,
> -							in_decl),
> -					   complain);
> +	    return calculate_direct_bases (type, complain);
>  	  else
> -	    return calculate_bases (tsubst_expr (BASES_TYPE (parm_pack),
> -						 args, complain, in_decl),
> -				    complain);
> +	    return calculate_bases (type, complain);
>  	}
>        else if (builtin_pack_call_p (parm_pack))
>  	{
> @@ -15171,7 +15166,8 @@ tsubst_decl (tree t, tree args, tsubst_flags_t complain,
>  	      variadic_p = true;
>  	    }
>  	  else
> -	    name = tsubst_copy (name, args, complain, in_decl);
> +	    name = tsubst_copy_and_build (name, args,
> +					  complain | tf_no_name_lookup, in_decl);
>  
>  	  int len;
>  	  if (!variadic_p)
> @@ -16108,7 +16104,7 @@ tsubst (tree t, tree args, tsubst_flags_t complain, tree in_decl)
>        if (template_placeholder_p (t))
>  	{
>  	  tree tmpl = CLASS_PLACEHOLDER_TEMPLATE (t);
> -	  tmpl = tsubst_copy (tmpl, args, complain, in_decl);
> +	  tmpl = tsubst_copy_and_build (tmpl, args, complain, in_decl);
>  	  if (TREE_CODE (tmpl) == TEMPLATE_TEMPLATE_PARM)
>  	    tmpl = TEMPLATE_TEMPLATE_PARM_TEMPLATE_DECL (tmpl);
>  
> @@ -16592,8 +16588,8 @@ tsubst (tree t, tree args, tsubst_flags_t complain, tree in_decl)
>  	if (ctx == error_mark_node)
>  	  return error_mark_node;
>  
> -	tree f = tsubst_copy (TYPENAME_TYPE_FULLNAME (t), args,
> -			      complain, in_decl);
> +	tree f = tsubst_copy_and_build (TYPENAME_TYPE_FULLNAME (t), args,
> +					complain | tf_no_name_lookup, in_decl);
>  	if (f == error_mark_node)
>  	  return error_mark_node;
>  
> @@ -17045,7 +17041,8 @@ tsubst_qualified_id (tree qualified_id, tree args,
>    if (args)
>      {
>        scope = tsubst_scope (scope, args, complain, in_decl);
> -      expr = tsubst_copy (name, args, complain, in_decl);
> +      expr = tsubst_copy_and_build (name, args,
> +				    complain | tf_no_name_lookup, in_decl);
>      }
>    else
>      expr = name;
> @@ -17277,878 +17274,177 @@ maybe_dependent_member_ref (tree t, tree args, tsubst_flags_t complain,
>  				 TREE_CODE (t) == TEMPLATE_DECL);
>  }
>  
> -/* Like tsubst, but deals with expressions.  This function just replaces
> -   template parms; to finish processing the resultant expression, use
> -   tsubst_copy_and_build or tsubst_expr.  */
> +/* Helper function for tsubst_omp_clauses, used for instantiation of
> +   OMP_CLAUSE_DECL of clauses.  */
>  
>  static tree
> -tsubst_copy (tree t, tree args, tsubst_flags_t complain, tree in_decl)
> +tsubst_omp_clause_decl (tree decl, tree args, tsubst_flags_t complain,
> +			tree in_decl, tree *iterator_cache)
>  {
> -  enum tree_code code;
> -  tree r;
> -
> -  if (t == NULL_TREE || t == error_mark_node || args == NULL_TREE)
> -    return t;
> -
> -  if (TYPE_P (t))
> -    return tsubst (t, args, complain, in_decl);
> -
> -  if (tree d = maybe_dependent_member_ref (t, args, complain, in_decl))
> -    return d;
> -
> -  code = TREE_CODE (t);
> +  if (decl == NULL_TREE || decl == ridpointers[RID_OMP_ALL_MEMORY])
> +    return decl;
>  
> -  switch (code)
> +  /* Handle OpenMP iterators.  */
> +  if (TREE_CODE (decl) == TREE_LIST
> +      && TREE_PURPOSE (decl)
> +      && TREE_CODE (TREE_PURPOSE (decl)) == TREE_VEC)
>      {
> -    case PARM_DECL:
> -      r = retrieve_local_specialization (t);
> -
> -      if (r == NULL_TREE)
> +      tree ret;
> +      if (iterator_cache[0] == TREE_PURPOSE (decl))
> +	ret = iterator_cache[1];
> +      else
>  	{
> -	  /* We get here for a use of 'this' in an NSDMI.  */
> -	  if (DECL_NAME (t) == this_identifier && current_class_ptr)
> -	    return current_class_ptr;
> -
> -	  /* This can happen for a parameter name used later in a function
> -	     declaration (such as in a late-specified return type).  Just
> -	     make a dummy decl, since it's only used for its type.  */
> -	  gcc_assert (cp_unevaluated_operand);
> -	  r = tsubst_decl (t, args, complain);
> -	  /* Give it the template pattern as its context; its true context
> -	     hasn't been instantiated yet and this is good enough for
> -	     mangling.  */
> -	  DECL_CONTEXT (r) = DECL_CONTEXT (t);
> +	  tree *tp = &ret;
> +	  begin_scope (sk_omp, NULL);
> +	  for (tree it = TREE_PURPOSE (decl); it; it = TREE_CHAIN (it))
> +	    {
> +	      *tp = copy_node (it);
> +	      TREE_VEC_ELT (*tp, 0)
> +		= tsubst_decl (TREE_VEC_ELT (it, 0), args, complain);
> +	      DECL_CONTEXT (TREE_VEC_ELT (*tp, 0)) = current_function_decl;
> +	      pushdecl (TREE_VEC_ELT (*tp, 0));
> +	      TREE_VEC_ELT (*tp, 1)
> +		= tsubst_expr (TREE_VEC_ELT (it, 1), args, complain, in_decl);
> +	      TREE_VEC_ELT (*tp, 2)
> +		= tsubst_expr (TREE_VEC_ELT (it, 2), args, complain, in_decl);
> +	      TREE_VEC_ELT (*tp, 3)
> +		= tsubst_expr (TREE_VEC_ELT (it, 3), args, complain, in_decl);
> +	      TREE_CHAIN (*tp) = NULL_TREE;
> +	      tp = &TREE_CHAIN (*tp);
> +	    }
> +	  TREE_VEC_ELT (ret, 5) = poplevel (1, 1, 0);
> +	  iterator_cache[0] = TREE_PURPOSE (decl);
> +	  iterator_cache[1] = ret;
>  	}
> +      return build_tree_list (ret, tsubst_omp_clause_decl (TREE_VALUE (decl),
> +							   args, complain,
> +							   in_decl, NULL));
> +    }
>  
> -      if (TREE_CODE (r) == ARGUMENT_PACK_SELECT)
> -	r = argument_pack_select_arg (r);
> -      if (!mark_used (r, complain) && !(complain & tf_error))
> -	return error_mark_node;
> -      return r;
> -
> -    case CONST_DECL:
> -      {
> -	tree enum_type;
> -	tree v;
> -
> -	if (DECL_TEMPLATE_PARM_P (t))
> -	  return tsubst_copy (DECL_INITIAL (t), args, complain, in_decl);
> -	if (!uses_template_parms (DECL_CONTEXT (t)))
> -	  return t;
> -
> -	/* Unfortunately, we cannot just call lookup_name here.
> -	   Consider:
> -
> -	     template <int I> int f() {
> -	     enum E { a = I };
> -	     struct S { void g() { E e = a; } };
> -	     };
> -
> -	   When we instantiate f<7>::S::g(), say, lookup_name is not
> -	   clever enough to find f<7>::a.  */
> -	enum_type
> -	  = tsubst_aggr_type (DECL_CONTEXT (t), args, complain, in_decl,
> -			      /*entering_scope=*/0);
> -
> -	for (v = TYPE_VALUES (enum_type);
> -	     v != NULL_TREE;
> -	     v = TREE_CHAIN (v))
> -	  if (TREE_PURPOSE (v) == DECL_NAME (t))
> -	    return TREE_VALUE (v);
> -
> -	  /* We didn't find the name.  That should never happen; if
> -	     name-lookup found it during preliminary parsing, we
> -	     should find it again here during instantiation.  */
> -	gcc_unreachable ();
> -      }
> -      return t;
> +  /* Handle an OpenMP array section represented as a TREE_LIST (or
> +     OMP_CLAUSE_DOACROSS_KIND).  An OMP_CLAUSE_DOACROSS (with a depend
> +     kind of OMP_CLAUSE_DOACROSS_SINK) can also be represented as a
> +     TREE_LIST.  We can handle it exactly the same as an array section
> +     (purpose, value, and a chain), even though the nomenclature
> +     (low_bound, length, etc) is different.  */
> +  if (TREE_CODE (decl) == TREE_LIST)
> +    {
> +      tree low_bound
> +	= tsubst_expr (TREE_PURPOSE (decl), args, complain, in_decl);
> +      tree length = tsubst_expr (TREE_VALUE (decl), args, complain, in_decl);
> +      tree chain = tsubst_omp_clause_decl (TREE_CHAIN (decl), args, complain,
> +					   in_decl, NULL);
> +      if (TREE_PURPOSE (decl) == low_bound
> +	  && TREE_VALUE (decl) == length
> +	  && TREE_CHAIN (decl) == chain)
> +	return decl;
> +      tree ret = tree_cons (low_bound, length, chain);
> +      OMP_CLAUSE_DOACROSS_SINK_NEGATIVE (ret)
> +	= OMP_CLAUSE_DOACROSS_SINK_NEGATIVE (decl);
> +      return ret;
> +    }
> +  tree ret = tsubst_expr (decl, args, complain, in_decl);
> +  /* Undo convert_from_reference tsubst_expr could have called.  */
> +  if (decl
> +      && REFERENCE_REF_P (ret)
> +      && !REFERENCE_REF_P (decl))
> +    ret = TREE_OPERAND (ret, 0);
> +  return ret;
> +}
>  
> -    case FIELD_DECL:
> -      if (DECL_CONTEXT (t))
> -	{
> -	  tree ctx;
> +/* Like tsubst_copy, but specifically for OpenMP clauses.  */
>  
> -	  ctx = tsubst_aggr_type (DECL_CONTEXT (t), args, complain, in_decl,
> -				  /*entering_scope=*/1);
> -	  if (ctx != DECL_CONTEXT (t))
> -	    {
> -	      tree r = lookup_field (ctx, DECL_NAME (t), 0, false);
> -	      if (!r)
> -		{
> -		  if (complain & tf_error)
> -		    error ("using invalid field %qD", t);
> -		  return error_mark_node;
> -		}
> -	      return r;
> -	    }
> -	}
> +static tree
> +tsubst_omp_clauses (tree clauses, enum c_omp_region_type ort,
> +		    tree args, tsubst_flags_t complain, tree in_decl)
> +{
> +  tree new_clauses = NULL_TREE, nc, oc;
> +  tree linear_no_step = NULL_TREE;
> +  tree iterator_cache[2] = { NULL_TREE, NULL_TREE };
>  
> -      return t;
> +  for (oc = clauses; oc ; oc = OMP_CLAUSE_CHAIN (oc))
> +    {
> +      nc = copy_node (oc);
> +      OMP_CLAUSE_CHAIN (nc) = new_clauses;
> +      new_clauses = nc;
>  
> -    case VAR_DECL:
> -    case FUNCTION_DECL:
> -      if (DECL_LANG_SPECIFIC (t) && DECL_TEMPLATE_INFO (t))
> -	r = tsubst (t, args, complain, in_decl);
> -      else if (DECL_LOCAL_DECL_P (t))
> +      switch (OMP_CLAUSE_CODE (nc))
>  	{
> -	  /* Local specialization will usually have been created when
> -	     we instantiated the DECL_EXPR_DECL. */
> -	  r = retrieve_local_specialization (t);
> -	  if (!r)
> +	case OMP_CLAUSE_LASTPRIVATE:
> +	  if (OMP_CLAUSE_LASTPRIVATE_STMT (oc))
>  	    {
> -	      /* We're in a generic lambda referencing a local extern
> -		 from an outer block-scope of a non-template.  */
> -	      gcc_checking_assert (LAMBDA_FUNCTION_P (current_function_decl));
> -	      r = t;
> +	      OMP_CLAUSE_LASTPRIVATE_STMT (nc) = push_stmt_list ();
> +	      tsubst_expr (OMP_CLAUSE_LASTPRIVATE_STMT (oc), args,
> +			   complain, in_decl);
> +	      OMP_CLAUSE_LASTPRIVATE_STMT (nc)
> +		= pop_stmt_list (OMP_CLAUSE_LASTPRIVATE_STMT (nc));
>  	    }
> -	}
> -      else if (local_variable_p (t)
> -	       && uses_template_parms (DECL_CONTEXT (t)))
> -	{
> -	  r = retrieve_local_specialization (t);
> -	  if (r == NULL_TREE)
> +	  /* FALLTHRU */
> +	case OMP_CLAUSE_PRIVATE:
> +	case OMP_CLAUSE_SHARED:
> +	case OMP_CLAUSE_FIRSTPRIVATE:
> +	case OMP_CLAUSE_COPYIN:
> +	case OMP_CLAUSE_COPYPRIVATE:
> +	case OMP_CLAUSE_UNIFORM:
> +	case OMP_CLAUSE_DEPEND:
> +	case OMP_CLAUSE_DOACROSS:
> +	case OMP_CLAUSE_AFFINITY:
> +	case OMP_CLAUSE_FROM:
> +	case OMP_CLAUSE_TO:
> +	case OMP_CLAUSE_MAP:
> +	case OMP_CLAUSE__CACHE_:
> +	case OMP_CLAUSE_NONTEMPORAL:
> +	case OMP_CLAUSE_USE_DEVICE_PTR:
> +	case OMP_CLAUSE_USE_DEVICE_ADDR:
> +	case OMP_CLAUSE_IS_DEVICE_PTR:
> +	case OMP_CLAUSE_HAS_DEVICE_ADDR:
> +	case OMP_CLAUSE_INCLUSIVE:
> +	case OMP_CLAUSE_EXCLUSIVE:
> +	  OMP_CLAUSE_DECL (nc)
> +	    = tsubst_omp_clause_decl (OMP_CLAUSE_DECL (oc), args, complain,
> +				      in_decl, iterator_cache);
> +	  break;
> +	case OMP_CLAUSE_NUM_TEAMS:
> +	  if (OMP_CLAUSE_NUM_TEAMS_LOWER_EXPR (oc))
> +	    OMP_CLAUSE_NUM_TEAMS_LOWER_EXPR (nc)
> +	      = tsubst_expr (OMP_CLAUSE_NUM_TEAMS_LOWER_EXPR (oc), args,
> +			     complain, in_decl);
> +	  /* FALLTHRU */
> +	case OMP_CLAUSE_TILE:
> +	case OMP_CLAUSE_IF:
> +	case OMP_CLAUSE_NUM_THREADS:
> +	case OMP_CLAUSE_SCHEDULE:
> +	case OMP_CLAUSE_COLLAPSE:
> +	case OMP_CLAUSE_FINAL:
> +	case OMP_CLAUSE_DEVICE:
> +	case OMP_CLAUSE_DIST_SCHEDULE:
> +	case OMP_CLAUSE_THREAD_LIMIT:
> +	case OMP_CLAUSE_SAFELEN:
> +	case OMP_CLAUSE_SIMDLEN:
> +	case OMP_CLAUSE_NUM_TASKS:
> +	case OMP_CLAUSE_GRAINSIZE:
> +	case OMP_CLAUSE_PRIORITY:
> +	case OMP_CLAUSE_ORDERED:
> +	case OMP_CLAUSE_HINT:
> +	case OMP_CLAUSE_FILTER:
> +	case OMP_CLAUSE_NUM_GANGS:
> +	case OMP_CLAUSE_NUM_WORKERS:
> +	case OMP_CLAUSE_VECTOR_LENGTH:
> +	case OMP_CLAUSE_WORKER:
> +	case OMP_CLAUSE_VECTOR:
> +	case OMP_CLAUSE_ASYNC:
> +	case OMP_CLAUSE_WAIT:
> +	case OMP_CLAUSE_DETACH:
> +	  OMP_CLAUSE_OPERAND (nc, 0)
> +	    = tsubst_expr (OMP_CLAUSE_OPERAND (oc, 0), args, complain, in_decl);
> +	  break;
> +	case OMP_CLAUSE_REDUCTION:
> +	case OMP_CLAUSE_IN_REDUCTION:
> +	case OMP_CLAUSE_TASK_REDUCTION:
> +	  if (OMP_CLAUSE_REDUCTION_PLACEHOLDER (oc))
>  	    {
> -	      /* First try name lookup to find the instantiation.  */
> -	      r = lookup_name (DECL_NAME (t));
> -	      if (r)
> -		{
> -		  if (!VAR_P (r))
> -		    {
> -		      /* During error-recovery we may find a non-variable,
> -			 even an OVERLOAD: just bail out and avoid ICEs and
> -			 duplicate diagnostics (c++/62207).  */
> -		      gcc_assert (seen_error ());
> -		      return error_mark_node;
> -		    }
> -		  if (!is_capture_proxy (r))
> -		    {
> -		      /* Make sure the one we found is the one we want.  */
> -		      tree ctx = enclosing_instantiation_of (DECL_CONTEXT (t));
> -		      if (ctx != DECL_CONTEXT (r))
> -			r = NULL_TREE;
> -		    }
> -		}
> -
> -	      if (r)
> -		/* OK */;
> -	      else
> -		{
> -		  /* This can happen for a variable used in a
> -		     late-specified return type of a local lambda, or for a
> -		     local static or constant.  Building a new VAR_DECL
> -		     should be OK in all those cases.  */
> -		  r = tsubst_decl (t, args, complain);
> -		  if (local_specializations)
> -		    /* Avoid infinite recursion (79640).  */
> -		    register_local_specialization (r, t);
> -		  if (decl_maybe_constant_var_p (r))
> -		    {
> -		      /* We can't call cp_finish_decl, so handle the
> -			 initializer by hand.  */
> -		      tree init = tsubst_init (DECL_INITIAL (t), r, args,
> -					       complain, in_decl);
> -		      if (!processing_template_decl)
> -			init = maybe_constant_init (init);
> -		      if (processing_template_decl
> -			  ? potential_constant_expression (init)
> -			  : reduced_constant_expression_p (init))
> -			DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (r)
> -			  = TREE_CONSTANT (r) = true;
> -		      DECL_INITIAL (r) = init;
> -		      if (tree auto_node = type_uses_auto (TREE_TYPE (r)))
> -			TREE_TYPE (r)
> -			  = do_auto_deduction (TREE_TYPE (r), init, auto_node,
> -					       complain, adc_variable_type);
> -		    }
> -		  gcc_assert (cp_unevaluated_operand
> -			      || processing_contract_condition
> -			      || TREE_STATIC (r)
> -			      || decl_constant_var_p (r)
> -			      || seen_error ());
> -		  if (!processing_template_decl
> -		      && !TREE_STATIC (r))
> -		    r = process_outer_var_ref (r, complain);
> -		}
> -	      /* Remember this for subsequent uses.  */
> -	      if (local_specializations)
> -		register_local_specialization (r, t);
> -	    }
> -	  if (TREE_CODE (r) == ARGUMENT_PACK_SELECT)
> -	    r = argument_pack_select_arg (r);
> -	}
> -      else
> -	r = t;
> -      if (!mark_used (r, complain))
> -	return error_mark_node;
> -      return r;
> -
> -    case NAMESPACE_DECL:
> -      return t;
> -
> -    case OVERLOAD:
> -      return t;
> -
> -    case BASELINK:
> -      return tsubst_baselink (t, current_nonlambda_class_type (),
> -			      args, complain, in_decl);
> -
> -    case TEMPLATE_DECL:
> -      if (DECL_TEMPLATE_TEMPLATE_PARM_P (t))
> -	return tsubst (TREE_TYPE (DECL_TEMPLATE_RESULT (t)),
> -		       args, complain, in_decl);
> -      else if (DECL_FUNCTION_TEMPLATE_P (t) && DECL_MEMBER_TEMPLATE_P (t))
> -	return tsubst (t, args, complain, in_decl);
> -      else if (DECL_CLASS_SCOPE_P (t)
> -	       && uses_template_parms (DECL_CONTEXT (t)))
> -	{
> -	  /* Template template argument like the following example need
> -	     special treatment:
> -
> -	       template <template <class> class TT> struct C {};
> -	       template <class T> struct D {
> -		 template <class U> struct E {};
> -		 C<E> c;				// #1
> -	       };
> -	       D<int> d;				// #2
> -
> -	     We are processing the template argument `E' in #1 for
> -	     the template instantiation #2.  Originally, `E' is a
> -	     TEMPLATE_DECL with `D<T>' as its DECL_CONTEXT.  Now we
> -	     have to substitute this with one having context `D<int>'.  */
> -
> -	  tree context = tsubst_aggr_type (DECL_CONTEXT (t), args, complain,
> -					   in_decl, /*entering_scope=*/true);
> -	  return lookup_field (context, DECL_NAME(t), 0, false);
> -	}
> -      else
> -	/* Ordinary template template argument.  */
> -	return t;
> -
> -    case NON_LVALUE_EXPR:
> -    case VIEW_CONVERT_EXPR:
> -	{
> -	  /* Handle location wrappers by substituting the wrapped node
> -	     first, *then* reusing the resulting type.  Doing the type
> -	     first ensures that we handle template parameters and
> -	     parameter pack expansions.  */
> -	  if (location_wrapper_p (t))
> -	    {
> -	      tree op0 = tsubst_copy (TREE_OPERAND (t, 0), args,
> -				      complain, in_decl);
> -	      return maybe_wrap_with_location (op0, EXPR_LOCATION (t));
> -	    }
> -	  tree op = TREE_OPERAND (t, 0);
> -	  /* force_paren_expr can also create a VIEW_CONVERT_EXPR.  */
> -	  if (code == VIEW_CONVERT_EXPR && REF_PARENTHESIZED_P (t))
> -	    {
> -	      op = tsubst_copy (op, args, complain, in_decl);
> -	      op = build1 (code, TREE_TYPE (op), op);
> -	      REF_PARENTHESIZED_P (op) = true;
> -	      return op;
> -	    }
> -	  /* We shouldn't see any other uses of these in templates
> -	     (tsubst_copy_and_build handles C++20 tparm object wrappers).  */
> -	  gcc_unreachable ();
> -	}
> -
> -    case CAST_EXPR:
> -    case REINTERPRET_CAST_EXPR:
> -    case CONST_CAST_EXPR:
> -    case STATIC_CAST_EXPR:
> -    case DYNAMIC_CAST_EXPR:
> -    case IMPLICIT_CONV_EXPR:
> -    CASE_CONVERT:
> -      {
> -	tsubst_flags_t tcomplain = complain;
> -	if (code == CAST_EXPR)
> -	  tcomplain |= tf_tst_ok;
> -	tree type = tsubst (TREE_TYPE (t), args, tcomplain, in_decl);
> -	tree op0 = tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl);
> -	return build1 (code, type, op0);
> -      }
> -
> -    case BIT_CAST_EXPR:
> -      {
> -	tree type = tsubst (TREE_TYPE (t), args, complain, in_decl);
> -	tree op0 = tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl);
> -	r = build_min (BIT_CAST_EXPR, type, op0);
> -	SET_EXPR_LOCATION (r, EXPR_LOCATION (t));
> -	return r;
> -      }
> -
> -    case SIZEOF_EXPR:
> -      if (PACK_EXPANSION_P (TREE_OPERAND (t, 0))
> -	  || ARGUMENT_PACK_P (TREE_OPERAND (t, 0)))
> -        {
> -          tree expanded, op = TREE_OPERAND (t, 0);
> -	  int len = 0;
> -
> -	  if (SIZEOF_EXPR_TYPE_P (t))
> -	    op = TREE_TYPE (op);
> -
> -	  ++cp_unevaluated_operand;
> -	  ++c_inhibit_evaluation_warnings;
> -	  /* We only want to compute the number of arguments.  */
> -	  if (PACK_EXPANSION_P (op))
> -	    expanded = tsubst_pack_expansion (op, args, complain, in_decl);
> -	  else
> -	    expanded = tsubst_template_args (ARGUMENT_PACK_ARGS (op),
> -					     args, complain, in_decl);
> -	  --cp_unevaluated_operand;
> -	  --c_inhibit_evaluation_warnings;
> -
> -	  if (TREE_CODE (expanded) == TREE_VEC)
> -	    {
> -	      len = TREE_VEC_LENGTH (expanded);
> -	      /* Set TREE_USED for the benefit of -Wunused.  */
> -	      for (int i = 0; i < len; i++)
> -		if (DECL_P (TREE_VEC_ELT (expanded, i)))
> -		  TREE_USED (TREE_VEC_ELT (expanded, i)) = true;
> -	    }
> -
> -	  if (expanded == error_mark_node)
> -	    return error_mark_node;
> -	  else if (PACK_EXPANSION_P (expanded)
> -		   || (TREE_CODE (expanded) == TREE_VEC
> -		       && pack_expansion_args_count (expanded)))
> -
> -	    {
> -	      if (PACK_EXPANSION_P (expanded))
> -		/* OK.  */;
> -	      else if (TREE_VEC_LENGTH (expanded) == 1)
> -		expanded = TREE_VEC_ELT (expanded, 0);
> -	      else
> -		expanded = make_argument_pack (expanded);
> -
> -	      if (TYPE_P (expanded))
> -		return cxx_sizeof_or_alignof_type (input_location,
> -						   expanded, SIZEOF_EXPR,
> -						   false,
> -						   complain & tf_error);
> -	      else
> -		return cxx_sizeof_or_alignof_expr (input_location,
> -						   expanded, SIZEOF_EXPR,
> -						   false,
> -                                                   complain & tf_error);
> -	    }
> -	  else
> -	    return build_int_cst (size_type_node, len);
> -        }
> -      if (SIZEOF_EXPR_TYPE_P (t))
> -	{
> -	  r = tsubst (TREE_TYPE (TREE_OPERAND (t, 0)),
> -		      args, complain, in_decl);
> -	  r = build1 (NOP_EXPR, r, error_mark_node);
> -	  r = build1 (SIZEOF_EXPR,
> -		      tsubst (TREE_TYPE (t), args, complain, in_decl), r);
> -	  SIZEOF_EXPR_TYPE_P (r) = 1;
> -	  return r;
> -	}
> -      /* Fall through */
> -
> -    case INDIRECT_REF:
> -    case NEGATE_EXPR:
> -    case TRUTH_NOT_EXPR:
> -    case BIT_NOT_EXPR:
> -    case ADDR_EXPR:
> -    case UNARY_PLUS_EXPR:      /* Unary + */
> -    case ALIGNOF_EXPR:
> -    case AT_ENCODE_EXPR:
> -    case ARROW_EXPR:
> -    case THROW_EXPR:
> -    case TYPEID_EXPR:
> -    case REALPART_EXPR:
> -    case IMAGPART_EXPR:
> -    case PAREN_EXPR:
> -      {
> -	tree type = tsubst (TREE_TYPE (t), args, complain, in_decl);
> -	tree op0 = tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl);
> -	r = build1_loc (EXPR_LOCATION (t), code, type, op0);
> -	if (code == ALIGNOF_EXPR)
> -	  ALIGNOF_EXPR_STD_P (r) = ALIGNOF_EXPR_STD_P (t);
> -	/* For addresses of immediate functions ensure we have EXPR_LOCATION
> -	   set for possible later diagnostics.  */
> -	if (code == ADDR_EXPR
> -	    && EXPR_LOCATION (r) == UNKNOWN_LOCATION
> -	    && TREE_CODE (op0) == FUNCTION_DECL
> -	    && DECL_IMMEDIATE_FUNCTION_P (op0))
> -	  SET_EXPR_LOCATION (r, input_location);
> -	return r;
> -      }
> -
> -    case EXCESS_PRECISION_EXPR:
> -      {
> -	tree type = tsubst (TREE_TYPE (t), args, complain, in_decl);
> -	tree op0 = tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl);
> -	if (TREE_CODE (op0) == EXCESS_PRECISION_EXPR)
> -	  {
> -	    gcc_checking_assert (same_type_p (type, TREE_TYPE (op0)));
> -	    return op0;
> -	  }
> -	return build1_loc (EXPR_LOCATION (t), code, type, op0);
> -      }
> -
> -    case COMPONENT_REF:
> -      {
> -	tree object;
> -	tree name;
> -
> -	object = tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl);
> -	name = TREE_OPERAND (t, 1);
> -	if (TREE_CODE (name) == BIT_NOT_EXPR)
> -	  {
> -	    name = tsubst_copy (TREE_OPERAND (name, 0), args,
> -				complain, in_decl);
> -	    name = build1 (BIT_NOT_EXPR, NULL_TREE, name);
> -	  }
> -	else if (TREE_CODE (name) == SCOPE_REF
> -		 && TREE_CODE (TREE_OPERAND (name, 1)) == BIT_NOT_EXPR)
> -	  {
> -	    tree base = tsubst_copy (TREE_OPERAND (name, 0), args,
> -				     complain, in_decl);
> -	    name = TREE_OPERAND (name, 1);
> -	    name = tsubst_copy (TREE_OPERAND (name, 0), args,
> -				complain, in_decl);
> -	    name = build1 (BIT_NOT_EXPR, NULL_TREE, name);
> -	    name = build_qualified_name (/*type=*/NULL_TREE,
> -					 base, name,
> -					 /*template_p=*/false);
> -	  }
> -	else if (BASELINK_P (name))
> -	  name = tsubst_baselink (name,
> -				  non_reference (TREE_TYPE (object)),
> -				  args, complain,
> -				  in_decl);
> -	else
> -	  name = tsubst_copy (name, args, complain, in_decl);
> -	return build_nt (COMPONENT_REF, object, name, NULL_TREE);
> -      }
> -
> -    case PLUS_EXPR:
> -    case MINUS_EXPR:
> -    case MULT_EXPR:
> -    case TRUNC_DIV_EXPR:
> -    case CEIL_DIV_EXPR:
> -    case FLOOR_DIV_EXPR:
> -    case ROUND_DIV_EXPR:
> -    case EXACT_DIV_EXPR:
> -    case BIT_AND_EXPR:
> -    case BIT_IOR_EXPR:
> -    case BIT_XOR_EXPR:
> -    case TRUNC_MOD_EXPR:
> -    case FLOOR_MOD_EXPR:
> -    case TRUTH_ANDIF_EXPR:
> -    case TRUTH_ORIF_EXPR:
> -    case TRUTH_AND_EXPR:
> -    case TRUTH_OR_EXPR:
> -    case RSHIFT_EXPR:
> -    case LSHIFT_EXPR:
> -    case EQ_EXPR:
> -    case NE_EXPR:
> -    case MAX_EXPR:
> -    case MIN_EXPR:
> -    case LE_EXPR:
> -    case GE_EXPR:
> -    case LT_EXPR:
> -    case GT_EXPR:
> -    case COMPOUND_EXPR:
> -    case DOTSTAR_EXPR:
> -    case MEMBER_REF:
> -    case PREDECREMENT_EXPR:
> -    case PREINCREMENT_EXPR:
> -    case POSTDECREMENT_EXPR:
> -    case POSTINCREMENT_EXPR:
> -      {
> -	tree op0 = tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl);
> -	tree op1 = tsubst_copy (TREE_OPERAND (t, 1), args, complain, in_decl);
> -	return build_nt (code, op0, op1);
> -      }
> -
> -    case SCOPE_REF:
> -      {
> -	tree op0 = tsubst_scope (TREE_OPERAND (t, 0), args, complain, in_decl);
> -	tree op1 = tsubst_copy (TREE_OPERAND (t, 1), args, complain, in_decl);
> -	return build_qualified_name (/*type=*/NULL_TREE, op0, op1,
> -				     QUALIFIED_NAME_IS_TEMPLATE (t));
> -      }
> -
> -    case ARRAY_REF:
> -      {
> -	tree op0 = tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl);
> -	tree op1 = tsubst_copy (TREE_OPERAND (t, 1), args, complain, in_decl);
> -	return build_nt (ARRAY_REF, op0, op1, NULL_TREE, NULL_TREE);
> -      }
> -
> -    case CALL_EXPR:
> -      {
> -	int n = VL_EXP_OPERAND_LENGTH (t);
> -	tree result = build_vl_exp (CALL_EXPR, n);
> -	int i;
> -	for (i = 0; i < n; i++)
> -	  TREE_OPERAND (t, i) = tsubst_copy (TREE_OPERAND (t, i), args,
> -					     complain, in_decl);
> -	return result;
> -      }
> -
> -    case COND_EXPR:
> -    case MODOP_EXPR:
> -    case PSEUDO_DTOR_EXPR:
> -    case VEC_PERM_EXPR:
> -      {
> -	tree op0 = tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl);
> -	tree op1 = tsubst_copy (TREE_OPERAND (t, 1), args, complain, in_decl);
> -	tree op2 = tsubst_copy (TREE_OPERAND (t, 2), args, complain, in_decl);
> -	r = build_nt (code, op0, op1, op2);
> -	copy_warning (r, t);
> -	return r;
> -      }
> -
> -    case NEW_EXPR:
> -      {
> -	tree op0 = tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl);
> -	tree op1 = tsubst_copy (TREE_OPERAND (t, 1), args, complain, in_decl);
> -	tree op2 = tsubst_copy (TREE_OPERAND (t, 2), args, complain, in_decl);
> -	r = build_nt (code, op0, op1, op2);
> -	NEW_EXPR_USE_GLOBAL (r) = NEW_EXPR_USE_GLOBAL (t);
> -	return r;
> -      }
> -
> -    case DELETE_EXPR:
> -      {
> -	tree op0 = tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl);
> -	tree op1 = tsubst_copy (TREE_OPERAND (t, 1), args, complain, in_decl);
> -	r = build_nt (code, op0, op1);
> -	DELETE_EXPR_USE_GLOBAL (r) = DELETE_EXPR_USE_GLOBAL (t);
> -	DELETE_EXPR_USE_VEC (r) = DELETE_EXPR_USE_VEC (t);
> -	return r;
> -      }
> -
> -    case TEMPLATE_ID_EXPR:
> -      {
> -	/* Substituted template arguments */
> -	tree tmpl = TREE_OPERAND (t, 0);
> -	tree targs = TREE_OPERAND (t, 1);
> -
> -	tmpl = tsubst_copy (tmpl, args, complain, in_decl);
> -	if (targs)
> -	  targs = tsubst_template_args (targs, args, complain, in_decl);
> -
> -	if (variable_template_p (tmpl))
> -	  return lookup_template_variable (tmpl, targs, complain);
> -	else
> -	  return lookup_template_function (tmpl, targs);
> -      }
> -
> -    case TREE_LIST:
> -      {
> -	tree purpose, value, chain;
> -
> -	if (t == void_list_node)
> -	  return t;
> -
> -	purpose = TREE_PURPOSE (t);
> -	if (purpose)
> -	  purpose = tsubst_copy (purpose, args, complain, in_decl);
> -	value = TREE_VALUE (t);
> -	if (value)
> -	  value = tsubst_copy (value, args, complain, in_decl);
> -	chain = TREE_CHAIN (t);
> -	if (chain && chain != void_type_node)
> -	  chain = tsubst_copy (chain, args, complain, in_decl);
> -	if (purpose == TREE_PURPOSE (t)
> -	    && value == TREE_VALUE (t)
> -	    && chain == TREE_CHAIN (t))
> -	  return t;
> -	return tree_cons (purpose, value, chain);
> -      }
> -
> -    case TEMPLATE_PARM_INDEX:
> -    case TYPE_DECL:
> -      return tsubst (t, args, complain, in_decl);
> -
> -    case USING_DECL:
> -      t = DECL_NAME (t);
> -      /* Fall through.  */
> -    case IDENTIFIER_NODE:
> -      if (IDENTIFIER_CONV_OP_P (t))
> -	{
> -	  tree new_type = tsubst (TREE_TYPE (t), args, complain, in_decl);
> -	  return make_conv_op_name (new_type);
> -	}
> -      else
> -	return t;
> -
> -    case CONSTRUCTOR:
> -      /* This is handled by tsubst_copy_and_build.  */
> -      gcc_unreachable ();
> -
> -    case VA_ARG_EXPR:
> -      {
> -	tree op0 = tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl);
> -	tree type = tsubst (TREE_TYPE (t), args, complain, in_decl);
> -	return build_x_va_arg (EXPR_LOCATION (t), op0, type);
> -      }
> -
> -    case CLEANUP_POINT_EXPR:
> -      /* We shouldn't have built any of these during initial template
> -	 generation.  Instead, they should be built during instantiation
> -	 in response to the saved STMT_IS_FULL_EXPR_P setting.  */
> -      gcc_unreachable ();
> -
> -    case OFFSET_REF:
> -      {
> -	tree type = tsubst (TREE_TYPE (t), args, complain, in_decl);
> -	tree op0 = tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl);
> -	tree op1 = tsubst_copy (TREE_OPERAND (t, 1), args, complain, in_decl);
> -	r = build2 (code, type, op0, op1);
> -	PTRMEM_OK_P (r) = PTRMEM_OK_P (t);
> -	if (!mark_used (TREE_OPERAND (r, 1), complain)
> -	    && !(complain & tf_error))
> -	  return error_mark_node;
> -	return r;
> -      }
> -
> -    case EXPR_PACK_EXPANSION:
> -      error ("invalid use of pack expansion expression");
> -      return error_mark_node;
> -
> -    case NONTYPE_ARGUMENT_PACK:
> -      error ("use %<...%> to expand argument pack");
> -      return error_mark_node;
> -
> -    case VOID_CST:
> -      gcc_checking_assert (t == void_node && VOID_TYPE_P (TREE_TYPE (t)));
> -      return t;
> -
> -    case INTEGER_CST:
> -    case REAL_CST:
> -    case COMPLEX_CST:
> -    case VECTOR_CST:
> -      {
> -	/* Instantiate any typedefs in the type.  */
> -	tree type = tsubst (TREE_TYPE (t), args, complain, in_decl);
> -	r = fold_convert (type, t);
> -	gcc_assert (TREE_CODE (r) == code);
> -	return r;
> -      }
> -
> -    case STRING_CST:
> -      {
> -	tree type = tsubst (TREE_TYPE (t), args, complain, in_decl);
> -	r = t;
> -	if (type != TREE_TYPE (t))
> -	  {
> -	    r = copy_node (t);
> -	    TREE_TYPE (r) = type;
> -	  }
> -	return r;
> -      }
> -
> -    case PTRMEM_CST:
> -      /* These can sometimes show up in a partial instantiation, but never
> -	 involve template parms.  */
> -      gcc_assert (!uses_template_parms (t));
> -      return t;
> -
> -    case UNARY_LEFT_FOLD_EXPR:
> -      return tsubst_unary_left_fold (t, args, complain, in_decl);
> -    case UNARY_RIGHT_FOLD_EXPR:
> -      return tsubst_unary_right_fold (t, args, complain, in_decl);
> -    case BINARY_LEFT_FOLD_EXPR:
> -      return tsubst_binary_left_fold (t, args, complain, in_decl);
> -    case BINARY_RIGHT_FOLD_EXPR:
> -      return tsubst_binary_right_fold (t, args, complain, in_decl);
> -    case PREDICT_EXPR:
> -      return t;
> -
> -    case DEBUG_BEGIN_STMT:
> -      /* ??? There's no point in copying it for now, but maybe some
> -	 day it will contain more information, such as a pointer back
> -	 to the containing function, inlined copy or so.  */
> -      return t;
> -
> -    case CO_AWAIT_EXPR:
> -      return tsubst_expr (t, args, complain, in_decl);
> -
> -    default:
> -      /* We shouldn't get here, but keep going if !flag_checking.  */
> -      if (flag_checking)
> -	gcc_unreachable ();
> -      return t;
> -    }
> -}
> -
> -/* Helper function for tsubst_omp_clauses, used for instantiation of
> -   OMP_CLAUSE_DECL of clauses.  */
> -
> -static tree
> -tsubst_omp_clause_decl (tree decl, tree args, tsubst_flags_t complain,
> -			tree in_decl, tree *iterator_cache)
> -{
> -  if (decl == NULL_TREE || decl == ridpointers[RID_OMP_ALL_MEMORY])
> -    return decl;
> -
> -  /* Handle OpenMP iterators.  */
> -  if (TREE_CODE (decl) == TREE_LIST
> -      && TREE_PURPOSE (decl)
> -      && TREE_CODE (TREE_PURPOSE (decl)) == TREE_VEC)
> -    {
> -      tree ret;
> -      if (iterator_cache[0] == TREE_PURPOSE (decl))
> -	ret = iterator_cache[1];
> -      else
> -	{
> -	  tree *tp = &ret;
> -	  begin_scope (sk_omp, NULL);
> -	  for (tree it = TREE_PURPOSE (decl); it; it = TREE_CHAIN (it))
> -	    {
> -	      *tp = copy_node (it);
> -	      TREE_VEC_ELT (*tp, 0)
> -		= tsubst_decl (TREE_VEC_ELT (it, 0), args, complain);
> -	      DECL_CONTEXT (TREE_VEC_ELT (*tp, 0)) = current_function_decl;
> -	      pushdecl (TREE_VEC_ELT (*tp, 0));
> -	      TREE_VEC_ELT (*tp, 1)
> -		= tsubst_expr (TREE_VEC_ELT (it, 1), args, complain, in_decl);
> -	      TREE_VEC_ELT (*tp, 2)
> -		= tsubst_expr (TREE_VEC_ELT (it, 2), args, complain, in_decl);
> -	      TREE_VEC_ELT (*tp, 3)
> -		= tsubst_expr (TREE_VEC_ELT (it, 3), args, complain, in_decl);
> -	      TREE_CHAIN (*tp) = NULL_TREE;
> -	      tp = &TREE_CHAIN (*tp);
> -	    }
> -	  TREE_VEC_ELT (ret, 5) = poplevel (1, 1, 0);
> -	  iterator_cache[0] = TREE_PURPOSE (decl);
> -	  iterator_cache[1] = ret;
> -	}
> -      return build_tree_list (ret, tsubst_omp_clause_decl (TREE_VALUE (decl),
> -							   args, complain,
> -							   in_decl, NULL));
> -    }
> -
> -  /* Handle an OpenMP array section represented as a TREE_LIST (or
> -     OMP_CLAUSE_DOACROSS_KIND).  An OMP_CLAUSE_DOACROSS (with a depend
> -     kind of OMP_CLAUSE_DOACROSS_SINK) can also be represented as a
> -     TREE_LIST.  We can handle it exactly the same as an array section
> -     (purpose, value, and a chain), even though the nomenclature
> -     (low_bound, length, etc) is different.  */
> -  if (TREE_CODE (decl) == TREE_LIST)
> -    {
> -      tree low_bound
> -	= tsubst_expr (TREE_PURPOSE (decl), args, complain, in_decl);
> -      tree length = tsubst_expr (TREE_VALUE (decl), args, complain, in_decl);
> -      tree chain = tsubst_omp_clause_decl (TREE_CHAIN (decl), args, complain,
> -					   in_decl, NULL);
> -      if (TREE_PURPOSE (decl) == low_bound
> -	  && TREE_VALUE (decl) == length
> -	  && TREE_CHAIN (decl) == chain)
> -	return decl;
> -      tree ret = tree_cons (low_bound, length, chain);
> -      OMP_CLAUSE_DOACROSS_SINK_NEGATIVE (ret)
> -	= OMP_CLAUSE_DOACROSS_SINK_NEGATIVE (decl);
> -      return ret;
> -    }
> -  tree ret = tsubst_expr (decl, args, complain, in_decl);
> -  /* Undo convert_from_reference tsubst_expr could have called.  */
> -  if (decl
> -      && REFERENCE_REF_P (ret)
> -      && !REFERENCE_REF_P (decl))
> -    ret = TREE_OPERAND (ret, 0);
> -  return ret;
> -}
> -
> -/* Like tsubst_copy, but specifically for OpenMP clauses.  */
> -
> -static tree
> -tsubst_omp_clauses (tree clauses, enum c_omp_region_type ort,
> -		    tree args, tsubst_flags_t complain, tree in_decl)
> -{
> -  tree new_clauses = NULL_TREE, nc, oc;
> -  tree linear_no_step = NULL_TREE;
> -  tree iterator_cache[2] = { NULL_TREE, NULL_TREE };
> -
> -  for (oc = clauses; oc ; oc = OMP_CLAUSE_CHAIN (oc))
> -    {
> -      nc = copy_node (oc);
> -      OMP_CLAUSE_CHAIN (nc) = new_clauses;
> -      new_clauses = nc;
> -
> -      switch (OMP_CLAUSE_CODE (nc))
> -	{
> -	case OMP_CLAUSE_LASTPRIVATE:
> -	  if (OMP_CLAUSE_LASTPRIVATE_STMT (oc))
> -	    {
> -	      OMP_CLAUSE_LASTPRIVATE_STMT (nc) = push_stmt_list ();
> -	      tsubst_expr (OMP_CLAUSE_LASTPRIVATE_STMT (oc), args,
> -			   complain, in_decl);
> -	      OMP_CLAUSE_LASTPRIVATE_STMT (nc)
> -		= pop_stmt_list (OMP_CLAUSE_LASTPRIVATE_STMT (nc));
> -	    }
> -	  /* FALLTHRU */
> -	case OMP_CLAUSE_PRIVATE:
> -	case OMP_CLAUSE_SHARED:
> -	case OMP_CLAUSE_FIRSTPRIVATE:
> -	case OMP_CLAUSE_COPYIN:
> -	case OMP_CLAUSE_COPYPRIVATE:
> -	case OMP_CLAUSE_UNIFORM:
> -	case OMP_CLAUSE_DEPEND:
> -	case OMP_CLAUSE_DOACROSS:
> -	case OMP_CLAUSE_AFFINITY:
> -	case OMP_CLAUSE_FROM:
> -	case OMP_CLAUSE_TO:
> -	case OMP_CLAUSE_MAP:
> -	case OMP_CLAUSE__CACHE_:
> -	case OMP_CLAUSE_NONTEMPORAL:
> -	case OMP_CLAUSE_USE_DEVICE_PTR:
> -	case OMP_CLAUSE_USE_DEVICE_ADDR:
> -	case OMP_CLAUSE_IS_DEVICE_PTR:
> -	case OMP_CLAUSE_HAS_DEVICE_ADDR:
> -	case OMP_CLAUSE_INCLUSIVE:
> -	case OMP_CLAUSE_EXCLUSIVE:
> -	  OMP_CLAUSE_DECL (nc)
> -	    = tsubst_omp_clause_decl (OMP_CLAUSE_DECL (oc), args, complain,
> -				      in_decl, iterator_cache);
> -	  break;
> -	case OMP_CLAUSE_NUM_TEAMS:
> -	  if (OMP_CLAUSE_NUM_TEAMS_LOWER_EXPR (oc))
> -	    OMP_CLAUSE_NUM_TEAMS_LOWER_EXPR (nc)
> -	      = tsubst_expr (OMP_CLAUSE_NUM_TEAMS_LOWER_EXPR (oc), args,
> -			     complain, in_decl);
> -	  /* FALLTHRU */
> -	case OMP_CLAUSE_TILE:
> -	case OMP_CLAUSE_IF:
> -	case OMP_CLAUSE_NUM_THREADS:
> -	case OMP_CLAUSE_SCHEDULE:
> -	case OMP_CLAUSE_COLLAPSE:
> -	case OMP_CLAUSE_FINAL:
> -	case OMP_CLAUSE_DEVICE:
> -	case OMP_CLAUSE_DIST_SCHEDULE:
> -	case OMP_CLAUSE_THREAD_LIMIT:
> -	case OMP_CLAUSE_SAFELEN:
> -	case OMP_CLAUSE_SIMDLEN:
> -	case OMP_CLAUSE_NUM_TASKS:
> -	case OMP_CLAUSE_GRAINSIZE:
> -	case OMP_CLAUSE_PRIORITY:
> -	case OMP_CLAUSE_ORDERED:
> -	case OMP_CLAUSE_HINT:
> -	case OMP_CLAUSE_FILTER:
> -	case OMP_CLAUSE_NUM_GANGS:
> -	case OMP_CLAUSE_NUM_WORKERS:
> -	case OMP_CLAUSE_VECTOR_LENGTH:
> -	case OMP_CLAUSE_WORKER:
> -	case OMP_CLAUSE_VECTOR:
> -	case OMP_CLAUSE_ASYNC:
> -	case OMP_CLAUSE_WAIT:
> -	case OMP_CLAUSE_DETACH:
> -	  OMP_CLAUSE_OPERAND (nc, 0)
> -	    = tsubst_expr (OMP_CLAUSE_OPERAND (oc, 0), args, complain, in_decl);
> -	  break;
> -	case OMP_CLAUSE_REDUCTION:
> -	case OMP_CLAUSE_IN_REDUCTION:
> -	case OMP_CLAUSE_TASK_REDUCTION:
> -	  if (OMP_CLAUSE_REDUCTION_PLACEHOLDER (oc))
> -	    {
> -	      tree placeholder = OMP_CLAUSE_REDUCTION_PLACEHOLDER (oc);
> -	      if (TREE_CODE (placeholder) == SCOPE_REF)
> +	      tree placeholder = OMP_CLAUSE_REDUCTION_PLACEHOLDER (oc);
> +	      if (TREE_CODE (placeholder) == SCOPE_REF)
>  		{
>  		  tree scope = tsubst (TREE_OPERAND (placeholder, 0), args,
>  				       complain, in_decl);
> @@ -20420,6 +19716,13 @@ tsubst_copy_and_build (tree t,
>    tsubst_flags_t decltype_flag = (complain & tf_decltype);
>    complain &= ~tf_decltype;
>  
> +  /* This flag only applies to id-expressions at the top level.  */
> +  tsubst_flags_t no_name_lookup_flag = (complain & tf_no_name_lookup);
> +  complain &= ~tf_no_name_lookup;
> +
> +  if (tree d = maybe_dependent_member_ref (t, args, complain, in_decl))
> +    return d;
> +
>    switch (TREE_CODE (t))
>      {
>      case USING_DECL:
> @@ -20437,6 +19740,9 @@ tsubst_copy_and_build (tree t,
>  	    t = make_conv_op_name (new_type);
>  	  }
>  
> +	if (no_name_lookup_flag)
> +	  RETURN (t);
> +
>  	/* Look up the name.  */
>  	decl = lookup_name (t);
>  
> @@ -20471,7 +19777,8 @@ tsubst_copy_and_build (tree t,
>        {
>  	tree object;
>  	tree templ = tsubst_copy_and_build (TREE_OPERAND (t, 0), args,
> -					    complain, in_decl);
> +					    complain | no_name_lookup_flag,
> +					    in_decl);
>  	tree targs = TREE_OPERAND (t, 1);
>  
>  	if (targs)
> @@ -20505,6 +19812,9 @@ tsubst_copy_and_build (tree t,
>  
>  	if (variable_template_p (templ))
>  	  {
> +	    if (no_name_lookup_flag)
> +	      RETURN (lookup_template_variable (templ, targs, complain));
> +
>  	    tree r = lookup_and_finish_template_variable (templ, targs,
>  							  complain);
>  	    r = convert_from_reference (r);
> @@ -20526,6 +19836,8 @@ tsubst_copy_and_build (tree t,
>  	if (object)
>  	  RETURN (build3 (COMPONENT_REF, TREE_TYPE (tid),
>  			 object, tid, NULL_TREE));
> +	else if (no_name_lookup_flag)
> +	  RETURN (tid);
>  	else if (identifier_p (templ))
>  	  {
>  	    /* C++20 P0846: we can encounter an IDENTIFIER_NODE here when
> @@ -20659,10 +19971,22 @@ tsubst_copy_and_build (tree t,
>  				templated_operator_saved_lookups (t),
>  				complain|decltype_flag));
>  
> +    case BIT_NOT_EXPR:
> +      if (identifier_p (TREE_OPERAND (t, 0)))
> +	{
> +	  gcc_checking_assert (no_name_lookup_flag);
> +	  RETURN (t);
> +	}
> +      else if (TYPE_P (TREE_OPERAND (t, 0)))
> +	{
> +	  gcc_checking_assert (no_name_lookup_flag);
> +	  tree op0 = tsubst (TREE_OPERAND (t, 0), args, complain, in_decl);
> +	  RETURN (build_min_nt_loc (EXPR_LOCATION (t), BIT_NOT_EXPR, op0));
> +	}
> +      /* Fall through.  */
>      case PREDECREMENT_EXPR:
>      case PREINCREMENT_EXPR:
>      case NEGATE_EXPR:
> -    case BIT_NOT_EXPR:
>      case ABS_EXPR:
>      case TRUTH_NOT_EXPR:
>      case UNARY_PLUS_EXPR:  /* Unary + */
> @@ -20779,8 +20103,18 @@ tsubst_copy_and_build (tree t,
>        }
>  
>      case SCOPE_REF:
> -      RETURN (tsubst_qualified_id (t, args, complain, in_decl, /*done=*/true,
> -				  /*address_p=*/false));
> +      if (no_name_lookup_flag)
> +	{
> +	  tree op0 = tsubst_scope (TREE_OPERAND (t, 0), args, complain, in_decl);
> +	  tree op1 = tsubst_copy_and_build (TREE_OPERAND (t, 1), args,
> +					    complain | no_name_lookup_flag,
> +					    in_decl);
> +	  RETURN (build_qualified_name (/*type=*/NULL_TREE, op0, op1,
> +					QUALIFIED_NAME_IS_TEMPLATE (t)));
> +	}
> +      else
> +	RETURN (tsubst_qualified_id (t, args, complain, in_decl, /*done=*/true,
> +				    /*address_p=*/false));
>  
>      case BASELINK:
>        RETURN (tsubst_baselink (t, current_nonlambda_class_type (),
> @@ -20798,26 +20132,80 @@ tsubst_copy_and_build (tree t,
>  	  tsubst_copy_and_build_call_args (c, args, complain, in_decl,
>  					   index_exp_list);
>  
> -	  tree r;
> -	  if (vec_safe_length (index_exp_list) == 1
> -	      && !PACK_EXPANSION_P (index_exp_list[0]))
> -	    r = grok_array_decl (EXPR_LOCATION (t), op1,
> -				 index_exp_list[0], NULL,
> -				 complain | decltype_flag);
> +	  tree r;
> +	  if (vec_safe_length (index_exp_list) == 1
> +	      && !PACK_EXPANSION_P (index_exp_list[0]))
> +	    r = grok_array_decl (EXPR_LOCATION (t), op1,
> +				 index_exp_list[0], NULL,
> +				 complain | decltype_flag);
> +	  else
> +	    r = grok_array_decl (EXPR_LOCATION (t), op1,
> +				 NULL_TREE, &index_exp_list,
> +				 complain | decltype_flag);
> +	  RETURN (r);
> +	}
> +      RETURN (build_x_array_ref (EXPR_LOCATION (t), op1,
> +				 RECUR (TREE_OPERAND (t, 1)),
> +				 complain|decltype_flag));
> +
> +    case SIZEOF_EXPR:
> +      if (PACK_EXPANSION_P (TREE_OPERAND (t, 0))
> +	  || ARGUMENT_PACK_P (TREE_OPERAND (t, 0)))
> +	{
> +	  tree expanded, op = TREE_OPERAND (t, 0);
> +	  int len = 0;
> +
> +	  if (SIZEOF_EXPR_TYPE_P (t))
> +	    op = TREE_TYPE (op);
> +
> +	  ++cp_unevaluated_operand;
> +	  ++c_inhibit_evaluation_warnings;
> +	  /* We only want to compute the number of arguments.  */
> +	  if (PACK_EXPANSION_P (op))
> +	    expanded = tsubst_pack_expansion (op, args, complain, in_decl);
> +	  else
> +	    expanded = tsubst_template_args (ARGUMENT_PACK_ARGS (op),
> +					     args, complain, in_decl);
> +	  --cp_unevaluated_operand;
> +	  --c_inhibit_evaluation_warnings;
> +
> +	  if (TREE_CODE (expanded) == TREE_VEC)
> +	    {
> +	      len = TREE_VEC_LENGTH (expanded);
> +	      /* Set TREE_USED for the benefit of -Wunused.  */
> +	      for (int i = 0; i < len; i++)
> +		if (DECL_P (TREE_VEC_ELT (expanded, i)))
> +		  TREE_USED (TREE_VEC_ELT (expanded, i)) = true;
> +	    }
> +
> +	  if (expanded == error_mark_node)
> +	    RETURN (error_mark_node);
> +	  else if (PACK_EXPANSION_P (expanded)
> +		   || (TREE_CODE (expanded) == TREE_VEC
> +		       && pack_expansion_args_count (expanded)))
> +
> +	    {
> +	      if (PACK_EXPANSION_P (expanded))
> +		/* OK.  */;
> +	      else if (TREE_VEC_LENGTH (expanded) == 1)
> +		expanded = TREE_VEC_ELT (expanded, 0);
> +	      else
> +		expanded = make_argument_pack (expanded);
> +
> +	      if (TYPE_P (expanded))
> +		RETURN (cxx_sizeof_or_alignof_type (input_location,
> +						    expanded, SIZEOF_EXPR,
> +						    false,
> +						    complain & tf_error));
> +	      else
> +		RETURN (cxx_sizeof_or_alignof_expr (input_location,
> +						    expanded, SIZEOF_EXPR,
> +						    false,
> +						    complain & tf_error));
> +	    }
>  	  else
> -	    r = grok_array_decl (EXPR_LOCATION (t), op1,
> -				 NULL_TREE, &index_exp_list,
> -				 complain | decltype_flag);
> -	  RETURN (r);
> +	    RETURN (build_int_cst (size_type_node, len));
>  	}
> -      RETURN (build_x_array_ref (EXPR_LOCATION (t), op1,
> -				 RECUR (TREE_OPERAND (t, 1)),
> -				 complain|decltype_flag));
> -
> -    case SIZEOF_EXPR:
> -      if (PACK_EXPANSION_P (TREE_OPERAND (t, 0))
> -	  || ARGUMENT_PACK_P (TREE_OPERAND (t, 0)))
> -	RETURN (tsubst_copy (t, args, complain, in_decl));
>        /* Fall through */
>  
>      case ALIGNOF_EXPR:
> @@ -21072,10 +20460,9 @@ tsubst_copy_and_build (tree t,
>  	    qualified_p = false;
>  
>  	    if (TREE_CODE (function) == TEMPLATE_ID_EXPR)
> -	      /* Use tsubst_copy to substitute through the template arguments
> -		 of the template-id without performing unqualified lookup of
> -		 the template name.  */
> -	      function = tsubst_copy (function, args, complain, in_decl);
> +	      function = tsubst_copy_and_build (function, args,
> +						complain | tf_no_name_lookup,
> +						in_decl);
>  	  }
>  	else
>  	  {
> @@ -21473,7 +20860,8 @@ tsubst_copy_and_build (tree t,
>  				    non_reference (TREE_TYPE (object)),
>  				    args, complain, in_decl);
>  	else
> -	  member = tsubst_copy (member, args, complain, in_decl);
> +	  member = tsubst_copy_and_build (member, args,
> +					  complain | tf_no_name_lookup, in_decl);
>  	if (member == error_mark_node)
>  	  RETURN (error_mark_node);
>  
> @@ -21556,154 +20944,446 @@ tsubst_copy_and_build (tree t,
>  	    RETURN (error_mark_node);
>  	  }
>  
> -	r = finish_class_member_access_expr (object, member,
> -					     /*template_p=*/false,
> -					     complain);
> -	if (REF_PARENTHESIZED_P (t))
> -	  r = force_paren_expr (r);
> -	RETURN (r);
> +	r = finish_class_member_access_expr (object, member,
> +					     /*template_p=*/false,
> +					     complain);
> +	if (REF_PARENTHESIZED_P (t))
> +	  r = force_paren_expr (r);
> +	RETURN (r);
> +      }
> +
> +    case THROW_EXPR:
> +      RETURN (build_throw
> +       (input_location, RECUR (TREE_OPERAND (t, 0))));
> +
> +    case CONSTRUCTOR:
> +      {
> +	vec<constructor_elt, va_gc> *n;
> +	constructor_elt *ce;
> +	unsigned HOST_WIDE_INT idx;
> +	bool process_index_p;
> +        int newlen;
> +        bool need_copy_p = false;
> +	tree r;
> +
> +	tsubst_flags_t tcomplain = complain;
> +	if (COMPOUND_LITERAL_P (t))
> +	  tcomplain |= tf_tst_ok;
> +	tree type = tsubst (TREE_TYPE (t), args, tcomplain, in_decl);
> +	if (type == error_mark_node)
> +	  RETURN (error_mark_node);
> +
> +	/* We do not want to process the index of aggregate
> +	   initializers as they are identifier nodes which will be
> +	   looked up by digest_init.  */
> +	process_index_p = !(type && MAYBE_CLASS_TYPE_P (type));
> +
> +	if (null_member_pointer_value_p (t))
> +	  {
> +	    gcc_assert (same_type_p (type, TREE_TYPE (t)));
> +	    RETURN (t);
> +	  }
> +
> +	n = vec_safe_copy (CONSTRUCTOR_ELTS (t));
> +        newlen = vec_safe_length (n);
> +	FOR_EACH_VEC_SAFE_ELT (n, idx, ce)
> +	  {
> +	    if (ce->index && process_index_p
> +		/* An identifier index is looked up in the type
> +		   being initialized, not the current scope.  */
> +		&& TREE_CODE (ce->index) != IDENTIFIER_NODE)
> +	      ce->index = RECUR (ce->index);
> +
> +            if (PACK_EXPANSION_P (ce->value))
> +              {
> +                /* Substitute into the pack expansion.  */
> +                ce->value = tsubst_pack_expansion (ce->value, args, complain,
> +                                                  in_decl);
> +
> +		if (ce->value == error_mark_node
> +		    || PACK_EXPANSION_P (ce->value))
> +		  ;
> +		else if (TREE_VEC_LENGTH (ce->value) == 1)
> +                  /* Just move the argument into place.  */
> +                  ce->value = TREE_VEC_ELT (ce->value, 0);
> +                else
> +                  {
> +                    /* Update the length of the final CONSTRUCTOR
> +                       arguments vector, and note that we will need to
> +                       copy.*/
> +                    newlen = newlen + TREE_VEC_LENGTH (ce->value) - 1;
> +                    need_copy_p = true;
> +                  }
> +              }
> +            else
> +              ce->value = RECUR (ce->value);
> +	  }
> +
> +        if (need_copy_p)
> +          {
> +            vec<constructor_elt, va_gc> *old_n = n;
> +
> +            vec_alloc (n, newlen);
> +            FOR_EACH_VEC_ELT (*old_n, idx, ce)
> +              {
> +                if (TREE_CODE (ce->value) == TREE_VEC)
> +                  {
> +                    int i, len = TREE_VEC_LENGTH (ce->value);
> +                    for (i = 0; i < len; ++i)
> +                      CONSTRUCTOR_APPEND_ELT (n, 0,
> +                                              TREE_VEC_ELT (ce->value, i));
> +                  }
> +                else
> +                  CONSTRUCTOR_APPEND_ELT (n, 0, ce->value);
> +              }
> +          }
> +
> +	r = build_constructor (init_list_type_node, n);
> +	CONSTRUCTOR_IS_DIRECT_INIT (r) = CONSTRUCTOR_IS_DIRECT_INIT (t);
> +	CONSTRUCTOR_IS_DESIGNATED_INIT (r)
> +	  = CONSTRUCTOR_IS_DESIGNATED_INIT (t);
> +
> +	if (TREE_HAS_CONSTRUCTOR (t))
> +	  {
> +	    fcl_t cl = fcl_functional;
> +	    if (CONSTRUCTOR_C99_COMPOUND_LITERAL (t))
> +	      cl = fcl_c99;
> +	    RETURN (finish_compound_literal (type, r, complain, cl));
> +	  }
> +
> +	TREE_TYPE (r) = type;
> +	RETURN (r);
> +      }
> +
> +    case TYPEID_EXPR:
> +      {
> +	tree operand_0 = TREE_OPERAND (t, 0);
> +	if (TYPE_P (operand_0))
> +	  {
> +	    operand_0 = tsubst (operand_0, args, complain, in_decl);
> +	    RETURN (get_typeid (operand_0, complain));
> +	  }
> +	else
> +	  {
> +	    operand_0 = RECUR (operand_0);
> +	    RETURN (build_typeid (operand_0, complain));
> +	  }
> +      }
> +
> +    case FUNCTION_DECL:
> +    case PARM_DECL:
> +    case VAR_DECL:
> +      if (!args)
> +	RETURN (t);
> +      tree r;
> +      if (VAR_OR_FUNCTION_DECL_P (t)
> +	  && DECL_LANG_SPECIFIC (t) && DECL_TEMPLATE_INFO (t))
> +	r = tsubst_decl (t, args, complain);
> +      else if (VAR_OR_FUNCTION_DECL_P (t) && DECL_LOCAL_DECL_P (t))
> +	{
> +	  /* Local specialization will usually have been created when
> +	     we instantiated the DECL_EXPR_DECL. */
> +	  r = retrieve_local_specialization (t);
> +	  if (!r)
> +	    {
> +	      /* We're in a generic lambda referencing a local extern
> +		 from an outer block-scope of a non-template.  */
> +	      gcc_checking_assert (LAMBDA_FUNCTION_P (current_function_decl));
> +	      r = t;
> +	    }
> +	}
> +      else if (local_variable_p (t)
> +	       && ((r = retrieve_local_specialization (t))
> +		   || TREE_CODE (t) == PARM_DECL
> +		   || uses_template_parms (DECL_CONTEXT (t))))
> +	{
> +	  if (r == NULL_TREE && TREE_CODE (t) == PARM_DECL)
> +	    {
> +	      /* We get here for a use of 'this' in an NSDMI.  */
> +	      if (DECL_NAME (t) == this_identifier && current_class_ptr)
> +		RETURN (current_class_ptr);
> +
> +	      /* This can happen for a parameter name used later in a function
> +		 declaration (such as in a late-specified return type).  Just
> +		 make a dummy decl, since it's only used for its type.  */
> +	      gcc_assert (cp_unevaluated_operand);
> +	      r = tsubst_decl (t, args, complain);
> +	      /* Give it the template pattern as its context; its true context
> +		 hasn't been instantiated yet and this is good enough for
> +		 mangling.  */
> +	      DECL_CONTEXT (r) = DECL_CONTEXT (t);
> +	    }
> +	  else if (r == NULL_TREE)
> +	    {
> +	      /* First try name lookup to find the instantiation.  */
> +	      r = lookup_name (DECL_NAME (t));
> +	      if (r)
> +		{
> +		  if (!VAR_P (r))
> +		    {
> +		      /* During error-recovery we may find a non-variable,
> +			 even an OVERLOAD: just bail out and avoid ICEs and
> +			 duplicate diagnostics (c++/62207).  */
> +		      gcc_assert (seen_error ());
> +		      RETURN (error_mark_node);
> +		    }
> +		  if (!is_capture_proxy (r))
> +		    {
> +		      /* Make sure the one we found is the one we want.  */
> +		      tree ctx = enclosing_instantiation_of (DECL_CONTEXT (t));
> +		      if (ctx != DECL_CONTEXT (r))
> +			r = NULL_TREE;
> +		    }
> +		}
> +
> +	      if (r)
> +		/* OK */;
> +	      else
> +		{
> +		  /* This can happen for a variable used in a
> +		     late-specified return type of a local lambda, or for a
> +		     local static or constant.  Building a new VAR_DECL
> +		     should be OK in all those cases.  */
> +		  r = tsubst_decl (t, args, complain);
> +		  if (local_specializations)
> +		    /* Avoid infinite recursion (79640).  */
> +		    register_local_specialization (r, t);
> +		  if (decl_maybe_constant_var_p (r))
> +		    {
> +		      /* We can't call cp_finish_decl, so handle the
> +			 initializer by hand.  */
> +		      tree init = tsubst_init (DECL_INITIAL (t), r, args,
> +					       complain, in_decl);
> +		      if (!processing_template_decl)
> +			init = maybe_constant_init (init);
> +		      if (processing_template_decl
> +			  ? potential_constant_expression (init)
> +			  : reduced_constant_expression_p (init))
> +			DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (r)
> +			  = TREE_CONSTANT (r) = true;
> +		      DECL_INITIAL (r) = init;
> +		      if (tree auto_node = type_uses_auto (TREE_TYPE (r)))
> +			TREE_TYPE (r)
> +			  = do_auto_deduction (TREE_TYPE (r), init, auto_node,
> +					       complain, adc_variable_type);
> +		    }
> +		  gcc_assert (cp_unevaluated_operand
> +			      || processing_contract_condition
> +			      || TREE_STATIC (r)
> +			      || decl_constant_var_p (r)
> +			      || seen_error ());
> +		  if (!processing_template_decl
> +		      && !TREE_STATIC (r))
> +		    r = process_outer_var_ref (r, complain);
> +		}
> +	      /* Remember this for subsequent uses.  */
> +	      if (local_specializations)
> +		register_local_specialization (r, t);
> +	    }
> +	  if (TREE_CODE (r) == ARGUMENT_PACK_SELECT)
> +	    r = argument_pack_select_arg (r);
> +	}
> +      else
> +	r = t;
> +      if (!mark_used (r, complain))
> +	RETURN (error_mark_node);
> +
> +      if (!no_name_lookup_flag
> +	  && (TREE_CODE (t) == PARM_DECL || TREE_CODE (t) == VAR_DECL))
> +	{
> +	  /* ??? We're doing a subset  of finish_id_expression here.  */
> +	  if (tree wrap = maybe_get_tls_wrapper_call (r))
> +	    /* Replace an evaluated use of the thread_local variable with
> +	       a call to its wrapper.  */
> +	    r = wrap;
> +	  else if (outer_automatic_var_p (r))
> +	    r = process_outer_var_ref (r, complain);
> +
> +	  if (!TYPE_REF_P (TREE_TYPE (t)))
> +	    /* If the original type was a reference, we'll be wrapped in
> +	       the appropriate INDIRECT_REF.  */
> +	    r = convert_from_reference (r);
> +	}
> +      RETURN (r);
> +
> +    case CONST_DECL:
> +      {
> +	tree enum_type;
> +	tree v;
> +
> +	if (DECL_TEMPLATE_PARM_P (t))
> +	  RETURN (RECUR (DECL_INITIAL (t)));
> +	if (!uses_template_parms (DECL_CONTEXT (t)))
> +	  RETURN (t);
> +
> +	/* Unfortunately, we cannot just call lookup_name here.
> +	   Consider:
> +
> +	     template <int I> int f() {
> +	     enum E { a = I };
> +	     struct S { void g() { E e = a; } };
> +	     };
> +
> +	   When we instantiate f<7>::S::g(), say, lookup_name is not
> +	   clever enough to find f<7>::a.  */
> +	enum_type
> +	  = tsubst_aggr_type (DECL_CONTEXT (t), args, complain, in_decl,
> +			      /*entering_scope=*/0);
> +
> +	for (v = TYPE_VALUES (enum_type);
> +	     v != NULL_TREE;
> +	     v = TREE_CHAIN (v))
> +	  if (TREE_PURPOSE (v) == DECL_NAME (t))
> +	    RETURN (TREE_VALUE (v));
> +
> +	  /* We didn't find the name.  That should never happen; if
> +	     name-lookup found it during preliminary parsing, we
> +	     should find it again here during instantiation.  */
> +	gcc_unreachable ();
> +	RETURN (t);
>        }
>  
> -    case THROW_EXPR:
> -      RETURN (build_throw
> -       (input_location, RECUR (TREE_OPERAND (t, 0))));
> +    case FIELD_DECL:
> +      if (DECL_CONTEXT (t))
> +	{
> +	  tree ctx;
>  
> -    case CONSTRUCTOR:
> -      {
> -	vec<constructor_elt, va_gc> *n;
> -	constructor_elt *ce;
> -	unsigned HOST_WIDE_INT idx;
> -	bool process_index_p;
> -        int newlen;
> -        bool need_copy_p = false;
> -	tree r;
> +	  ctx = tsubst_aggr_type (DECL_CONTEXT (t), args, complain, in_decl,
> +				  /*entering_scope=*/1);
> +	  if (ctx != DECL_CONTEXT (t))
> +	    {
> +	      tree r = lookup_field (ctx, DECL_NAME (t), 0, false);
> +	      if (!r)
> +		{
> +		  if (complain & tf_error)
> +		    error ("using invalid field %qD", t);
> +		  RETURN (error_mark_node);
> +		}
> +	      RETURN (r);
> +	    }
> +	}
> +      RETURN (t);
>  
> -	tsubst_flags_t tcomplain = complain;
> -	if (COMPOUND_LITERAL_P (t))
> -	  tcomplain |= tf_tst_ok;
> -	tree type = tsubst (TREE_TYPE (t), args, tcomplain, in_decl);
> -	if (type == error_mark_node)
> -	  RETURN (error_mark_node);
> +    case NAMESPACE_DECL:
> +    case OVERLOAD:
> +      RETURN (t);
>  
> -	/* We do not want to process the index of aggregate
> -	   initializers as they are identifier nodes which will be
> -	   looked up by digest_init.  */
> -	process_index_p = !(type && MAYBE_CLASS_TYPE_P (type));
> +    case TEMPLATE_DECL:
> +      if (DECL_TEMPLATE_TEMPLATE_PARM_P (t))
> +	RETURN (tsubst (TREE_TYPE (DECL_TEMPLATE_RESULT (t)),
> +			args, complain, in_decl));
> +      else if (DECL_FUNCTION_TEMPLATE_P (t) && DECL_MEMBER_TEMPLATE_P (t))
> +	RETURN (tsubst (t, args, complain, in_decl));
> +      else if (DECL_CLASS_SCOPE_P (t)
> +	       && uses_template_parms (DECL_CONTEXT (t)))
> +	{
> +	  /* Template template argument like the following example need
> +	     special treatment:
>  
> -	if (null_member_pointer_value_p (t))
> -	  {
> -	    gcc_assert (same_type_p (type, TREE_TYPE (t)));
> -	    RETURN (t);
> -	  }
> +	       template <template <class> class TT> struct C {};
> +	       template <class T> struct D {
> +		 template <class U> struct E {};
> +		 C<E> c;				// #1
> +	       };
> +	       D<int> d;				// #2
>  
> -	n = vec_safe_copy (CONSTRUCTOR_ELTS (t));
> -        newlen = vec_safe_length (n);
> -	FOR_EACH_VEC_SAFE_ELT (n, idx, ce)
> -	  {
> -	    if (ce->index && process_index_p
> -		/* An identifier index is looked up in the type
> -		   being initialized, not the current scope.  */
> -		&& TREE_CODE (ce->index) != IDENTIFIER_NODE)
> -	      ce->index = RECUR (ce->index);
> +	     We are processing the template argument `E' in #1 for
> +	     the template instantiation #2.  Originally, `E' is a
> +	     TEMPLATE_DECL with `D<T>' as its DECL_CONTEXT.  Now we
> +	     have to substitute this with one having context `D<int>'.  */
>  
> -            if (PACK_EXPANSION_P (ce->value))
> -              {
> -                /* Substitute into the pack expansion.  */
> -                ce->value = tsubst_pack_expansion (ce->value, args, complain,
> -                                                  in_decl);
> +	  tree context = tsubst_aggr_type (DECL_CONTEXT (t), args, complain,
> +					   in_decl, /*entering_scope=*/true);
> +	  RETURN (lookup_field (context, DECL_NAME(t), 0, false));
> +	}
> +      else
> +	/* Ordinary template template argument.  */
> +	RETURN (t);
>  
> -		if (ce->value == error_mark_node
> -		    || PACK_EXPANSION_P (ce->value))
> -		  ;
> -		else if (TREE_VEC_LENGTH (ce->value) == 1)
> -                  /* Just move the argument into place.  */
> -                  ce->value = TREE_VEC_ELT (ce->value, 0);
> -                else
> -                  {
> -                    /* Update the length of the final CONSTRUCTOR
> -                       arguments vector, and note that we will need to
> -                       copy.*/
> -                    newlen = newlen + TREE_VEC_LENGTH (ce->value) - 1;
> -                    need_copy_p = true;
> -                  }
> -              }
> -            else
> -              ce->value = RECUR (ce->value);
> -	  }
> +    case TEMPLATE_PARM_INDEX:
> +    case TYPE_DECL:
> +      RETURN (tsubst (t, args, complain, in_decl));
>  
> -        if (need_copy_p)
> -          {
> -            vec<constructor_elt, va_gc> *old_n = n;
> +    case CLEANUP_POINT_EXPR:
> +      /* We shouldn't have built any of these during initial template
> +	 generation.  Instead, they should be built during instantiation
> +	 in response to the saved STMT_IS_FULL_EXPR_P setting.  */
> +      gcc_unreachable ();
>  
> -            vec_alloc (n, newlen);
> -            FOR_EACH_VEC_ELT (*old_n, idx, ce)
> -              {
> -                if (TREE_CODE (ce->value) == TREE_VEC)
> -                  {
> -                    int i, len = TREE_VEC_LENGTH (ce->value);
> -                    for (i = 0; i < len; ++i)
> -                      CONSTRUCTOR_APPEND_ELT (n, 0,
> -                                              TREE_VEC_ELT (ce->value, i));
> -                  }
> -                else
> -                  CONSTRUCTOR_APPEND_ELT (n, 0, ce->value);
> -              }
> -          }
> +    case OFFSET_REF:
> +      {
> +	tree type = tsubst (TREE_TYPE (t), args, complain, in_decl);
> +	tree op0 = RECUR (TREE_OPERAND (t, 0));
> +	tree op1 = RECUR (TREE_OPERAND (t, 1));
> +	r = build2 (OFFSET_REF, type, op0, op1);
> +	PTRMEM_OK_P (r) = PTRMEM_OK_P (t);
> +	if (!mark_used (TREE_OPERAND (r, 1), complain)
> +	    && !(complain & tf_error))
> +	  RETURN (error_mark_node);
> +	RETURN (r);
> +      }
>  
> -	r = build_constructor (init_list_type_node, n);
> -	CONSTRUCTOR_IS_DIRECT_INIT (r) = CONSTRUCTOR_IS_DIRECT_INIT (t);
> -	CONSTRUCTOR_IS_DESIGNATED_INIT (r)
> -	  = CONSTRUCTOR_IS_DESIGNATED_INIT (t);
> +    case EXPR_PACK_EXPANSION:
> +      error ("invalid use of pack expansion expression");
> +      RETURN (error_mark_node);
>  
> -	if (TREE_HAS_CONSTRUCTOR (t))
> -	  {
> -	    fcl_t cl = fcl_functional;
> -	    if (CONSTRUCTOR_C99_COMPOUND_LITERAL (t))
> -	      cl = fcl_c99;
> -	    RETURN (finish_compound_literal (type, r, complain, cl));
> -	  }
> +    case NONTYPE_ARGUMENT_PACK:
> +      error ("use %<...%> to expand argument pack");
> +      RETURN (error_mark_node);
>  
> -	TREE_TYPE (r) = type;
> +    case VOID_CST:
> +      gcc_checking_assert (t == void_node && VOID_TYPE_P (TREE_TYPE (t)));
> +      RETURN (t);
> +
> +    case INTEGER_CST:
> +    case REAL_CST:
> +    case COMPLEX_CST:
> +    case VECTOR_CST:
> +      {
> +	/* Instantiate any typedefs in the type.  */
> +	tree type = tsubst (TREE_TYPE (t), args, complain, in_decl);
> +	r = fold_convert (type, t);
> +	gcc_assert (TREE_CODE (r) == TREE_CODE (t));
>  	RETURN (r);
>        }
>  
> -    case TYPEID_EXPR:
> +    case STRING_CST:
>        {
> -	tree operand_0 = TREE_OPERAND (t, 0);
> -	if (TYPE_P (operand_0))
> -	  {
> -	    operand_0 = tsubst (operand_0, args, complain, in_decl);
> -	    RETURN (get_typeid (operand_0, complain));
> -	  }
> -	else
> +	tree type = tsubst (TREE_TYPE (t), args, complain, in_decl);
> +	r = t;
> +	if (type != TREE_TYPE (t))
>  	  {
> -	    operand_0 = RECUR (operand_0);
> -	    RETURN (build_typeid (operand_0, complain));
> +	    r = copy_node (t);
> +	    TREE_TYPE (r) = type;
>  	  }
> +	RETURN (r);
>        }
>  
> -    case VAR_DECL:
> -      if (!args)
> -	RETURN (t);
> -      /* Fall through */
> +    case PTRMEM_CST:
> +      /* These can sometimes show up in a partial instantiation, but never
> +	 involve template parms.  */
> +      gcc_assert (!uses_template_parms (t));
> +      RETURN (t);
>  
> -    case PARM_DECL:
> -      {
> -	tree r = tsubst_copy (t, args, complain, in_decl);
> -	/* ??? We're doing a subset of finish_id_expression here.  */
> -	if (tree wrap = maybe_get_tls_wrapper_call (r))
> -	  /* Replace an evaluated use of the thread_local variable with
> -	     a call to its wrapper.  */
> -	  r = wrap;
> -	else if (outer_automatic_var_p (r))
> -	  r = process_outer_var_ref (r, complain);
> -
> -	if (!TYPE_REF_P (TREE_TYPE (t)))
> -	  /* If the original type was a reference, we'll be wrapped in
> -	     the appropriate INDIRECT_REF.  */
> -	  r = convert_from_reference (r);
> -	RETURN (r);
> -      }
> +    case UNARY_LEFT_FOLD_EXPR:
> +      RETURN (tsubst_unary_left_fold (t, args, complain, in_decl));
> +    case UNARY_RIGHT_FOLD_EXPR:
> +      RETURN (tsubst_unary_right_fold (t, args, complain, in_decl));
> +    case BINARY_LEFT_FOLD_EXPR:
> +      RETURN (tsubst_binary_left_fold (t, args, complain, in_decl));
> +    case BINARY_RIGHT_FOLD_EXPR:
> +      RETURN (tsubst_binary_right_fold (t, args, complain, in_decl));
> +    case PREDICT_EXPR:
> +      RETURN (t);
> +
> +    case DEBUG_BEGIN_STMT:
> +      /* ??? There's no point in copying it for now, but maybe some
> +	 day it will contain more information, such as a pointer back
> +	 to the containing function, inlined copy or so.  */
> +      RETURN (t);
> +
> +    case CO_AWAIT_EXPR:
> +      RETURN (tsubst_expr (t, args, complain, in_decl));
>  
>      case VA_ARG_EXPR:
>        {
> @@ -21728,8 +21408,11 @@ tsubst_copy_and_build (tree t,
>  
>      case TRAIT_EXPR:
>        {
> -	tree type1 = tsubst_copy (TRAIT_EXPR_TYPE1 (t), args,
> -				  complain, in_decl);
> +	tree type1 = TRAIT_EXPR_TYPE1 (t);
> +	if (TYPE_P (type1))
> +	  type1 = tsubst (type1, args, complain, in_decl);
> +	else
> +	  type1 = tsubst_copy_and_build (type1, args, complain, in_decl);
>  	tree type2 = tsubst (TRAIT_EXPR_TYPE2 (t), args,
>  			     complain, in_decl);
>  	RETURN (finish_trait_expr (TRAIT_EXPR_LOCATION (t),
> @@ -21856,7 +21539,10 @@ tsubst_copy_and_build (tree t,
>  	if (subst)
>  	  RETURN (subst);
>        }
> -      RETURN (tsubst_copy (t, args, complain, in_decl));
> +      /* We shouldn't get here, but keep going if !flag_checking.  */
> +      if (flag_checking)
> +	gcc_unreachable ();
> +      RETURN (t);
>      }
>  
>  #undef RECUR
> @@ -27580,8 +27266,12 @@ tsubst_initializer_list (tree t, tree argvec)
>            else
>              {
>  	      tree tmp;
> -              decl = tsubst_copy (TREE_PURPOSE (t), argvec, 
> -                                  tf_warning_or_error, NULL_TREE);
> +	      if (TYPE_P (TREE_PURPOSE (t)))
> +		decl = tsubst (TREE_PURPOSE (t), argvec,
> +			       tf_warning_or_error, NULL_TREE);
> +	      else
> +		decl = tsubst_copy_and_build (TREE_PURPOSE (t), argvec,
> +					      tf_warning_or_error, NULL_TREE);
>  
>                decl = expand_member_init (decl);
>                if (decl && !DECL_P (decl))
> -- 
> 2.42.0.296.g493f462273
> 
>