From 44d9eceb47dd8f47e4cefd99e5197ab2e361d9fc Mon Sep 17 00:00:00 2001 From: Richard Smith Date: Sat, 17 May 2014 01:58:45 +0000 Subject: [PATCH] Correct incoherent function versus function template partial ordering for conversion operators (the comparison could claim that two conversion operators are both better than each other). Actually implement DR495, rather than passing its test by chance because the declarations happened to be in the "lucky" order. git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@209054 91177308-0d34-0410-b5e6-96231b3b80d8 --- lib/Sema/SemaOverload.cpp | 54 +++++++++++++++------------- test/CXX/drs/dr4xx.cpp | 10 +++++- test/SemaCXX/overloaded-operator.cpp | 12 +++++++ www/cxx_dr_status.html | 2 +- 4 files changed, 52 insertions(+), 26 deletions(-) diff --git a/lib/Sema/SemaOverload.cpp b/lib/Sema/SemaOverload.cpp index df4970ec8e..bc8eb2cf6a 100644 --- a/lib/Sema/SemaOverload.cpp +++ b/lib/Sema/SemaOverload.cpp @@ -8237,29 +8237,6 @@ isBetterOverloadCandidate(Sema &S, if (HasBetterConversion) return true; - // - F1 is a non-template function and F2 is a function template - // specialization, or, if not that, - if ((!Cand1.Function || !Cand1.Function->getPrimaryTemplate()) && - Cand2.Function && Cand2.Function->getPrimaryTemplate()) - return true; - - // -- F1 and F2 are function template specializations, and the function - // template for F1 is more specialized than the template for F2 - // according to the partial ordering rules described in 14.5.5.2, or, - // if not that, - if (Cand1.Function && Cand1.Function->getPrimaryTemplate() && - Cand2.Function && Cand2.Function->getPrimaryTemplate()) { - if (FunctionTemplateDecl *BetterTemplate - = S.getMoreSpecializedTemplate(Cand1.Function->getPrimaryTemplate(), - Cand2.Function->getPrimaryTemplate(), - Loc, - isa(Cand1.Function)? TPOC_Conversion - : TPOC_Call, - Cand1.ExplicitCallArguments, - Cand2.ExplicitCallArguments)) - return BetterTemplate == Cand1.Function->getPrimaryTemplate(); - } - // -- the context is an initialization by user-defined conversion // (see 8.5, 13.3.1.5) and the standard conversion sequence // from the return type of F1 to the destination type (i.e., @@ -8277,7 +8254,7 @@ isBetterOverloadCandidate(Sema &S, = compareConversionFunctions(S, Cand1.Function, Cand2.Function); if (FuncResult != ImplicitConversionSequence::Indistinguishable) return FuncResult; - + switch (CompareStandardConversionSequences(S, Cand1.FinalConversion, Cand2.FinalConversion)) { @@ -8293,6 +8270,35 @@ isBetterOverloadCandidate(Sema &S, // Do nothing break; } + + // FIXME: Compare kind of reference binding if conversion functions + // convert to a reference type used in direct reference binding, per + // C++14 [over.match.best]p1 section 2 bullet 3. + } + + // -- F1 is a non-template function and F2 is a function template + // specialization, or, if not that, + bool Cand1IsSpecialization = Cand1.Function && + Cand1.Function->getPrimaryTemplate(); + bool Cand2IsSpecialization = Cand2.Function && + Cand2.Function->getPrimaryTemplate(); + if (Cand1IsSpecialization != Cand2IsSpecialization) + return Cand2IsSpecialization; + + // -- F1 and F2 are function template specializations, and the function + // template for F1 is more specialized than the template for F2 + // according to the partial ordering rules described in 14.5.5.2, or, + // if not that, + if (Cand1IsSpecialization && Cand2IsSpecialization) { + if (FunctionTemplateDecl *BetterTemplate + = S.getMoreSpecializedTemplate(Cand1.Function->getPrimaryTemplate(), + Cand2.Function->getPrimaryTemplate(), + Loc, + isa(Cand1.Function)? TPOC_Conversion + : TPOC_Call, + Cand1.ExplicitCallArguments, + Cand2.ExplicitCallArguments)) + return BetterTemplate == Cand1.Function->getPrimaryTemplate(); } // Check for enable_if value-based overload resolution. diff --git a/test/CXX/drs/dr4xx.cpp b/test/CXX/drs/dr4xx.cpp index 03f384aeb9..815dbfc0b4 100644 --- a/test/CXX/drs/dr4xx.cpp +++ b/test/CXX/drs/dr4xx.cpp @@ -1165,7 +1165,7 @@ namespace dr494 { // dr494: dup 372 }; } -namespace dr495 { // dr495: yes +namespace dr495 { // dr495: 3.5 template struct S { operator int() { return T::error; } @@ -1173,6 +1173,14 @@ namespace dr495 { // dr495: yes }; S s; long n = s; + + template + struct S2 { + template operator U(); + operator int() { return T::error; } + }; + S2 s2; + long n2 = s2; } namespace dr496 { // dr496: no diff --git a/test/SemaCXX/overloaded-operator.cpp b/test/SemaCXX/overloaded-operator.cpp index cd2b2d3e7a..feb7c716ff 100644 --- a/test/SemaCXX/overloaded-operator.cpp +++ b/test/SemaCXX/overloaded-operator.cpp @@ -507,3 +507,15 @@ namespace PR14995 { // expected-note@-12 {{candidate template ignored: substitution failure}} } // namespace PR14995 +namespace ConversionVersusTemplateOrdering { + struct A { + operator short() = delete; + template operator T(); + } a; + struct B { + template operator T(); + operator short() = delete; + } b; + int x = a; + int y = b; +} diff --git a/www/cxx_dr_status.html b/www/cxx_dr_status.html index dc6339982c..35e7231367 100644 --- a/www/cxx_dr_status.html +++ b/www/cxx_dr_status.html @@ -3011,7 +3011,7 @@ of class templates 495 CD2 Overload resolution with template and non-template conversion functions - Yes + SVN 496 -- 2.50.1