Fix failure to treat overloaded function in braced-init-list as a non-deduced context.

Previously, if an overloaded function in a braced-init-list was encountered in
template argument deduction, and the overload set couldn't be resolved to a
particular function, we'd immediately produce a deduction failure. That's not
correct; this situation is supposed to result in that particular P/A pair being
treated as a non-deduced context, and deduction can still succeed if the type
can be deduced from elsewhere.

git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@291014 91177308-0d34-0410-b5e6-96231b3b80d8

diff --git a/include/clang/Basic/DiagnosticSemaKinds.td b/include/clang/Basic/DiagnosticSemaKinds.td
index 7f249c434ad64974a0423113c864166c967d005c..610fe0cb4c01ba37160f8512cc405736d5b8d4ca 100644 (file)
--- a/include/clang/Basic/DiagnosticSemaKinds.td
+++ b/include/clang/Basic/DiagnosticSemaKinds.td
@@ -3375,9 +3375,6 @@ def err_addrof_function_disabled_by_enable_if_attr : Error<
     "non-tautological enable_if conditions">;
 def note_addrof_ovl_candidate_disabled_by_enable_if_attr : Note<
     "candidate function made ineligible by enable_if">;
-def note_ovl_candidate_failed_overload_resolution : Note<
-    "candidate template ignored: couldn't resolve reference to overloaded "
-    "function %0">;
 def note_ovl_candidate_deduced_mismatch : Note<
     "candidate template ignored: deduced type "
     "%diff{$ of %ordinal0 parameter does not match adjusted type $ of argument"

diff --git a/include/clang/Sema/Sema.h b/include/clang/Sema/Sema.h
index f0999f68470c8ea54240712b8a8ec0e9da3845d0..3762253ef1131ef6767d80e86f50b42699fdad14 100644 (file)
--- a/include/clang/Sema/Sema.h
+++ b/include/clang/Sema/Sema.h
@@ -6576,9 +6576,6 @@ public:
     /// \brief The explicitly-specified template arguments were not valid
     /// template arguments for the given template.
     TDK_InvalidExplicitArguments,
-    /// \brief The arguments included an overloaded function name that could
-    /// not be resolved to a suitable function.
-    TDK_FailedOverloadResolution,
     /// \brief Deduction failed; that's all we know.
     TDK_MiscellaneousDeductionFailure,
     /// \brief CUDA Target attributes do not match.

