* Fix handling of explicit specifiers

* Prefer a constructor template over a non-template conversion function

Author: cor3ntin

clang/include/clang/Sema/Overload.h

@@ -1199,6 +1199,9 @@ class Sema;
     llvm::SmallPtrSet<uintptr_t, 16> Functions;
     SmallVector<DeferredTemplateOverloadCandidate, 8> DeferredCandidates;
 
+    LLVM_PREFERRED_TYPE(bool)
+    unsigned HasDeferredTemplateConstructors : 1;
+
     // Allocator for ConversionSequenceLists and deferred candidate args.
     // We store the first few of these
     // inline to avoid allocation for small sets.
@@ -1248,7 +1251,8 @@ class Sema;
   public:
     OverloadCandidateSet(SourceLocation Loc, CandidateSetKind CSK,
                          OperatorRewriteInfo RewriteInfo = {})
-        : Loc(Loc), Kind(CSK), RewriteInfo(RewriteInfo) {}
+        : HasDeferredTemplateConstructors(false), Loc(Loc), Kind(CSK),
+          RewriteInfo(RewriteInfo) {}
     OverloadCandidateSet(const OverloadCandidateSet &) = delete;
     OverloadCandidateSet &operator=(const OverloadCandidateSet &) = delete;
     ~OverloadCandidateSet() { destroyCandidates(); }
@@ -1260,7 +1264,7 @@ class Sema;
     /// Whether diagnostics should be deferred.
     bool shouldDeferDiags(Sema &S, ArrayRef<Expr *> Args, SourceLocation OpLoc);
 
-    // Whether the resolution of template candidates should be defered
+    // Whether the resolution of template candidates should be deferred
     bool shouldDeferTemplateArgumentDeduction(const LangOptions &Opts) const;
 
     /// Determine when this overload candidate will be new to the
@@ -1455,10 +1459,9 @@ class Sema;
       const LangOptions &Opts) const {
     return
         // For user defined conversion we need to check against different
-        // combination of CV qualifiers and look at any expicit specifier, so
+        // combination of CV qualifiers and look at any explicit specifier, so
         // always deduce template candidates.
-        Kind != CSK_InitByUserDefinedConversion &&
-        Kind != CSK_InitByConstructor
+        Kind != CSK_InitByUserDefinedConversion
         // When doing code completion, we want to see all the
         // viable candidates.
         && Kind != CSK_CodeCompletion

clang/lib/Sema/SemaOverload.cpp

@@ -1124,6 +1124,7 @@ void OverloadCandidateSet::clear(CandidateSetKind CSK) {
   Candidates.clear();
   Functions.clear();
   Kind = CSK;
+  HasDeferredTemplateConstructors = false;
 }
 
 namespace {
@@ -7883,6 +7884,11 @@ static bool isNonDependentlyExplicit(FunctionTemplateDecl *FTD) {
   return ExplicitSpecifier::getFromDecl(FTD->getTemplatedDecl()).isExplicit();
 }
 
+static bool hasDependentExplicit(FunctionTemplateDecl *FTD) {
+  return ExplicitSpecifier::getFromDecl(FTD->getTemplatedDecl()).getKind() ==
+         ExplicitSpecKind::Unresolved;
+}
+
 static void AddTemplateOverloadCandidateImmediately(
     Sema &S, OverloadCandidateSet &CandidateSet,
     FunctionTemplateDecl *FunctionTemplate, DeclAccessPair FoundDecl,
@@ -7974,7 +7980,10 @@ void Sema::AddTemplateOverloadCandidate(
     return;
 
   if (ExplicitTemplateArgs ||
-      !CandidateSet.shouldDeferTemplateArgumentDeduction(getLangOpts())) {
+      !CandidateSet.shouldDeferTemplateArgumentDeduction(getLangOpts()) ||
+      (isa<CXXConstructorDecl>(FunctionTemplate->getTemplatedDecl()) &&
+       hasDependentExplicit(FunctionTemplate))) {
+
     AddTemplateOverloadCandidateImmediately(
         *this, CandidateSet, FunctionTemplate, FoundDecl, ExplicitTemplateArgs,
         Args, SuppressUserConversions, PartialOverloading, AllowExplicit,
@@ -8362,7 +8371,9 @@ void Sema::AddTemplateConversionCandidate(
   if (!CandidateSet.isNewCandidate(FunctionTemplate))
     return;
 
-  if (!CandidateSet.shouldDeferTemplateArgumentDeduction(getLangOpts())) {
+  if (!CandidateSet.shouldDeferTemplateArgumentDeduction(getLangOpts()) ||
+      hasDependentExplicit(FunctionTemplate)) {
+
     AddTemplateConversionCandidateImmediately(
         *this, CandidateSet, FunctionTemplate, FoundDecl, ActingDC, From,
         ToType, AllowObjCConversionOnExplicit, AllowExplicit,
@@ -11003,6 +11014,8 @@ void OverloadCandidateSet::AddDeferredTemplateCandidate(
                                               AllowExplicit,
                                               AggregateCandidateDeduction};
   DeferredCandidates.emplace_back(std::move(C));
+  HasDeferredTemplateConstructors |=
+      isa<CXXConstructorDecl>(FunctionTemplate->getTemplatedDecl());
 }
 
 void OverloadCandidateSet::AddDeferredMethodTemplateCandidate(
@@ -11158,6 +11171,15 @@ void OverloadCandidateSet::PerfectViableFunction(
   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.
+    if (HasDeferredTemplateConstructors &&
+        isa_and_nonnull<CXXConversionDecl>(It->Function)) {
+      Best = end();
+      break;
+    }
+
     if (Best == end()) {
       Best = It;
       continue;

clang/lib/Sema/SemaTemplateDeduction.cpp

@@ -6204,9 +6204,9 @@ FunctionDecl *Sema::getMoreConstrainedFunction(FunctionDecl *FD1,
   assert(!FD1->getDescribedTemplate() && !FD2->getDescribedTemplate() &&
          "not for function templates");
   assert(!FD1->isFunctionTemplateSpecialization() ||
-         isa<CXXConversionDecl>(FD1));
+         (isa<CXXConversionDecl, CXXConstructorDecl>(FD1)));
   assert(!FD2->isFunctionTemplateSpecialization() ||
-         isa<CXXConversionDecl>(FD2));
+         (isa<CXXConversionDecl, CXXConstructorDecl>(FD2)));
 
   FunctionDecl *F1 = FD1;
   if (FunctionDecl *P = FD1->getTemplateInstantiationPattern(false))

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

@@ -116,6 +116,18 @@ static_assert(m1.g(0) == 1);
 static_assert(Members<int[3]>{}.s(0) == 2);
 
 
+namespace ConstructorInit{
+struct S {
+  template <typename T>
+  S(T&&) {}
+};
+struct Test {
+  operator S() = delete;
+};
+
+static_assert(__is_constructible(S, Test));
+}
+
 
 namespace GH62096 {
 template <typename T>