[Sema] Add MacroQualified case for FunctionTypeUnwrapper

[leonardchan]

Summary

This is a fix for PR43315. An assertion error is hit for this minimal example:

//clang -cc1 -triple x86_64-- -S tstVMStructRC-min.cpp
#define a __attribute__((__cdecl__, __regparm__(0))) 
int (a b)();  // Assertion `Chunk.Kind == DeclaratorChunk::Function' failed.

This is because we do not cover the case in the FunctionTypeUnwrapper where it receives a MacroQualifiedType. We have not run into this earlier because this is a unique case where the __attribute__ contains both __cdecl__ and __regparm__ (in that order), and we are compiling for x86_64. Changing the architecture or the order of __cdecl__ and __regparm__ does not raise the assertion.

[dim]

This works for me, and also for the original test case from https://bugs.freebsd.org/240764.

[leonardchan]

*ping* @rsmith

[jkim]

Ping... @rsmith

clang/lib/Sema/SemaType.cpp

namespace {
   struct FunctionTypeUnwrapper {
     enum WrapKind {
       Desugar,
       Attributed,
       Parens,
       Pointer,
       BlockPointer,
       Reference,
-      MemberPointer
+      MemberPointer,
+      MacroQualified,
     };
 
     QualType Original;
     const FunctionType *Fn;
     SmallVector<unsigned char /*WrapKind*/, 8> Stack;
 
     FunctionTypeUnwrapper(Sema &S, QualType T) : Original(T) {
       while (true) {
FunctionTypeUnwrapper(Sema &S, QualType T) : Original(T) {
           T = cast<MemberPointerType>(Ty)->getPointeeType();
           Stack.push_back(MemberPointer);
         } else if (isa<ReferenceType>(Ty)) {
           T = cast<ReferenceType>(Ty)->getPointeeType();
           Stack.push_back(Reference);
         } else if (isa<AttributedType>(Ty)) {
           T = cast<AttributedType>(Ty)->getEquivalentType();
           Stack.push_back(Attributed);
+        } else if (isa<MacroQualifiedType>(Ty)) {
+          T = cast<MacroQualifiedType>(Ty)->getUnderlyingType();
+          Stack.push_back(MacroQualified);
         } else {
           const Type *DTy = Ty->getUnqualifiedDesugaredType();
           if (Ty == DTy) {
             Fn = nullptr;
             return;
           }
 
           T = QualType(DTy, 0);
QualType wrap(ASTContext &C, const Type *Old, unsigned I) {
       case Attributed:
         return wrap(C, cast<AttributedType>(Old)->getEquivalentType(), I);
 
       case Parens: {
         QualType New = wrap(C, cast<ParenType>(Old)->getInnerType(), I);
         return C.getParenType(New);
       }
 
+      case MacroQualified:
+        return wrap(C, cast<MacroQualifiedType>(Old)->getUnderlyingType(), I);
+
       case Pointer: {
         QualType New = wrap(C, cast<PointerType>(Old)->getPointeeType(), I);
         return C.getPointerType(New);
       }
 
       case BlockPointer: {
         QualType New = wrap(C, cast<BlockPointerType>(Old)->getPointeeType(),I);
         return C.getBlockPointerType(New);

clang/test/Frontend/macro_defined_type.cpp

void Func() {
   auto NODEREF auto_i2 = i; // expected-warning{{'noderef' can only be used on an array or pointer type}}
 }
 
 // Added test for fix for P41835
 #define _LIBCPP_FLOAT_ABI __attribute__((pcs("aapcs")))
 struct A {
   _LIBCPP_FLOAT_ABI int operator()() throw(); // expected-warning{{'pcs' calling convention is not supported for this target}}
 };
+
+// Added test for fix for PR43315
+#define a __attribute__((__cdecl__, __regparm__(0)))
+int(a b)();