diff --git a/include/clang/Sema/TemplateDeduction.h b/include/clang/Sema/TemplateDeduction.h
index f4a706ecb9ab2e0dd96c06fcd96b2ad749bba6b2..d92cbab4fbcf83e20dac6766ddd89a080e767b26 100644 (file)
--- a/include/clang/Sema/TemplateDeduction.h
+++ b/include/clang/Sema/TemplateDeduction.h
@@ -53,7 +53,7 @@ class TemplateDeductionInfo {
 public:
   TemplateDeductionInfo(SourceLocation Loc, unsigned DeducedDepth = 0)
     : Deduced(nullptr), Loc(Loc), HasSFINAEDiagnostic(false),
-      DeducedDepth(DeducedDepth), Expression(nullptr) {}
+      DeducedDepth(DeducedDepth), CallArgIndex(0) {}
 
   /// \brief Returns the location at which template argument is
   /// occurring.
@@ -175,21 +175,12 @@ public:
   /// FIXME: Finish documenting this.
   TemplateArgument SecondArg;
 
-  union {
-    /// \brief The expression which caused a deduction failure.
-    ///
-    ///   TDK_FailedOverloadResolution: this argument is the reference to
-    ///   an overloaded function which could not be resolved to a specific
-    ///   function.
-    Expr *Expression;
-
-    /// \brief The index of the function argument that caused a deduction
-    /// failure.
-    ///
-    ///   TDK_DeducedMismatch: this is the index of the argument that had a
-    ///   different argument type from its substituted parameter type.
-    unsigned CallArgIndex;
-  };
+  /// \brief The index of the function argument that caused a deduction
+  /// failure.
+  ///
+  ///   TDK_DeducedMismatch: this is the index of the argument that had a
+  ///   different argument type from its substituted parameter type.
+  unsigned CallArgIndex;
 
   /// \brief Information on packs that we're currently expanding.
   ///
@@ -235,10 +226,6 @@ struct DeductionFailureInfo {
   /// refers to, if any.
   const TemplateArgument *getSecondArg();
 
-  /// \brief Return the expression this deduction failure refers to,
-  /// if any.
-  Expr *getExpr();
-
   /// \brief Return the index of the call argument that this deduction
   /// failure refers to, if any.
   llvm::Optional<unsigned> getCallArgIndex();

diff --git a/lib/Sema/SemaOverload.cpp b/lib/Sema/SemaOverload.cpp
index b5c0e634fa504491f29386b1f49dfe1d465f9102..1c026d7adb36dc91eb9f44bc9ee75945a1af7505 100644 (file)
--- a/lib/Sema/SemaOverload.cpp
+++ b/lib/Sema/SemaOverload.cpp
@@ -644,10 +644,6 @@ clang::MakeDeductionFailureInfo(ASTContext &Context,
       Result.HasDiagnostic = true;
     }
     break;
-
-  case Sema::TDK_FailedOverloadResolution:
-    Result.Data = Info.Expression;
-    break;
   }
 
   return Result;
@@ -662,7 +658,6 @@ void DeductionFailureInfo::Destroy() {
   case Sema::TDK_TooManyArguments:
   case Sema::TDK_TooFewArguments:
   case Sema::TDK_InvalidExplicitArguments:
-  case Sema::TDK_FailedOverloadResolution:
   case Sema::TDK_CUDATargetMismatch:
     break;
 
@@ -705,7 +700,6 @@ TemplateParameter DeductionFailureInfo::getTemplateParameter() {
   case Sema::TDK_SubstitutionFailure:
   case Sema::TDK_DeducedMismatch:
   case Sema::TDK_NonDeducedMismatch:
-  case Sema::TDK_FailedOverloadResolution:
   case Sema::TDK_CUDATargetMismatch:
     return TemplateParameter();
 
@@ -737,7 +731,6 @@ TemplateArgumentList *DeductionFailureInfo::getTemplateArgumentList() {
   case Sema::TDK_Inconsistent:
   case Sema::TDK_Underqualified:
   case Sema::TDK_NonDeducedMismatch:
-  case Sema::TDK_FailedOverloadResolution:
   case Sema::TDK_CUDATargetMismatch:
     return nullptr;
 
@@ -765,7 +758,6 @@ const TemplateArgument *DeductionFailureInfo::getFirstArg() {
   case Sema::TDK_TooFewArguments:
   case Sema::TDK_InvalidExplicitArguments:
   case Sema::TDK_SubstitutionFailure:
-  case Sema::TDK_FailedOverloadResolution:
   case Sema::TDK_CUDATargetMismatch:
     return nullptr;
 
@@ -793,7 +785,6 @@ const TemplateArgument *DeductionFailureInfo::getSecondArg() {
   case Sema::TDK_TooFewArguments:
   case Sema::TDK_InvalidExplicitArguments:
   case Sema::TDK_SubstitutionFailure:
-  case Sema::TDK_FailedOverloadResolution:
   case Sema::TDK_CUDATargetMismatch:
     return nullptr;
 
@@ -811,14 +802,6 @@ const TemplateArgument *DeductionFailureInfo::getSecondArg() {
   return nullptr;
 }
 
-Expr *DeductionFailureInfo::getExpr() {
-  if (static_cast<Sema::TemplateDeductionResult>(Result) ==
-        Sema::TDK_FailedOverloadResolution)
-    return static_cast<Expr*>(Data);
-
-  return nullptr;
-}
-
 llvm::Optional<unsigned> DeductionFailureInfo::getCallArgIndex() {
   if (static_cast<Sema::TemplateDeductionResult>(Result) ==
         Sema::TDK_DeducedMismatch)
@@ -9699,14 +9682,6 @@ static void DiagnoseBadDeduction(Sema &S, NamedDecl *Found, Decl *Templated,
     return;
   }
 
-  case Sema::TDK_FailedOverloadResolution: {
-    OverloadExpr::FindResult R = OverloadExpr::find(DeductionFailure.getExpr());
-    S.Diag(Templated->getLocation(),
-           diag::note_ovl_candidate_failed_overload_resolution)
-        << R.Expression->getName();
-    return;
-  }
-
   case Sema::TDK_DeducedMismatch: {
     // Format the template argument list into the argument string.
     SmallString<128> TemplateArgString;
@@ -10043,7 +10018,6 @@ static unsigned RankDeductionFailure(const DeductionFailureInfo &DFI) {
     return 3;
 
   case Sema::TDK_InstantiationDepth:
-  case Sema::TDK_FailedOverloadResolution:
     return 4;
 
   case Sema::TDK_InvalidExplicitArguments:

diff --git a/lib/Sema/SemaTemplateDeduction.cpp b/lib/Sema/SemaTemplateDeduction.cpp
index 7f1fd91c46f0563bc8cc05e508ced4ffe3862aa6..c16b28bcf13902330c8917ffd375d78a8c94fe9c 100644 (file)
--- a/lib/Sema/SemaTemplateDeduction.cpp
+++ b/lib/Sema/SemaTemplateDeduction.cpp
@@ -3279,10 +3279,9 @@ DeduceTemplateArgumentByListElement(Sema &S,
   // For all other cases, just match by type.
   QualType ArgType = Arg->getType();
   if (AdjustFunctionParmAndArgTypesForDeduction(S, TemplateParams, ParamType,
-                                                ArgType, Arg, TDF)) {
-    Info.Expression = Arg;
-    return Sema::TDK_FailedOverloadResolution;
-  }
+                                                ArgType, Arg, TDF))
+    return Sema::TDK_Success;
+
   return DeduceTemplateArgumentsByTypeMatch(S, TemplateParams, ParamType,
                                             ArgType, Info, Deduced, TDF);
 }

diff --git a/test/SemaCXX/cxx0x-initializer-stdinitializerlist.cpp b/test/SemaCXX/cxx0x-initializer-stdinitializerlist.cpp
index c8595d2e3648b727bd6ddce230e5f3973c0be6bd..75c6734bce3087ade586b9df3adc445ba5821c5f 100644 (file)
--- a/test/SemaCXX/cxx0x-initializer-stdinitializerlist.cpp
+++ b/test/SemaCXX/cxx0x-initializer-stdinitializerlist.cpp
@@ -220,10 +220,14 @@ namespace initlist_of_array {
 namespace init_list_deduction_failure {
   void f();
   void f(int);
+  // FIXME: It'd be nice to track that 'T' became a non-deduced context due to
+  // overload resolution failure for 'f'.
   template<typename T> void g(std::initializer_list<T>);
-  // expected-note@-1 {{candidate template ignored: couldn't resolve reference to overloaded function 'f'}}
-  void h() { g({f}); }
-  // expected-error@-1 {{no matching function for call to 'g'}}
+  // expected-note@-1 {{candidate template ignored: couldn't infer template argument 'T'}}
+  void h() {
+    g({f}); // expected-error {{no matching function for call to 'g'}}
+    g({f, h}); // ok
+  }
 }
 
 namespace deleted_copy {