let EST_Uninstantiated in FunctionProtoType::canThrow return CT_Dependent

[zhouyizhou]

Summary

When compile following code without -std=c++17, clang will abort by llvm_unreachable:

class A {
public:

static const char X;

};
const char A::X = 0;

template<typename U> void func() noexcept(U::X);

template<class... B, char x>
void foo(void(B...) noexcept(x)) {}

void bar()
{

foo(func<A>);

}

So, my solution is to let EST_Uninstantiated in FunctionProtoType::canThrow return CT_Dependent

Thanks
Zhouyi Zhou <[e-mail]>

[erichkeane]

This seems reasonable to me, but can you please add a lit test and fix the format of the code in your commit message?

[zhouyizhou]

In D121498#3379222, @erichkeane wrote:

This seems reasonable to me, but can you please add a lit test and fix the format of the code in your commit message?

Thank you for reviewing the patch for me ;-) I am a beginner, please give me a couple of days to add the lit test and fix the format of the code in my commit message and make my patch better.

Thanks again
Zhouyi

[erichkeane]

1 small request, otherwise LGTM.

clang/lib/AST/Type.cpp

3330

Slight preference for moving just this line to 3351 (above or below) to get the fallthrough behavior on the existing CT_Dependent without condition.

[erichkeane]

LGTM! Let me know if you need me to commit this for you (and if so, what name/email address you'd like it committed under).

[zhouyizhou]

In D121498#3385896, @erichkeane wrote:

LGTM! Let me know if you need me to commit this for you (and if so, what name/email address you'd like it committed under).

Thank you for your guidance!
I do need you to commit this for me. I want my name and following email address be committed with the patch:
Zhouyi Zhou<[e-mail]>

Thanks again
Zhouyi

clang/lib/AST/Type.cpp

3330

thank you for your guidance, thanks zhouyi

clang/lib/AST/Type.cpp

if (ET->isInstantiationDependentType())
       return true;
   return false;
 }
 
 CanThrowResult FunctionProtoType::canThrow() const {
   switch (getExceptionSpecType()) {
   case EST_Unparsed:
   case EST_Unevaluated:
-  case EST_Uninstantiated:
     llvm_unreachable("should not call this with unresolved exception specs");
 
   case EST_DynamicNone:
   case EST_BasicNoexcept:
   case EST_NoexceptTrue:
   case EST_NoThrow:
     return CT_Cannot;
 
   case EST_None:
   case EST_MSAny:
   case EST_NoexceptFalse:
     return CT_Can;
 
   case EST_Dynamic:
     // A dynamic exception specification is throwing unless every exception
     // type is an (unexpanded) pack expansion type.
     for (unsigned I = 0; I != getNumExceptions(); ++I)
       if (!getExceptionType(I)->getAs<PackExpansionType>())
         return CT_Can;
     return CT_Dependent;
 
+  case EST_Uninstantiated:
   case EST_DependentNoexcept:
     return CT_Dependent;
   }
 
   llvm_unreachable("unexpected exception specification kind");
 }
 
 bool FunctionProtoType::isTemplateVariadic() const {

clang/test/SemaTemplate/class-template-noexcept.cpp

+// RUN: %clang_cc1 -verify %s
+// RUN: %clang_cc1 -std=c++11 -verify %s
+// RUN: %clang_cc1 -std=c++17 -verify %s
+// RUN: %clang_cc1 -std=c++1z -verify %s
+#if __cplusplus >= 201703
+// expected-no-diagnostics
+#endif
+class A {
+public:
+  static const char X;
+};
+const char A::X = 0;
+
+template<typename U> void func() noexcept(U::X);
+
+template<class... B, char x>
+#if __cplusplus >= 201703
+void foo(void(B...) noexcept(x)) {} 
+#else
+void foo(void(B...) noexcept(x)) {} // expected-note{{candidate template ignored}}
+#endif
+
+void bar()
+{
+#if __cplusplus >= 201703
+  foo(func<A>);
+#else
+  foo(func<A>);  // expected-error{{no matching function for call}}
+#endif  
+}
+
+