[clang][AST] Fix crash when printing error

[ellis]

Summary

Clang will crash if it tries to compile the following code. This commit
fixes it.

$ cat foo.c
void foo(_Nullable int *ptr) {
    __auto_type _Nonnull a = ptr;
};
$ clang foo.c -c -Wnullable-to-nonnull-conversion

[ellis]

clang/lib/AST/TypePrinter.cpp

242

Hi @dblaikie, I'm not familiar with this code but I'm wondering if these uses of T should actually be UnderlyingType. Will this cause a crash similar to what I found?

[sammccall]

clang/lib/AST/TypePrinter.cpp

242

There's no functional difference - these helpers all start with getAs<SomeTypeClass> so they'll see through the sugar on T.

Potentially UnderlyingType does a bit less work (since there's less sugar to look through) while T is marginally more obvious (to me at least). I wouldn't change it, I doubt this matters at all.

clang/lib/AST/TypePrinter.cpp

switch (TC) {
     case Type::Atomic:
     case Type::Pipe:
     case Type::BitInt:
     case Type::DependentBitInt:
       CanPrefixQualifiers = true;
       break;
 
     case Type::ObjCObjectPointer:
       CanPrefixQualifiers = T->isObjCIdType() || T->isObjCClassType() ||
         T->isObjCQualifiedIdType() || T->isObjCQualifiedClassType();
       break;
 
     case Type::VariableArray:
     case Type::DependentSizedArray:
       NeedARCStrongQualifier = true;
       LLVM_FALLTHROUGH;
 
switch (TC) {
     case Type::SubstTemplateTypeParm:
     case Type::MacroQualified:
       CanPrefixQualifiers = false;
       break;
 
     case Type::Attributed: {
       // We still want to print the address_space before the type if it is an
       // address_space attribute.
-      const auto *AttrTy = cast<AttributedType>(T);
+      const auto *AttrTy = cast<AttributedType>(UnderlyingType);
       CanPrefixQualifiers = AttrTy->getAttrKind() == attr::AddressSpace;
     }
   }
 
   return CanPrefixQualifiers;
 }
 
 void TypePrinter::printBefore(QualType T, raw_ostream &OS) {

clang/test/Sema/nullability.c

_Nonnull int *returns_int_ptr(int x) {
   return (_Nonnull int *)0;
 }
 
 // Check nullable-to-nonnull conversions.
 void nullable_to_nonnull(_Nullable int *ptr) {
   int *a = ptr; // okay
   _Nonnull int *b = ptr; // expected-warning{{implicit conversion from nullable pointer 'int * _Nullable' to non-nullable pointer type 'int * _Nonnull'}}
   b = ptr; // expected-warning{{implicit conversion from nullable pointer 'int * _Nullable' to non-nullable pointer type 'int * _Nonnull'}}
+  __auto_type _Nonnull c = ptr; // expected-warning{{implicit conversion from nullable pointer 'int * _Nullable' to non-nullable pointer type 'int * _Nullable _Nonnull'}}
 
   accepts_nonnull_1(ptr); // expected-warning{{implicit conversion from nullable pointer 'int * _Nullable' to non-nullable pointer type 'int * _Nonnull'}}
 }
 
 // Check nullability of conditional expressions.
 void conditional_expr(int c) {
   int * _Nonnull p;
   int * _Nonnull nonnullP;