[Sema] Fix an assert-on-invalid by avoiding function template specialisation deduction for invalid functions with fabricated template arguments

[arphaman]

Summary

This patch fixes an an assertion that previously occurred for the following sample:

template <typename InputT, typename OutputT>
struct SourceSelectionRequirement {

  template<typename T>
  OutputT evaluateSelectionRequirement(InputT &&Value) {
  }
};

template <typename InputT, typename OutputT>
OutputT SourceSelectionRequirement<InputT, OutputT>::evaluateSelectionRequirement<void>(InputT &&Value) {
    return Value;
}

Clang asserted when it was trying to deduce the function template specialisation for evaluateSelectionRequirement, because it was trying to do deduction with the template specialisation <void> and template <typename InputT, typename OutputT> which have different template depths.

I initially fixed the issue by setting the right depth, during the deduction, but wasn't happy with the results (we produced two errors, the second one complained about failed deduction). Thus I changed my approach to the one that's presented in this patch - we can detect if the template parameters are fabricated and then avoid the deduction. This approach avoids the second error while fixing the assertion. It also fixed a redundant error FIXME in SemaTemplate/explicit-specialization-member.cpp (Basically removed a redundant deduction error).

Thanks for taking a look

[vsapsai]

Does your fix work for deeper nesting too (e.g. template in template in template)? Looks like it should, just want to confirm.

Are there other places where you need to avoid calling DeduceTemplateArguments due to templates depth mismatch? CheckDependentFunctionTemplateSpecialization should be OK as it's not deducing template arguments. But I'm not sure about CheckMemberSpecialization. It doesn't call DeduceTemplateArguments directly but I haven't dug deep enough to confirm it's not performing deduction indirectly.

lib/Sema/SemaDecl.cpp

8307–8308 ↗

(On Diff #113418)

Checking if angle location is invalid looks suspicious. It can be my lack of knowledge but I expect various locations not to convey sema information.

8880–8881 ↗

(On Diff #113418)

Will something more general like

!NewFD->isInvalidDecl() && CheckFunctionTemplateSpecialization(...)

work here? Because if matching template parameters to scope specifier fails, NewFD is marked as invalid decl and seems like we can use that.

[arphaman]

In D37341#869042, @vsapsai wrote:

Does your fix work for deeper nesting too (e.g. template in template in template)? Looks like it should, just want to confirm.

Yes.

Are there other places where you need to avoid calling DeduceTemplateArguments due to templates depth mismatch? CheckDependentFunctionTemplateSpecialization should be OK as it's not deducing template arguments. But I'm not sure about CheckMemberSpecialization. It doesn't call DeduceTemplateArguments directly but I haven't dug deep enough to confirm it's not performing deduction indirectly.

The problem only seems to happen when the TPL is fabricated. I didn't see other potential places where such an issue might happen.

lib/Sema/SemaDecl.cpp

8880–8881 ↗

(On Diff #113418)

Yeah, good idea.

[arphaman]

Use just the isInvalidDecl check.

[vsapsai]

Looks good to me.

cfe/trunk/lib/Sema/SemaDecl.cpp

if (!getLangOpts().CPlusPlus) {
     } else if (isFunctionTemplateSpecialization) {
       if (CurContext->isDependentContext() && CurContext->isRecord()
           && !isFriend) {
         isDependentClassScopeExplicitSpecialization = true;
         Diag(NewFD->getLocation(), getLangOpts().MicrosoftExt ?
           diag::ext_function_specialization_in_class :
           diag::err_function_specialization_in_class)
           << NewFD->getDeclName();
-      } else if (CheckFunctionTemplateSpecialization(NewFD,
-                                  (HasExplicitTemplateArgs ? &TemplateArgs
-                                                           : nullptr),
-                                                     Previous))
+      } else if (!NewFD->isInvalidDecl() &&
+                 CheckFunctionTemplateSpecialization(
+                     NewFD, (HasExplicitTemplateArgs ? &TemplateArgs : nullptr),
         NewFD->setInvalidDecl();
 
       // C++ [dcl.stc]p1:
       //   A storage-class-specifier shall not be specified in an explicit
       //   specialization (14.7.3)
       FunctionTemplateSpecializationInfo *Info =
           NewFD->getTemplateSpecializationInfo();
       if (Info && SC != SC_None) {

cfe/trunk/test/SemaTemplate/deduction-crash.cpp

namespace PR14281_part3 {
   A<B<int, &some_decl>, &some_decl>::type x;
 }
 
 namespace var_template_partial_spec_incomplete {
   template<typename T> int n;
   template<typename T, typename U = void> int n<T *>; // expected-error +{{}} expected-note {{}}
   int k = n<void *>;
 }
+
+namespace deduceFunctionSpecializationForInvalidOutOfLineFunction {
+
+template <typename InputT, typename OutputT>
+struct SourceSelectionRequirement {
+  template<typename T>
+  OutputT evaluateSelectionRequirement(InputT &&Value) {
+  }
+};
+
+template <typename InputT, typename OutputT>
+OutputT SourceSelectionRequirement<InputT, OutputT>::
+evaluateSelectionRequirement<void>(InputT &&Value) { // expected-error {{cannot specialize a member of an unspecialized template}}
+  return Value;
+}
+
+}

cfe/trunk/test/SemaTemplate/explicit-specialization-member.cpp

namespace PR18246 {
   template<typename T>
   class Baz {
   public:
     template<int N> void bar();
   };
 
   template<typename T>
   template<int N>
-  void Baz<T>::bar() { // expected-note {{couldn't infer template argument 'N'}}
+  void Baz<T>::bar() {
   }
 
-  // FIXME: We shouldn't try to match this against a prior declaration if
-  // template parameter matching failed.
   template<typename T>
-  void Baz<T>::bar<0>() { // expected-error {{cannot specialize a member of an unspecialized template}} \
-                          // expected-error {{no function template matches}}
+  void Baz<T>::bar<0>() { // expected-error {{cannot specialize a member of an unspecialized template}}
   }
 }
 
 namespace PR19340 {
 template<typename T> struct Helper {
-  template<int N> static void func(const T *m) {} // expected-note {{failed template argument deduction}}
+  template<int N> static void func(const T *m) {}
 };
 
-template<typename T> void Helper<T>::func<2>() {} // expected-error {{cannot specialize a member}} \
-                                                  // expected-error {{no function template matches}}
+template<typename T> void Helper<T>::func<2>() {} // expected-error {{cannot specialize a member}}
 }
 
 namespace SpecLoc {
   template <typename T> struct A {
     static int n; // expected-note {{previous}}
     static void f(); // expected-note {{previous}}
   };
   template<> float A<int>::n; // expected-error {{different type}}
   template<> void A<int>::f() throw(); // expected-error {{does not match}}
 }