Fix segfault caused by the "libstdc++ eager exception spec hack"

[bmoody]

Summary

Segfault occurs when the hack is applied to a function decl containing
an unparsed default argument. Parser::HandleMemberFunctionDeclDelays
was assuming that if a decl contains an unparsed default arg then it
must also have an unparsed exception spec. This causes a
read-from-wrong-union-member on FunctionTypeInfo::ExceptionSpecTokens,
triggering a segfault later on when the pointer is used.

clang/lib/Parse/ParseDeclCXX.cpp

void Parser::HandleMemberFunctionDeclDelays(Declarator& DeclaratorInfo,
   if (NeedLateParse) {
     // Push this method onto the stack of late-parsed method
     // declarations.
     auto LateMethod = new LateParsedMethodDeclaration(this, ThisDecl);
     getCurrentClass().LateParsedDeclarations.push_back(LateMethod);
     LateMethod->TemplateScope = getCurScope()->isTemplateParamScope();
 
     // Stash the exception-specification tokens in the late-pased method.
+    if (FTI.getExceptionSpecType() == EST_Unparsed) {
       LateMethod->ExceptionSpecTokens = FTI.ExceptionSpecTokens;
       FTI.ExceptionSpecTokens = nullptr;
+    }
 
     // Push tokens for each parameter.  Those that do not have
     // defaults will be NULL.
     LateMethod->DefaultArgs.reserve(FTI.NumParams);
     for (unsigned ParamIdx = 0; ParamIdx < FTI.NumParams; ++ParamIdx)
       LateMethod->DefaultArgs.push_back(LateParsedDefaultArgument(
           FTI.Params[ParamIdx].Param,
           std::move(FTI.Params[ParamIdx].DefaultArgTokens)));

clang/test/SemaCXX/libstdcxx_pair_swap_hack.cpp

 // This is a test for an egregious hack in Clang that works around
 // an issue with GCC's <utility> implementation. std::pair::swap
 // has an exception specification that makes an unqualified call to
 // swap. This is invalid, because it ends up calling itself with
 // the wrong number of arguments.
 //
 // The same problem afflicts a bunch of other class templates. Those
 // affected are array, pair, priority_queue, stack, and queue.
 
 // RUN: %clang_cc1 -fsyntax-only %s -std=c++11 -verify -fexceptions -fcxx-exceptions -DCLASS=array
 // RUN: %clang_cc1 -fsyntax-only %s -std=c++11 -verify -fexceptions -fcxx-exceptions -DCLASS=array -DPR28423
+// RUN: %clang_cc1 -fsyntax-only %s -std=c++11 -verify -fexceptions -fcxx-exceptions -DCLASS=array -DDEFAULT_ARG
 // RUN: %clang_cc1 -fsyntax-only %s -std=c++11 -verify -fexceptions -fcxx-exceptions -DCLASS=pair
 // RUN: %clang_cc1 -fsyntax-only %s -std=c++11 -verify -fexceptions -fcxx-exceptions -DCLASS=priority_queue
 // RUN: %clang_cc1 -fsyntax-only %s -std=c++11 -verify -fexceptions -fcxx-exceptions -DCLASS=stack
 // RUN: %clang_cc1 -fsyntax-only %s -std=c++11 -verify -fexceptions -fcxx-exceptions -DCLASS=queue
 //
 // RUN: %clang_cc1 -fsyntax-only %s -std=c++11 -verify -fexceptions -fcxx-exceptions -DCLASS=array -DNAMESPACE=__debug
 // RUN: %clang_cc1 -fsyntax-only %s -std=c++11 -verify -fexceptions -fcxx-exceptions -DCLASS=array -DNAMESPACE=__profile
 

 #endif
 
   template<typename A, typename B> struct CLASS {
 #ifdef MSVC
     void swap(CLASS &other) noexcept(noexcept(do_swap(member, other.member)));
 #endif
     A member;
 #ifndef MSVC
+#ifndef DEFAULT_ARG
     void swap(CLASS &other) noexcept(noexcept(swap(member, other.member)));
+#else
+    void swap(CLASS &other, int = 0) noexcept(noexcept(swap(member, other.member)));
+#endif
 #endif
   };
 
 //  template<typename T> void do_swap(T &, T &);
 //  template<typename A> struct vector {
 //    void swap(vector &other) noexcept(noexcept(do_swap(member, other.member)));
 //    A member;
 //  };