From: Jason Merrill <jason@redhat.com>
To: Patrick Palka <ppalka@redhat.com>
Cc: gcc-patches@gcc.gnu.org
Subject: Re: [PATCH] c++: two-stage name lookup for overloaded operators [PR51577]
Date: Wed, 15 Dec 2021 22:30:37 -0500 [thread overview]
Message-ID: <e05e889e-b319-8500-7fc7-a47f10c204ec@redhat.com> (raw)
In-Reply-To: <318cb467-0e62-2694-d838-125d2f49b11a@idea>
On 12/15/21 17:53, Patrick Palka wrote:
>
>
> On Wed, 15 Dec 2021, Jason Merrill wrote:
>
>> On 12/10/21 09:53, Patrick Palka wrote:
>>> In order to properly implement two-stage name lookup for dependent
>>> operator expressions, we need to remember the result of unqualified
>>> lookup of the operator at template definition time, and reuse that
>>> result rather than performing another unqualified lookup at
>>> instantiation time.
>>>
>>> Ideally we could just store the lookup result in the expression directly,
>>> but as pointed out in r9-6405 this isn't really possible since we use
>>> the standard tree codes to represent most dependent operator expressions.
>>>
>>> We could perhaps create a new tree code to represent dependent operator
>>> expressions, say a DEPENDENT_OPERATOR_EXPR with enough operands to store
>>> the lookup results along and everything else, but that'd require a lot
>>> of careful work to make sure we handle this new tree code properly
>>> across the frontend.
>>>
>>> However, currently type-dependent operator (and call) expressions are
>>> given an empty TREE_TYPE, so this space is effectively unused except to
>>> signal that the expression is type-dependent. It'd be convenient if we
>>> could use this space to store the lookup results while preserving the
>>> dependent-ness of the expression.
>>>
>>> To that end, this patch creates a new kind of type, called
>>> DEPENDENT_OPERATOR_TYPE, which we give to dependent operator expressions
>>> and into which we can store the result of operator lookup at template
>>> definition time (DEPENDENT_OPERATOR_TYPE_SAVED_LOOKUPS). Since this
>>> type is always dependent, and since the frontend doesn't seem to care
>>> much about the particular type of a type-dependent expression, using
>>> this type in place of a NULL_TREE type seems to just work; only
>>> dependent_type_p and WILDCARD_TYPE_P need to be adjusted to return true
>>> for this new type.
>>>
>>> The rest of the patch mostly consists of adding the necessary plumbing
>>> to pass DEPENDENT_OPERATOR_TYPE_SAVED_LOOKUPS to add_operator_candidates,
>>> adjusting all callers of build_x_binary_op & friends appropriately, and
>>> removing the now unnecessary push_operator_bindings mechanism.
>>>
>>> In passing, this patch simplifies finish_constraint_binary_op to avoid
>>> using build_x_binary_op for building a binary constraint-expr; we don't
>>> need to consider operator||/&& overloads here. This patch also makes
>>> FOLD_EXPR_OP yield a tree_code instead of a raw INTEGER_CST.
>>>
>>> Finally, this patch adds the XFAILed test operator-8.C which is about
>>> broken two-stage name lookup for rewritten non-dependent operator
>>> expressions, an existing bug that's otherwise only documented in
>>> build_new_op.
>>>
>>> Bootstrapped and regtested on x86-64-pc-linux-gnu, does this look OK for
>>> trunk?
>>>
>>> PR c++/51577
>>> PR c++/83035
>>> PR c++/100465
>>>
>>> gcc/cp/ChangeLog:
>>>
>>> * call.c (add_operator_candidates): Add lookups parameter.
>>> Use it to avoid performing a second unqualified lookup when
>>> instantiating a dependent operator expression.
>>> (build_new_op): Add lookups parameter and pass it appropriately.
>>> * constraint.cc (finish_constraint_binary_op): Use
>>> build_min_nt_loc instead of build_x_binary_op.
>>> * coroutines.cc (build_co_await): Adjust call to build_new_op.
>>> * cp-objcp-common.c (cp_common_init_ts): Mark
>>> DEPENDENT_OPERATOR_TYPE appropriately.
>>> * cp-tree.def (DEPENDENT_OPERATOR_TYPE): Define.
>>> * cp-tree.h (WILDCARD_TYPE_P): Accept DEPENDENT_OPERATOR_TYPE.
>>> (FOLD_EXPR_OP_RAW): New, renamed from ...
>>> (FOLD_EXPR_OP): ... this. Change this to return the tree_code
>>> directly.
>>> (DEPENDENT_OPERATOR_TYPE_SAVED_LOOKUPS): Define.
>>> (DEPENDENT_OPERATOR_SAVED_LOOKUPS): Define.
>>> (build_new_op): Add lookups parameter.
>>> (build_dependent_operator_type): Declare.
>>> (build_x_indirect_ref): Add lookups parameter.
>>> (build_x_binary_op): Likewise.
>>> (build_x_unary_op): Likewise.
>>> (build_x_compound_expr): Likewise.
>>> (build_x_modify_expr): Likewise.
>>> * cxx-pretty-print.c (get_fold_operator): Adjust after
>>> FOLD_EXPR_OP change.
>>> * decl.c (start_preparsed_function): Don't call
>>> push_operator_bindings.
>>> * decl2.c (grok_array_decl): Adjust calls to build_new_op.
>>> * method.c (do_one_comp): Likewise.
>>> (build_comparison_op): Likewise.
>>> * module.cc (trees_out::type_node): Handle DEPENDENT_OPERATOR_TYPE.
>>> (trees_in::tree_node): Likewise.
>>> * name-lookup.c (lookup_name): Revert r11-2876 change.
>>> (op_unqualified_lookup): Remove.
>>> (maybe_save_operator_binding): Remove.
>>> (discard_operator_bindings): Remove.
>>> (push_operator_bindings): Remove.
>>> * name-lookup.h (maybe_save_operator_binding): Remove.
>>> (push_operator_bindings): Remove.
>>> (discard_operator_bindings): Remove.
>>> * parser.c (cp_parser_unary_expression): Adjust calls to build_x_*.
>>> (cp_parser_binary_expression): Likewise.
>>> (cp_parser_assignment_expression): Likewise.
>>> (cp_parser_expression): Likewise.
>>> (do_range_for_auto_deduction): Likewise.
>>> (cp_convert_range_for): Likewise.
>>> (cp_parser_perform_range_for_lookup): Likewise.
>>> (cp_parser_template_argument): Likewise.
>>> (cp_parser_omp_for_cond): Likewise.
>>> (cp_parser_omp_for_incr): Likewise.
>>> (cp_parser_omp_for_loop_init): Likewise.
>>> (cp_convert_omp_range_for): Likewise.
>>> (cp_finish_omp_range_for): Likewise.
>>> * pt.c (fold_expression): Adjust after FOLD_EXPR_OP change. Pass
>>> DEPENDENT_OPERATOR_TYPE_SAVED_LOOKUPS to build_x_*.
>>> (tsubst_omp_for_iterator): Adjust call to build_x_modify_expr.
>>> (tsubst_expr) <case COMPOUND_EXPR>: Pass
>>> DEPENDENT_OPERATOR_TYPE_SAVED_LOOKUPS to build_x_*.
>>> (tsubst_copy_and_build) <case INDIRECT_REF>: Likewise.
>>> <case tcc_unary>: Likewise.
>>> <case tcc_binary>: Likewise.
>>> <case MODOP_EXPR>: Likewise.
>>> <case COMPOUND_EXPR>: Likewise.
>>> (dependent_type_p_r): Return true for DEPENDENT_OPERATOR_TYPE.
>>> * ptree.c (cxx_print_type): Handle DEPENDENT_OPERATOR_TYPE.
>>> * semantics.c (finish_increment_expr): Adjust call to
>>> build_x_unary_op.
>>> (finish_unary_op_expr): Likewise.
>>> (handle_omp_for_class_iterator): Adjust calls to build_x_*.
>>> (finish_omp_cancel): Likewise.
>>> (finish_unary_fold_expr): Use build_dependent_operator_type.
>>> (finish_binary_fold_expr): Likewise.
>>> * tree.c (cp_free_lang_data): Don't call discard_operator_bindings.
>>> * typeck.c (rationalize_conditional_expr): Adjust call to
>>> build_x_binary_op.
>>> (op_unqualified_lookup): Define.
>>> (build_dependent_operator_type): Define.
>>> (build_x_indirect_ref): Add lookups parmaeter and use
>>> build_dependent_operator_type.
>>> (build_x_binary_op): Likewise.
>>> (build_x_array_ref): Likewise.
>>> (build_x_unary_op): Likewise.
>>> (build_x_compound_expr_from_list): Adjust call to
>>> build_x_compound_expr.
>>> (build_x_compound_expr_from_vec): Likewise.
>>> (build_x_compound_expr): Add lookups parameter and use
>>> build_dependent_operator_type.
>>> (cp_build_modify_expr): Adjust call to build_new_op.
>>> (build_x_modify_expr): Add lookups parameter and use
>>> build_dependent_operator_type.
>>> * typeck2.c (build_x_arrow): Adjust call to build_new_op.
>>>
>>> libcc1/ChangeLog:
>>>
>>> * libcp1plugin.cc (plugin_build_unary_expr): Adjust call to
>>> build_x_unary_op.
>>> (plugin_build_binary_expr): Adjust call to build_x_binary_op.
>>>
>>> gcc/testsuite/ChangeLog:
>>>
>>> * g++.dg/lookup/operator-3.C: Split out operator overload
>>> declarations into ...
>>> * g++.dg/lookup/operator-3-ops.h: ... here.
>>> * g++.dg/lookup/operator-3a.C: New test.
>>> * g++.dg/lookup/operator-4.C: New test.
>>> * g++.dg/lookup/operator-4a.C: New test.
>>> * g++.dg/lookup/operator-5.C: New test.
>>> * g++.dg/lookup/operator-5a.C: New test.
>>> * g++.dg/lookup/operator-6.C: New test.
>>> * g++.dg/lookup/operator-7.C: New test.
>>> * g++.dg/lookup/operator-8.C: New test.
>>> ---
>>> gcc/cp/call.c | 33 +++--
>>> gcc/cp/constraint.cc | 11 +-
>>> gcc/cp/coroutines.cc | 2 +-
>>> gcc/cp/cp-objcp-common.c | 1 +
>>> gcc/cp/cp-tree.def | 5 +
>>> gcc/cp/cp-tree.h | 45 +++++--
>>> gcc/cp/cxx-pretty-print.c | 4 +-
>>> gcc/cp/decl.c | 2 -
>>> gcc/cp/decl2.c | 5 +-
>>> gcc/cp/method.c | 12 +-
>>> gcc/cp/module.cc | 2 +
>>> gcc/cp/name-lookup.c | 133 +------------------
>>> gcc/cp/name-lookup.h | 3 -
>>> gcc/cp/parser.c | 40 +++---
>>> gcc/cp/pt.c | 27 +++-
>>> gcc/cp/ptree.c | 6 +
>>> gcc/cp/semantics.c | 46 ++++---
>>> gcc/cp/tree.c | 2 -
>>> gcc/cp/typeck.c | 112 +++++++++++++---
>>> gcc/cp/typeck2.c | 2 +-
>>> gcc/testsuite/g++.dg/lookup/operator-3-ops.h | 53 ++++++++
>>> gcc/testsuite/g++.dg/lookup/operator-3.C | 56 +-------
>>> gcc/testsuite/g++.dg/lookup/operator-3a.C | 61 +++++++++
>>> gcc/testsuite/g++.dg/lookup/operator-4.C | 74 +++++++++++
>>> gcc/testsuite/g++.dg/lookup/operator-4a.C | 76 +++++++++++
>>> gcc/testsuite/g++.dg/lookup/operator-5.C | 74 +++++++++++
>>> gcc/testsuite/g++.dg/lookup/operator-5a.C | 76 +++++++++++
>>> gcc/testsuite/g++.dg/lookup/operator-6.C | 59 ++++++++
>>> gcc/testsuite/g++.dg/lookup/operator-7.C | 27 ++++
>>> gcc/testsuite/g++.dg/lookup/operator-8.C | 34 +++++
>>> libcc1/libcp1plugin.cc | 4 +-
>>> 31 files changed, 787 insertions(+), 300 deletions(-)
>>> create mode 100644 gcc/testsuite/g++.dg/lookup/operator-3-ops.h
>>> create mode 100644 gcc/testsuite/g++.dg/lookup/operator-3a.C
>>> create mode 100644 gcc/testsuite/g++.dg/lookup/operator-4.C
>>> create mode 100644 gcc/testsuite/g++.dg/lookup/operator-4a.C
>>> create mode 100644 gcc/testsuite/g++.dg/lookup/operator-5.C
>>> create mode 100644 gcc/testsuite/g++.dg/lookup/operator-5a.C
>>> create mode 100644 gcc/testsuite/g++.dg/lookup/operator-6.C
>>> create mode 100644 gcc/testsuite/g++.dg/lookup/operator-7.C
>>> create mode 100644 gcc/testsuite/g++.dg/lookup/operator-8.C
>>>
>>> diff --git a/gcc/cp/call.c b/gcc/cp/call.c
>>> index 28bd8e0c260..53a391cbc6b 100644
>>> --- a/gcc/cp/call.c
>>> +++ b/gcc/cp/call.c
>>> @@ -6285,12 +6285,17 @@ op_is_ordered (tree_code code)
>>> /* Subroutine of build_new_op: Add to CANDIDATES all candidates for the
>>> operator indicated by CODE/CODE2. This function calls itself
>>> recursively to
>>> - handle C++20 rewritten comparison operator candidates. */
>>> + handle C++20 rewritten comparison operator candidates.
>>> +
>>> + LOOKUPS, if non-NULL, is the set of pertinent namespace-scope operator
>>> + overloads to consider. This parameter is used when instantiating a
>>> + dependent operator expression and has the same structure as
>>> + DEPENDENT_OPERATOR_TYPE_SAVED_LOOKUPS. */
>>> static tree
>>> add_operator_candidates (z_candidate **candidates,
>>> tree_code code, tree_code code2,
>>> - vec<tree, va_gc> *arglist,
>>> + vec<tree, va_gc> *arglist, tree lookups,
>>> int flags, tsubst_flags_t complain)
>>> {
>>> z_candidate *start_candidates = *candidates;
>>> @@ -6326,7 +6331,15 @@ add_operator_candidates (z_candidate **candidates,
>>> consider. */
>>> if (!memonly)
>>> {
>>> - tree fns = lookup_name (fnname, LOOK_where::BLOCK_NAMESPACE);
>>> + tree fns;
>>> + if (!lookups)
>>> + fns = lookup_name (fnname, LOOK_where::BLOCK_NAMESPACE);
>>> + /* If LOOKUPS is non-NULL, then we're instantiating a dependent
>>> operator
>>> + expression, and LOOKUPS contains the result of stage 1 name lookup.
>>> */
>>> + else if (tree found = purpose_member (fnname, lookups))
>>> + fns = TREE_VALUE (found);
>>> + else
>>> + fns = NULL_TREE;
>>> fns = lookup_arg_dependent (fnname, fns, arglist);
>>> add_candidates (fns, NULL_TREE, arglist, NULL_TREE,
>>> NULL_TREE, false, NULL_TREE, NULL_TREE,
>>> @@ -6429,7 +6442,7 @@ add_operator_candidates (z_candidate **candidates,
>>> if (rewrite_code != code)
>>> /* Add rewritten candidates in same order. */
>>> add_operator_candidates (candidates, rewrite_code, ERROR_MARK,
>>> - arglist, flags, complain);
>>> + arglist, lookups, flags, complain);
>>> z_candidate *save_cand = *candidates;
>>> @@ -6439,7 +6452,7 @@ add_operator_candidates (z_candidate **candidates,
>>> revlist->quick_push ((*arglist)[1]);
>>> revlist->quick_push ((*arglist)[0]);
>>> add_operator_candidates (candidates, rewrite_code, ERROR_MARK,
>>> - revlist, flags, complain);
>>> + revlist, lookups, flags, complain);
>>> /* Release the vec if we didn't add a candidate that uses it. */
>>> for (z_candidate *c = *candidates; c != save_cand; c = c->next)
>>> @@ -6457,8 +6470,8 @@ add_operator_candidates (z_candidate **candidates,
>>> tree
>>> build_new_op (const op_location_t &loc, enum tree_code code, int flags,
>>> - tree arg1, tree arg2, tree arg3, tree *overload,
>>> - tsubst_flags_t complain)
>>> + tree arg1, tree arg2, tree arg3, tree lookups,
>>> + tree *overload, tsubst_flags_t complain)
>>> {
>>> struct z_candidate *candidates = 0, *cand;
>>> vec<tree, va_gc> *arglist;
>>> @@ -6554,7 +6567,7 @@ build_new_op (const op_location_t &loc, enum tree_code
>>> code, int flags,
>>> p = conversion_obstack_alloc (0);
>>> result = add_operator_candidates (&candidates, code, code2, arglist,
>>> - flags, complain);
>>> + lookups, flags, complain);
>>> if (result == error_mark_node)
>>> goto user_defined_result_ready;
>>> @@ -6610,7 +6623,7 @@ build_new_op (const op_location_t &loc, enum
>>> tree_code code, int flags,
>>> else
>>> code = PREDECREMENT_EXPR;
>>> result = build_new_op (loc, code, flags, arg1, NULL_TREE,
>>> - NULL_TREE, overload, complain);
>>> + NULL_TREE, lookups, overload, complain);
>>> break;
>>> /* The caller will deal with these. */
>>> @@ -6767,7 +6780,7 @@ build_new_op (const op_location_t &loc, enum tree_code
>>> code, int flags,
>>> warning_sentinel ws (warn_zero_as_null_pointer_constant);
>>> result = build_new_op (loc, code,
>>> LOOKUP_NORMAL|LOOKUP_REWRITTEN,
>>> - lhs, rhs, NULL_TREE,
>>> + lhs, rhs, NULL_TREE, lookups,
>>> NULL, complain);
>>> }
>>> break;
>>> diff --git a/gcc/cp/constraint.cc b/gcc/cp/constraint.cc
>>> index 2896efdd7f2..c235a657a77 100644
>>> --- a/gcc/cp/constraint.cc
>>> +++ b/gcc/cp/constraint.cc
>>> @@ -202,15 +202,8 @@ finish_constraint_binary_op (location_t loc,
>>> return error_mark_node;
>>> if (!check_constraint_operands (loc, lhs, rhs))
>>> return error_mark_node;
>>> - tree overload;
>>> - cp_expr expr = build_x_binary_op (loc, code,
>>> - lhs, TREE_CODE (lhs),
>>> - rhs, TREE_CODE (rhs),
>>> - &overload, tf_none);
>>> - /* When either operand is dependent, the overload set may be non-empty.
>>> */
>>> - if (expr == error_mark_node)
>>> - return error_mark_node;
>>> - expr.set_location (loc);
>>> + cp_expr expr
>>> + = build_min_nt_loc (loc, code, lhs.get_value (), rhs.get_value ());
>>> expr.set_range (lhs.get_start (), rhs.get_finish ());
>>> return expr;
>>> }
>>> diff --git a/gcc/cp/coroutines.cc b/gcc/cp/coroutines.cc
>>> index 9017902e6fb..c00672eeb6e 100644
>>> --- a/gcc/cp/coroutines.cc
>>> +++ b/gcc/cp/coroutines.cc
>>> @@ -912,7 +912,7 @@ build_co_await (location_t loc, tree a,
>>> suspend_point_kind suspend_kind)
>>> if (MAYBE_CLASS_TYPE_P (TREE_TYPE (a)))
>>> {
>>> o = build_new_op (loc, CO_AWAIT_EXPR, LOOKUP_NORMAL, a, NULL_TREE,
>>> - NULL_TREE, NULL, tf_warning_or_error);
>>> + NULL_TREE, NULL_TREE, NULL, tf_warning_or_error);
>>> /* If no viable functions are found, o is a. */
>>> if (!o || o == error_mark_node)
>>> o = a;
>>> diff --git a/gcc/cp/cp-objcp-common.c b/gcc/cp/cp-objcp-common.c
>>> index 38eae881f0c..36e04cdee5e 100644
>>> --- a/gcc/cp/cp-objcp-common.c
>>> +++ b/gcc/cp/cp-objcp-common.c
>>> @@ -484,6 +484,7 @@ cp_common_init_ts (void)
>>> /* New Types. */
>>> MARK_TS_TYPE_COMMON (UNBOUND_CLASS_TEMPLATE);
>>> MARK_TS_TYPE_COMMON (TYPE_ARGUMENT_PACK);
>>> + MARK_TS_TYPE_COMMON (DEPENDENT_OPERATOR_TYPE);
>>> MARK_TS_TYPE_NON_COMMON (DECLTYPE_TYPE);
>>> MARK_TS_TYPE_NON_COMMON (TYPENAME_TYPE);
>>> diff --git a/gcc/cp/cp-tree.def b/gcc/cp/cp-tree.def
>>> index 725139bb457..6fb838cc850 100644
>>> --- a/gcc/cp/cp-tree.def
>>> +++ b/gcc/cp/cp-tree.def
>>> @@ -476,6 +476,11 @@ DEFTREECODE (UNDERLYING_TYPE, "underlying_type",
>>> tcc_type, 0)
>>> BASES_TYPE is the type in question. */
>>> DEFTREECODE (BASES, "bases", tcc_type, 0)
>>> +/* Dependent operator expressions are given this type rather than a
>>> NULL_TREE
>>> + type so that we have somewhere to stash the result of phase 1 name
>>> lookup
>>> + (namely into DEPENDENT_OPERATOR_TYPE_SAVED_LOOKUPS). */
>>> +DEFTREECODE (DEPENDENT_OPERATOR_TYPE, "dependent_operator_type", tcc_type,
>>> 0)
>>> +
>>> /* Used to represent the template information stored by template
>>> specializations.
>>> The accessors are:
>>> diff --git a/gcc/cp/cp-tree.h b/gcc/cp/cp-tree.h
>>> index e4330fb1f8b..8b98c061eea 100644
>>> --- a/gcc/cp/cp-tree.h
>>> +++ b/gcc/cp/cp-tree.h
>>> @@ -2183,7 +2183,8 @@ enum languages { lang_c, lang_cplusplus };
>>> || TREE_CODE (T) == TYPENAME_TYPE \
>>> || TREE_CODE (T) == TYPEOF_TYPE \
>>> || TREE_CODE (T) == BOUND_TEMPLATE_TEMPLATE_PARM \
>>> - || TREE_CODE (T) == DECLTYPE_TYPE)
>>> + || TREE_CODE (T) == DECLTYPE_TYPE \
>>> + || TREE_CODE (T) == DEPENDENT_OPERATOR_TYPE)
>>> /* Nonzero if T is a class (or struct or union) type. Also nonzero
>>> for template type parameters, typename types, and instantiated
>>> @@ -3976,9 +3977,13 @@ struct GTY(()) lang_decl {
>>> TREE_LANG_FLAG_0 (FOLD_EXPR_CHECK (NODE))
>>> /* An INTEGER_CST containing the tree code of the folded operator. */
>>> -#define FOLD_EXPR_OP(NODE) \
>>> +#define FOLD_EXPR_OP_RAW(NODE) \
>>> TREE_OPERAND (FOLD_EXPR_CHECK (NODE), 0)
>>> +/* The tree code of the folded operator. */
>>> +#define FOLD_EXPR_OP(NODE) \
>>> + ((enum tree_code) TREE_INT_CST_LOW (FOLD_EXPR_OP_RAW (NODE)))
>>> +
>>> /* The expression containing an unexpanded parameter pack. */
>>> #define FOLD_EXPR_PACK(NODE) \
>>> TREE_OPERAND (FOLD_EXPR_CHECK (NODE), 1)
>>> @@ -4033,6 +4038,20 @@ struct GTY(()) lang_decl {
>>> #define CALL_EXPR_OPERATOR_SYNTAX(NODE) \
>>> TREE_LANG_FLAG_6 (CALL_OR_AGGR_INIT_CHECK (NODE))
>>> +/* A TREE_LIST containing the result of phase 1 name lookup of the
>>> operator
>>> + overloads that are pertinent to the dependent operator expression whose
>>> + type is NODE. Each TREE_PURPOSE is an IDENTIFIER_NODE and TREE_VALUE is
>>> + the corresponding (possibly empty) lookup result. */
>>> +#define DEPENDENT_OPERATOR_TYPE_SAVED_LOOKUPS(NODE) \
>>> + TYPE_VALUES_RAW (DEPENDENT_OPERATOR_TYPE_CHECK (NODE))
>>> +
>>> +/* Helper for the above accessor macro that takes a dependent operator
>>> + expression instead of the type thereof. */
>>> +#define DEPENDENT_OPERATOR_SAVED_LOOKUPS(NODE) \
>>> + (TREE_TYPE (NODE) && TREE_CODE (TREE_TYPE (NODE)) ==
>>> DEPENDENT_OPERATOR_TYPE \
>>> + ? DEPENDENT_OPERATOR_TYPE_SAVED_LOOKUPS (TREE_TYPE (NODE)) \
>>> + : NULL_TREE)
>>
>> Let's make this one an inline function; I'd prefer in general to avoid adding
>> new macros with rvalue results, or that use their argument more than once.
>
> Sounds good. I also renamed it to the more apt TEMPLATED_OPERATOR_SAVED_LOOKUPS
> since we use it on dependent as well as non-dependent operator expressions.
Since it's now a function, it should also be lower case. OK with that
change.
>>
>>> /* Indicates whether a string literal has been parenthesized. Such
>>> usages are disallowed in certain circumstances. */
>>> @@ -6462,14 +6481,15 @@ extern tree build_special_member_call
>>> (tree, tree,
>>> tree, int, tsubst_flags_t);
>>> extern tree build_new_op (const op_location_t &,
>>> enum tree_code,
>>> - int, tree, tree, tree, tree
>>> *,
>>> - tsubst_flags_t);
>>> + int, tree, tree, tree, tree,
>>> + tree *, tsubst_flags_t);
>>> /* Wrapper that leaves out the usually-null op3 and overload parms. */
>>> inline tree build_new_op (const op_location_t &loc, enum tree_code code,
>>> int flags, tree arg1, tree arg2,
>>> tsubst_flags_t complain)
>>> {
>>> - return build_new_op (loc, code, flags, arg1, arg2, NULL_TREE, NULL,
>>> complain);
>>> + return build_new_op (loc, code, flags, arg1, arg2, NULL_TREE, NULL_TREE,
>>> + NULL, complain);
>>> }
>>> extern tree build_op_call (tree, vec<tree, va_gc> **,
>>> tsubst_flags_t);
>>> @@ -7873,8 +7893,9 @@ extern tree build_class_member_access_expr
>>> (cp_expr, tree, tree, bool,
>>> extern tree finish_class_member_access_expr (cp_expr, tree, bool,
>>> tsubst_flags_t);
>>> extern tree lookup_destructor (tree, tree, tree,
>>> tsubst_flags_t);
>>> +extern tree build_dependent_operator_type (tree, enum tree_code, bool);
>>> extern tree build_x_indirect_ref (location_t, tree,
>>> - ref_operator,
>>> + ref_operator, tree,
>>> tsubst_flags_t);
>>> extern tree cp_build_indirect_ref (location_t, tree,
>>> ref_operator,
>>> @@ -7892,20 +7913,20 @@ extern tree cp_build_function_call_vec
>>> (tree, vec<tree, va_gc> **,
>>> extern tree build_x_binary_op (const op_location_t
>>> &,
>>> enum tree_code, tree,
>>> enum tree_code, tree,
>>> - enum tree_code, tree *,
>>> - tsubst_flags_t);
>>> + enum tree_code, tree,
>>> + tree *, tsubst_flags_t);
>>> inline tree build_x_binary_op (const op_location_t &loc,
>>> enum tree_code code, tree arg1, tree arg2,
>>> tsubst_flags_t complain)
>>> {
>>> return build_x_binary_op (loc, code, arg1, TREE_CODE (arg1), arg2,
>>> - TREE_CODE (arg2), NULL, complain);
>>> + TREE_CODE (arg2), NULL_TREE, NULL, complain);
>>> }
>>> extern tree build_x_array_ref (location_t, tree,
>>> tree,
>>> tsubst_flags_t);
>>> extern tree build_x_unary_op (location_t,
>>> enum tree_code, cp_expr,
>>> - tsubst_flags_t);
>>> + tree, tsubst_flags_t);
>>> extern tree cp_build_addressof (location_t, tree,
>>> tsubst_flags_t);
>>> extern tree cp_build_addr_expr (tree,
>>> tsubst_flags_t);
>>> @@ -7920,7 +7941,7 @@ extern tree build_x_compound_expr_from_list (tree,
>>> expr_list_kind,
>>> extern tree build_x_compound_expr_from_vec (vec<tree, va_gc> *,
>>> const char *,
>>> tsubst_flags_t);
>>> extern tree build_x_compound_expr (location_t, tree, tree,
>>> - tsubst_flags_t);
>>> + tree, tsubst_flags_t);
>>> extern tree build_compound_expr (location_t, tree, tree);
>>> extern tree cp_build_compound_expr (tree, tree, tsubst_flags_t);
>>> extern tree build_static_cast (location_t, tree,
>>> tree,
>>> @@ -7936,7 +7957,7 @@ extern tree cp_build_c_cast
>>> (location_t, tree, tree,
>>> tsubst_flags_t);
>>> extern cp_expr build_x_modify_expr (location_t, tree,
>>> enum tree_code, tree,
>>> - tsubst_flags_t);
>>> + tree, tsubst_flags_t);
>>> extern tree cp_build_modify_expr (location_t, tree,
>>> enum tree_code, tree,
>>> tsubst_flags_t);
>>> diff --git a/gcc/cp/cxx-pretty-print.c b/gcc/cp/cxx-pretty-print.c
>>> index 3ea357deb80..6af009c6890 100644
>>> --- a/gcc/cp/cxx-pretty-print.c
>>> +++ b/gcc/cp/cxx-pretty-print.c
>>> @@ -2541,8 +2541,8 @@ pp_cxx_addressof_expression (cxx_pretty_printer *pp,
>>> tree t)
>>> static char const*
>>> get_fold_operator (tree t)
>>> {
>>> - int op = int_cst_value (FOLD_EXPR_OP (t));
>>> - ovl_op_info_t *info = OVL_OP_INFO (FOLD_EXPR_MODIFY_P (t), op);
>>> + ovl_op_info_t *info = OVL_OP_INFO (FOLD_EXPR_MODIFY_P (t),
>>> + FOLD_EXPR_OP (t));
>>> return info->name;
>>> }
>>> diff --git a/gcc/cp/decl.c b/gcc/cp/decl.c
>>> index 56f80775ca0..0b8b33a097c 100644
>>> --- a/gcc/cp/decl.c
>>> +++ b/gcc/cp/decl.c
>>> @@ -17098,8 +17098,6 @@ start_preparsed_function (tree decl1, tree attrs,
>>> int flags)
>>> store_parm_decls (current_function_parms);
>>> - push_operator_bindings ();
>>> -
>>> if (!processing_template_decl
>>> && (flag_lifetime_dse > 1)
>>> && DECL_CONSTRUCTOR_P (decl1)
>>> diff --git a/gcc/cp/decl2.c b/gcc/cp/decl2.c
>>> index 99f5dc784b7..062c175430b 100644
>>> --- a/gcc/cp/decl2.c
>>> +++ b/gcc/cp/decl2.c
>>> @@ -417,7 +417,8 @@ grok_array_decl (location_t loc, tree array_expr, tree
>>> index_exp,
>>> {
>>> if (index_exp)
>>> expr = build_new_op (loc, ARRAY_REF, LOOKUP_NORMAL, array_expr,
>>> - index_exp, NULL_TREE, &overload, complain);
>>> + index_exp, NULL_TREE, NULL_TREE,
>>> + &overload, complain);
>>> else if ((*index_exp_list)->is_empty ())
>>> expr = build_op_subscript (loc, array_expr, index_exp_list, &overload,
>>> complain);
>>> @@ -431,7 +432,7 @@ grok_array_decl (location_t loc, tree array_expr, tree
>>> index_exp,
>>> tf_none);
>>> if (idx != error_mark_node)
>>> expr = build_new_op (loc, ARRAY_REF, LOOKUP_NORMAL,
>>> array_expr,
>>> - idx, NULL_TREE, &overload,
>>> + idx, NULL_TREE, NULL_TREE, &overload,
>>> complain & tf_decltype);
>>> if (expr == error_mark_node)
>>> {
>>> diff --git a/gcc/cp/method.c b/gcc/cp/method.c
>>> index 935946f5eef..44439bae4ec 100644
>>> --- a/gcc/cp/method.c
>>> +++ b/gcc/cp/method.c
>>> @@ -1372,7 +1372,7 @@ do_one_comp (location_t loc, const comp_info &info,
>>> tree sub, tree lhs, tree rhs
>>> to </=, so don't give an error yet if <=> lookup fails. */
>>> bool tentative = retcat != cc_last;
>>> tree comp = build_new_op (loc, code, flags, lhs, rhs,
>>> - NULL_TREE, &overload,
>>> + NULL_TREE, NULL_TREE, &overload,
>>> tentative ? tf_none : complain);
>>> if (code != SPACESHIP_EXPR)
>>> @@ -1684,8 +1684,8 @@ build_comparison_op (tree fndecl, bool defining,
>>> tsubst_flags_t complain)
>>> comp = retval = var;
>>> }
>>> eq = build_new_op (info.loc, EQ_EXPR, flags, comp,
>>> - integer_zero_node, NULL_TREE, NULL,
>>> - complain);
>>> + integer_zero_node, NULL_TREE, NULL_TREE,
>>> + NULL, complain);
>>> }
>>> tree ceq = contextual_conv_bool (eq, complain);
>>> info.check (ceq);
>>> @@ -1720,7 +1720,7 @@ build_comparison_op (tree fndecl, bool defining,
>>> tsubst_flags_t complain)
>>> else if (code == NE_EXPR)
>>> {
>>> tree comp = build_new_op (info.loc, EQ_EXPR, flags, lhs, rhs,
>>> - NULL_TREE, NULL, complain);
>>> + NULL_TREE, NULL_TREE, NULL, complain);
>>> comp = contextual_conv_bool (comp, complain);
>>> info.check (comp);
>>> if (defining)
>>> @@ -1732,9 +1732,9 @@ build_comparison_op (tree fndecl, bool defining,
>>> tsubst_flags_t complain)
>>> else
>>> {
>>> tree comp = build_new_op (info.loc, SPACESHIP_EXPR, flags, lhs, rhs,
>>> - NULL_TREE, NULL, complain);
>>> + NULL_TREE, NULL_TREE, NULL, complain);
>>> tree comp2 = build_new_op (info.loc, code, flags, comp,
>>> integer_zero_node,
>>> - NULL_TREE, NULL, complain);
>>> + NULL_TREE, NULL_TREE, NULL, complain);
>>> info.check (comp2);
>>> if (defining)
>>> finish_return_stmt (comp2);
>>> diff --git a/gcc/cp/module.cc b/gcc/cp/module.cc
>>> index 71d0fab411f..28283264da6 100644
>>> --- a/gcc/cp/module.cc
>>> +++ b/gcc/cp/module.cc
>>> @@ -8789,6 +8789,7 @@ trees_out::type_node (tree type)
>>> case DECLTYPE_TYPE:
>>> case TYPEOF_TYPE:
>>> case UNDERLYING_TYPE:
>>> + case DEPENDENT_OPERATOR_TYPE:
>>> tree_node (TYPE_VALUES_RAW (type));
>>> if (TREE_CODE (type) == DECLTYPE_TYPE)
>>> /* We stash a whole bunch of things into decltype's
>>> @@ -9311,6 +9312,7 @@ trees_in::tree_node (bool is_use)
>>> case DECLTYPE_TYPE:
>>> case TYPEOF_TYPE:
>>> case UNDERLYING_TYPE:
>>> + case DEPENDENT_OPERATOR_TYPE:
>>> {
>>> tree expr = tree_node ();
>>> if (!get_overrun ())
>>> diff --git a/gcc/cp/name-lookup.c b/gcc/cp/name-lookup.c
>>> index 080692899a8..5ae7d870cc0 100644
>>> --- a/gcc/cp/name-lookup.c
>>> +++ b/gcc/cp/name-lookup.c
>>> @@ -7725,20 +7725,14 @@ lookup_name (tree name, LOOK_where where, LOOK_want
>>> want)
>>> if (binding)
>>> {
>>> - /* The saved lookups for an operator record 'nothing
>>> - found' as error_mark_node. We need to stop the search
>>> - here, but not return the error mark node. */
>>> - if (binding == error_mark_node)
>>> - binding = NULL_TREE;
>>> -
>>> val = binding;
>>> - goto found;
>>> + break;
>>> }
>>> }
>>> }
>>> /* Now lookup in namespace scopes. */
>>> - if (bool (where & LOOK_where::NAMESPACE))
>>> + if (!val && bool (where & LOOK_where::NAMESPACE))
>>> {
>>> name_lookup lookup (name, want);
>>> if (lookup.search_unqualified
>>> @@ -7746,8 +7740,6 @@ lookup_name (tree name, LOOK_where where, LOOK_want
>>> want)
>>> val = lookup.value;
>>> }
>>> - found:;
>>> -
>>> /* If we have a known type overload, pull it out. This can happen
>>> for both using decls and unhidden functions. */
>>> if (val && TREE_CODE (val) == OVERLOAD && TREE_TYPE (val) !=
>>> unknown_type_node)
>>> @@ -8949,125 +8941,4 @@ cp_emit_debug_info_for_using (tree t, tree context)
>>> }
>>> }
>>> -/* Return the result of unqualified lookup for the overloaded operator
>>> - designated by CODE, if we are in a template and the binding we find is
>>> - not. */
>>> -
>>> -static tree
>>> -op_unqualified_lookup (tree fnname)
>>> -{
>>> - if (cxx_binding *binding = IDENTIFIER_BINDING (fnname))
>>> - {
>>> - cp_binding_level *l = binding->scope;
>>> - while (l && !l->this_entity)
>>> - l = l->level_chain;
>>> -
>>> - if (l && uses_template_parms (l->this_entity))
>>> - /* Don't preserve decls from an uninstantiated template,
>>> - wait until that template is instantiated. */
>>> - return NULL_TREE;
>>> - }
>>> -
>>> - tree fns = lookup_name (fnname);
>>> - if (!fns)
>>> - /* Remember we found nothing! */
>>> - return error_mark_node;
>>> -
>>> - tree d = fns;
>>> - if (TREE_CODE (d) == TREE_LIST)
>>> - d = TREE_VALUE (d);
>>> - if (is_overloaded_fn (d))
>>> - d = get_first_fn (d);
>>> - if (DECL_CLASS_SCOPE_P (d))
>>> - /* We don't need to remember class-scope functions or declarations,
>>> - normal unqualified lookup will find them again. */
>>> - return NULL_TREE;
>>> -
>>> - return fns;
>>> -}
>>> -
>>> -/* E is an expression representing an operation with dependent type, so we
>>> - don't know yet whether it will use the built-in meaning of the operator
>>> or a
>>> - function. Remember declarations of that operator in scope.
>>> -
>>> - We then inject a fake binding of that lookup into the
>>> - instantiation's parameter scope. This approach fails if the user
>>> - has different using declarations or directives in different local
>>> - binding of the current function from whence we need to do lookups
>>> - (we'll cache what we see on the first lookup). */
>>> -
>>> -static const char *const op_bind_attrname = "operator bindings";
>>> -
>>> -void
>>> -maybe_save_operator_binding (tree e)
>>> -{
>>> - /* This is only useful in a template. */
>>> - if (!processing_template_decl)
>>> - return;
>>> -
>>> - tree cfn = current_function_decl;
>>> - if (!cfn)
>>> - return;
>>> -
>>> - tree fnname;
>>> - if(TREE_CODE (e) == MODOP_EXPR)
>>> - fnname = ovl_op_identifier (true, TREE_CODE (TREE_OPERAND (e, 1)));
>>> - else
>>> - fnname = ovl_op_identifier (false, TREE_CODE (e));
>>> - if (!fnname || fnname == assign_op_identifier)
>>> - return;
>>> -
>>> - tree attributes = DECL_ATTRIBUTES (cfn);
>>> - tree op_attr = lookup_attribute (op_bind_attrname, attributes);
>>> - if (!op_attr)
>>> - {
>>> - tree *ap = &DECL_ATTRIBUTES (cfn);
>>> - while (*ap && ATTR_IS_DEPENDENT (*ap))
>>> - ap = &TREE_CHAIN (*ap);
>>> - op_attr = tree_cons (get_identifier (op_bind_attrname),
>>> - NULL_TREE, *ap);
>>> - *ap = op_attr;
>>> - }
>>> -
>>> - tree op_bind = purpose_member (fnname, TREE_VALUE (op_attr));
>>> - if (!op_bind)
>>> - {
>>> - tree fns = op_unqualified_lookup (fnname);
>>> -
>>> - /* Always record, so we don't keep looking for this
>>> - operator. */
>>> - TREE_VALUE (op_attr) = tree_cons (fnname, fns, TREE_VALUE (op_attr));
>>> - }
>>> -}
>>> -
>>> -/* Called from cp_free_lang_data so we don't put this into LTO. */
>>> -
>>> -void
>>> -discard_operator_bindings (tree decl)
>>> -{
>>> - DECL_ATTRIBUTES (decl) = remove_attribute (op_bind_attrname,
>>> - DECL_ATTRIBUTES (decl));
>>> -}
>>> -
>>> -/* Subroutine of start_preparsed_function: push the bindings we saved away
>>> in
>>> - maybe_save_op_lookup into the function parameter binding level. */
>>> -
>>> -void
>>> -push_operator_bindings ()
>>> -{
>>> - tree decl1 = current_function_decl;
>>> - if (tree attr = lookup_attribute (op_bind_attrname,
>>> - DECL_ATTRIBUTES (decl1)))
>>> - for (tree binds = TREE_VALUE (attr); binds; binds = TREE_CHAIN (binds))
>>> - if (tree val = TREE_VALUE (binds))
>>> - {
>>> - tree name = TREE_PURPOSE (binds);
>>> - if (TREE_CODE (val) == TREE_LIST)
>>> - for (tree v = val; v; v = TREE_CHAIN (v))
>>> - push_local_binding (name, TREE_VALUE (v), /*using*/true);
>>> - else
>>> - push_local_binding (name, val, /*using*/true);
>>> - }
>>> -}
>>> -
>>> #include "gt-cp-name-lookup.h"
>>> diff --git a/gcc/cp/name-lookup.h b/gcc/cp/name-lookup.h
>>> index f63c4f5b8bb..db705d20c68 100644
>>> --- a/gcc/cp/name-lookup.h
>>> +++ b/gcc/cp/name-lookup.h
>>> @@ -465,10 +465,7 @@ extern void push_nested_namespace (tree);
>>> extern void pop_nested_namespace (tree);
>>> extern void push_to_top_level (void);
>>> extern void pop_from_top_level (void);
>>> -extern void maybe_save_operator_binding (tree);
>>> -extern void push_operator_bindings (void);
>>> extern void push_using_decl_bindings (tree, tree);
>>> -extern void discard_operator_bindings (tree);
>>> /* Lower level interface for modules. */
>>> extern tree *mergeable_namespace_slots (tree ns, tree name, bool
>>> is_global,
>>> diff --git a/gcc/cp/parser.c b/gcc/cp/parser.c
>>> index 6f273bfe21f..1baa90ef8fd 100644
>>> --- a/gcc/cp/parser.c
>>> +++ b/gcc/cp/parser.c
>>> @@ -8731,7 +8731,7 @@ cp_parser_unary_expression (cp_parser *parser,
>>> cp_id_kind * pidk,
>>> return build_x_unary_op (token->location,
>>> (keyword == RID_REALPART
>>> ? REALPART_EXPR : IMAGPART_EXPR),
>>> - expression,
>>> + expression, NULL_TREE,
>>> tf_warning_or_error);
>>> }
>>> break;
>>> @@ -8908,7 +8908,7 @@ cp_parser_unary_expression (cp_parser *parser,
>>> cp_id_kind * pidk,
>>> case INDIRECT_REF:
>>> non_constant_p = NIC_STAR;
>>> expression = build_x_indirect_ref (loc, cast_expression,
>>> - RO_UNARY_STAR,
>>> + RO_UNARY_STAR, NULL_TREE,
>>> complain);
>>> /* TODO: build_x_indirect_ref does not always honor the
>>> location, so ensure it is set. */
>>> @@ -8921,7 +8921,7 @@ cp_parser_unary_expression (cp_parser *parser,
>>> cp_id_kind * pidk,
>>> case BIT_NOT_EXPR:
>>> expression = build_x_unary_op (loc, unary_operator,
>>> cast_expression,
>>> - complain);
>>> + NULL_TREE, complain);
>>> /* TODO: build_x_unary_op does not always honor the location,
>>> so ensure it is set. */
>>> expression.set_location (loc);
>>> @@ -10149,7 +10149,7 @@ cp_parser_binary_expression (cp_parser* parser, bool
>>> cast_p,
>>> op_location_t op_loc (current.loc, combined_loc);
>>> current.lhs = build_x_binary_op (op_loc, current.tree_type,
>>> current.lhs, current.lhs_type,
>>> - rhs, rhs_type, &overload,
>>> + rhs, rhs_type, NULL_TREE,
>>> &overload,
>>> complain_flags (decltype_p));
>>> /* TODO: build_x_binary_op doesn't always honor the location.
>>> */
>>> current.lhs.set_location (combined_loc);
>>> @@ -10328,7 +10328,7 @@ cp_parser_assignment_expression (cp_parser* parser,
>>> cp_id_kind * pidk,
>>> rhs.get_finish ());
>>> expr = build_x_modify_expr (loc, expr,
>>> assignment_operator,
>>> - rhs,
>>> + rhs, NULL_TREE,
>>> complain_flags (decltype_p));
>>> /* TODO: build_x_modify_expr doesn't honor the location,
>>> so we must set it here. */
>>> @@ -10480,7 +10480,7 @@ cp_parser_expression (cp_parser* parser, cp_id_kind
>>> * pidk,
>>> expression.get_start (),
>>> assignment_expression.get_finish ());
>>> expression = build_x_compound_expr (loc, expression,
>>> - assignment_expression,
>>> + assignment_expression,
>>> NULL_TREE,
>>> complain_flags (decltype_p));
>>> expression.set_location (loc);
>>> }
>>> @@ -13617,7 +13617,7 @@ do_range_for_auto_deduction (tree decl, tree
>>> range_expr)
>>> iter_decl = build_decl (input_location, VAR_DECL, NULL_TREE,
>>> iter_type);
>>> iter_decl = build_x_indirect_ref (input_location, iter_decl,
>>> - RO_UNARY_STAR,
>>> + RO_UNARY_STAR, NULL_TREE,
>>> tf_warning_or_error);
>>> TREE_TYPE (decl) = do_auto_deduction (TREE_TYPE (decl),
>>> iter_decl, auto_node,
>>> @@ -13804,7 +13804,7 @@ cp_convert_range_for (tree statement, tree
>>> range_decl, tree range_expr,
>>> condition = build_x_binary_op (input_location, NE_EXPR,
>>> begin, ERROR_MARK,
>>> end, ERROR_MARK,
>>> - NULL, tf_warning_or_error);
>>> + NULL_TREE, NULL, tf_warning_or_error);
>>> finish_for_cond (condition, statement, ivdep, unroll);
>>> /* The new increment expression. */
>>> @@ -13818,7 +13818,7 @@ cp_convert_range_for (tree statement, tree
>>> range_decl, tree range_expr,
>>> /* The declaration is initialized with *__begin inside the loop body.
>>> */
>>> tree deref_begin = build_x_indirect_ref (input_location, begin,
>>> RO_UNARY_STAR,
>>> - tf_warning_or_error);
>>> + NULL_TREE, tf_warning_or_error);
>>> cp_finish_decl (range_decl, deref_begin,
>>> /*is_constant_init*/false, NULL_TREE,
>>> LOOKUP_ONLYCONVERTING);
>>> @@ -13924,7 +13924,7 @@ cp_parser_perform_range_for_lookup (tree range, tree
>>> *begin, tree *end)
>>> && (build_x_binary_op (input_location, NE_EXPR,
>>> *begin, ERROR_MARK,
>>> *end, ERROR_MARK,
>>> - NULL, tf_none)
>>> + NULL_TREE, NULL, tf_none)
>>> != error_mark_node))
>>> /* P0184R0 allows __begin and __end to have different types,
>>> but make sure they are comparable so we can give a better
>>> @@ -18914,7 +18914,7 @@ cp_parser_template_argument (cp_parser* parser)
>>> {
>>> if (address_p)
>>> argument = build_x_unary_op (loc, ADDR_EXPR, argument,
>>> - tf_warning_or_error);
>>> + NULL_TREE, tf_warning_or_error);
>>> else
>>> argument = convert_from_reference (argument);
>>> return argument;
>>> @@ -41551,7 +41551,7 @@ cp_parser_omp_for_cond (cp_parser *parser, tree
>>> decl, enum tree_code code)
>>> TREE_CODE (cond),
>>> TREE_OPERAND (cond, 0), ERROR_MARK,
>>> TREE_OPERAND (cond, 1), ERROR_MARK,
>>> - /*overload=*/NULL, tf_warning_or_error);
>>> + NULL_TREE, /*overload=*/NULL,
>>> tf_warning_or_error);
>>> }
>>> /* Helper function, to parse omp for increment expression. */
>>> @@ -41628,11 +41628,13 @@ cp_parser_omp_for_incr (cp_parser *parser, tree
>>> decl)
>>> lhs = rhs;
>>> else
>>> lhs = build_x_unary_op (input_location, NEGATE_EXPR, rhs,
>>> - tf_warning_or_error);
>>> + NULL_TREE, tf_warning_or_error);
>>> }
>>> else
>>> - lhs = build_x_binary_op (input_location, op, lhs, ERROR_MARK, rhs,
>>> - ERROR_MARK, NULL, tf_warning_or_error);
>>> + lhs = build_x_binary_op (input_location, op,
>>> + lhs, ERROR_MARK,
>>> + rhs, ERROR_MARK,
>>> + NULL_TREE, NULL, tf_warning_or_error);
>>> }
>>> }
>>> while (token->type == CPP_PLUS || token->type == CPP_MINUS);
>>> @@ -41860,7 +41862,7 @@ cp_parser_omp_for_loop_init (cp_parser *parser,
>>> orig_init = rhs;
>>> finish_expr_stmt (build_x_modify_expr (EXPR_LOCATION (rhs),
>>> decl, NOP_EXPR,
>>> - rhs,
>>> + rhs, NULL_TREE,
>>> tf_warning_or_error));
>>> if (!add_private_clause)
>>> add_private_clause = decl;
>>> @@ -41982,7 +41984,7 @@ cp_convert_omp_range_for (tree &this_pre_body,
>>> vec<tree, va_gc> *for_block,
>>> cond = build_x_binary_op (input_location, NE_EXPR,
>>> begin, ERROR_MARK,
>>> end, ERROR_MARK,
>>> - NULL, tf_warning_or_error);
>>> + NULL_TREE, NULL, tf_warning_or_error);
>>> /* The new increment expression. */
>>> if (CLASS_TYPE_P (iter_type))
>>> @@ -42020,7 +42022,7 @@ cp_convert_omp_range_for (tree &this_pre_body,
>>> vec<tree, va_gc> *for_block,
>>> if (auto_node)
>>> {
>>> tree t = build_x_indirect_ref (input_location, begin, RO_UNARY_STAR,
>>> - tf_none);
>>> + NULL_TREE, tf_none);
>>> if (!error_operand_p (t))
>>> TREE_TYPE (orig_decl) = do_auto_deduction (TREE_TYPE (orig_decl),
>>> t, auto_node);
>>> @@ -42060,7 +42062,7 @@ cp_finish_omp_range_for (tree orig, tree begin)
>>> /* The declaration is initialized with *__begin inside the loop body.
>>> */
>>> cp_finish_decl (decl,
>>> build_x_indirect_ref (input_location, begin, RO_UNARY_STAR,
>>> - tf_warning_or_error),
>>> + NULL_TREE, tf_warning_or_error),
>>> /*is_constant_init*/false, NULL_TREE,
>>> LOOKUP_ONLYCONVERTING);
>>> if (VAR_P (decl) && DECL_DECOMPOSITION_P (decl))
>>> diff --git a/gcc/cp/pt.c b/gcc/cp/pt.c
>>> index cbdb4b566aa..2340139b238 100644
>>> --- a/gcc/cp/pt.c
>>> +++ b/gcc/cp/pt.c
>>> @@ -12657,23 +12657,26 @@ expand_empty_fold (tree t, tsubst_flags_t
>>> complain)
>>> static tree
>>> fold_expression (tree t, tree left, tree right, tsubst_flags_t complain)
>>> {
>>> - tree op = FOLD_EXPR_OP (t);
>>> - tree_code code = (tree_code)TREE_INT_CST_LOW (op);
>>> + tree_code code = FOLD_EXPR_OP (t);
>>> +
>>> + tree lookups = DEPENDENT_OPERATOR_SAVED_LOOKUPS (t);
>>> // Handle compound assignment operators.
>>> if (FOLD_EXPR_MODIFY_P (t))
>>> - return build_x_modify_expr (input_location, left, code, right,
>>> complain);
>>> + return build_x_modify_expr (input_location, left, code, right,
>>> + lookups, complain);
>>> warning_sentinel s(warn_parentheses);
>>> switch (code)
>>> {
>>> case COMPOUND_EXPR:
>>> - return build_x_compound_expr (input_location, left, right, complain);
>>> + return build_x_compound_expr (input_location, left, right,
>>> + lookups, complain);
>>> default:
>>> return build_x_binary_op (input_location, code,
>>> left, TREE_CODE (left),
>>> right, TREE_CODE (right),
>>> - /*overload=*/NULL,
>>> + lookups, /*overload=*/NULL,
>>> complain);
>>> }
>>> }
>>> @@ -17908,7 +17911,7 @@ tsubst_omp_for_iterator (tree t, int i, tree declv,
>>> tree &orig_declv,
>>> tree lhs = RECUR (TREE_OPERAND (incr, 0));
>>> tree rhs = RECUR (TREE_OPERAND (incr, 1));
>>> incr = build_x_modify_expr (EXPR_LOCATION (incr), lhs,
>>> - NOP_EXPR, rhs, complain);
>>> + NOP_EXPR, rhs, NULL_TREE, complain);
>>> }
>>> else
>>> incr = RECUR (incr);
>>> @@ -19221,6 +19224,7 @@ tsubst_expr (tree t, tree args, tsubst_flags_t
>>> complain, tree in_decl,
>>> RETURN (RECUR (TREE_OPERAND (t, 1)));
>>> RETURN (build_x_compound_expr (EXPR_LOCATION (t), tmp,
>>> RECUR (TREE_OPERAND (t, 1)),
>>> + DEPENDENT_OPERATOR_SAVED_LOOKUPS (t),
>>> complain));
>>> case ANNOTATE_EXPR:
>>> @@ -19872,6 +19876,7 @@ tsubst_copy_and_build (tree t,
>>> }
>>> else
>>> r = build_x_indirect_ref (input_location, r, RO_UNARY_STAR,
>>> + DEPENDENT_OPERATOR_SAVED_LOOKUPS (t),
>>> complain|decltype_flag);
>>> if (REF_PARENTHESIZED_P (t))
>>> @@ -19982,6 +19987,7 @@ tsubst_copy_and_build (tree t,
>>> op1 = tsubst_non_call_postfix_expression (TREE_OPERAND (t, 0),
>>> args, complain, in_decl);
>>> RETURN (build_x_unary_op (input_location, TREE_CODE (t), op1,
>>> + DEPENDENT_OPERATOR_SAVED_LOOKUPS (t),
>>> complain|decltype_flag));
>>> case PREDECREMENT_EXPR:
>>> @@ -19995,6 +20001,7 @@ tsubst_copy_and_build (tree t,
>>> case IMAGPART_EXPR:
>>> RETURN (build_x_unary_op (input_location, TREE_CODE (t),
>>> RECUR (TREE_OPERAND (t, 0)),
>>> + DEPENDENT_OPERATOR_SAVED_LOOKUPS (t),
>>> complain|decltype_flag));
>>> case FIX_TRUNC_EXPR:
>>> @@ -20013,6 +20020,7 @@ tsubst_copy_and_build (tree t,
>>> op1 = tsubst_non_call_postfix_expression (op1, args, complain,
>>> in_decl);
>>> RETURN (build_x_unary_op (input_location, ADDR_EXPR, op1,
>>> + DEPENDENT_OPERATOR_SAVED_LOOKUPS (t),
>>> complain|decltype_flag));
>>> case PLUS_EXPR:
>>> @@ -20077,6 +20085,7 @@ tsubst_copy_and_build (tree t,
>>> (warning_suppressed_p (TREE_OPERAND (t, 1))
>>> ? ERROR_MARK
>>> : TREE_CODE (TREE_OPERAND (t, 1))),
>>> + DEPENDENT_OPERATOR_SAVED_LOOKUPS (t),
>>> /*overload=*/NULL,
>>> complain|decltype_flag);
>>> if (EXPR_P (r))
>>> @@ -20229,8 +20238,10 @@ tsubst_copy_and_build (tree t,
>>> warning_sentinel s(warn_div_by_zero);
>>> tree lhs = RECUR (TREE_OPERAND (t, 0));
>>> tree rhs = RECUR (TREE_OPERAND (t, 2));
>>> +
>>> tree r = build_x_modify_expr
>>> (EXPR_LOCATION (t), lhs, TREE_CODE (TREE_OPERAND (t, 1)), rhs,
>>> + DEPENDENT_OPERATOR_SAVED_LOOKUPS (t),
>>> complain|decltype_flag);
>>> /* TREE_NO_WARNING must be set if either the expression was
>>> parenthesized or it uses an operator such as >>= rather
>>> @@ -20331,6 +20342,7 @@ tsubst_copy_and_build (tree t,
>>> RETURN (build_x_compound_expr (EXPR_LOCATION (t),
>>> op0,
>>> RECUR (TREE_OPERAND (t, 1)),
>>> + DEPENDENT_OPERATOR_SAVED_LOOKUPS (t),
>>> complain|decltype_flag));
>>> }
>>> @@ -27011,6 +27023,9 @@ dependent_type_p_r (tree type)
>>> if (TREE_CODE (type) == TYPE_PACK_EXPANSION)
>>> return true;
>>> + if (TREE_CODE (type) == DEPENDENT_OPERATOR_TYPE)
>>> + return true;
>>> +
>>> if (any_dependent_type_attributes_p (TYPE_ATTRIBUTES (type)))
>>> return true;
>>> diff --git a/gcc/cp/ptree.c b/gcc/cp/ptree.c
>>> index d514aa2cad2..f7ddae77679 100644
>>> --- a/gcc/cp/ptree.c
>>> +++ b/gcc/cp/ptree.c
>>> @@ -151,6 +151,12 @@ cxx_print_type (FILE *file, tree node, int indent)
>>> print_node (file, "expr", DECLTYPE_TYPE_EXPR (node), indent + 4);
>>> return;
>>> + case DEPENDENT_OPERATOR_TYPE:
>>> + print_node (file, "saved_lookups",
>>> + DEPENDENT_OPERATOR_TYPE_SAVED_LOOKUPS (node),
>>> + indent + 4);
>>> + return;
>>> +
>>> case TYPENAME_TYPE:
>>> print_node (file, "fullname", TYPENAME_TYPE_FULLNAME (node),
>>> indent + 4);
>>> diff --git a/gcc/cp/semantics.c b/gcc/cp/semantics.c
>>> index cdf63c15e21..7078af03d3c 100644
>>> --- a/gcc/cp/semantics.c
>>> +++ b/gcc/cp/semantics.c
>>> @@ -2920,7 +2920,7 @@ finish_increment_expr (cp_expr expr, enum tree_code
>>> code)
>>> expr.get_start (),
>>> get_finish (input_location));
>>> cp_expr result = build_x_unary_op (combined_loc, code, expr,
>>> - tf_warning_or_error);
>>> + NULL_TREE, tf_warning_or_error);
>>> /* TODO: build_x_unary_op doesn't honor the location, so set it here.
>>> */
>>> result.set_location (combined_loc);
>>> return result;
>>> @@ -3031,7 +3031,8 @@ finish_unary_op_expr (location_t op_loc, enum
>>> tree_code code, cp_expr expr,
>>> of the operator token to the end of EXPR. */
>>> location_t combined_loc = make_location (op_loc,
>>> op_loc, expr.get_finish ());
>>> - cp_expr result = build_x_unary_op (combined_loc, code, expr, complain);
>>> + cp_expr result = build_x_unary_op (combined_loc, code, expr,
>>> + NULL_TREE, complain);
>>> /* TODO: build_x_unary_op doesn't always honor the location. */
>>> result.set_location (combined_loc);
>>> @@ -9881,7 +9882,7 @@ handle_omp_for_class_iterator (int i, location_t
>>> locus, enum tree_code code,
>>> TREE_CODE (cond),
>>> iter, ERROR_MARK,
>>> TREE_OPERAND (cond, 1), ERROR_MARK,
>>> - NULL, tf_warning_or_error);
>>> + NULL_TREE, NULL, tf_warning_or_error);
>>> if (error_operand_p (tem))
>>> return true;
>>> }
>>> @@ -9895,9 +9896,10 @@ handle_omp_for_class_iterator (int i, location_t
>>> locus, enum tree_code code,
>>> error_at (elocus, "invalid controlling predicate");
>>> return true;
>>> }
>>> - diff = build_x_binary_op (elocus, MINUS_EXPR, TREE_OPERAND (cond, 1),
>>> - ERROR_MARK, iter, ERROR_MARK, NULL,
>>> - tf_warning_or_error);
>>> + diff = build_x_binary_op (elocus, MINUS_EXPR,
>>> + TREE_OPERAND (cond, 1), ERROR_MARK,
>>> + iter, ERROR_MARK,
>>> + NULL_TREE, NULL, tf_warning_or_error);
>>> diff = cp_fully_fold (diff);
>>> if (error_operand_p (diff))
>>> return true;
>>> @@ -9925,7 +9927,7 @@ handle_omp_for_class_iterator (int i, location_t
>>> locus, enum tree_code code,
>>> }
>>> iter_incr = build_x_unary_op (EXPR_LOCATION (incr),
>>> TREE_CODE (incr), iter,
>>> - tf_warning_or_error);
>>> + NULL_TREE, tf_warning_or_error);
>>> if (error_operand_p (iter_incr))
>>> return true;
>>> else if (TREE_CODE (incr) == PREINCREMENT_EXPR
>>> @@ -9951,6 +9953,7 @@ handle_omp_for_class_iterator (int i, location_t
>>> locus, enum tree_code code,
>>> iter_incr = build_x_modify_expr (EXPR_LOCATION (rhs),
>>> iter, TREE_CODE (rhs),
>>> TREE_OPERAND (rhs, 1),
>>> + NULL_TREE,
>>> tf_warning_or_error);
>>> if (error_operand_p (iter_incr))
>>> return true;
>>> @@ -9980,13 +9983,13 @@ handle_omp_for_class_iterator (int i, location_t
>>> locus, enum tree_code code,
>>> PLUS_EXPR,
>>> TREE_OPERAND (rhs, 0),
>>> ERROR_MARK, iter,
>>> - ERROR_MARK, NULL,
>>> + ERROR_MARK, NULL_TREE, NULL,
>>> tf_warning_or_error);
>>> if (error_operand_p (iter_incr))
>>> return true;
>>> iter_incr = build_x_modify_expr (EXPR_LOCATION (rhs),
>>> iter, NOP_EXPR,
>>> - iter_incr,
>>> + iter_incr, NULL_TREE,
>>> tf_warning_or_error);
>>> if (error_operand_p (iter_incr))
>>> return true;
>>> @@ -10097,7 +10100,7 @@ handle_omp_for_class_iterator (int i, location_t
>>> locus, enum tree_code code,
>>> if (init != NULL)
>>> finish_expr_stmt (build_x_modify_expr (elocus,
>>> iter, NOP_EXPR, init,
>>> - tf_warning_or_error));
>>> + NULL_TREE, tf_warning_or_error));
>>> init = build_int_cst (TREE_TYPE (diff), 0);
>>> if (c && iter_incr == NULL
>>> && (!ordered || (i < collapse && collapse > 1)))
>>> @@ -10106,23 +10109,24 @@ handle_omp_for_class_iterator (int i, location_t
>>> locus, enum tree_code code,
>>> {
>>> finish_expr_stmt (build_x_modify_expr (elocus,
>>> incr_var, NOP_EXPR,
>>> - incr, tf_warning_or_error));
>>> + incr, NULL_TREE,
>>> + tf_warning_or_error));
>>> incr = incr_var;
>>> }
>>> iter_incr = build_x_modify_expr (elocus,
>>> iter, PLUS_EXPR, incr,
>>> - tf_warning_or_error);
>>> + NULL_TREE, tf_warning_or_error);
>>> }
>>> if (c && ordered && i < collapse && collapse > 1)
>>> iter_incr = incr;
>>> finish_expr_stmt (build_x_modify_expr (elocus,
>>> last, NOP_EXPR, init,
>>> - tf_warning_or_error));
>>> + NULL_TREE, tf_warning_or_error));
>>> if (diffvar)
>>> {
>>> finish_expr_stmt (build_x_modify_expr (elocus,
>>> diffvar, NOP_EXPR,
>>> - diff, tf_warning_or_error));
>>> + diff, NULL_TREE,
>>> tf_warning_or_error));
>>> diff = diffvar;
>>> }
>>> *pre_body = pop_stmt_list (*pre_body);
>>> @@ -10138,13 +10142,13 @@ handle_omp_for_class_iterator (int i, location_t
>>> locus, enum tree_code code,
>>> iter_init = build2 (MINUS_EXPR, TREE_TYPE (diff), decl, last);
>>> iter_init = build_x_modify_expr (elocus,
>>> iter, PLUS_EXPR, iter_init,
>>> - tf_warning_or_error);
>>> + NULL_TREE, tf_warning_or_error);
>>> if (iter_init != error_mark_node)
>>> iter_init = build1 (NOP_EXPR, void_type_node, iter_init);
>>> finish_expr_stmt (iter_init);
>>> finish_expr_stmt (build_x_modify_expr (elocus,
>>> last, NOP_EXPR, decl,
>>> - tf_warning_or_error));
>>> + NULL_TREE, tf_warning_or_error));
>>> add_stmt (orig_body);
>>> *body = pop_stmt_list (*body);
>>> @@ -10162,7 +10166,7 @@ handle_omp_for_class_iterator (int i, location_t
>>> locus, enum tree_code code,
>>> iter_init = build2 (MINUS_EXPR, TREE_TYPE (diff), iter_init, last);
>>> iter_init = build_x_modify_expr (elocus,
>>> iter, PLUS_EXPR, iter_init,
>>> - tf_warning_or_error);
>>> + NULL_TREE, tf_warning_or_error);
>>> if (iter_init != error_mark_node)
>>> iter_init = build1 (NOP_EXPR, void_type_node, iter_init);
>>> finish_expr_stmt (iter_init);
>>> @@ -10873,7 +10877,7 @@ finish_omp_cancel (tree clauses)
>>> ifc = build_x_binary_op (OMP_CLAUSE_LOCATION (ifc), NE_EXPR,
>>> OMP_CLAUSE_IF_EXPR (ifc), ERROR_MARK,
>>> integer_zero_node, ERROR_MARK,
>>> - NULL, tf_warning_or_error);
>>> + NULL_TREE, NULL, tf_warning_or_error);
>>> }
>>> else
>>> ifc = boolean_true_node;
>>> @@ -12125,6 +12129,9 @@ finish_unary_fold_expr (tree expr, int op, tree_code
>>> dir)
>>> tree code = build_int_cstu (integer_type_node, abs (op));
>>> tree fold = build_min_nt_loc (UNKNOWN_LOCATION, dir, code, pack);
>>> FOLD_EXPR_MODIFY_P (fold) = (op < 0);
>>> + TREE_TYPE (fold) = build_dependent_operator_type (NULL_TREE,
>>> + FOLD_EXPR_OP (fold),
>>> + FOLD_EXPR_MODIFY_P
>>> (fold));
>>> return fold;
>>> }
>>> @@ -12151,6 +12158,9 @@ finish_binary_fold_expr (tree pack, tree init, int
>>> op, tree_code dir)
>>> tree code = build_int_cstu (integer_type_node, abs (op));
>>> tree fold = build_min_nt_loc (UNKNOWN_LOCATION, dir, code, pack, init);
>>> FOLD_EXPR_MODIFY_P (fold) = (op < 0);
>>> + TREE_TYPE (fold) = build_dependent_operator_type (NULL_TREE,
>>> + FOLD_EXPR_OP (fold),
>>> + FOLD_EXPR_MODIFY_P
>>> (fold));
>>> return fold;
>>> }
>>> diff --git a/gcc/cp/tree.c b/gcc/cp/tree.c
>>> index f6f7927f293..f319dbf3526 100644
>>> --- a/gcc/cp/tree.c
>>> +++ b/gcc/cp/tree.c
>>> @@ -5974,8 +5974,6 @@ cp_free_lang_data (tree t)
>>> DECL_EXTERNAL (t) = 1;
>>> TREE_STATIC (t) = 0;
>>> }
>>> - if (TREE_CODE (t) == FUNCTION_DECL)
>>> - discard_operator_bindings (t);
>>> if (TREE_CODE (t) == NAMESPACE_DECL)
>>> /* We do not need the leftover chaining of namespaces from the
>>> binding level. */
>>> diff --git a/gcc/cp/typeck.c b/gcc/cp/typeck.c
>>> index 4e60db40c76..88dca343315 100644
>>> --- a/gcc/cp/typeck.c
>>> +++ b/gcc/cp/typeck.c
>>> @@ -2602,6 +2602,7 @@ rationalize_conditional_expr (enum tree_code code,
>>> tree t,
>>> ? LE_EXPR : GE_EXPR),
>>> op0, TREE_CODE (op0),
>>> op1, TREE_CODE (op1),
>>> + NULL_TREE,
>>> /*overload=*/NULL,
>>> complain),
>>> cp_build_unary_op (code, op0, false,
>>> complain),
>>> @@ -3487,6 +3488,64 @@ build_ptrmemfunc_access_expr (tree ptrmem, tree
>>> member_name)
>>> return build_simple_component_ref (ptrmem, member);
>>> }
>>> +/* Return a TREE_LIST of namespace-scope overloads for the given
>>> operator,
>>> + and for any other relevant operator. */
>>> +
>>> +static tree
>>> +op_unqualified_lookup (tree_code code, bool is_assign)
>>> +{
>>> + tree lookups = NULL_TREE;
>>> +
>>> + if (cxx_dialect >= cxx20 && !is_assign)
>>> + {
>>> + if (code == NE_EXPR)
>>> + {
>>> + /* != can get rewritten in terms of ==. */
>>> + tree fnname = ovl_op_identifier (false, EQ_EXPR);
>>> + if (tree fns = lookup_name (fnname, LOOK_where::BLOCK_NAMESPACE))
>>> + lookups = tree_cons (fnname, fns, lookups);
>>> + }
>>> + else if (code == GT_EXPR || code == LE_EXPR
>>> + || code == LT_EXPR || code == GE_EXPR)
>>> + {
>>> + /* These can get rewritten in terms of <=>. */
>>> + tree fnname = ovl_op_identifier (false, SPACESHIP_EXPR);
>>> + if (tree fns = lookup_name (fnname, LOOK_where::BLOCK_NAMESPACE))
>>> + lookups = tree_cons (fnname, fns, lookups);
>>> + }
>>> + }
>>> +
>>> + tree fnname = ovl_op_identifier (is_assign, code);
>>> + if (tree fns = lookup_name (fnname, LOOK_where::BLOCK_NAMESPACE))
>>> + lookups = tree_cons (fnname, fns, lookups);
>>> +
>>> + if (lookups)
>>> + return lookups;
>>> + else
>>> + return build_tree_list (NULL_TREE, NULL_TREE);
>>> +}
>>> +
>>> +/* Create a DEPENDENT_OPERATOR_TYPE for a dependent operator expression of
>>> + the given operator. LOOKUPS, if non-NULL, is the result of phase 1
>>> + name lookup for the given operator. */
>>> +
>>> +tree
>>> +build_dependent_operator_type (tree lookups, tree_code code, bool
>>> is_assign)
>>> +{
>>> + if (lookups)
>>> + /* We're partially instantiating a dependent operator expression, and
>>> + LOOKUPS contains the result of phase 1 name lookup that we performed
>>> + earlier at template definition time, so just carry it over. */;
>>
>> If we're going to keep using the same set of lookups, can we also reuse the
>> same DEPENDENT_OPERATOR_TYPE? It seems like you could pass the type to
>> build_x_* instead of pulling the lookups out as early.
>
> That sounds like it'd work well. But what if we instead just make
> DEPENDENT_OPERATOR_TYPE_SAVED_LOOKUPS point back to the corresponding
> DEPENDENT_OPERATOR_TYPE via TREE_TYPE? As in the below...
>
> v2: Rename DEPENDENT_OPERATOR_SAVED_LOOKUPS to
> TEMPLATED_OPERATOR_SAVED_LOOKUPS and turn into an inline function.
>
> Make build_dependent_operator_type set/inspect the TREE_TYPE of the
> lookup result in order to reuse the DEPENDENT_OPERATOR_TYPE during
> partial instantiations. Document this in the comment for
> DEPENDENT_OPERATOR_TYPE_SAVED_LOOKUPS.
>
> Bootstrap and regtest in progress.
>
> -- >8 --
>
> PR c++/51577
> PR c++/83035
> PR c++/100465
>
> gcc/cp/ChangeLog:
>
> * call.c (add_operator_candidates): Add lookups parameter.
> Use it to avoid performing a second unqualified lookup when
> instantiating a dependent operator expression.
> (build_new_op): Add lookups parameter and pass it appropriately.
> * constraint.cc (finish_constraint_binary_op): Use
> build_min_nt_loc instead of build_x_binary_op.
> * coroutines.cc (build_co_await): Adjust call to build_new_op.
> * cp-objcp-common.c (cp_common_init_ts): Mark
> DEPENDENT_OPERATOR_TYPE appropriately.
> * cp-tree.def (DEPENDENT_OPERATOR_TYPE): Define.
> * cp-tree.h (WILDCARD_TYPE_P): Accept DEPENDENT_OPERATOR_TYPE.
> (FOLD_EXPR_OP_RAW): New, renamed from ...
> (FOLD_EXPR_OP): ... this. Change this to return the tree_code directly.
> (DEPENDENT_OPERATOR_TYPE_SAVED_LOOKUPS): Define.
> (TEMPLATED_OPERATOR_SAVED_LOOKUPS): Define.
> (build_new_op): Add lookups parameter.
> (build_dependent_operator_type): Declare.
> (build_x_indirect_ref): Add lookups parameter.
> (build_x_binary_op): Likewise.
> (build_x_unary_op): Likewise.
> (build_x_compound_expr): Likewise.
> (build_x_modify_expr): Likewise.
> * cxx-pretty-print.c (get_fold_operator): Adjust after
> FOLD_EXPR_OP change.
> * decl.c (start_preparsed_function): Don't call
> push_operator_bindings.
> * decl2.c (grok_array_decl): Adjust calls to build_new_op.
> * method.c (do_one_comp): Likewise.
> (build_comparison_op): Likewise.
> * module.cc (trees_out::type_node): Handle DEPENDENT_OPERATOR_TYPE.
> (trees_in::tree_node): Likewise.
> * name-lookup.c (lookup_name): Revert r11-2876 change.
> (op_unqualified_lookup): Remove.
> (maybe_save_operator_binding): Remove.
> (discard_operator_bindings): Remove.
> (push_operator_bindings): Remove.
> * name-lookup.h (maybe_save_operator_binding): Remove.
> (push_operator_bindings): Remove.
> (discard_operator_bindings): Remove.
> * parser.c (cp_parser_unary_expression): Adjust calls to build_x_*.
> (cp_parser_binary_expression): Likewise.
> (cp_parser_assignment_expression): Likewise.
> (cp_parser_expression): Likewise.
> (do_range_for_auto_deduction): Likewise.
> (cp_convert_range_for): Likewise.
> (cp_parser_perform_range_for_lookup): Likewise.
> (cp_parser_template_argument): Likewise.
> (cp_parser_omp_for_cond): Likewise.
> (cp_parser_omp_for_incr): Likewise.
> (cp_parser_omp_for_loop_init): Likewise.
> (cp_convert_omp_range_for): Likewise.
> (cp_finish_omp_range_for): Likewise.
> * pt.c (fold_expression): Adjust after FOLD_EXPR_OP change. Pass
> TEMPLATED_OPERATOR_SAVED_LOOKUPS to build_x_*.
> (tsubst_omp_for_iterator): Adjust call to build_x_modify_expr.
> (tsubst_expr) <case COMPOUND_EXPR>: Pass
> TEMPLATED_OPERATOR_SAVED_LOOKUPS to build_x_*.
> (tsubst_copy_and_build) <case INDIRECT_REF>: Likewise.
> <case tcc_unary>: Likewise.
> <case tcc_binary>: Likewise.
> <case MODOP_EXPR>: Likewise.
> <case COMPOUND_EXPR>: Likewise.
> (dependent_type_p_r): Return true for DEPENDENT_OPERATOR_TYPE.
> * ptree.c (cxx_print_type): Handle DEPENDENT_OPERATOR_TYPE.
> * semantics.c (finish_increment_expr): Adjust call to
> build_x_unary_op.
> (finish_unary_op_expr): Likewise.
> (handle_omp_for_class_iterator): Adjust calls to build_x_*.
> (finish_omp_cancel): Likewise.
> (finish_unary_fold_expr): Use build_dependent_operator_type.
> (finish_binary_fold_expr): Likewise.
> * tree.c (cp_free_lang_data): Don't call discard_operator_bindings.
> * typeck.c (rationalize_conditional_expr): Adjust call to
> build_x_binary_op.
> (op_unqualified_lookup): Define.
> (build_dependent_operator_type): Define.
> (build_x_indirect_ref): Add lookups parmaeter and use
> build_dependent_operator_type.
> (build_x_binary_op): Likewise.
> (build_x_array_ref): Likewise.
> (build_x_unary_op): Likewise.
> (build_x_compound_expr_from_list): Adjust call to
> build_x_compound_expr.
> (build_x_compound_expr_from_vec): Likewise.
> (build_x_compound_expr): Add lookups parameter and use
> build_dependent_operator_type.
> (cp_build_modify_expr): Adjust call to build_new_op.
> (build_x_modify_expr): Add lookups parameter and use
> build_dependent_operator_type.
> * typeck2.c (build_x_arrow): Adjust call to build_new_op.
>
> libcc1/ChangeLog:
>
> * libcp1plugin.cc (plugin_build_unary_expr): Adjust call to
> build_x_unary_op.
> (plugin_build_binary_expr): Adjust call to build_x_binary_op.
>
> gcc/testsuite/ChangeLog:
>
> * g++.dg/lookup/operator-3.C: Split out operator overload
> declarations into ...
> * g++.dg/lookup/operator-3-ops.h: ... here.
> * g++.dg/lookup/operator-3a.C: New test.
> * g++.dg/lookup/operator-4.C: New test.
> * g++.dg/lookup/operator-4a.C: New test.
> * g++.dg/lookup/operator-5.C: New test.
> * g++.dg/lookup/operator-5a.C: New test.
> * g++.dg/lookup/operator-6.C: New test.
> * g++.dg/lookup/operator-7.C: New test.
> * g++.dg/lookup/operator-8.C: New test.
> ---
> gcc/cp/call.c | 33 +++--
> gcc/cp/constraint.cc | 11 +-
> gcc/cp/coroutines.cc | 2 +-
> gcc/cp/cp-objcp-common.c | 1 +
> gcc/cp/cp-tree.def | 5 +
> gcc/cp/cp-tree.h | 49 +++++--
> gcc/cp/cxx-pretty-print.c | 4 +-
> gcc/cp/decl.c | 2 -
> gcc/cp/decl2.c | 5 +-
> gcc/cp/method.c | 12 +-
> gcc/cp/module.cc | 2 +
> gcc/cp/name-lookup.c | 133 +------------------
> gcc/cp/name-lookup.h | 3 -
> gcc/cp/parser.c | 40 +++---
> gcc/cp/pt.c | 27 +++-
> gcc/cp/ptree.c | 6 +
> gcc/cp/semantics.c | 46 ++++---
> gcc/cp/tree.c | 2 -
> gcc/cp/typeck.c | 115 +++++++++++++---
> gcc/cp/typeck2.c | 2 +-
> gcc/testsuite/g++.dg/lookup/operator-3-ops.h | 53 ++++++++
> gcc/testsuite/g++.dg/lookup/operator-3.C | 56 +-------
> gcc/testsuite/g++.dg/lookup/operator-3a.C | 61 +++++++++
> gcc/testsuite/g++.dg/lookup/operator-4.C | 74 +++++++++++
> gcc/testsuite/g++.dg/lookup/operator-4a.C | 76 +++++++++++
> gcc/testsuite/g++.dg/lookup/operator-5.C | 74 +++++++++++
> gcc/testsuite/g++.dg/lookup/operator-5a.C | 76 +++++++++++
> gcc/testsuite/g++.dg/lookup/operator-6.C | 59 ++++++++
> gcc/testsuite/g++.dg/lookup/operator-7.C | 27 ++++
> gcc/testsuite/g++.dg/lookup/operator-8.C | 34 +++++
> libcc1/libcp1plugin.cc | 4 +-
> 31 files changed, 794 insertions(+), 300 deletions(-)
> create mode 100644 gcc/testsuite/g++.dg/lookup/operator-3-ops.h
> create mode 100644 gcc/testsuite/g++.dg/lookup/operator-3a.C
> create mode 100644 gcc/testsuite/g++.dg/lookup/operator-4.C
> create mode 100644 gcc/testsuite/g++.dg/lookup/operator-4a.C
> create mode 100644 gcc/testsuite/g++.dg/lookup/operator-5.C
> create mode 100644 gcc/testsuite/g++.dg/lookup/operator-5a.C
> create mode 100644 gcc/testsuite/g++.dg/lookup/operator-6.C
> create mode 100644 gcc/testsuite/g++.dg/lookup/operator-7.C
> create mode 100644 gcc/testsuite/g++.dg/lookup/operator-8.C
>
> diff --git a/gcc/cp/call.c b/gcc/cp/call.c
> index 347df5da35d..31c2308dc28 100644
> --- a/gcc/cp/call.c
> +++ b/gcc/cp/call.c
> @@ -6285,12 +6285,17 @@ op_is_ordered (tree_code code)
>
> /* Subroutine of build_new_op: Add to CANDIDATES all candidates for the
> operator indicated by CODE/CODE2. This function calls itself recursively to
> - handle C++20 rewritten comparison operator candidates. */
> + handle C++20 rewritten comparison operator candidates.
> +
> + LOOKUPS, if non-NULL, is the set of pertinent namespace-scope operator
> + overloads to consider. This parameter is used when instantiating a
> + dependent operator expression and has the same structure as
> + DEPENDENT_OPERATOR_TYPE_SAVED_LOOKUPS. */
>
> static tree
> add_operator_candidates (z_candidate **candidates,
> tree_code code, tree_code code2,
> - vec<tree, va_gc> *arglist,
> + vec<tree, va_gc> *arglist, tree lookups,
> int flags, tsubst_flags_t complain)
> {
> z_candidate *start_candidates = *candidates;
> @@ -6326,7 +6331,15 @@ add_operator_candidates (z_candidate **candidates,
> consider. */
> if (!memonly)
> {
> - tree fns = lookup_name (fnname, LOOK_where::BLOCK_NAMESPACE);
> + tree fns;
> + if (!lookups)
> + fns = lookup_name (fnname, LOOK_where::BLOCK_NAMESPACE);
> + /* If LOOKUPS is non-NULL, then we're instantiating a dependent operator
> + expression, and LOOKUPS contains the result of stage 1 name lookup. */
> + else if (tree found = purpose_member (fnname, lookups))
> + fns = TREE_VALUE (found);
> + else
> + fns = NULL_TREE;
> fns = lookup_arg_dependent (fnname, fns, arglist);
> add_candidates (fns, NULL_TREE, arglist, NULL_TREE,
> NULL_TREE, false, NULL_TREE, NULL_TREE,
> @@ -6429,7 +6442,7 @@ add_operator_candidates (z_candidate **candidates,
> if (rewrite_code != code)
> /* Add rewritten candidates in same order. */
> add_operator_candidates (candidates, rewrite_code, ERROR_MARK,
> - arglist, flags, complain);
> + arglist, lookups, flags, complain);
>
> z_candidate *save_cand = *candidates;
>
> @@ -6439,7 +6452,7 @@ add_operator_candidates (z_candidate **candidates,
> revlist->quick_push ((*arglist)[1]);
> revlist->quick_push ((*arglist)[0]);
> add_operator_candidates (candidates, rewrite_code, ERROR_MARK,
> - revlist, flags, complain);
> + revlist, lookups, flags, complain);
>
> /* Release the vec if we didn't add a candidate that uses it. */
> for (z_candidate *c = *candidates; c != save_cand; c = c->next)
> @@ -6457,8 +6470,8 @@ add_operator_candidates (z_candidate **candidates,
>
> tree
> build_new_op (const op_location_t &loc, enum tree_code code, int flags,
> - tree arg1, tree arg2, tree arg3, tree *overload,
> - tsubst_flags_t complain)
> + tree arg1, tree arg2, tree arg3, tree lookups,
> + tree *overload, tsubst_flags_t complain)
> {
> struct z_candidate *candidates = 0, *cand;
> releasing_vec arglist;
> @@ -6552,7 +6565,7 @@ build_new_op (const op_location_t &loc, enum tree_code code, int flags,
> p = conversion_obstack_alloc (0);
>
> result = add_operator_candidates (&candidates, code, code2, arglist,
> - flags, complain);
> + lookups, flags, complain);
> if (result == error_mark_node)
> goto user_defined_result_ready;
>
> @@ -6608,7 +6621,7 @@ build_new_op (const op_location_t &loc, enum tree_code code, int flags,
> else
> code = PREDECREMENT_EXPR;
> result = build_new_op (loc, code, flags, arg1, NULL_TREE,
> - NULL_TREE, overload, complain);
> + NULL_TREE, lookups, overload, complain);
> break;
>
> /* The caller will deal with these. */
> @@ -6765,7 +6778,7 @@ build_new_op (const op_location_t &loc, enum tree_code code, int flags,
> warning_sentinel ws (warn_zero_as_null_pointer_constant);
> result = build_new_op (loc, code,
> LOOKUP_NORMAL|LOOKUP_REWRITTEN,
> - lhs, rhs, NULL_TREE,
> + lhs, rhs, NULL_TREE, lookups,
> NULL, complain);
> }
> break;
> diff --git a/gcc/cp/constraint.cc b/gcc/cp/constraint.cc
> index 566f4e38fac..8e25ae23670 100644
> --- a/gcc/cp/constraint.cc
> +++ b/gcc/cp/constraint.cc
> @@ -202,15 +202,8 @@ finish_constraint_binary_op (location_t loc,
> return error_mark_node;
> if (!check_constraint_operands (loc, lhs, rhs))
> return error_mark_node;
> - tree overload;
> - cp_expr expr = build_x_binary_op (loc, code,
> - lhs, TREE_CODE (lhs),
> - rhs, TREE_CODE (rhs),
> - &overload, tf_none);
> - /* When either operand is dependent, the overload set may be non-empty. */
> - if (expr == error_mark_node)
> - return error_mark_node;
> - expr.set_location (loc);
> + cp_expr expr
> + = build_min_nt_loc (loc, code, lhs.get_value (), rhs.get_value ());
> expr.set_range (lhs.get_start (), rhs.get_finish ());
> return expr;
> }
> diff --git a/gcc/cp/coroutines.cc b/gcc/cp/coroutines.cc
> index 9017902e6fb..c00672eeb6e 100644
> --- a/gcc/cp/coroutines.cc
> +++ b/gcc/cp/coroutines.cc
> @@ -912,7 +912,7 @@ build_co_await (location_t loc, tree a, suspend_point_kind suspend_kind)
> if (MAYBE_CLASS_TYPE_P (TREE_TYPE (a)))
> {
> o = build_new_op (loc, CO_AWAIT_EXPR, LOOKUP_NORMAL, a, NULL_TREE,
> - NULL_TREE, NULL, tf_warning_or_error);
> + NULL_TREE, NULL_TREE, NULL, tf_warning_or_error);
> /* If no viable functions are found, o is a. */
> if (!o || o == error_mark_node)
> o = a;
> diff --git a/gcc/cp/cp-objcp-common.c b/gcc/cp/cp-objcp-common.c
> index 38eae881f0c..36e04cdee5e 100644
> --- a/gcc/cp/cp-objcp-common.c
> +++ b/gcc/cp/cp-objcp-common.c
> @@ -484,6 +484,7 @@ cp_common_init_ts (void)
> /* New Types. */
> MARK_TS_TYPE_COMMON (UNBOUND_CLASS_TEMPLATE);
> MARK_TS_TYPE_COMMON (TYPE_ARGUMENT_PACK);
> + MARK_TS_TYPE_COMMON (DEPENDENT_OPERATOR_TYPE);
>
> MARK_TS_TYPE_NON_COMMON (DECLTYPE_TYPE);
> MARK_TS_TYPE_NON_COMMON (TYPENAME_TYPE);
> diff --git a/gcc/cp/cp-tree.def b/gcc/cp/cp-tree.def
> index 725139bb457..6fb838cc850 100644
> --- a/gcc/cp/cp-tree.def
> +++ b/gcc/cp/cp-tree.def
> @@ -476,6 +476,11 @@ DEFTREECODE (UNDERLYING_TYPE, "underlying_type", tcc_type, 0)
> BASES_TYPE is the type in question. */
> DEFTREECODE (BASES, "bases", tcc_type, 0)
>
> +/* Dependent operator expressions are given this type rather than a NULL_TREE
> + type so that we have somewhere to stash the result of phase 1 name lookup
> + (namely into DEPENDENT_OPERATOR_TYPE_SAVED_LOOKUPS). */
> +DEFTREECODE (DEPENDENT_OPERATOR_TYPE, "dependent_operator_type", tcc_type, 0)
> +
> /* Used to represent the template information stored by template
> specializations.
> The accessors are:
> diff --git a/gcc/cp/cp-tree.h b/gcc/cp/cp-tree.h
> index 7f32cf56383..57a0da4e0ef 100644
> --- a/gcc/cp/cp-tree.h
> +++ b/gcc/cp/cp-tree.h
> @@ -2185,7 +2185,8 @@ enum languages { lang_c, lang_cplusplus };
> || TREE_CODE (T) == TYPENAME_TYPE \
> || TREE_CODE (T) == TYPEOF_TYPE \
> || TREE_CODE (T) == BOUND_TEMPLATE_TEMPLATE_PARM \
> - || TREE_CODE (T) == DECLTYPE_TYPE)
> + || TREE_CODE (T) == DECLTYPE_TYPE \
> + || TREE_CODE (T) == DEPENDENT_OPERATOR_TYPE)
>
> /* Nonzero if T is a class (or struct or union) type. Also nonzero
> for template type parameters, typename types, and instantiated
> @@ -3978,9 +3979,13 @@ struct GTY(()) lang_decl {
> TREE_LANG_FLAG_0 (FOLD_EXPR_CHECK (NODE))
>
> /* An INTEGER_CST containing the tree code of the folded operator. */
> -#define FOLD_EXPR_OP(NODE) \
> +#define FOLD_EXPR_OP_RAW(NODE) \
> TREE_OPERAND (FOLD_EXPR_CHECK (NODE), 0)
>
> +/* The tree code of the folded operator. */
> +#define FOLD_EXPR_OP(NODE) \
> + ((enum tree_code) TREE_INT_CST_LOW (FOLD_EXPR_OP_RAW (NODE)))
> +
> /* The expression containing an unexpanded parameter pack. */
> #define FOLD_EXPR_PACK(NODE) \
> TREE_OPERAND (FOLD_EXPR_CHECK (NODE), 1)
> @@ -4035,6 +4040,24 @@ struct GTY(()) lang_decl {
> #define CALL_EXPR_OPERATOR_SYNTAX(NODE) \
> TREE_LANG_FLAG_6 (CALL_OR_AGGR_INIT_CHECK (NODE))
>
> +/* A TREE_LIST containing the result of phase 1 name lookup of the operator
> + overloads that are pertinent to the dependent operator expression whose
> + type is NODE. Each TREE_PURPOSE is an IDENTIFIER_NODE and TREE_VALUE is
> + the corresponding (possibly empty) lookup result. The TREE_TYPE of the
> + first TREE_LIST node points back to NODE. */
> +#define DEPENDENT_OPERATOR_TYPE_SAVED_LOOKUPS(NODE) \
> + TYPE_VALUES_RAW (DEPENDENT_OPERATOR_TYPE_CHECK (NODE))
> +
> +/* Guarded helper for the above accessor macro that takes a (templated)
> + operator expression instead of the type thereof. */
> +inline tree
> +TEMPLATED_OPERATOR_SAVED_LOOKUPS (tree t)
> +{
> + return TREE_TYPE (EXPR_CHECK (t)) && TREE_CODE (TREE_TYPE (t)) == DEPENDENT_OPERATOR_TYPE
> + ? DEPENDENT_OPERATOR_TYPE_SAVED_LOOKUPS (TREE_TYPE (t))
> + : NULL_TREE;
> +}
> +
> /* Indicates whether a string literal has been parenthesized. Such
> usages are disallowed in certain circumstances. */
>
> @@ -6464,14 +6487,15 @@ extern tree build_special_member_call (tree, tree,
> tree, int, tsubst_flags_t);
> extern tree build_new_op (const op_location_t &,
> enum tree_code,
> - int, tree, tree, tree, tree *,
> - tsubst_flags_t);
> + int, tree, tree, tree, tree,
> + tree *, tsubst_flags_t);
> /* Wrapper that leaves out the usually-null op3 and overload parms. */
> inline tree build_new_op (const op_location_t &loc, enum tree_code code,
> int flags, tree arg1, tree arg2,
> tsubst_flags_t complain)
> {
> - return build_new_op (loc, code, flags, arg1, arg2, NULL_TREE, NULL, complain);
> + return build_new_op (loc, code, flags, arg1, arg2, NULL_TREE, NULL_TREE,
> + NULL, complain);
> }
> extern tree build_op_call (tree, vec<tree, va_gc> **,
> tsubst_flags_t);
> @@ -7875,8 +7899,9 @@ extern tree build_class_member_access_expr (cp_expr, tree, tree, bool,
> extern tree finish_class_member_access_expr (cp_expr, tree, bool,
> tsubst_flags_t);
> extern tree lookup_destructor (tree, tree, tree, tsubst_flags_t);
> +extern tree build_dependent_operator_type (tree, enum tree_code, bool);
> extern tree build_x_indirect_ref (location_t, tree,
> - ref_operator,
> + ref_operator, tree,
> tsubst_flags_t);
> extern tree cp_build_indirect_ref (location_t, tree,
> ref_operator,
> @@ -7894,20 +7919,20 @@ extern tree cp_build_function_call_vec (tree, vec<tree, va_gc> **,
> extern tree build_x_binary_op (const op_location_t &,
> enum tree_code, tree,
> enum tree_code, tree,
> - enum tree_code, tree *,
> - tsubst_flags_t);
> + enum tree_code, tree,
> + tree *, tsubst_flags_t);
> inline tree build_x_binary_op (const op_location_t &loc,
> enum tree_code code, tree arg1, tree arg2,
> tsubst_flags_t complain)
> {
> return build_x_binary_op (loc, code, arg1, TREE_CODE (arg1), arg2,
> - TREE_CODE (arg2), NULL, complain);
> + TREE_CODE (arg2), NULL_TREE, NULL, complain);
> }
> extern tree build_x_array_ref (location_t, tree, tree,
> tsubst_flags_t);
> extern tree build_x_unary_op (location_t,
> enum tree_code, cp_expr,
> - tsubst_flags_t);
> + tree, tsubst_flags_t);
> extern tree cp_build_addressof (location_t, tree,
> tsubst_flags_t);
> extern tree cp_build_addr_expr (tree, tsubst_flags_t);
> @@ -7922,7 +7947,7 @@ extern tree build_x_compound_expr_from_list (tree, expr_list_kind,
> extern tree build_x_compound_expr_from_vec (vec<tree, va_gc> *,
> const char *, tsubst_flags_t);
> extern tree build_x_compound_expr (location_t, tree, tree,
> - tsubst_flags_t);
> + tree, tsubst_flags_t);
> extern tree build_compound_expr (location_t, tree, tree);
> extern tree cp_build_compound_expr (tree, tree, tsubst_flags_t);
> extern tree build_static_cast (location_t, tree, tree,
> @@ -7938,7 +7963,7 @@ extern tree cp_build_c_cast (location_t, tree, tree,
> tsubst_flags_t);
> extern cp_expr build_x_modify_expr (location_t, tree,
> enum tree_code, tree,
> - tsubst_flags_t);
> + tree, tsubst_flags_t);
> extern tree cp_build_modify_expr (location_t, tree,
> enum tree_code, tree,
> tsubst_flags_t);
> diff --git a/gcc/cp/cxx-pretty-print.c b/gcc/cp/cxx-pretty-print.c
> index 3ea357deb80..6af009c6890 100644
> --- a/gcc/cp/cxx-pretty-print.c
> +++ b/gcc/cp/cxx-pretty-print.c
> @@ -2541,8 +2541,8 @@ pp_cxx_addressof_expression (cxx_pretty_printer *pp, tree t)
> static char const*
> get_fold_operator (tree t)
> {
> - int op = int_cst_value (FOLD_EXPR_OP (t));
> - ovl_op_info_t *info = OVL_OP_INFO (FOLD_EXPR_MODIFY_P (t), op);
> + ovl_op_info_t *info = OVL_OP_INFO (FOLD_EXPR_MODIFY_P (t),
> + FOLD_EXPR_OP (t));
> return info->name;
> }
>
> diff --git a/gcc/cp/decl.c b/gcc/cp/decl.c
> index 7c2048c6acb..24dd6701663 100644
> --- a/gcc/cp/decl.c
> +++ b/gcc/cp/decl.c
> @@ -17098,8 +17098,6 @@ start_preparsed_function (tree decl1, tree attrs, int flags)
>
> store_parm_decls (current_function_parms);
>
> - push_operator_bindings ();
> -
> if (!processing_template_decl
> && (flag_lifetime_dse > 1)
> && DECL_CONSTRUCTOR_P (decl1)
> diff --git a/gcc/cp/decl2.c b/gcc/cp/decl2.c
> index 99f5dc784b7..062c175430b 100644
> --- a/gcc/cp/decl2.c
> +++ b/gcc/cp/decl2.c
> @@ -417,7 +417,8 @@ grok_array_decl (location_t loc, tree array_expr, tree index_exp,
> {
> if (index_exp)
> expr = build_new_op (loc, ARRAY_REF, LOOKUP_NORMAL, array_expr,
> - index_exp, NULL_TREE, &overload, complain);
> + index_exp, NULL_TREE, NULL_TREE,
> + &overload, complain);
> else if ((*index_exp_list)->is_empty ())
> expr = build_op_subscript (loc, array_expr, index_exp_list, &overload,
> complain);
> @@ -431,7 +432,7 @@ grok_array_decl (location_t loc, tree array_expr, tree index_exp,
> tf_none);
> if (idx != error_mark_node)
> expr = build_new_op (loc, ARRAY_REF, LOOKUP_NORMAL, array_expr,
> - idx, NULL_TREE, &overload,
> + idx, NULL_TREE, NULL_TREE, &overload,
> complain & tf_decltype);
> if (expr == error_mark_node)
> {
> diff --git a/gcc/cp/method.c b/gcc/cp/method.c
> index 935946f5eef..44439bae4ec 100644
> --- a/gcc/cp/method.c
> +++ b/gcc/cp/method.c
> @@ -1372,7 +1372,7 @@ do_one_comp (location_t loc, const comp_info &info, tree sub, tree lhs, tree rhs
> to </=, so don't give an error yet if <=> lookup fails. */
> bool tentative = retcat != cc_last;
> tree comp = build_new_op (loc, code, flags, lhs, rhs,
> - NULL_TREE, &overload,
> + NULL_TREE, NULL_TREE, &overload,
> tentative ? tf_none : complain);
>
> if (code != SPACESHIP_EXPR)
> @@ -1684,8 +1684,8 @@ build_comparison_op (tree fndecl, bool defining, tsubst_flags_t complain)
> comp = retval = var;
> }
> eq = build_new_op (info.loc, EQ_EXPR, flags, comp,
> - integer_zero_node, NULL_TREE, NULL,
> - complain);
> + integer_zero_node, NULL_TREE, NULL_TREE,
> + NULL, complain);
> }
> tree ceq = contextual_conv_bool (eq, complain);
> info.check (ceq);
> @@ -1720,7 +1720,7 @@ build_comparison_op (tree fndecl, bool defining, tsubst_flags_t complain)
> else if (code == NE_EXPR)
> {
> tree comp = build_new_op (info.loc, EQ_EXPR, flags, lhs, rhs,
> - NULL_TREE, NULL, complain);
> + NULL_TREE, NULL_TREE, NULL, complain);
> comp = contextual_conv_bool (comp, complain);
> info.check (comp);
> if (defining)
> @@ -1732,9 +1732,9 @@ build_comparison_op (tree fndecl, bool defining, tsubst_flags_t complain)
> else
> {
> tree comp = build_new_op (info.loc, SPACESHIP_EXPR, flags, lhs, rhs,
> - NULL_TREE, NULL, complain);
> + NULL_TREE, NULL_TREE, NULL, complain);
> tree comp2 = build_new_op (info.loc, code, flags, comp, integer_zero_node,
> - NULL_TREE, NULL, complain);
> + NULL_TREE, NULL_TREE, NULL, complain);
> info.check (comp2);
> if (defining)
> finish_return_stmt (comp2);
> diff --git a/gcc/cp/module.cc b/gcc/cp/module.cc
> index 9266055cd92..f3e7af22699 100644
> --- a/gcc/cp/module.cc
> +++ b/gcc/cp/module.cc
> @@ -8789,6 +8789,7 @@ trees_out::type_node (tree type)
> case DECLTYPE_TYPE:
> case TYPEOF_TYPE:
> case UNDERLYING_TYPE:
> + case DEPENDENT_OPERATOR_TYPE:
> tree_node (TYPE_VALUES_RAW (type));
> if (TREE_CODE (type) == DECLTYPE_TYPE)
> /* We stash a whole bunch of things into decltype's
> @@ -9311,6 +9312,7 @@ trees_in::tree_node (bool is_use)
> case DECLTYPE_TYPE:
> case TYPEOF_TYPE:
> case UNDERLYING_TYPE:
> + case DEPENDENT_OPERATOR_TYPE:
> {
> tree expr = tree_node ();
> if (!get_overrun ())
> diff --git a/gcc/cp/name-lookup.c b/gcc/cp/name-lookup.c
> index 6b5e4349595..3bd7b206abb 100644
> --- a/gcc/cp/name-lookup.c
> +++ b/gcc/cp/name-lookup.c
> @@ -7725,20 +7725,14 @@ lookup_name (tree name, LOOK_where where, LOOK_want want)
>
> if (binding)
> {
> - /* The saved lookups for an operator record 'nothing
> - found' as error_mark_node. We need to stop the search
> - here, but not return the error mark node. */
> - if (binding == error_mark_node)
> - binding = NULL_TREE;
> -
> val = binding;
> - goto found;
> + break;
> }
> }
> }
>
> /* Now lookup in namespace scopes. */
> - if (bool (where & LOOK_where::NAMESPACE))
> + if (!val && bool (where & LOOK_where::NAMESPACE))
> {
> name_lookup lookup (name, want);
> if (lookup.search_unqualified
> @@ -7746,8 +7740,6 @@ lookup_name (tree name, LOOK_where where, LOOK_want want)
> val = lookup.value;
> }
>
> - found:;
> -
> /* If we have a known type overload, pull it out. This can happen
> for both using decls and unhidden functions. */
> if (val && TREE_CODE (val) == OVERLOAD && TREE_TYPE (val) != unknown_type_node)
> @@ -8949,125 +8941,4 @@ cp_emit_debug_info_for_using (tree t, tree context)
> }
> }
>
> -/* Return the result of unqualified lookup for the overloaded operator
> - designated by CODE, if we are in a template and the binding we find is
> - not. */
> -
> -static tree
> -op_unqualified_lookup (tree fnname)
> -{
> - if (cxx_binding *binding = IDENTIFIER_BINDING (fnname))
> - {
> - cp_binding_level *l = binding->scope;
> - while (l && !l->this_entity)
> - l = l->level_chain;
> -
> - if (l && uses_template_parms (l->this_entity))
> - /* Don't preserve decls from an uninstantiated template,
> - wait until that template is instantiated. */
> - return NULL_TREE;
> - }
> -
> - tree fns = lookup_name (fnname);
> - if (!fns)
> - /* Remember we found nothing! */
> - return error_mark_node;
> -
> - tree d = fns;
> - if (TREE_CODE (d) == TREE_LIST)
> - d = TREE_VALUE (d);
> - if (is_overloaded_fn (d))
> - d = get_first_fn (d);
> - if (DECL_CLASS_SCOPE_P (d))
> - /* We don't need to remember class-scope functions or declarations,
> - normal unqualified lookup will find them again. */
> - return NULL_TREE;
> -
> - return fns;
> -}
> -
> -/* E is an expression representing an operation with dependent type, so we
> - don't know yet whether it will use the built-in meaning of the operator or a
> - function. Remember declarations of that operator in scope.
> -
> - We then inject a fake binding of that lookup into the
> - instantiation's parameter scope. This approach fails if the user
> - has different using declarations or directives in different local
> - binding of the current function from whence we need to do lookups
> - (we'll cache what we see on the first lookup). */
> -
> -static const char *const op_bind_attrname = "operator bindings";
> -
> -void
> -maybe_save_operator_binding (tree e)
> -{
> - /* This is only useful in a template. */
> - if (!processing_template_decl)
> - return;
> -
> - tree cfn = current_function_decl;
> - if (!cfn)
> - return;
> -
> - tree fnname;
> - if(TREE_CODE (e) == MODOP_EXPR)
> - fnname = ovl_op_identifier (true, TREE_CODE (TREE_OPERAND (e, 1)));
> - else
> - fnname = ovl_op_identifier (false, TREE_CODE (e));
> - if (!fnname || fnname == assign_op_identifier)
> - return;
> -
> - tree attributes = DECL_ATTRIBUTES (cfn);
> - tree op_attr = lookup_attribute (op_bind_attrname, attributes);
> - if (!op_attr)
> - {
> - tree *ap = &DECL_ATTRIBUTES (cfn);
> - while (*ap && ATTR_IS_DEPENDENT (*ap))
> - ap = &TREE_CHAIN (*ap);
> - op_attr = tree_cons (get_identifier (op_bind_attrname),
> - NULL_TREE, *ap);
> - *ap = op_attr;
> - }
> -
> - tree op_bind = purpose_member (fnname, TREE_VALUE (op_attr));
> - if (!op_bind)
> - {
> - tree fns = op_unqualified_lookup (fnname);
> -
> - /* Always record, so we don't keep looking for this
> - operator. */
> - TREE_VALUE (op_attr) = tree_cons (fnname, fns, TREE_VALUE (op_attr));
> - }
> -}
> -
> -/* Called from cp_free_lang_data so we don't put this into LTO. */
> -
> -void
> -discard_operator_bindings (tree decl)
> -{
> - DECL_ATTRIBUTES (decl) = remove_attribute (op_bind_attrname,
> - DECL_ATTRIBUTES (decl));
> -}
> -
> -/* Subroutine of start_preparsed_function: push the bindings we saved away in
> - maybe_save_op_lookup into the function parameter binding level. */
> -
> -void
> -push_operator_bindings ()
> -{
> - tree decl1 = current_function_decl;
> - if (tree attr = lookup_attribute (op_bind_attrname,
> - DECL_ATTRIBUTES (decl1)))
> - for (tree binds = TREE_VALUE (attr); binds; binds = TREE_CHAIN (binds))
> - if (tree val = TREE_VALUE (binds))
> - {
> - tree name = TREE_PURPOSE (binds);
> - if (TREE_CODE (val) == TREE_LIST)
> - for (tree v = val; v; v = TREE_CHAIN (v))
> - push_local_binding (name, TREE_VALUE (v), /*using*/true);
> - else
> - push_local_binding (name, val, /*using*/true);
> - }
> -}
> -
> #include "gt-cp-name-lookup.h"
> diff --git a/gcc/cp/name-lookup.h b/gcc/cp/name-lookup.h
> index f63c4f5b8bb..db705d20c68 100644
> --- a/gcc/cp/name-lookup.h
> +++ b/gcc/cp/name-lookup.h
> @@ -465,10 +465,7 @@ extern void push_nested_namespace (tree);
> extern void pop_nested_namespace (tree);
> extern void push_to_top_level (void);
> extern void pop_from_top_level (void);
> -extern void maybe_save_operator_binding (tree);
> -extern void push_operator_bindings (void);
> extern void push_using_decl_bindings (tree, tree);
> -extern void discard_operator_bindings (tree);
>
> /* Lower level interface for modules. */
> extern tree *mergeable_namespace_slots (tree ns, tree name, bool is_global,
> diff --git a/gcc/cp/parser.c b/gcc/cp/parser.c
> index c2564e51e41..5d72201f87c 100644
> --- a/gcc/cp/parser.c
> +++ b/gcc/cp/parser.c
> @@ -8731,7 +8731,7 @@ cp_parser_unary_expression (cp_parser *parser, cp_id_kind * pidk,
> return build_x_unary_op (token->location,
> (keyword == RID_REALPART
> ? REALPART_EXPR : IMAGPART_EXPR),
> - expression,
> + expression, NULL_TREE,
> tf_warning_or_error);
> }
> break;
> @@ -8908,7 +8908,7 @@ cp_parser_unary_expression (cp_parser *parser, cp_id_kind * pidk,
> case INDIRECT_REF:
> non_constant_p = NIC_STAR;
> expression = build_x_indirect_ref (loc, cast_expression,
> - RO_UNARY_STAR,
> + RO_UNARY_STAR, NULL_TREE,
> complain);
> /* TODO: build_x_indirect_ref does not always honor the
> location, so ensure it is set. */
> @@ -8921,7 +8921,7 @@ cp_parser_unary_expression (cp_parser *parser, cp_id_kind * pidk,
> case BIT_NOT_EXPR:
> expression = build_x_unary_op (loc, unary_operator,
> cast_expression,
> - complain);
> + NULL_TREE, complain);
> /* TODO: build_x_unary_op does not always honor the location,
> so ensure it is set. */
> expression.set_location (loc);
> @@ -10149,7 +10149,7 @@ cp_parser_binary_expression (cp_parser* parser, bool cast_p,
> op_location_t op_loc (current.loc, combined_loc);
> current.lhs = build_x_binary_op (op_loc, current.tree_type,
> current.lhs, current.lhs_type,
> - rhs, rhs_type, &overload,
> + rhs, rhs_type, NULL_TREE, &overload,
> complain_flags (decltype_p));
> /* TODO: build_x_binary_op doesn't always honor the location. */
> current.lhs.set_location (combined_loc);
> @@ -10328,7 +10328,7 @@ cp_parser_assignment_expression (cp_parser* parser, cp_id_kind * pidk,
> rhs.get_finish ());
> expr = build_x_modify_expr (loc, expr,
> assignment_operator,
> - rhs,
> + rhs, NULL_TREE,
> complain_flags (decltype_p));
> /* TODO: build_x_modify_expr doesn't honor the location,
> so we must set it here. */
> @@ -10480,7 +10480,7 @@ cp_parser_expression (cp_parser* parser, cp_id_kind * pidk,
> expression.get_start (),
> assignment_expression.get_finish ());
> expression = build_x_compound_expr (loc, expression,
> - assignment_expression,
> + assignment_expression, NULL_TREE,
> complain_flags (decltype_p));
> expression.set_location (loc);
> }
> @@ -13617,7 +13617,7 @@ do_range_for_auto_deduction (tree decl, tree range_expr)
> iter_decl = build_decl (input_location, VAR_DECL, NULL_TREE,
> iter_type);
> iter_decl = build_x_indirect_ref (input_location, iter_decl,
> - RO_UNARY_STAR,
> + RO_UNARY_STAR, NULL_TREE,
> tf_warning_or_error);
> TREE_TYPE (decl) = do_auto_deduction (TREE_TYPE (decl),
> iter_decl, auto_node,
> @@ -13804,7 +13804,7 @@ cp_convert_range_for (tree statement, tree range_decl, tree range_expr,
> condition = build_x_binary_op (input_location, NE_EXPR,
> begin, ERROR_MARK,
> end, ERROR_MARK,
> - NULL, tf_warning_or_error);
> + NULL_TREE, NULL, tf_warning_or_error);
> finish_for_cond (condition, statement, ivdep, unroll);
>
> /* The new increment expression. */
> @@ -13818,7 +13818,7 @@ cp_convert_range_for (tree statement, tree range_decl, tree range_expr,
>
> /* The declaration is initialized with *__begin inside the loop body. */
> tree deref_begin = build_x_indirect_ref (input_location, begin, RO_UNARY_STAR,
> - tf_warning_or_error);
> + NULL_TREE, tf_warning_or_error);
> cp_finish_decl (range_decl, deref_begin,
> /*is_constant_init*/false, NULL_TREE,
> LOOKUP_ONLYCONVERTING);
> @@ -13924,7 +13924,7 @@ cp_parser_perform_range_for_lookup (tree range, tree *begin, tree *end)
> && (build_x_binary_op (input_location, NE_EXPR,
> *begin, ERROR_MARK,
> *end, ERROR_MARK,
> - NULL, tf_none)
> + NULL_TREE, NULL, tf_none)
> != error_mark_node))
> /* P0184R0 allows __begin and __end to have different types,
> but make sure they are comparable so we can give a better
> @@ -18924,7 +18924,7 @@ cp_parser_template_argument (cp_parser* parser)
> {
> if (address_p)
> argument = build_x_unary_op (loc, ADDR_EXPR, argument,
> - tf_warning_or_error);
> + NULL_TREE, tf_warning_or_error);
> else
> argument = convert_from_reference (argument);
> return argument;
> @@ -41564,7 +41564,7 @@ cp_parser_omp_for_cond (cp_parser *parser, tree decl, enum tree_code code)
> TREE_CODE (cond),
> TREE_OPERAND (cond, 0), ERROR_MARK,
> TREE_OPERAND (cond, 1), ERROR_MARK,
> - /*overload=*/NULL, tf_warning_or_error);
> + NULL_TREE, /*overload=*/NULL, tf_warning_or_error);
> }
>
> /* Helper function, to parse omp for increment expression. */
> @@ -41641,11 +41641,13 @@ cp_parser_omp_for_incr (cp_parser *parser, tree decl)
> lhs = rhs;
> else
> lhs = build_x_unary_op (input_location, NEGATE_EXPR, rhs,
> - tf_warning_or_error);
> + NULL_TREE, tf_warning_or_error);
> }
> else
> - lhs = build_x_binary_op (input_location, op, lhs, ERROR_MARK, rhs,
> - ERROR_MARK, NULL, tf_warning_or_error);
> + lhs = build_x_binary_op (input_location, op,
> + lhs, ERROR_MARK,
> + rhs, ERROR_MARK,
> + NULL_TREE, NULL, tf_warning_or_error);
> }
> }
> while (token->type == CPP_PLUS || token->type == CPP_MINUS);
> @@ -41873,7 +41875,7 @@ cp_parser_omp_for_loop_init (cp_parser *parser,
> orig_init = rhs;
> finish_expr_stmt (build_x_modify_expr (EXPR_LOCATION (rhs),
> decl, NOP_EXPR,
> - rhs,
> + rhs, NULL_TREE,
> tf_warning_or_error));
> if (!add_private_clause)
> add_private_clause = decl;
> @@ -41995,7 +41997,7 @@ cp_convert_omp_range_for (tree &this_pre_body, vec<tree, va_gc> *for_block,
> cond = build_x_binary_op (input_location, NE_EXPR,
> begin, ERROR_MARK,
> end, ERROR_MARK,
> - NULL, tf_warning_or_error);
> + NULL_TREE, NULL, tf_warning_or_error);
>
> /* The new increment expression. */
> if (CLASS_TYPE_P (iter_type))
> @@ -42033,7 +42035,7 @@ cp_convert_omp_range_for (tree &this_pre_body, vec<tree, va_gc> *for_block,
> if (auto_node)
> {
> tree t = build_x_indirect_ref (input_location, begin, RO_UNARY_STAR,
> - tf_none);
> + NULL_TREE, tf_none);
> if (!error_operand_p (t))
> TREE_TYPE (orig_decl) = do_auto_deduction (TREE_TYPE (orig_decl),
> t, auto_node);
> @@ -42073,7 +42075,7 @@ cp_finish_omp_range_for (tree orig, tree begin)
> /* The declaration is initialized with *__begin inside the loop body. */
> cp_finish_decl (decl,
> build_x_indirect_ref (input_location, begin, RO_UNARY_STAR,
> - tf_warning_or_error),
> + NULL_TREE, tf_warning_or_error),
> /*is_constant_init*/false, NULL_TREE,
> LOOKUP_ONLYCONVERTING);
> if (VAR_P (decl) && DECL_DECOMPOSITION_P (decl))
> diff --git a/gcc/cp/pt.c b/gcc/cp/pt.c
> index 42133a30c97..60cc23ba987 100644
> --- a/gcc/cp/pt.c
> +++ b/gcc/cp/pt.c
> @@ -12640,23 +12640,26 @@ expand_empty_fold (tree t, tsubst_flags_t complain)
> static tree
> fold_expression (tree t, tree left, tree right, tsubst_flags_t complain)
> {
> - tree op = FOLD_EXPR_OP (t);
> - tree_code code = (tree_code)TREE_INT_CST_LOW (op);
> + tree_code code = FOLD_EXPR_OP (t);
> +
> + tree lookups = TEMPLATED_OPERATOR_SAVED_LOOKUPS (t);
>
> // Handle compound assignment operators.
> if (FOLD_EXPR_MODIFY_P (t))
> - return build_x_modify_expr (input_location, left, code, right, complain);
> + return build_x_modify_expr (input_location, left, code, right,
> + lookups, complain);
>
> warning_sentinel s(warn_parentheses);
> switch (code)
> {
> case COMPOUND_EXPR:
> - return build_x_compound_expr (input_location, left, right, complain);
> + return build_x_compound_expr (input_location, left, right,
> + lookups, complain);
> default:
> return build_x_binary_op (input_location, code,
> left, TREE_CODE (left),
> right, TREE_CODE (right),
> - /*overload=*/NULL,
> + lookups, /*overload=*/NULL,
> complain);
> }
> }
> @@ -17891,7 +17894,7 @@ tsubst_omp_for_iterator (tree t, int i, tree declv, tree &orig_declv,
> tree lhs = RECUR (TREE_OPERAND (incr, 0));
> tree rhs = RECUR (TREE_OPERAND (incr, 1));
> incr = build_x_modify_expr (EXPR_LOCATION (incr), lhs,
> - NOP_EXPR, rhs, complain);
> + NOP_EXPR, rhs, NULL_TREE, complain);
> }
> else
> incr = RECUR (incr);
> @@ -19204,6 +19207,7 @@ tsubst_expr (tree t, tree args, tsubst_flags_t complain, tree in_decl,
> RETURN (RECUR (TREE_OPERAND (t, 1)));
> RETURN (build_x_compound_expr (EXPR_LOCATION (t), tmp,
> RECUR (TREE_OPERAND (t, 1)),
> + TEMPLATED_OPERATOR_SAVED_LOOKUPS (t),
> complain));
>
> case ANNOTATE_EXPR:
> @@ -19855,6 +19859,7 @@ tsubst_copy_and_build (tree t,
> }
> else
> r = build_x_indirect_ref (input_location, r, RO_UNARY_STAR,
> + TEMPLATED_OPERATOR_SAVED_LOOKUPS (t),
> complain|decltype_flag);
>
> if (REF_PARENTHESIZED_P (t))
> @@ -19965,6 +19970,7 @@ tsubst_copy_and_build (tree t,
> op1 = tsubst_non_call_postfix_expression (TREE_OPERAND (t, 0),
> args, complain, in_decl);
> RETURN (build_x_unary_op (input_location, TREE_CODE (t), op1,
> + TEMPLATED_OPERATOR_SAVED_LOOKUPS (t),
> complain|decltype_flag));
>
> case PREDECREMENT_EXPR:
> @@ -19978,6 +19984,7 @@ tsubst_copy_and_build (tree t,
> case IMAGPART_EXPR:
> RETURN (build_x_unary_op (input_location, TREE_CODE (t),
> RECUR (TREE_OPERAND (t, 0)),
> + TEMPLATED_OPERATOR_SAVED_LOOKUPS (t),
> complain|decltype_flag));
>
> case FIX_TRUNC_EXPR:
> @@ -19996,6 +20003,7 @@ tsubst_copy_and_build (tree t,
> op1 = tsubst_non_call_postfix_expression (op1, args, complain,
> in_decl);
> RETURN (build_x_unary_op (input_location, ADDR_EXPR, op1,
> + TEMPLATED_OPERATOR_SAVED_LOOKUPS (t),
> complain|decltype_flag));
>
> case PLUS_EXPR:
> @@ -20060,6 +20068,7 @@ tsubst_copy_and_build (tree t,
> (warning_suppressed_p (TREE_OPERAND (t, 1))
> ? ERROR_MARK
> : TREE_CODE (TREE_OPERAND (t, 1))),
> + TEMPLATED_OPERATOR_SAVED_LOOKUPS (t),
> /*overload=*/NULL,
> complain|decltype_flag);
> if (EXPR_P (r))
> @@ -20212,8 +20221,10 @@ tsubst_copy_and_build (tree t,
> warning_sentinel s(warn_div_by_zero);
> tree lhs = RECUR (TREE_OPERAND (t, 0));
> tree rhs = RECUR (TREE_OPERAND (t, 2));
> +
> tree r = build_x_modify_expr
> (EXPR_LOCATION (t), lhs, TREE_CODE (TREE_OPERAND (t, 1)), rhs,
> + TEMPLATED_OPERATOR_SAVED_LOOKUPS (t),
> complain|decltype_flag);
> /* TREE_NO_WARNING must be set if either the expression was
> parenthesized or it uses an operator such as >>= rather
> @@ -20314,6 +20325,7 @@ tsubst_copy_and_build (tree t,
> RETURN (build_x_compound_expr (EXPR_LOCATION (t),
> op0,
> RECUR (TREE_OPERAND (t, 1)),
> + TEMPLATED_OPERATOR_SAVED_LOOKUPS (t),
> complain|decltype_flag));
> }
>
> @@ -26994,6 +27006,9 @@ dependent_type_p_r (tree type)
> if (TREE_CODE (type) == TYPE_PACK_EXPANSION)
> return true;
>
> + if (TREE_CODE (type) == DEPENDENT_OPERATOR_TYPE)
> + return true;
> +
> if (any_dependent_type_attributes_p (TYPE_ATTRIBUTES (type)))
> return true;
>
> diff --git a/gcc/cp/ptree.c b/gcc/cp/ptree.c
> index d514aa2cad2..f7ddae77679 100644
> --- a/gcc/cp/ptree.c
> +++ b/gcc/cp/ptree.c
> @@ -151,6 +151,12 @@ cxx_print_type (FILE *file, tree node, int indent)
> print_node (file, "expr", DECLTYPE_TYPE_EXPR (node), indent + 4);
> return;
>
> + case DEPENDENT_OPERATOR_TYPE:
> + print_node (file, "saved_lookups",
> + DEPENDENT_OPERATOR_TYPE_SAVED_LOOKUPS (node),
> + indent + 4);
> + return;
> +
> case TYPENAME_TYPE:
> print_node (file, "fullname", TYPENAME_TYPE_FULLNAME (node),
> indent + 4);
> diff --git a/gcc/cp/semantics.c b/gcc/cp/semantics.c
> index 356fb83200c..6603066c620 100644
> --- a/gcc/cp/semantics.c
> +++ b/gcc/cp/semantics.c
> @@ -2920,7 +2920,7 @@ finish_increment_expr (cp_expr expr, enum tree_code code)
> expr.get_start (),
> get_finish (input_location));
> cp_expr result = build_x_unary_op (combined_loc, code, expr,
> - tf_warning_or_error);
> + NULL_TREE, tf_warning_or_error);
> /* TODO: build_x_unary_op doesn't honor the location, so set it here. */
> result.set_location (combined_loc);
> return result;
> @@ -3031,7 +3031,8 @@ finish_unary_op_expr (location_t op_loc, enum tree_code code, cp_expr expr,
> of the operator token to the end of EXPR. */
> location_t combined_loc = make_location (op_loc,
> op_loc, expr.get_finish ());
> - cp_expr result = build_x_unary_op (combined_loc, code, expr, complain);
> + cp_expr result = build_x_unary_op (combined_loc, code, expr,
> + NULL_TREE, complain);
> /* TODO: build_x_unary_op doesn't always honor the location. */
> result.set_location (combined_loc);
>
> @@ -9884,7 +9885,7 @@ handle_omp_for_class_iterator (int i, location_t locus, enum tree_code code,
> TREE_CODE (cond),
> iter, ERROR_MARK,
> TREE_OPERAND (cond, 1), ERROR_MARK,
> - NULL, tf_warning_or_error);
> + NULL_TREE, NULL, tf_warning_or_error);
> if (error_operand_p (tem))
> return true;
> }
> @@ -9898,9 +9899,10 @@ handle_omp_for_class_iterator (int i, location_t locus, enum tree_code code,
> error_at (elocus, "invalid controlling predicate");
> return true;
> }
> - diff = build_x_binary_op (elocus, MINUS_EXPR, TREE_OPERAND (cond, 1),
> - ERROR_MARK, iter, ERROR_MARK, NULL,
> - tf_warning_or_error);
> + diff = build_x_binary_op (elocus, MINUS_EXPR,
> + TREE_OPERAND (cond, 1), ERROR_MARK,
> + iter, ERROR_MARK,
> + NULL_TREE, NULL, tf_warning_or_error);
> diff = cp_fully_fold (diff);
> if (error_operand_p (diff))
> return true;
> @@ -9928,7 +9930,7 @@ handle_omp_for_class_iterator (int i, location_t locus, enum tree_code code,
> }
> iter_incr = build_x_unary_op (EXPR_LOCATION (incr),
> TREE_CODE (incr), iter,
> - tf_warning_or_error);
> + NULL_TREE, tf_warning_or_error);
> if (error_operand_p (iter_incr))
> return true;
> else if (TREE_CODE (incr) == PREINCREMENT_EXPR
> @@ -9954,6 +9956,7 @@ handle_omp_for_class_iterator (int i, location_t locus, enum tree_code code,
> iter_incr = build_x_modify_expr (EXPR_LOCATION (rhs),
> iter, TREE_CODE (rhs),
> TREE_OPERAND (rhs, 1),
> + NULL_TREE,
> tf_warning_or_error);
> if (error_operand_p (iter_incr))
> return true;
> @@ -9983,13 +9986,13 @@ handle_omp_for_class_iterator (int i, location_t locus, enum tree_code code,
> PLUS_EXPR,
> TREE_OPERAND (rhs, 0),
> ERROR_MARK, iter,
> - ERROR_MARK, NULL,
> + ERROR_MARK, NULL_TREE, NULL,
> tf_warning_or_error);
> if (error_operand_p (iter_incr))
> return true;
> iter_incr = build_x_modify_expr (EXPR_LOCATION (rhs),
> iter, NOP_EXPR,
> - iter_incr,
> + iter_incr, NULL_TREE,
> tf_warning_or_error);
> if (error_operand_p (iter_incr))
> return true;
> @@ -10100,7 +10103,7 @@ handle_omp_for_class_iterator (int i, location_t locus, enum tree_code code,
> if (init != NULL)
> finish_expr_stmt (build_x_modify_expr (elocus,
> iter, NOP_EXPR, init,
> - tf_warning_or_error));
> + NULL_TREE, tf_warning_or_error));
> init = build_int_cst (TREE_TYPE (diff), 0);
> if (c && iter_incr == NULL
> && (!ordered || (i < collapse && collapse > 1)))
> @@ -10109,23 +10112,24 @@ handle_omp_for_class_iterator (int i, location_t locus, enum tree_code code,
> {
> finish_expr_stmt (build_x_modify_expr (elocus,
> incr_var, NOP_EXPR,
> - incr, tf_warning_or_error));
> + incr, NULL_TREE,
> + tf_warning_or_error));
> incr = incr_var;
> }
> iter_incr = build_x_modify_expr (elocus,
> iter, PLUS_EXPR, incr,
> - tf_warning_or_error);
> + NULL_TREE, tf_warning_or_error);
> }
> if (c && ordered && i < collapse && collapse > 1)
> iter_incr = incr;
> finish_expr_stmt (build_x_modify_expr (elocus,
> last, NOP_EXPR, init,
> - tf_warning_or_error));
> + NULL_TREE, tf_warning_or_error));
> if (diffvar)
> {
> finish_expr_stmt (build_x_modify_expr (elocus,
> diffvar, NOP_EXPR,
> - diff, tf_warning_or_error));
> + diff, NULL_TREE, tf_warning_or_error));
> diff = diffvar;
> }
> *pre_body = pop_stmt_list (*pre_body);
> @@ -10141,13 +10145,13 @@ handle_omp_for_class_iterator (int i, location_t locus, enum tree_code code,
> iter_init = build2 (MINUS_EXPR, TREE_TYPE (diff), decl, last);
> iter_init = build_x_modify_expr (elocus,
> iter, PLUS_EXPR, iter_init,
> - tf_warning_or_error);
> + NULL_TREE, tf_warning_or_error);
> if (iter_init != error_mark_node)
> iter_init = build1 (NOP_EXPR, void_type_node, iter_init);
> finish_expr_stmt (iter_init);
> finish_expr_stmt (build_x_modify_expr (elocus,
> last, NOP_EXPR, decl,
> - tf_warning_or_error));
> + NULL_TREE, tf_warning_or_error));
> add_stmt (orig_body);
> *body = pop_stmt_list (*body);
>
> @@ -10165,7 +10169,7 @@ handle_omp_for_class_iterator (int i, location_t locus, enum tree_code code,
> iter_init = build2 (MINUS_EXPR, TREE_TYPE (diff), iter_init, last);
> iter_init = build_x_modify_expr (elocus,
> iter, PLUS_EXPR, iter_init,
> - tf_warning_or_error);
> + NULL_TREE, tf_warning_or_error);
> if (iter_init != error_mark_node)
> iter_init = build1 (NOP_EXPR, void_type_node, iter_init);
> finish_expr_stmt (iter_init);
> @@ -10876,7 +10880,7 @@ finish_omp_cancel (tree clauses)
> ifc = build_x_binary_op (OMP_CLAUSE_LOCATION (ifc), NE_EXPR,
> OMP_CLAUSE_IF_EXPR (ifc), ERROR_MARK,
> integer_zero_node, ERROR_MARK,
> - NULL, tf_warning_or_error);
> + NULL_TREE, NULL, tf_warning_or_error);
> }
> else
> ifc = boolean_true_node;
> @@ -12128,6 +12132,9 @@ finish_unary_fold_expr (tree expr, int op, tree_code dir)
> tree code = build_int_cstu (integer_type_node, abs (op));
> tree fold = build_min_nt_loc (UNKNOWN_LOCATION, dir, code, pack);
> FOLD_EXPR_MODIFY_P (fold) = (op < 0);
> + TREE_TYPE (fold) = build_dependent_operator_type (NULL_TREE,
> + FOLD_EXPR_OP (fold),
> + FOLD_EXPR_MODIFY_P (fold));
> return fold;
> }
>
> @@ -12154,6 +12161,9 @@ finish_binary_fold_expr (tree pack, tree init, int op, tree_code dir)
> tree code = build_int_cstu (integer_type_node, abs (op));
> tree fold = build_min_nt_loc (UNKNOWN_LOCATION, dir, code, pack, init);
> FOLD_EXPR_MODIFY_P (fold) = (op < 0);
> + TREE_TYPE (fold) = build_dependent_operator_type (NULL_TREE,
> + FOLD_EXPR_OP (fold),
> + FOLD_EXPR_MODIFY_P (fold));
> return fold;
> }
>
> diff --git a/gcc/cp/tree.c b/gcc/cp/tree.c
> index 284fb5f4b2a..29f3c171606 100644
> --- a/gcc/cp/tree.c
> +++ b/gcc/cp/tree.c
> @@ -5975,8 +5975,6 @@ cp_free_lang_data (tree t)
> DECL_EXTERNAL (t) = 1;
> TREE_STATIC (t) = 0;
> }
> - if (TREE_CODE (t) == FUNCTION_DECL)
> - discard_operator_bindings (t);
> if (TREE_CODE (t) == NAMESPACE_DECL)
> /* We do not need the leftover chaining of namespaces from the
> binding level. */
> diff --git a/gcc/cp/typeck.c b/gcc/cp/typeck.c
> index 4e60db40c76..d73c7fb6e33 100644
> --- a/gcc/cp/typeck.c
> +++ b/gcc/cp/typeck.c
> @@ -2602,6 +2602,7 @@ rationalize_conditional_expr (enum tree_code code, tree t,
> ? LE_EXPR : GE_EXPR),
> op0, TREE_CODE (op0),
> op1, TREE_CODE (op1),
> + NULL_TREE,
> /*overload=*/NULL,
> complain),
> cp_build_unary_op (code, op0, false, complain),
> @@ -3487,6 +3488,67 @@ build_ptrmemfunc_access_expr (tree ptrmem, tree member_name)
> return build_simple_component_ref (ptrmem, member);
> }
>
> +/* Return a TREE_LIST of namespace-scope overloads for the given operator,
> + and for any other relevant operator. */
> +
> +static tree
> +op_unqualified_lookup (tree_code code, bool is_assign)
> +{
> + tree lookups = NULL_TREE;
> +
> + if (cxx_dialect >= cxx20 && !is_assign)
> + {
> + if (code == NE_EXPR)
> + {
> + /* != can get rewritten in terms of ==. */
> + tree fnname = ovl_op_identifier (false, EQ_EXPR);
> + if (tree fns = lookup_name (fnname, LOOK_where::BLOCK_NAMESPACE))
> + lookups = tree_cons (fnname, fns, lookups);
> + }
> + else if (code == GT_EXPR || code == LE_EXPR
> + || code == LT_EXPR || code == GE_EXPR)
> + {
> + /* These can get rewritten in terms of <=>. */
> + tree fnname = ovl_op_identifier (false, SPACESHIP_EXPR);
> + if (tree fns = lookup_name (fnname, LOOK_where::BLOCK_NAMESPACE))
> + lookups = tree_cons (fnname, fns, lookups);
> + }
> + }
> +
> + tree fnname = ovl_op_identifier (is_assign, code);
> + if (tree fns = lookup_name (fnname, LOOK_where::BLOCK_NAMESPACE))
> + lookups = tree_cons (fnname, fns, lookups);
> +
> + if (lookups)
> + return lookups;
> + else
> + return build_tree_list (NULL_TREE, NULL_TREE);
> +}
> +
> +/* Create a DEPENDENT_OPERATOR_TYPE for a dependent operator expression of
> + the given operator. LOOKUPS, if non-NULL, is the result of phase 1
> + name lookup for the given operator. */
> +
> +tree
> +build_dependent_operator_type (tree lookups, tree_code code, bool is_assign)
> +{
> + if (lookups)
> + /* We're partially instantiating a dependent operator expression, and
> + LOOKUPS contains the result of phase 1 name lookup that we performed
> + earlier at template definition time, so just reuse the corresponding
> + DEPENDENT_OPERATOR_TYPE. */
> + return TREE_TYPE (lookups);
> +
> + /* Otherwise we're processing a dependent operator expression at template
> + definition time, so perform phase 1 name lookup now. */
> + lookups = op_unqualified_lookup (code, is_assign);
> +
> + tree type = cxx_make_type (DEPENDENT_OPERATOR_TYPE);
> + DEPENDENT_OPERATOR_TYPE_SAVED_LOOKUPS (type) = lookups;
> + TREE_TYPE (lookups) = type;
> + return type;
> +}
> +
> /* Given an expression PTR for a pointer, return an expression
> for the value pointed to.
> ERRORSTRING is the name of the operator to appear in error messages.
> @@ -3496,7 +3558,7 @@ build_ptrmemfunc_access_expr (tree ptrmem, tree member_name)
>
> tree
> build_x_indirect_ref (location_t loc, tree expr, ref_operator errorstring,
> - tsubst_flags_t complain)
> + tree lookups, tsubst_flags_t complain)
> {
> tree orig_expr = expr;
> tree rval;
> @@ -3516,12 +3578,18 @@ build_x_indirect_ref (location_t loc, tree expr, ref_operator errorstring,
> return build_min (INDIRECT_REF, TREE_TYPE (TREE_TYPE (expr)), expr);
> }
> if (type_dependent_expression_p (expr))
> - return build_min_nt_loc (loc, INDIRECT_REF, expr);
> + {
> + expr = build_min_nt_loc (loc, INDIRECT_REF, expr);
> + TREE_TYPE (expr)
> + = build_dependent_operator_type (lookups, INDIRECT_REF, false);
> + return expr;
> + }
> expr = build_non_dependent_expr (expr);
> }
>
> rval = build_new_op (loc, INDIRECT_REF, LOOKUP_NORMAL, expr,
> - NULL_TREE, NULL_TREE, &overload, complain);
> + NULL_TREE, NULL_TREE, lookups,
> + &overload, complain);
> if (!rval)
> rval = cp_build_indirect_ref (loc, expr, errorstring, complain);
>
> @@ -4458,8 +4526,8 @@ convert_arguments (tree typelist, vec<tree, va_gc> **values, tree fndecl,
> tree
> build_x_binary_op (const op_location_t &loc, enum tree_code code, tree arg1,
> enum tree_code arg1_code, tree arg2,
> - enum tree_code arg2_code, tree *overload_p,
> - tsubst_flags_t complain)
> + enum tree_code arg2_code, tree lookups,
> + tree *overload_p, tsubst_flags_t complain)
> {
> tree orig_arg1;
> tree orig_arg2;
> @@ -4475,7 +4543,8 @@ build_x_binary_op (const op_location_t &loc, enum tree_code code, tree arg1,
> || type_dependent_expression_p (arg2))
> {
> expr = build_min_nt_loc (loc, code, arg1, arg2);
> - maybe_save_operator_binding (expr);
> + TREE_TYPE (expr)
> + = build_dependent_operator_type (lookups, code, false);
> return expr;
> }
> arg1 = build_non_dependent_expr (arg1);
> @@ -4486,7 +4555,7 @@ build_x_binary_op (const op_location_t &loc, enum tree_code code, tree arg1,
> expr = build_m_component_ref (arg1, arg2, complain);
> else
> expr = build_new_op (loc, code, LOOKUP_NORMAL, arg1, arg2, NULL_TREE,
> - &overload, complain);
> + lookups, &overload, complain);
>
> if (overload_p != NULL)
> *overload_p = overload;
> @@ -4538,7 +4607,7 @@ build_x_array_ref (location_t loc, tree arg1, tree arg2,
> }
>
> expr = build_new_op (loc, ARRAY_REF, LOOKUP_NORMAL, arg1, arg2,
> - NULL_TREE, &overload, complain);
> + NULL_TREE, NULL_TREE, &overload, complain);
>
> if (processing_template_decl && expr != error_mark_node)
> {
> @@ -6402,7 +6471,7 @@ pointer_diff (location_t loc, tree op0, tree op1, tree ptrtype,
>
> tree
> build_x_unary_op (location_t loc, enum tree_code code, cp_expr xarg,
> - tsubst_flags_t complain)
> + tree lookups, tsubst_flags_t complain)
> {
> tree orig_expr = xarg;
> tree exp;
> @@ -6414,7 +6483,7 @@ build_x_unary_op (location_t loc, enum tree_code code, cp_expr xarg,
> if (type_dependent_expression_p (xarg))
> {
> tree e = build_min_nt_loc (loc, code, xarg.get_value (), NULL_TREE);
> - maybe_save_operator_binding (e);
> + TREE_TYPE (e) = build_dependent_operator_type (lookups, code, false);
> return e;
> }
>
> @@ -6439,7 +6508,7 @@ build_x_unary_op (location_t loc, enum tree_code code, cp_expr xarg,
> /* Don't look for a function. */;
> else
> exp = build_new_op (loc, code, LOOKUP_NORMAL, xarg, NULL_TREE,
> - NULL_TREE, &overload, complain);
> + NULL_TREE, lookups, &overload, complain);
>
> if (!exp && code == ADDR_EXPR)
> {
> @@ -7508,7 +7577,8 @@ build_x_compound_expr_from_list (tree list, expr_list_kind exp,
>
> for (list = TREE_CHAIN (list); list; list = TREE_CHAIN (list))
> expr = build_x_compound_expr (EXPR_LOCATION (TREE_VALUE (list)),
> - expr, TREE_VALUE (list), complain);
> + expr, TREE_VALUE (list), NULL_TREE,
> + complain);
> }
>
> return expr;
> @@ -7543,7 +7613,7 @@ build_x_compound_expr_from_vec (vec<tree, va_gc> *vec, const char *msg,
> expr = (*vec)[0];
> for (ix = 1; vec->iterate (ix, &t); ++ix)
> expr = build_x_compound_expr (EXPR_LOCATION (t), expr,
> - t, complain);
> + t, NULL_TREE, complain);
>
> return expr;
> }
> @@ -7553,7 +7623,7 @@ build_x_compound_expr_from_vec (vec<tree, va_gc> *vec, const char *msg,
>
> tree
> build_x_compound_expr (location_t loc, tree op1, tree op2,
> - tsubst_flags_t complain)
> + tree lookups, tsubst_flags_t complain)
> {
> tree result;
> tree orig_op1 = op1;
> @@ -7566,7 +7636,8 @@ build_x_compound_expr (location_t loc, tree op1, tree op2,
> || type_dependent_expression_p (op2))
> {
> result = build_min_nt_loc (loc, COMPOUND_EXPR, op1, op2);
> - maybe_save_operator_binding (result);
> + TREE_TYPE (result)
> + = build_dependent_operator_type (lookups, COMPOUND_EXPR, false);
> return result;
> }
> op1 = build_non_dependent_expr (op1);
> @@ -7574,7 +7645,7 @@ build_x_compound_expr (location_t loc, tree op1, tree op2,
> }
>
> result = build_new_op (loc, COMPOUND_EXPR, LOOKUP_NORMAL, op1, op2,
> - NULL_TREE, &overload, complain);
> + NULL_TREE, lookups, &overload, complain);
> if (!result)
> result = cp_build_compound_expr (op1, op2, complain);
>
> @@ -9017,8 +9088,8 @@ cp_build_modify_expr (location_t loc, tree lhs, enum tree_code modifycode,
> {
> result = build_new_op (input_location, MODIFY_EXPR,
> LOOKUP_NORMAL, lhs, rhs,
> - make_node (NOP_EXPR), /*overload=*/NULL,
> - complain);
> + make_node (NOP_EXPR), NULL_TREE,
> + /*overload=*/NULL, complain);
> if (result == NULL_TREE)
> return error_mark_node;
> goto ret;
> @@ -9233,7 +9304,7 @@ cp_build_modify_expr (location_t loc, tree lhs, enum tree_code modifycode,
>
> cp_expr
> build_x_modify_expr (location_t loc, tree lhs, enum tree_code modifycode,
> - tree rhs, tsubst_flags_t complain)
> + tree rhs, tree lookups, tsubst_flags_t complain)
> {
> tree orig_lhs = lhs;
> tree orig_rhs = rhs;
> @@ -9250,7 +9321,9 @@ build_x_modify_expr (location_t loc, tree lhs, enum tree_code modifycode,
> {
> tree op = build_min_nt_loc (loc, modifycode, NULL_TREE, NULL_TREE);
> tree rval = build_min_nt_loc (loc, MODOP_EXPR, lhs, op, rhs);
> - maybe_save_operator_binding (rval);
> + if (modifycode != NOP_EXPR)
> + TREE_TYPE (rval)
> + = build_dependent_operator_type (lookups, modifycode, true);
> return rval;
> }
>
> @@ -9262,7 +9335,7 @@ build_x_modify_expr (location_t loc, tree lhs, enum tree_code modifycode,
> {
> tree op = build_nt (modifycode, NULL_TREE, NULL_TREE);
> tree rval = build_new_op (loc, MODIFY_EXPR, LOOKUP_NORMAL,
> - lhs, rhs, op, &overload, complain);
> + lhs, rhs, op, lookups, &overload, complain);
> if (rval)
> {
> if (rval == error_mark_node)
> diff --git a/gcc/cp/typeck2.c b/gcc/cp/typeck2.c
> index 3fb651a02ba..724684c0457 100644
> --- a/gcc/cp/typeck2.c
> +++ b/gcc/cp/typeck2.c
> @@ -1956,7 +1956,7 @@ build_x_arrow (location_t loc, tree expr, tsubst_flags_t complain)
>
> while ((expr = build_new_op (loc, COMPONENT_REF,
> LOOKUP_NORMAL, expr, NULL_TREE, NULL_TREE,
> - &fn, complain)))
> + NULL_TREE, &fn, complain)))
> {
> if (expr == error_mark_node)
> return error_mark_node;
> diff --git a/gcc/testsuite/g++.dg/lookup/operator-3-ops.h b/gcc/testsuite/g++.dg/lookup/operator-3-ops.h
> new file mode 100644
> index 00000000000..fbd242a4e66
> --- /dev/null
> +++ b/gcc/testsuite/g++.dg/lookup/operator-3-ops.h
> @@ -0,0 +1,53 @@
> +void operator+(N::A);
> +void operator-(N::A);
> +void operator*(N::A);
> +void operator~(N::A);
> +#if __cplusplus >= 201103L
> +void operator&(N::A) = delete;
> +#else
> +void operator&(N::A);
> +#endif
> +void operator!(N::A);
> +void operator++(N::A);
> +void operator--(N::A);
> +void operator++(N::A, int);
> +void operator--(N::A, int);
> +
> +void operator->*(N::A, N::A);
> +void operator/(N::A, N::A);
> +void operator*(N::A, N::A);
> +void operator+(N::A, N::A);
> +void operator-(N::A, N::A);
> +void operator%(N::A, N::A);
> +void operator&(N::A, N::A);
> +void operator|(N::A, N::A);
> +void operator^(N::A, N::A);
> +void operator<<(N::A, N::A);
> +void operator>>(N::A, N::A);
> +void operator&&(N::A, N::A);
> +void operator||(N::A, N::A);
> +#if __cplusplus >= 201103L
> +void operator,(N::A, N::A) = delete;
> +#else
> +void operator,(N::A, N::A);
> +#endif
> +
> +void operator==(N::A, N::A);
> +void operator!=(N::A, N::A);
> +void operator<(N::A, N::A);
> +void operator>(N::A, N::A);
> +void operator<=(N::A, N::A);
> +void operator>=(N::A, N::A);
> +#if __cplusplus > 201703L
> +void operator<=>(N::A, N::A);
> +#endif
> +
> +void operator+=(N::A, N::A);
> +void operator-=(N::A, N::A);
> +void operator*=(N::A, N::A);
> +void operator/=(N::A, N::A);
> +void operator%=(N::A, N::A);
> +void operator|=(N::A, N::A);
> +void operator^=(N::A, N::A);
> +void operator<<=(N::A, N::A);
> +void operator>>=(N::A, N::A);
> diff --git a/gcc/testsuite/g++.dg/lookup/operator-3.C b/gcc/testsuite/g++.dg/lookup/operator-3.C
> index bc5eb3d6693..98011efd543 100644
> --- a/gcc/testsuite/g++.dg/lookup/operator-3.C
> +++ b/gcc/testsuite/g++.dg/lookup/operator-3.C
> @@ -1,4 +1,6 @@
> // PR c++/51577
> +// Verify we don't consider later-declared namespace-scope operator overloads
> +// when instantiating a dependent operator expression at block scope.
>
> template <class T> void f (T x) {
> +x; // { dg-error "no match" }
> @@ -50,59 +52,7 @@ template <class T> void f (T x) {
>
> namespace N { struct A { }; }
>
> -void operator+(N::A);
> -void operator-(N::A);
> -void operator*(N::A);
> -void operator~(N::A);
> -#if __cplusplus >= 201103L
> -void operator&(N::A) = delete;
> -#else
> -void operator&(N::A);
> -#endif
> -void operator!(N::A);
> -void operator++(N::A);
> -void operator--(N::A);
> -void operator++(N::A, int);
> -void operator--(N::A, int);
> -
> -void operator->*(N::A, N::A);
> -void operator/(N::A, N::A);
> -void operator*(N::A, N::A);
> -void operator+(N::A, N::A);
> -void operator-(N::A, N::A);
> -void operator%(N::A, N::A);
> -void operator&(N::A, N::A);
> -void operator|(N::A, N::A);
> -void operator^(N::A, N::A);
> -void operator<<(N::A, N::A);
> -void operator>>(N::A, N::A);
> -void operator&&(N::A, N::A);
> -void operator||(N::A, N::A);
> -#if __cplusplus >= 201103L
> -void operator,(N::A, N::A) = delete;
> -#else
> -void operator,(N::A, N::A);
> -#endif
> -
> -void operator==(N::A, N::A);
> -void operator!=(N::A, N::A);
> -void operator<(N::A, N::A);
> -void operator>(N::A, N::A);
> -void operator<=(N::A, N::A);
> -void operator>=(N::A, N::A);
> -#if __cplusplus > 201703L
> -void operator<=>(N::A, N::A);
> -#endif
> -
> -void operator+=(N::A, N::A);
> -void operator-=(N::A, N::A);
> -void operator*=(N::A, N::A);
> -void operator/=(N::A, N::A);
> -void operator%=(N::A, N::A);
> -void operator|=(N::A, N::A);
> -void operator^=(N::A, N::A);
> -void operator<<=(N::A, N::A);
> -void operator>>=(N::A, N::A);
> +#include "operator-3-ops.h"
>
> int main() {
> f(N::A());
> diff --git a/gcc/testsuite/g++.dg/lookup/operator-3a.C b/gcc/testsuite/g++.dg/lookup/operator-3a.C
> new file mode 100644
> index 00000000000..62ae5c36dc2
> --- /dev/null
> +++ b/gcc/testsuite/g++.dg/lookup/operator-3a.C
> @@ -0,0 +1,61 @@
> +// PR c++/51577
> +// { dg-do compile { target c++14 } }
> +// Like operator-3.C but also containing a partial instantiation step.
> +
> +template <class...> auto f () {
> + return [] (auto x) {
> + +x; // { dg-error "no match" }
> + -x; // { dg-error "no match" }
> + *x; // { dg-error "no match" }
> + ~x; // { dg-error "no match" }
> + &x;
> + !x; // { dg-error "no match" }
> + ++x; // { dg-error "no match" }
> + --x; // { dg-error "no match" }
> + x++; // { dg-error "declared for postfix" }
> + x--; // { dg-error "declared for postfix" }
> +
> + x->*x; // { dg-error "no match" }
> + x / x; // { dg-error "no match" }
> + x * x; // { dg-error "no match" }
> + x + x; // { dg-error "no match" }
> + x - x; // { dg-error "no match" }
> + x % x; // { dg-error "no match" }
> + x & x; // { dg-error "no match" }
> + x | x; // { dg-error "no match" }
> + x ^ x; // { dg-error "no match" }
> + x << x; // { dg-error "no match" }
> + x >> x; // { dg-error "no match" }
> + x && x; // { dg-error "no match" }
> + x || x; // { dg-error "no match" }
> + x, x;
> +
> + x == x; // { dg-error "no match" }
> + x != x; // { dg-error "no match" }
> + x < x; // { dg-error "no match" }
> + x > x; // { dg-error "no match" }
> + x <= x; // { dg-error "no match" }
> + x >= x; // { dg-error "no match" }
> +#if __cplusplus > 201703L
> + x <=> x; // { dg-error "no match" "" { target c++20 } }
> +#endif
> +
> + x += x; // { dg-error "no match" }
> + x -= x; // { dg-error "no match" }
> + x *= x; // { dg-error "no match" }
> + x /= x; // { dg-error "no match" }
> + x %= x; // { dg-error "no match" }
> + x |= x; // { dg-error "no match" }
> + x ^= x; // { dg-error "no match" }
> + x <<= x; // { dg-error "no match" }
> + x >>= x; // { dg-error "no match" }
> + };
> +}
> +
> +namespace N { struct A { }; }
> +
> +#include "operator-3-ops.h"
> +
> +int main() {
> + f()(N::A());
> +}
> diff --git a/gcc/testsuite/g++.dg/lookup/operator-4.C b/gcc/testsuite/g++.dg/lookup/operator-4.C
> new file mode 100644
> index 00000000000..e0b80a1c3b3
> --- /dev/null
> +++ b/gcc/testsuite/g++.dg/lookup/operator-4.C
> @@ -0,0 +1,74 @@
> +// PR c++/51577
> +// { dg-do compile { target c++17 } }
> +// Like operator-3.C but for unary fold expressions.
> +
> +template <class... Ts> void f (Ts... xs) {
> + (xs->*...); // { dg-error "no match" }
> + (...->*xs); // { dg-error "no match" }
> + (xs / ...); // { dg-error "no match" }
> + (... / xs); // { dg-error "no match" }
> + (xs * ...); // { dg-error "no match" }
> + (... * xs); // { dg-error "no match" }
> + (xs + ...); // { dg-error "no match" }
> + (... + xs); // { dg-error "no match" }
> + (xs - ...); // { dg-error "no match" }
> + (... - xs); // { dg-error "no match" }
> + (xs % ...); // { dg-error "no match" }
> + (... % xs); // { dg-error "no match" }
> + (xs & ...); // { dg-error "no match" }
> + (... & xs); // { dg-error "no match" }
> + (xs | ...); // { dg-error "no match" }
> + (... | xs); // { dg-error "no match" }
> + (xs ^ ...); // { dg-error "no match" }
> + (... ^ xs); // { dg-error "no match" }
> + (xs << ...); // { dg-error "no match" }
> + (... << xs); // { dg-error "no match" }
> + (xs >> ...); // { dg-error "no match" }
> + (... >> xs); // { dg-error "no match" }
> + (xs && ...); // { dg-error "no match" }
> + (... && xs); // { dg-error "no match" }
> + (xs || ...); // { dg-error "no match" }
> + (... || xs); // { dg-error "no match" }
> + (xs, ...);
> + (..., xs);
> +
> + (xs == ...); // { dg-error "no match" }
> + (... == xs); // { dg-error "no match" }
> + (xs != ...); // { dg-error "no match" }
> + (... != xs); // { dg-error "no match" }
> + (xs < ...); // { dg-error "no match" }
> + (... < xs); // { dg-error "no match" }
> + (xs > ...); // { dg-error "no match" }
> + (... > xs); // { dg-error "no match" }
> + (xs <= ...); // { dg-error "no match" }
> + (... <= xs); // { dg-error "no match" }
> + (xs >= ...); // { dg-error "no match" }
> + (... >= xs); // { dg-error "no match" }
> +
> + (xs += ...); // { dg-error "no match" }
> + (... += xs); // { dg-error "no match" }
> + (xs -= ...); // { dg-error "no match" }
> + (... -= xs); // { dg-error "no match" }
> + (xs *= ...); // { dg-error "no match" }
> + (... *= xs); // { dg-error "no match" }
> + (xs /= ...); // { dg-error "no match" }
> + (... /= xs); // { dg-error "no match" }
> + (xs %= ...); // { dg-error "no match" }
> + (... %= xs); // { dg-error "no match" }
> + (xs |= ...); // { dg-error "no match" }
> + (... |= xs); // { dg-error "no match" }
> + (xs ^= ...); // { dg-error "no match" }
> + (... ^= xs); // { dg-error "no match" }
> + (xs <<= ...); // { dg-error "no match" }
> + (... <<= xs); // { dg-error "no match" }
> + (xs >>= ...); // { dg-error "no match" }
> + (... >>= xs); // { dg-error "no match" }
> +}
> +
> +namespace N { struct A { }; }
> +
> +#include "operator-3-ops.h"
> +
> +int main() {
> + f(N::A(), N::A());
> +}
> diff --git a/gcc/testsuite/g++.dg/lookup/operator-4a.C b/gcc/testsuite/g++.dg/lookup/operator-4a.C
> new file mode 100644
> index 00000000000..b4a3f947b05
> --- /dev/null
> +++ b/gcc/testsuite/g++.dg/lookup/operator-4a.C
> @@ -0,0 +1,76 @@
> +// PR c++/51577
> +// { dg-do compile { target c++17 } }
> +// Like operator-4.C but also containing a partial instantiation step.
> +
> +template <class...> auto f () {
> + return [] (auto... xs) {
> + (xs->*...); // { dg-error "no match" }
> + (...->*xs); // { dg-error "no match" }
> + (xs / ...); // { dg-error "no match" }
> + (... / xs); // { dg-error "no match" }
> + (xs * ...); // { dg-error "no match" }
> + (... * xs); // { dg-error "no match" }
> + (xs + ...); // { dg-error "no match" }
> + (... + xs); // { dg-error "no match" }
> + (xs - ...); // { dg-error "no match" }
> + (... - xs); // { dg-error "no match" }
> + (xs % ...); // { dg-error "no match" }
> + (... % xs); // { dg-error "no match" }
> + (xs & ...); // { dg-error "no match" }
> + (... & xs); // { dg-error "no match" }
> + (xs | ...); // { dg-error "no match" }
> + (... | xs); // { dg-error "no match" }
> + (xs ^ ...); // { dg-error "no match" }
> + (... ^ xs); // { dg-error "no match" }
> + (xs << ...); // { dg-error "no match" }
> + (... << xs); // { dg-error "no match" }
> + (xs >> ...); // { dg-error "no match" }
> + (... >> xs); // { dg-error "no match" }
> + (xs && ...); // { dg-error "no match" }
> + (... && xs); // { dg-error "no match" }
> + (xs || ...); // { dg-error "no match" }
> + (... || xs); // { dg-error "no match" }
> + (xs, ...);
> + (..., xs);
> +
> + (xs == ...); // { dg-error "no match" }
> + (... == xs); // { dg-error "no match" }
> + (xs != ...); // { dg-error "no match" }
> + (... != xs); // { dg-error "no match" }
> + (xs < ...); // { dg-error "no match" }
> + (... < xs); // { dg-error "no match" }
> + (xs > ...); // { dg-error "no match" }
> + (... > xs); // { dg-error "no match" }
> + (xs <= ...); // { dg-error "no match" }
> + (... <= xs); // { dg-error "no match" }
> + (xs >= ...); // { dg-error "no match" }
> + (... >= xs); // { dg-error "no match" }
> +
> + (xs += ...); // { dg-error "no match" }
> + (... += xs); // { dg-error "no match" }
> + (xs -= ...); // { dg-error "no match" }
> + (... -= xs); // { dg-error "no match" }
> + (xs *= ...); // { dg-error "no match" }
> + (... *= xs); // { dg-error "no match" }
> + (xs /= ...); // { dg-error "no match" }
> + (... /= xs); // { dg-error "no match" }
> + (xs %= ...); // { dg-error "no match" }
> + (... %= xs); // { dg-error "no match" }
> + (xs |= ...); // { dg-error "no match" }
> + (... |= xs); // { dg-error "no match" }
> + (xs ^= ...); // { dg-error "no match" }
> + (... ^= xs); // { dg-error "no match" }
> + (xs <<= ...); // { dg-error "no match" }
> + (... <<= xs); // { dg-error "no match" }
> + (xs >>= ...); // { dg-error "no match" }
> + (... >>= xs); // { dg-error "no match" }
> + };
> +}
> +
> +namespace N { struct A { }; }
> +
> +#include "operator-3-ops.h"
> +
> +int main() {
> + f()(N::A(), N::A());
> +}
> diff --git a/gcc/testsuite/g++.dg/lookup/operator-5.C b/gcc/testsuite/g++.dg/lookup/operator-5.C
> new file mode 100644
> index 00000000000..2bbb2c41618
> --- /dev/null
> +++ b/gcc/testsuite/g++.dg/lookup/operator-5.C
> @@ -0,0 +1,74 @@
> +// PR c++/51577
> +// { dg-do compile { target c++17 } }
> +// Like operator-4.C but for binary fold expressions.
> +
> +namespace N { struct A { }; }
> +
> +template <class... Ts> void f (Ts... xs) {
> + (xs->*...->*N::A{}); // { dg-error "no match" }
> + (N::A{}->*...->*xs); // { dg-error "no match" }
> + (xs / ... / N::A{}); // { dg-error "no match" }
> + (N::A{} / ... / xs); // { dg-error "no match" }
> + (xs * ... * N::A{}); // { dg-error "no match" }
> + (N::A{} * ... * xs); // { dg-error "no match" }
> + (xs + ... + N::A{}); // { dg-error "no match" }
> + (N::A{} + ... + xs); // { dg-error "no match" }
> + (xs - ... - N::A{}); // { dg-error "no match" }
> + (N::A{} - ... - xs); // { dg-error "no match" }
> + (xs % ... % N::A{}); // { dg-error "no match" }
> + (N::A{} % ... % xs); // { dg-error "no match" }
> + (xs & ... & N::A{}); // { dg-error "no match" }
> + (N::A{} & ... & xs); // { dg-error "no match" }
> + (xs | ... | N::A{}); // { dg-error "no match" }
> + (N::A{} | ... | xs); // { dg-error "no match" }
> + (xs ^ ... ^ N::A{}); // { dg-error "no match" }
> + (N::A{} ^ ... ^ xs); // { dg-error "no match" }
> + (xs << ... << N::A{}); // { dg-error "no match" }
> + (N::A{} << ... << xs); // { dg-error "no match" }
> + (xs >> ... >> N::A{}); // { dg-error "no match" }
> + (N::A{} >> ... >> xs); // { dg-error "no match" }
> + (xs && ... && N::A{}); // { dg-error "no match" }
> + (N::A{} && ... && xs); // { dg-error "no match" }
> + (xs || ... || N::A{}); // { dg-error "no match" }
> + (N::A{} || ... || xs); // { dg-error "no match" }
> + (xs , ... , N::A{});
> + (N::A{} , ... , xs);
> +
> + (xs == ... == N::A{}); // { dg-error "no match" }
> + (N::A{} == ... == xs); // { dg-error "no match" }
> + (xs != ... != N::A{}); // { dg-error "no match" }
> + (N::A{} != ... != xs); // { dg-error "no match" }
> + (xs < ... < N::A{}); // { dg-error "no match" }
> + (N::A{} < ... < xs); // { dg-error "no match" }
> + (xs > ... > N::A{}); // { dg-error "no match" }
> + (N::A{} > ... > xs); // { dg-error "no match" }
> + (xs <= ... <= N::A{}); // { dg-error "no match" }
> + (N::A{} <= ... <= xs); // { dg-error "no match" }
> + (xs >= ... >= N::A{}); // { dg-error "no match" }
> + (N::A{} >= ... >= xs); // { dg-error "no match" }
> +
> + (xs += ... += N::A{}); // { dg-error "no match" }
> + (N::A{} += ... += xs); // { dg-error "no match" }
> + (xs -= ... -= N::A{}); // { dg-error "no match" }
> + (N::A{} -= ... -= xs); // { dg-error "no match" }
> + (xs *= ... *= N::A{}); // { dg-error "no match" }
> + (N::A{} *= ... *= xs); // { dg-error "no match" }
> + (xs /= ... /= N::A{}); // { dg-error "no match" }
> + (N::A{} /= ... /= xs); // { dg-error "no match" }
> + (xs %= ... %= N::A{}); // { dg-error "no match" }
> + (N::A{} %= ... %= xs); // { dg-error "no match" }
> + (xs |= ... |= N::A{}); // { dg-error "no match" }
> + (N::A{} |= ... |= xs); // { dg-error "no match" }
> + (xs ^= ... ^= N::A{}); // { dg-error "no match" }
> + (N::A{} ^= ... ^= xs); // { dg-error "no match" }
> + (xs <<= ... <<= N::A{}); // { dg-error "no match" }
> + (N::A{} <<= ... <<= xs); // { dg-error "no match" }
> + (xs >>= ... >>= N::A{}); // { dg-error "no match" }
> + (N::A{} >>= ... >>= xs); // { dg-error "no match" }
> +}
> +
> +#include "operator-3-ops.h"
> +
> +int main() {
> + f(N::A());
> +}
> diff --git a/gcc/testsuite/g++.dg/lookup/operator-5a.C b/gcc/testsuite/g++.dg/lookup/operator-5a.C
> new file mode 100644
> index 00000000000..6f9ecd65a50
> --- /dev/null
> +++ b/gcc/testsuite/g++.dg/lookup/operator-5a.C
> @@ -0,0 +1,76 @@
> +// PR c++/51577
> +// { dg-do compile { target c++17 } }
> +// Like operator-5.C but also containing a partial instantiation step.
> +
> +namespace N { struct A { }; }
> +
> +template <class...> auto f () {
> + return [] (auto... xs) {
> + (xs->*...->*N::A{}); // { dg-error "no match" }
> + (N::A{}->*...->*xs); // { dg-error "no match" }
> + (xs / ... / N::A{}); // { dg-error "no match" }
> + (N::A{} / ... / xs); // { dg-error "no match" }
> + (xs * ... * N::A{}); // { dg-error "no match" }
> + (N::A{} * ... * xs); // { dg-error "no match" }
> + (xs + ... + N::A{}); // { dg-error "no match" }
> + (N::A{} + ... + xs); // { dg-error "no match" }
> + (xs - ... - N::A{}); // { dg-error "no match" }
> + (N::A{} - ... - xs); // { dg-error "no match" }
> + (xs % ... % N::A{}); // { dg-error "no match" }
> + (N::A{} % ... % xs); // { dg-error "no match" }
> + (xs & ... & N::A{}); // { dg-error "no match" }
> + (N::A{} & ... & xs); // { dg-error "no match" }
> + (xs | ... | N::A{}); // { dg-error "no match" }
> + (N::A{} | ... | xs); // { dg-error "no match" }
> + (xs ^ ... ^ N::A{}); // { dg-error "no match" }
> + (N::A{} ^ ... ^ xs); // { dg-error "no match" }
> + (xs << ... << N::A{}); // { dg-error "no match" }
> + (N::A{} << ... << xs); // { dg-error "no match" }
> + (xs >> ... >> N::A{}); // { dg-error "no match" }
> + (N::A{} >> ... >> xs); // { dg-error "no match" }
> + (xs && ... && N::A{}); // { dg-error "no match" }
> + (N::A{} && ... && xs); // { dg-error "no match" }
> + (xs || ... || N::A{}); // { dg-error "no match" }
> + (N::A{} || ... || xs); // { dg-error "no match" }
> + (xs , ... , N::A{});
> + (N::A{} , ... , xs);
> +
> + (xs == ... == N::A{}); // { dg-error "no match" }
> + (N::A{} == ... == xs); // { dg-error "no match" }
> + (xs != ... != N::A{}); // { dg-error "no match" }
> + (N::A{} != ... != xs); // { dg-error "no match" }
> + (xs < ... < N::A{}); // { dg-error "no match" }
> + (N::A{} < ... < xs); // { dg-error "no match" }
> + (xs > ... > N::A{}); // { dg-error "no match" }
> + (N::A{} > ... > xs); // { dg-error "no match" }
> + (xs <= ... <= N::A{}); // { dg-error "no match" }
> + (N::A{} <= ... <= xs); // { dg-error "no match" }
> + (xs >= ... >= N::A{}); // { dg-error "no match" }
> + (N::A{} >= ... >= xs); // { dg-error "no match" }
> +
> + (xs += ... += N::A{}); // { dg-error "no match" }
> + (N::A{} += ... += xs); // { dg-error "no match" }
> + (xs -= ... -= N::A{}); // { dg-error "no match" }
> + (N::A{} -= ... -= xs); // { dg-error "no match" }
> + (xs *= ... *= N::A{}); // { dg-error "no match" }
> + (N::A{} *= ... *= xs); // { dg-error "no match" }
> + (xs /= ... /= N::A{}); // { dg-error "no match" }
> + (N::A{} /= ... /= xs); // { dg-error "no match" }
> + (xs %= ... %= N::A{}); // { dg-error "no match" }
> + (N::A{} %= ... %= xs); // { dg-error "no match" }
> + (xs |= ... |= N::A{}); // { dg-error "no match" }
> + (N::A{} |= ... |= xs); // { dg-error "no match" }
> + (xs ^= ... ^= N::A{}); // { dg-error "no match" }
> + (N::A{} ^= ... ^= xs); // { dg-error "no match" }
> + (xs <<= ... <<= N::A{}); // { dg-error "no match" }
> + (N::A{} <<= ... <<= xs); // { dg-error "no match" }
> + (xs >>= ... >>= N::A{}); // { dg-error "no match" }
> + (N::A{} >>= ... >>= xs); // { dg-error "no match" }
> + };
> +}
> +
> +#include "operator-3-ops.h"
> +
> +int main() {
> + f()(N::A());
> +}
> diff --git a/gcc/testsuite/g++.dg/lookup/operator-6.C b/gcc/testsuite/g++.dg/lookup/operator-6.C
> new file mode 100644
> index 00000000000..b59c137226a
> --- /dev/null
> +++ b/gcc/testsuite/g++.dg/lookup/operator-6.C
> @@ -0,0 +1,59 @@
> +// PR c++/83035
> +// { dg-do compile { target c++11 } }
> +// Like operator-3.C but where the lookup occurs at non-block scope.
> +
> +template<class T, class = void> struct S {
> + static constexpr bool is_primary = true;
> +};
> +
> +template<class T> struct S<T, decltype(+T())> { };
> +template<class T> struct S<T, decltype(-T())> { };
> +template<class T> struct S<T, decltype(*T())> { };
> +template<class T> struct S<T, decltype(~T())> { };
> +template<class T> struct S<T, decltype(&T())> { };
> +template<class T> struct S<T, decltype(!T())> { };
> +template<class T> struct S<T, decltype(++T())> { };
> +template<class T> struct S<T, decltype(--T())> { };
> +template<class T> struct S<T, decltype(T()++)> { };
> +template<class T> struct S<T, decltype(T()--)> { };
> +
> +template<class T> struct S<T, decltype(T()->*T())> { };
> +template<class T> struct S<T, decltype(T() / T())> { };
> +template<class T> struct S<T, decltype(T() * T())> { };
> +template<class T> struct S<T, decltype(T() + T())> { };
> +template<class T> struct S<T, decltype(T() - T())> { };
> +template<class T> struct S<T, decltype(T() % T())> { };
> +template<class T> struct S<T, decltype(T() & T())> { };
> +template<class T> struct S<T, decltype(T() | T())> { };
> +template<class T> struct S<T, decltype(T() ^ T())> { };
> +template<class T> struct S<T, decltype(T() << T())> { };
> +template<class T> struct S<T, decltype(T() >> T())> { };
> +template<class T> struct S<T, decltype(T() && T())> { };
> +template<class T> struct S<T, decltype(T() || T())> { };
> +template<class T> struct S<T, decltype(T(), T())> { };
> +
> +template<class T> struct S<T, decltype(T() == T())> { };
> +template<class T> struct S<T, decltype(T() != T())> { };
> +template<class T> struct S<T, decltype(T() < T())> { };
> +template<class T> struct S<T, decltype(T() > T())> { };
> +template<class T> struct S<T, decltype(T() <= T())> { };
> +template<class T> struct S<T, decltype(T() >= T())> { };
> +#if __cplusplus > 201703L
> +template<class T> struct S<T, decltype(T() <=> T())> { };
> +#endif
> +
> +template<class T> struct S<T, decltype(T() += T())> { };
> +template<class T> struct S<T, decltype(T() -= T())> { };
> +template<class T> struct S<T, decltype(T() *= T())> { };
> +template<class T> struct S<T, decltype(T() /= T())> { };
> +template<class T> struct S<T, decltype(T() %= T())> { };
> +template<class T> struct S<T, decltype(T() |= T())> { };
> +template<class T> struct S<T, decltype(T() ^= T())> { };
> +template<class T> struct S<T, decltype(T() <<= T())> { };
> +template<class T> struct S<T, decltype(T() >>= T())> { };
> +
> +namespace N { struct A { }; }
> +
> +#include "operator-3-ops.h"
> +
> +static_assert(S<N::A>::is_primary, "");
> diff --git a/gcc/testsuite/g++.dg/lookup/operator-7.C b/gcc/testsuite/g++.dg/lookup/operator-7.C
> new file mode 100644
> index 00000000000..546fcb0a526
> --- /dev/null
> +++ b/gcc/testsuite/g++.dg/lookup/operator-7.C
> @@ -0,0 +1,27 @@
> +// PR c++/100465
> +
> +namespace N
> +{
> + struct string
> + {
> + template<typename T>
> + void operator+=(T);
> + };
> +
> + struct A {
> + void operator+=(char); // #1
> +
> + template<typename T>
> + void f() {
> + string s;
> + s += T();
> + }
> +
> + void g() {
> + f<char>();
> + }
> + };
> +} // namespace N
> +
> +template<typename T>
> +void operator+=(N::string, T);
> diff --git a/gcc/testsuite/g++.dg/lookup/operator-8.C b/gcc/testsuite/g++.dg/lookup/operator-8.C
> new file mode 100644
> index 00000000000..01adff963dc
> --- /dev/null
> +++ b/gcc/testsuite/g++.dg/lookup/operator-8.C
> @@ -0,0 +1,34 @@
> +// Verify phase 1 lookup works properly for rewritten non-dependent conditional
> +// operator expressions.
> +
> +// This test currently fails due to build_min_non_dep_op_overload not knowing
> +// how to handle rewritten operator expressions; see the FIXME in build_new_op.
> +
> +// { dg-do compile { target c++20 } }
> +
> +#include <compare>
> +
> +struct A {
> + bool operator==(int);
> + std::strong_ordering operator<=>(int);
> +};
> +
> +template<class T>
> +void f() {
> + A a;
> + (void)(a != 0, 0 != a); // { dg-bogus "deleted" "" { xfail *-*-* } }
> + (void)(a < 0, 0 < a); // { dg-bogus "deleted" "" { xfail *-*-* } }
> + (void)(a <= 0, 0 <= a); // { dg-bogus "deleted" "" { xfail *-*-* } }
> + (void)(a > 0, 0 > a); // { dg-bogus "deleted" "" { xfail *-*-* } }
> + (void)(a >= 0, 0 >= a); // { dg-bogus "deleted" "" { xfail *-*-* } }
> +}
> +
> +// These later-declared namespace-scope functions shouldn't be considered
> +// during instantiation of f<int>.
> +bool operator!=(A, int) = delete;
> +bool operator<(A, int) = delete;
> +bool operator<=(A, int) = delete;
> +bool operator>(A, int) = delete;
> +bool operator>=(A, int) = delete;
> +
> +template void f<int>();
> diff --git a/libcc1/libcp1plugin.cc b/libcc1/libcp1plugin.cc
> index ea6ee553401..fccdce6ad47 100644
> --- a/libcc1/libcp1plugin.cc
> +++ b/libcc1/libcp1plugin.cc
> @@ -2669,7 +2669,7 @@ plugin_build_unary_expr (cc1_plugin::connection *self,
> break;
>
> default:
> - result = build_x_unary_op (/*loc=*/0, opcode, op0, tf_error);
> + result = build_x_unary_op (/*loc=*/0, opcode, op0, NULL_TREE, tf_error);
> break;
> }
>
> @@ -2794,7 +2794,7 @@ plugin_build_binary_expr (cc1_plugin::connection *self,
>
> default:
> result = build_x_binary_op (/*loc=*/0, opcode, op0, ERROR_MARK,
> - op1, ERROR_MARK, NULL, tf_error);
> + op1, ERROR_MARK, NULL_TREE, NULL, tf_error);
> break;
> }
>
prev parent reply other threads:[~2021-12-16 3:30 UTC|newest]
Thread overview: 4+ messages / expand[flat|nested] mbox.gz Atom feed top
2021-12-10 14:53 Patrick Palka
2021-12-15 20:59 ` Jason Merrill
2021-12-15 22:53 ` Patrick Palka
2021-12-16 3:30 ` Jason Merrill [this message]
Reply instructions:
You may reply publicly to this message via plain-text email
using any one of the following methods:
* Save the following mbox file, import it into your mail client,
and reply-to-all from there: mbox
Avoid top-posting and favor interleaved quoting:
https://en.wikipedia.org/wiki/Posting_style#Interleaved_style
* Reply using the --to, --cc, and --in-reply-to
switches of git-send-email(1):
git send-email \
--in-reply-to=e05e889e-b319-8500-7fc7-a47f10c204ec@redhat.com \
--to=jason@redhat.com \
--cc=gcc-patches@gcc.gnu.org \
--cc=ppalka@redhat.com \
/path/to/YOUR_REPLY
https://kernel.org/pub/software/scm/git/docs/git-send-email.html
* If your mail client supports setting the In-Reply-To header
via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line
before the message body.
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for read-only IMAP folder(s) and NNTP newsgroup(s).