Part of PR15673: If a function template has a default argument in which

substitution failed, report that as a substitution failure rather than
pretending that there was no default argument.

The test cases in PR15673 have exposed some pre-existing poor diagnostics here.

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

diff --git a/include/clang/Sema/Sema.h b/include/clang/Sema/Sema.h
index 1b076a44cac5391fc125a110710b3ac6d93a2ada..047cd89ce8748553dfd79fef5bcf22328e84bc7b 100644 (file)
--- a/include/clang/Sema/Sema.h
+++ b/include/clang/Sema/Sema.h
@@ -5099,7 +5099,9 @@ public:
                                           SourceLocation TemplateLoc,
                                           SourceLocation RAngleLoc,
                                           Decl *Param,
-                          SmallVectorImpl<TemplateArgument> &Converted);
+                                          SmallVectorImpl<TemplateArgument>
+                                            &Converted,
+                                          bool &HasDefaultArg);
 
   /// \brief Specifies the context in which a particular template
   /// argument is being checked.

diff --git a/lib/Sema/SemaTemplate.cpp b/lib/Sema/SemaTemplate.cpp
index 2502db829b969746dce01dd1a3f8fb0b5a356e5f..e6006b6bf973d87ba1214d739b154fede2bdfcf3 100644 (file)
--- a/lib/Sema/SemaTemplate.cpp
+++ b/lib/Sema/SemaTemplate.cpp
@@ -2703,11 +2703,16 @@ Sema::SubstDefaultTemplateArgumentIfAvailable(TemplateDecl *Template,
                                               SourceLocation TemplateLoc,
                                               SourceLocation RAngleLoc,
                                               Decl *Param,
-                      SmallVectorImpl<TemplateArgument> &Converted) {
-   if (TemplateTypeParmDecl *TypeParm = dyn_cast<TemplateTypeParmDecl>(Param)) {
+                                              SmallVectorImpl<TemplateArgument>
+                                                &Converted,
+                                              bool &HasDefaultArg) {
+  HasDefaultArg = false;
+
+  if (TemplateTypeParmDecl *TypeParm = dyn_cast<TemplateTypeParmDecl>(Param)) {
     if (!TypeParm->hasDefaultArgument())
       return TemplateArgumentLoc();
 
+    HasDefaultArg = true;
     TypeSourceInfo *DI = SubstDefaultTemplateArgument(*this, Template,
                                                       TemplateLoc,
                                                       RAngleLoc,
@@ -2724,6 +2729,7 @@ Sema::SubstDefaultTemplateArgumentIfAvailable(TemplateDecl *Template,
     if (!NonTypeParm->hasDefaultArgument())
       return TemplateArgumentLoc();
 
+    HasDefaultArg = true;
     ExprResult Arg = SubstDefaultTemplateArgument(*this, Template,
                                                   TemplateLoc,
                                                   RAngleLoc,
@@ -2741,7 +2747,7 @@ Sema::SubstDefaultTemplateArgumentIfAvailable(TemplateDecl *Template,
   if (!TempTempParm->hasDefaultArgument())
     return TemplateArgumentLoc();
 
-
+  HasDefaultArg = true;
   NestedNameSpecifierLoc QualifierLoc;
   TemplateName TName = SubstDefaultTemplateArgument(*this, Template,
                                                     TemplateLoc,

diff --git a/lib/Sema/SemaTemplateDeduction.cpp b/lib/Sema/SemaTemplateDeduction.cpp
index 8efc7a0263478eaad9464f41a147352f8dc5926e..0fd29ea449652be10949373b601ee009581ae1d8 100644 (file)
--- a/lib/Sema/SemaTemplateDeduction.cpp
+++ b/lib/Sema/SemaTemplateDeduction.cpp
@@ -2704,18 +2704,21 @@ Sema::FinishTemplateArgumentDeduction(FunctionTemplateDecl *FunctionTemplate,
     }
 
     // Substitute into the default template argument, if available.
+    bool HasDefaultArg = false;
     TemplateArgumentLoc DefArg
       = SubstDefaultTemplateArgumentIfAvailable(FunctionTemplate,
                                               FunctionTemplate->getLocation(),
                                   FunctionTemplate->getSourceRange().getEnd(),
                                                 Param,
-                                                Builder);
+                                                Builder, HasDefaultArg);
 
     // If there was no default argument, deduction is incomplete.
     if (DefArg.getArgument().isNull()) {
       Info.Param = makeTemplateParameter(
                          const_cast<NamedDecl *>(TemplateParams->getParam(I)));
-      return TDK_Incomplete;
+      Info.reset(TemplateArgumentList::CreateCopy(Context, Builder.data(),
+                                                  Builder.size()));
+      return HasDefaultArg ? TDK_SubstitutionFailure : TDK_Incomplete;
     }
 
     // Check whether we can actually use the default argument.

diff --git a/test/SemaTemplate/overload-candidates.cpp b/test/SemaTemplate/overload-candidates.cpp
index ad65397865ad08c591c4c7f0ec942e0c34f850e2..544d897e24498907ec28dda4cf0d1deb2ef3583c 100644 (file)
--- a/test/SemaTemplate/overload-candidates.cpp
+++ b/test/SemaTemplate/overload-candidates.cpp
@@ -79,3 +79,48 @@ void foo(NS2::array<A>); // expected-note{{candidate template ignored: could not
 void test() {
   foo(NS1::array<int>()); // expected-error{{no matching function for call to 'foo'}}
 }
+
+namespace std {
+  template<bool, typename = void> struct enable_if {};
+  template<typename T> struct enable_if<true, T> { typedef T type; };
+
+  template<typename T, T V> struct integral_constant { static const T value = V; };
+  typedef integral_constant<bool, false> false_type;
+  typedef integral_constant<bool, true> true_type;
+};
+
+namespace PR15673 {
+  template<typename T>
+  struct a_trait : std::false_type {};
+
+  template<typename T,
+           typename Requires = typename std::enable_if<a_trait<T>::value>::type> // expected-warning {{C++11 extension}}
+  // expected-note@-1 {{candidate template ignored: disabled by 'enable_if' [with T = int]}}
+  void foo() {}
+  void bar() { foo<int>(); } // expected-error {{no matching function for call to 'foo'}}
+
+
+  template<typename T>
+  struct some_trait : std::false_type {};
+
+  // FIXME: It would be nice to tunnel the 'disabled by enable_if' diagnostic through here.
+  template<typename T>
+  struct a_pony : std::enable_if<some_trait<T>::value> {};
+
+  template<typename T,
+           typename Requires = typename a_pony<T>::type> // expected-warning {{C++11 extension}}
+  // FIXME: The source location here is poor.
+  void baz() { } // expected-note {{candidate template ignored: substitution failure [with T = int]: no type named 'type' in 'PR15673::a_pony<int>'}}
+  void quux() { baz<int>(); } // expected-error {{no matching function for call to 'baz'}}
+
+
+  // FIXME: This note doesn't make it clear which candidate we rejected.
+  template <typename T>
+  using unicorns = typename std::enable_if<some_trait<T>::value>::type; // expected-warning {{C++11 extension}}
+  // expected-note@-1 {{candidate template ignored: disabled by 'enable_if' [with T = int]}}
+
+  template<typename T,
+           typename Requires = unicorns<T> > // expected-warning {{C++11 extension}}
+  void wibble() {}
+  void wobble() { wibble<int>(); } // expected-error {{no matching function for call to 'wibble'}}
+}