Change approach to fixing this.

Author: katzdm

clang/lib/Sema/SemaConcept.cpp

@@ -1743,8 +1743,7 @@ bool Sema::IsAtLeastAsConstrained(NamedDecl *D1,
     auto IsExpectedEntity = [](const FunctionDecl *FD) {
       FunctionDecl::TemplatedKind Kind = FD->getTemplatedKind();
       return Kind == FunctionDecl::TK_NonTemplate ||
-             Kind == FunctionDecl::TK_MemberSpecialization ||
-             Kind == FunctionDecl::TK_FunctionTemplateSpecialization;
+             Kind == FunctionDecl::TK_FunctionTemplate;
     };
     const auto *FD2 = dyn_cast<FunctionDecl>(D2);
     (void)IsExpectedEntity;

clang/lib/Sema/SemaTemplateDeduction.cpp

@@ -5805,12 +5805,23 @@ FunctionDecl *Sema::getMoreConstrainedFunction(FunctionDecl *FD1,
                                                FunctionDecl *FD2) {
   assert(!FD1->getDescribedTemplate() && !FD2->getDescribedTemplate() &&
          "not for function templates");
-  FunctionDecl *F1 = FD1;
-  if (FunctionDecl *MF = FD1->getInstantiatedFromMemberFunction())
-    F1 = MF;
-  FunctionDecl *F2 = FD2;
-  if (FunctionDecl *MF = FD2->getInstantiatedFromMemberFunction())
-    F2 = MF;
+
+  auto getTemplatePattern = [](FunctionDecl *FD) {
+    // Specializations of conversion function templates are believed to be the
+    // only case where a function template specialization reaches here.
+    assert(!FD->isFunctionTemplateSpecialization() ||
+           isa<CXXConversionDecl>(FD));
+
+    if (FunctionDecl *MF = FD->getInstantiatedFromMemberFunction())
+      return MF;
+    else if (FunctionTemplateDecl *FTD = FD->getPrimaryTemplate())
+      return FTD->getTemplatedDecl();
+
+    return FD;
+  };
+  FunctionDecl *F1 = getTemplatePattern(FD1);
+  FunctionDecl *F2 = getTemplatePattern(FD2);
+
   llvm::SmallVector<const Expr *, 1> AC1, AC2;
   F1->getAssociatedConstraints(AC1);
   F2->getAssociatedConstraints(AC2);

clang/test/SemaCXX/PR98671.cpp

@@ -1,6 +1,6 @@
 // RUN: %clang_cc1 -std=c++20 -fsyntax-only %s -verify
 
-struct S {
+struct S1 {
   operator int();
 
   template <typename T>
@@ -10,5 +10,19 @@ struct S {
 
 // Ensure that no assertion is raised when overload resolution fails while
 // choosing between an operator function template and an operator function.
-constexpr auto r = &S::operator int;
+constexpr auto r = &S1::operator int;
 // expected-error@-1 {{initializer of type '<overloaded function type>'}}
+
+
+template <typename T>
+struct S2 {
+  template <typename U=T>
+    S2(U={}) requires (sizeof(T) > 0) {}
+    // expected-note@-1 {{candidate constructor}}
+
+  template <typename U=T>
+    S2(U={}) requires (true) {}
+    // expected-note@-1 {{candidate constructor}}
+};
+
+S2<int> s;  // expected-error {{call to constructor of 'S2<int>' is ambiguous}}