EricWF added inline comments.
================
Comment at: lib/Sema/SemaOverload.cpp:9218-9219
+ // --- F2 is a rewritten candidate ([over.match.oper]) and F1 is not.
+ if (Cand2.getRewrittenKind() && !Cand1.getRewrittenKind())
+ return true;
+ if (Cand1.getRewrittenKind() && Cand2.getRewrittenKind() &&
----------------
rsmith wrote:
> EricWF wrote:
> > EricWF wrote:
> > > EricWF wrote:
> > > > rsmith wrote:
> > > > > You also need to check the reverse condition and return false (the
> > > > > "or if not that" is ... somehow ... supposed to imply that).
> > > > Hmm. So I'm wondering what is intended by the language `F1 and F2 are
> > > > rewritten candidates, and F2 is a synthesized candidate with reversed
> > > > order of parameters and F1 is not`. For example, what happens when
> > > > comparing two distinct member functions with only one explicit
> > > > parameter?
> > > >
> > > > ```
> > > > struct T;
> > > > struct U { auto operator<=>(T); };
> > > > struct T { auto operator<=>(U); };
> > > > auto r = T{} < U{}; // Are the synthesized and rewritten overloads
> > > > ambiguous?
> > > > ```
> > > And what about
> > >
> > > ```
> > > struct U {};
> > > struct T { auto operator<=>(U); };
> > > auto operator<=>(U, T);
> > > auto r = T{} < U{};
> > > ```
> > Nevermind. I found the language. The implicit object parameter isn't
> > considered in this case.
> The parameters in scope in this rule are the parameters for the purpose of
> overload resolution, which include the implicit object parameter for a member
> function.
>
> In your first example, both candidates have implicit conversion sequences
> with Exact Match rank for both parameters (and none of the ordering special
> cases apply), so we fall down to this tie-breaker and it selects the
> `T::operator<=>(U)` candidate, unless I'm missing something.
>
> Your second example appears to receive the same treatment.
Alright. So I found the wrong language.
I think my first case meant to have `const &` parameters and `const` methods.
That way the implicit object parameter type matched the reversed parameter
type. The second example was meant to demonstrate the case where the implicit
object parameter type doesn't match.
What type should we be comparing against in these cases?
Repository:
rC Clang
https://reviews.llvm.org/D45680
_______________________________________________
cfe-commits mailing list
cfe-commits@lists.llvm.org
http://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
