Disable resolution by perfect match when

 - We find a template conversion candidate
 - A constructor with a dependent explicit specifier

Author: cor3ntin

clang/include/clang/Sema/Overload.h

@@ -1206,9 +1206,11 @@ class Sema;
     llvm::SmallPtrSet<uintptr_t, 16> Functions;
 
     DeferredTemplateOverloadCandidate *FirstDeferredCandidate;
-    unsigned DeferredCandidatesCount : 8 * sizeof(unsigned) - 1;
+    unsigned DeferredCandidatesCount : 8 * sizeof(unsigned) - 2;
     LLVM_PREFERRED_TYPE(bool)
     unsigned HasDeferredTemplateConstructors : 1;
+    LLVM_PREFERRED_TYPE(bool)
+    unsigned ResolutionByPerfectCandidateIsDisabled : 1;
 
     // Allocator for ConversionSequenceLists and deferred candidate args.
     // We store the first few of these
@@ -1274,7 +1276,8 @@ class Sema;
     OverloadCandidateSet(SourceLocation Loc, CandidateSetKind CSK,
                          OperatorRewriteInfo RewriteInfo = {})
         : FirstDeferredCandidate(nullptr), DeferredCandidatesCount(0),
-          HasDeferredTemplateConstructors(false), Loc(Loc), Kind(CSK),
+          HasDeferredTemplateConstructors(false),
+          ResolutionByPerfectCandidateIsDisabled(false), Loc(Loc), Kind(CSK),
           RewriteInfo(RewriteInfo) {}
     OverloadCandidateSet(const OverloadCandidateSet &) = delete;
     OverloadCandidateSet &operator=(const OverloadCandidateSet &) = delete;
@@ -1387,6 +1390,10 @@ class Sema;
 
     void InjectNonDeducedTemplateCandidates(Sema &S);
 
+    void DisableResolutionByPerfectCandidate() {
+      ResolutionByPerfectCandidateIsDisabled = true;
+    }
+
     /// Find the best viable function on this overload set, if it exists.
     OverloadingResult BestViableFunction(Sema &S, SourceLocation Loc,
                                          OverloadCandidateSet::iterator& Best);

clang/lib/Sema/SemaOverload.cpp

@@ -1127,6 +1127,7 @@ void OverloadCandidateSet::clear(CandidateSetKind CSK) {
   FirstDeferredCandidate = nullptr;
   DeferredCandidatesCount = 0;
   HasDeferredTemplateConstructors = false;
+  ResolutionByPerfectCandidateIsDisabled = false;
 }
 
 namespace {
@@ -7989,15 +7990,20 @@ void Sema::AddTemplateOverloadCandidate(
   if (!CandidateSet.isNewCandidate(FunctionTemplate, PO))
     return;
 
+  bool DependentExplicitSpecifier = hasDependentExplicit(FunctionTemplate);
+
   if (ExplicitTemplateArgs ||
       !CandidateSet.shouldDeferTemplateArgumentDeduction(getLangOpts()) ||
       (isa<CXXConstructorDecl>(FunctionTemplate->getTemplatedDecl()) &&
-       hasDependentExplicit(FunctionTemplate))) {
+       DependentExplicitSpecifier)) {
 
     AddTemplateOverloadCandidateImmediately(
         *this, CandidateSet, FunctionTemplate, FoundDecl, ExplicitTemplateArgs,
         Args, SuppressUserConversions, PartialOverloading, AllowExplicit,
         IsADLCandidate, PO, AggregateCandidateDeduction);
+
+    if (DependentExplicitSpecifier)
+      CandidateSet.DisableResolutionByPerfectCandidate();
     return;
   }
 
@@ -8382,13 +8388,15 @@ void Sema::AddTemplateConversionCandidate(
     return;
 
   if (!CandidateSet.shouldDeferTemplateArgumentDeduction(getLangOpts()) ||
-      hasDependentExplicit(FunctionTemplate)) {
-
+      CandidateSet.getKind() ==
+          OverloadCandidateSet::CSK_InitByUserDefinedConversion ||
+      CandidateSet.getKind() == OverloadCandidateSet::CSK_InitByConstructor) {
     AddTemplateConversionCandidateImmediately(
         *this, CandidateSet, FunctionTemplate, FoundDecl, ActingDC, From,
         ToType, AllowObjCConversionOnExplicit, AllowExplicit,
         AllowResultConversion);
 
+    CandidateSet.DisableResolutionByPerfectCandidate();
     return;
   }
 
@@ -11028,6 +11036,7 @@ void OverloadCandidateSet::AddDeferredTemplateCandidate(
       Args,
       IsADLCandidate,
       PO};
+
   HasDeferredTemplateConstructors |=
       isa<CXXConstructorDecl>(FunctionTemplate->getTemplatedDecl());
 }
@@ -11199,19 +11208,19 @@ OverloadingResult OverloadCandidateSet::BestViableFunction(Sema &S,
 
   assert(shouldDeferTemplateArgumentDeduction(S.getLangOpts()) ||
          DeferredCandidatesCount == 0 &&
-             "Unexpected deferred template candidate");
+             "Unexpected deferred template candidates");
 
-  bool TwoPhaseResolution = DeferredCandidatesCount != 0;
+  bool TwoPhaseResolution =
+      DeferredCandidatesCount != 0 && !ResolutionByPerfectCandidateIsDisabled;
 
   if (TwoPhaseResolution) {
 
     PerfectViableFunction(S, Loc, Best);
     if (Best != end())
       return ResultForBestCandidate(Best);
-
-    InjectNonDeducedTemplateCandidates(S);
   }
 
+  InjectNonDeducedTemplateCandidates(S);
   return BestViableFunctionImpl(S, Loc, Best);
 }
 
@@ -11220,8 +11229,10 @@ void OverloadCandidateSet::PerfectViableFunction(
 
   Best = end();
   for (auto It = begin(); It != end(); ++It) {
+
     if (!It->isPerfectMatch(S.getASTContext()))
       continue;
+
     // We found a suitable conversion function
     // but if there is a template constructor in the target class
     // we might prefer that instead.
@@ -11246,6 +11257,7 @@ void OverloadCandidateSet::PerfectViableFunction(
         Best = It;
       continue;
     }
+    // ambiguous
     Best = end();
     break;
   }

clang/test/SemaCXX/overload-resolution-deferred-templates.cpp

@@ -150,6 +150,13 @@ struct StringRef {
 
 }
 
+template <class> struct tuple {};
+struct BonkersBananas {
+  template <class T> operator T();
+  template <class = void> explicit operator tuple<int>() = delete;
+};
+static_assert(!__is_constructible(tuple<int>, BonkersBananas));
+
 namespace GH62096 {
 template <typename T>
 struct Oops {