Add QualType::getNullability for _Optional

[chrisbazley]

Summary

The purpose of this change is to ensure that a
qualified declaration such as '_Optional int *' is
treated as equivalent to the annotated declaration
'int *_Nullable' in all situations where type
qualifiers are available.

The new method falls back to Type::getNullability() if
called for a QualType which is not a pointer to an
_Optional-qualified type.

Updated all of the callers which previously invoked
Type::getNullability() via QualType::operator->() so
that they call the new method directly on the QualType
instead.

[chrisbazley]

Please refer to https://discourse.llvm.org/t/rfc-optional-a-type-qualifier-to-indicate-pointer-nullability/ and https://www.open-std.org/jtc1/sc22/wg14/www/docs/n3089.pdf for the wider context of this commit.

clang-tools-extra/clangd/unittests/DiagnosticsTests.cpp

TEST(DiagnosticsTest, PreambleWithPragmaAssumeNonnull) {
   auto TU = TestTU::withCode(R"cpp(
 #pragma clang assume_nonnull begin
 void foo(int *x);
 #pragma clang assume_nonnull end
 )cpp");
   auto AST = TU.build();
   EXPECT_THAT(*AST.getDiagnostics(), IsEmpty());
   const auto *X = cast<FunctionDecl>(findDecl(AST, "foo")).getParamDecl(0);
-  ASSERT_TRUE(X->getOriginalType()->getNullability() ==
+  ASSERT_TRUE(X->getOriginalType().getNullability() ==
               NullabilityKind::NonNull);
 }
 
 TEST(DiagnosticsTest, PreambleHeaderWithBadPragmaAssumeNonnull) {
   Annotations Header(R"cpp(
 #pragma clang assume_nonnull begin  // error-ok
 void foo(int *X);
 )cpp");
   auto TU = TestTU::withCode(R"cpp(
 #include "foo.h"  // unterminated assume_nonnull should not affect bar.
 void bar(int *Y);
 )cpp");
   TU.AdditionalFiles = {{"foo.h", std::string(Header.code())}};
   auto AST = TU.build();
   EXPECT_THAT(*AST.getDiagnostics(),
               ElementsAre(diagName("pp_eof_in_assume_nonnull")));
   const auto *X = cast<FunctionDecl>(findDecl(AST, "foo")).getParamDecl(0);
-  ASSERT_TRUE(X->getOriginalType()->getNullability() ==
+  ASSERT_TRUE(X->getOriginalType().getNullability() ==
               NullabilityKind::NonNull);
   const auto *Y = cast<FunctionDecl>(findDecl(AST, "bar")).getParamDecl(0);
-  ASSERT_FALSE(Y->getOriginalType()->getNullability());
+  ASSERT_FALSE(Y->getOriginalType().getNullability());
 }
 
 TEST(DiagnosticsTest, InsideMacros) {
   Annotations Test(R"cpp(
     #define TEN 10
     #define RET(x) return x + 10
 
     int* foo() {

clang/include/clang/AST/ASTContext.h

public:
   /// cvr-qualifiers have been removed.
   bool hasSameUnqualifiedType(QualType T1, QualType T2) const {
     return getCanonicalType(T1).getTypePtr() ==
            getCanonicalType(T2).getTypePtr();
   }
 
   bool hasSameNullabilityTypeQualifier(QualType SubT, QualType SuperT,
                                        bool IsParam) const {
-    auto SubTnullability = SubT->getNullability();
-    auto SuperTnullability = SuperT->getNullability();
+    auto SubTnullability = SubT.getNullability();
+    auto SuperTnullability = SuperT.getNullability();
     if (SubTnullability.has_value() == SuperTnullability.has_value()) {
       // Neither has nullability; return true
       if (!SubTnullability)
         return true;
       // Both have nullability qualifier.
       if (*SubTnullability == *SuperTnullability ||
           *SubTnullability == NullabilityKind::Unspecified ||
           *SuperTnullability == NullabilityKind::Unspecified)

clang/include/clang/AST/Type.h

QualType substObjCMemberType(QualType objectType,
                                ObjCSubstitutionContext context) const;
 
   /// Strip Objective-C "__kindof" types from the given type.
   QualType stripObjCKindOfType(const ASTContext &ctx) const;
 
   /// Remove all qualifiers including _Atomic.
   QualType getAtomicUnqualifiedType() const;
 
+  /// Determine the nullability of the given type.
+  ///
+  /// Accounts for nullability that is only captured as sugar within the type
+  /// system, as well as when it is part of the canonical type.
+  std::optional<NullabilityKind> getNullability() const;
+
 private:
   // These methods are implemented in a separate translation unit;
   // "static"-ize them to avoid creating temporary QualTypes in the
   // caller.
   static bool isConstant(QualType T, const ASTContext& Ctx);
   static QualType getDesugaredType(QualType T, const ASTContext &Context);
   static SplitQualType getSplitDesugaredType(QualType T);
   static SplitQualType getSplitUnqualifiedTypeImpl(QualType type);

clang/lib/AST/ASTContext.cpp

QualType ASTContext::getArrayDecayedType(QualType Ty) const {
 
   QualType PtrTy = getPointerType(PrettyArrayType->getElementType());
 
   // int x[restrict 4] ->  int *restrict
   QualType Result = getQualifiedType(PtrTy,
                                      PrettyArrayType->getIndexTypeQualifiers());
 
   // int x[_Nullable] -> int * _Nullable
-  if (auto Nullability = Ty->getNullability()) {
+  if (auto Nullability = Ty.getNullability()) {
     Result = const_cast<ASTContext *>(this)->getAttributedType(
         AttributedType::getNullabilityAttrKind(*Nullability), Result, Result);
   }
   return Result;
 }
 
 QualType ASTContext::getBaseElementType(const ArrayType *array) const {
   return getBaseElementType(array->getElementType());

clang/lib/AST/Type.cpp

 }
 
 QualType QualType::getAtomicUnqualifiedType() const {
   if (const auto AT = getTypePtr()->getAs<AtomicType>())
     return AT->getValueType().getUnqualifiedType();
   return getUnqualifiedType();
 }
 
+std::optional<NullabilityKind> QualType::getNullability() const {
+  if (const PointerType *PT = getTypePtr()->getAs<PointerType>()) {
+    auto PointeeType = PT->getPointeeType();
+    if (PointeeType.isOptionalQualified()) {
+      return NullabilityKind::Nullable;
+    }
+  }
+  return getTypePtr()->getNullability();
+}
+
 std::optional<ArrayRef<QualType>>
 Type::getObjCSubstitutions(const DeclContext *dc) const {
   // Look through method scopes.
   if (const auto method = dyn_cast<ObjCMethodDecl>(dc))
     dc = method->getDeclContext();
 
   // Find the class or category in which the type we're substituting
   // was declared.

clang/lib/CodeGen/CGCall.cpp

void CodeGenFunction::EmitNonNullArgCheck(RValue RV, QualType ArgType,
 
   // Prefer the nonnull attribute if it's present.
   const NonNullAttr *NNAttr = nullptr;
   if (SanOpts.has(SanitizerKind::NonnullAttribute))
     NNAttr = getNonNullAttr(AC.getDecl(), PVD, ArgType, ArgNo);
 
   bool CanCheckNullability = false;
   if (SanOpts.has(SanitizerKind::NullabilityArg) && !NNAttr && PVD) {
-    auto Nullability = PVD->getType()->getNullability();
+    auto Nullability = PVD->getType().getNullability();
     CanCheckNullability = Nullability &&
                           *Nullability == NullabilityKind::NonNull &&
                           PVD->getTypeSourceInfo();
   }
 
   if (!NNAttr && !CanCheckNullability)
     return;
 

clang/lib/CodeGen/CGDecl.cpp

static void drillIntoBlockVariable(CodeGenFunction &CGF,
   lvalue.setAddress(CGF.emitBlockByrefAddress(lvalue.getAddress(CGF), var));
 }
 
 void CodeGenFunction::EmitNullabilityCheck(LValue LHS, llvm::Value *RHS,
                                            SourceLocation Loc) {
   if (!SanOpts.has(SanitizerKind::NullabilityAssign))
     return;
 
-  auto Nullability = LHS.getType()->getNullability();
+  auto Nullability = LHS.getType().getNullability();
   if (!Nullability || *Nullability != NullabilityKind::NonNull)
     return;
 
   // Check if the right hand side of the assignment is nonnull, if the left
   // hand side must be nonnull.
   SanitizerScope SanScope(this);
   llvm::Value *IsNotNull = Builder.CreateIsNotNull(RHS);
   llvm::Constant *StaticData[] = {
void CodeGenFunction::EmitParmDecl(const VarDecl &D, ParamValue Arg,
 
   if (D.hasAttr<AnnotateAttr>())
     EmitVarAnnotations(&D, DeclPtr.getPointer());
 
   // We can only check return value nullability if all arguments to the
   // function satisfy their nullability preconditions. This makes it necessary
   // to emit null checks for args in the function body itself.
   if (requiresReturnValueNullabilityCheck()) {
-    auto Nullability = Ty->getNullability();
+    auto Nullability = Ty.getNullability();
     if (Nullability && *Nullability == NullabilityKind::NonNull) {
       SanitizerScope SanScope(this);
       RetValNullabilityPrecondition =
           Builder.CreateAnd(RetValNullabilityPrecondition,
                             Builder.CreateIsNotNull(Arg.getAnyValue()));
     }
   }
 }

clang/lib/CodeGen/CodeGenFunction.cpp

if (llvm::Constant *PrologueSig = getPrologueSignature(CGM, FD)) {
                       MDB.createRTTIPointerPrologue(PrologueSig, FTRTTIProxy));
       CGM.addCompilerUsedGlobal(FTRTTIProxy);
     }
   }
 
   // If we're checking nullability, we need to know whether we can check the
   // return value. Initialize the flag to 'true' and refine it in EmitParmDecl.
   if (SanOpts.has(SanitizerKind::NullabilityReturn)) {
-    auto Nullability = FnRetTy->getNullability();
+    auto Nullability = FnRetTy.getNullability();
     if (Nullability && *Nullability == NullabilityKind::NonNull) {
       if (!(SanOpts.has(SanitizerKind::ReturnsNonnullAttribute) &&
             CurCodeDecl && CurCodeDecl->getAttr<ReturnsNonNullAttr>()))
         RetValNullabilityPrecondition =
             llvm::ConstantInt::getTrue(getLLVMContext());
     }
   }
 

clang/lib/Sema/Sema.cpp

void Sema::PrintStats() const {
 
   BumpAlloc.PrintStats();
   AnalysisWarnings.PrintStats();
 }
 
 void Sema::diagnoseNullableToNonnullConversion(QualType DstType,
                                                QualType SrcType,
                                                SourceLocation Loc) {
-  std::optional<NullabilityKind> ExprNullability = SrcType->getNullability();
+  std::optional<NullabilityKind> ExprNullability = SrcType.getNullability();
   if (!ExprNullability || (*ExprNullability != NullabilityKind::Nullable &&
                            *ExprNullability != NullabilityKind::NullableResult))
     return;
 
-  std::optional<NullabilityKind> TypeNullability = DstType->getNullability();
+  std::optional<NullabilityKind> TypeNullability = DstType.getNullability();
   if (!TypeNullability || *TypeNullability != NullabilityKind::NonNull)
     return;
 
   Diag(Loc, diag::warn_nullability_lost) << SrcType << DstType;
 }
 
 void Sema::diagnoseZeroToNullptrConversion(CastKind Kind, const Expr *E) {
   // nullptr only exists from C++11 on, so don't warn on its absence earlier.

clang/lib/Sema/SemaChecking.cpp

bool Sema::getFormatStringInfo(const FormatAttr *Format, bool IsCXXMember,
   return true;
 }
 
 /// Checks if a the given expression evaluates to null.
 ///
 /// Returns true if the value evaluates to null.
 static bool CheckNonNullExpr(Sema &S, const Expr *Expr) {
   // If the expression has non-null type, it doesn't evaluate to null.
-  if (auto nullability = Expr->IgnoreImplicit()->getType()->getNullability()) {
+  if (auto nullability = Expr->IgnoreImplicit()->getType().getNullability()) {
     if (*nullability == NullabilityKind::NonNull)
       return false;
   }
 
   // As a special case, transparent unions initialized with zero are
   // considered null for the purposes of the nonnull attribute.
   if (const RecordType *UT = Expr->getType()->getAsUnionType()) {
     if (UT->getDecl()->hasAttr<TransparentUnionAttr>())
S.Diag(FormatExpr->getExprLoc(), diag::warn_objc_cdirective_format_string)
       << "%s" << 1 << 1;
     S.Diag(FDecl->getLocation(), diag::note_entity_declared_at)
       << FDecl->getDeclName();
   }
 }
 
 /// Determine whether the given type has a non-null nullability annotation.
 static bool isNonNullType(QualType type) {
-  if (auto nullability = type->getNullability())
+  if (auto nullability = type.getNullability())
     return *nullability == NullabilityKind::NonNull;
 
   return false;
 }
 
 static void CheckNonNullArguments(Sema &S,
                                   const NamedDecl *FDecl,
                                   const FunctionProtoType *Proto,

clang/lib/Sema/SemaDecl.cpp

static bool EquivalentArrayTypes(QualType Old, QualType New,
   }
 
   return Old == New;
 }
 
 static void mergeParamDeclTypes(ParmVarDecl *NewParam,
                                 const ParmVarDecl *OldParam,
                                 Sema &S) {
-  if (auto Oldnullability = OldParam->getType()->getNullability()) {
-    if (auto Newnullability = NewParam->getType()->getNullability()) {
+  if (auto Oldnullability = OldParam->getType().getNullability()) {
+    if (auto Newnullability = NewParam->getType().getNullability()) {
       if (*Oldnullability != *Newnullability) {
         S.Diag(NewParam->getLocation(), diag::warn_mismatched_nullability_attr)
           << DiagNullabilityKind(
                *Newnullability,
                ((NewParam->getObjCDeclQualifier() & Decl::OBJC_TQ_CSNullability)
                 != 0))
           << DiagNullabilityKind(
                *Oldnullability,

clang/lib/Sema/SemaDeclObjC.cpp

if (IsProtocolMethodDecl &&
     else
       return false;
   }
   if (Warn && IsOverridingMode &&
       !isa<ObjCImplementationDecl>(MethodImpl->getDeclContext()) &&
       !S.Context.hasSameNullabilityTypeQualifier(MethodImpl->getReturnType(),
                                                  MethodDecl->getReturnType(),
                                                  false)) {
-    auto nullabilityMethodImpl = *MethodImpl->getReturnType()->getNullability();
-    auto nullabilityMethodDecl = *MethodDecl->getReturnType()->getNullability();
+    auto nullabilityMethodImpl = *MethodImpl->getReturnType().getNullability();
+    auto nullabilityMethodDecl = *MethodDecl->getReturnType().getNullability();
     S.Diag(MethodImpl->getLocation(),
            diag::warn_conflicting_nullability_attr_overriding_ret_types)
         << DiagNullabilityKind(nullabilityMethodImpl,
                                ((MethodImpl->getObjCDeclQualifier() &
                                  Decl::OBJC_TQ_CSNullability) != 0))
         << DiagNullabilityKind(nullabilityMethodDecl,
                                ((MethodDecl->getObjCDeclQualifier() &
                                  Decl::OBJC_TQ_CSNullability) != 0));
static bool CheckMethodOverrideParam(Sema &S,
 
   QualType ImplTy = ImplVar->getType();
   QualType IfaceTy = IfaceVar->getType();
   if (Warn && IsOverridingMode &&
       !isa<ObjCImplementationDecl>(MethodImpl->getDeclContext()) &&
       !S.Context.hasSameNullabilityTypeQualifier(ImplTy, IfaceTy, true)) {
     S.Diag(ImplVar->getLocation(),
            diag::warn_conflicting_nullability_attr_overriding_param_types)
-        << DiagNullabilityKind(*ImplTy->getNullability(),
+        << DiagNullabilityKind(*ImplTy.getNullability(),
                                ((ImplVar->getObjCDeclQualifier() &
                                  Decl::OBJC_TQ_CSNullability) != 0))
-        << DiagNullabilityKind(*IfaceTy->getNullability(),
+        << DiagNullabilityKind(*IfaceTy.getNullability(),
                                ((IfaceVar->getObjCDeclQualifier() &
                                  Decl::OBJC_TQ_CSNullability) != 0));
     S.Diag(IfaceVar->getLocation(), diag::note_previous_declaration);
   }
   if (S.Context.hasSameUnqualifiedType(ImplTy, IfaceTy))
     return true;
 
   if (!Warn)

 /// producing the updated type of the redeclared entity.
 static QualType mergeTypeNullabilityForRedecl(Sema &S, SourceLocation loc,
                                               QualType type,
                                               bool usesCSKeyword,
                                               SourceLocation prevLoc,
                                               QualType prevType,
                                               bool prevUsesCSKeyword) {
   // Determine the nullability of both types.
-  auto nullability = type->getNullability();
-  auto prevNullability = prevType->getNullability();
+  auto nullability = type.getNullability();
+  auto prevNullability = prevType.getNullability();
 
   // Easy case: both have nullability.
   if (nullability.has_value() == prevNullability.has_value()) {
     // Neither has nullability; continue.
     if (!nullability)
       return type;
 
     // The nullabilities are equivalent; do nothing.

clang/lib/Sema/SemaExpr.cpp

 /// Compute the nullability of a conditional expression.
 static QualType computeConditionalNullability(QualType ResTy, bool IsBin,
                                               QualType LHSTy, QualType RHSTy,
                                               ASTContext &Ctx) {
   if (!ResTy->isAnyPointerType())
     return ResTy;
 
   auto GetNullability = [](QualType Ty) {
-    std::optional<NullabilityKind> Kind = Ty->getNullability();
+    std::optional<NullabilityKind> Kind = Ty.getNullability();
     if (Kind) {
       // For our purposes, treat _Nullable_result as _Nullable.
       if (*Kind == NullabilityKind::NullableResult)
         return NullabilityKind::Nullable;
       return *Kind;
     }
     return NullabilityKind::Unspecified;
   };
else
       MergedKind = NullabilityKind::Unspecified;
   }
 
   // Return if ResTy already has the correct nullability.
   if (GetNullability(ResTy) == MergedKind)
     return ResTy;
 
   // Strip all nullability from ResTy.
-  while (ResTy->getNullability())
+  while (ResTy.getNullability())
     ResTy = ResTy.getSingleStepDesugaredType(Ctx);
 
   // Create a new AttributedType with the new nullability kind.
   auto NewAttr = AttributedType::getNullabilityAttrKind(MergedKind);
   return Ctx.getAttributedType(NewAttr, ResTy, ResTy);
 }
 
 /// ActOnConditionalOp - Parse a ?: operation.  Note that 'LHS' may be null

clang/lib/Sema/SemaExprObjC.cpp

if (Context.hasSameUnqualifiedType(PointeeType, Context.CharTy)) {
 
         StringWithUTF8StringMethod = BoxingMethod;
       }
 
       BoxingMethod = StringWithUTF8StringMethod;
       BoxedType = NSStringPointer;
       // Transfer the nullability from method's return type.
       std::optional<NullabilityKind> Nullability =
-          BoxingMethod->getReturnType()->getNullability();
+          BoxingMethod->getReturnType().getNullability();
       if (Nullability)
         BoxedType = Context.getAttributedType(
             AttributedType::getNullabilityAttrKind(*Nullability), BoxedType,
             BoxedType);
     }
   } else if (ValueType->isBuiltinType()) {
     // The other types we support are numeric, char and BOOL/bool. We could also
     // provide limited support for structure types, such as NSRange, NSRect, and
static QualType getBaseMessageSendResultType(Sema &S,
 
   ASTContext &Context = S.Context;
 
   // Local function that transfers the nullability of the method's
   // result type to the returned result.
   auto transferNullability = [&](QualType type) -> QualType {
     // If the method's result type has nullability, extract it.
     if (auto nullability =
-            Method->getSendResultType(ReceiverType)->getNullability()) {
+            Method->getSendResultType(ReceiverType).getNullability()) {
       // Strip off any outer nullability sugar from the provided type.
       (void)AttributedType::stripOuterNullability(type);
 
       // Form a new attributed type using the method result type's nullability.
       return Context.getAttributedType(
                AttributedType::getNullabilityAttrKind(*nullability),
                type,
                type);
if (Receiver && Receiver->isObjCSelfExpr()) {
       if (T == Context.getObjCInstanceType()) {
         const ObjCMethodDecl *MD = cast<ObjCMethodDecl>(
             cast<ImplicitParamDecl>(
                 cast<DeclRefExpr>(Receiver->IgnoreParenImpCasts())->getDecl())
                 ->getDeclContext());
         assert(MD->isClassMethod() && "expected a class method");
         QualType NewResultType = Context.getObjCObjectPointerType(
             Context.getObjCInterfaceType(MD->getClassInterface()));
-        if (auto Nullability = resultType->getNullability())
+        if (auto Nullability = resultType.getNullability())
           NewResultType = Context.getAttributedType(
               AttributedType::getNullabilityAttrKind(*Nullability),
               NewResultType, NewResultType);
         return NewResultType;
       }
     }
     return resultType;
   }
 
   // There is nothing left to do if the result type cannot have a nullability
   // specifier.
   if (!resultType->canHaveNullability())
     return resultType;
 
   // Map the nullability of the result into a table index.
   unsigned receiverNullabilityIdx = 0;
   if (std::optional<NullabilityKind> nullability =
-          ReceiverType->getNullability()) {
+          ReceiverType.getNullability()) {
     if (*nullability == NullabilityKind::NullableResult)
       nullability = NullabilityKind::Nullable;
     receiverNullabilityIdx = 1 + static_cast<unsigned>(*nullability);
   }
 
   unsigned resultNullabilityIdx = 0;
   if (std::optional<NullabilityKind> nullability =
-          resultType->getNullability()) {
+          resultType.getNullability()) {
     if (*nullability == NullabilityKind::NullableResult)
       nullability = NullabilityKind::Nullable;
     resultNullabilityIdx = 1 + static_cast<unsigned>(*nullability);
   }
 
   // The table of nullability mappings, indexed by the receiver's nullability
   // and then the result type's nullability.
   static const uint8_t None = 0;
QualType Sema::getMessageSendResultType(const Expr *Receiver,
   // Strip off the existing nullability. This removes as little type sugar as
   // possible.
   do {
     if (auto attributed = dyn_cast<AttributedType>(resultType.getTypePtr())) {
       resultType = attributed->getModifiedType();
     } else {
       resultType = resultType.getDesugaredType(Context);
     }
-  } while (resultType->getNullability());
+  } while (resultType.getNullability());
 
   // Add nullability back if needed.
   if (newResultNullabilityIdx > 0) {
     auto newNullability
       = static_cast<NullabilityKind>(newResultNullabilityIdx-1);
     return Context.getAttributedType(
              AttributedType::getNullabilityAttrKind(newNullability),
              resultType, resultType);

clang/lib/Sema/SemaLambda.cpp

void Sema::deduceClosureReturnType(CapturingScopeInfo &CSI) {
   for (const ReturnStmt *RS : CSI.Returns) {
     const Expr *RetE = RS->getRetValue();
 
     QualType ReturnType =
         (RetE ? RetE->getType() : Context.VoidTy).getUnqualifiedType();
     if (Context.getCanonicalFunctionResultType(ReturnType) ==
           Context.getCanonicalFunctionResultType(CSI.ReturnType)) {
       // Use the return type with the strictest possible nullability annotation.
-      auto RetTyNullability = ReturnType->getNullability();
-      auto BlockNullability = CSI.ReturnType->getNullability();
+      auto RetTyNullability = ReturnType.getNullability();
+      auto BlockNullability = CSI.ReturnType.getNullability();
       if (BlockNullability &&
           (!RetTyNullability ||
            hasWeakerNullability(*RetTyNullability, *BlockNullability)))
         CSI.ReturnType = ReturnType;
       continue;
     }
 
     // FIXME: This is a poor diagnostic for ReturnStmts without expressions.

clang/lib/Sema/SemaObjCProperty.cpp

Attributes &= ~ObjCPropertyAttribute::kind_retain;
              (Attributes & ObjCPropertyAttribute::kind_weak)) {
     Diag(Loc, diag::err_objc_property_attr_mutually_exclusive) << "strong"
                                                                << "weak";
     Attributes &= ~ObjCPropertyAttribute::kind_weak;
   }
 
   if (Attributes & ObjCPropertyAttribute::kind_weak) {
     // 'weak' and 'nonnull' are mutually exclusive.
-    if (auto nullability = PropertyTy->getNullability()) {
+    if (auto nullability = PropertyTy.getNullability()) {
       if (*nullability == NullabilityKind::NonNull)
         Diag(Loc, diag::err_objc_property_attr_mutually_exclusive)
           << "nonnull" << "weak";
     }
   }
 
   if ((Attributes & ObjCPropertyAttribute::kind_atomic) &&
       (Attributes & ObjCPropertyAttribute::kind_nonatomic)) {

clang/lib/Sema/SemaType.cpp

static TypeSourceInfo *GetFullTypeForDeclarator(TypeProcessingState &state,
 
   if (IsTypedefName) {
     // For typedefs, we do not infer any nullability (the default),
     // and we only complain about missing nullability specifiers on
     // inner pointers.
     complainAboutMissingNullability = CAMN_InnerPointers;
 
     if (T->canHaveNullability(/*ResultIfUnknown*/ false) &&
-        !T->getNullability()) {
+        !T.getNullability()) {
       // Note that we allow but don't require nullability on dependent types.
       ++NumPointersRemaining;
     }
 
     for (unsigned i = 0, n = D.getNumTypeObjects(); i != n; ++i) {
       DeclaratorChunk &chunk = D.getTypeObject(i);
       switch (chunk.Kind) {
       case DeclaratorChunk::Array:
auto inferPointerNullability =
     }
     return nullptr;
   };
 
   // If the type itself could have nullability but does not, infer pointer
   // nullability and perform consistency checking.
   if (S.CodeSynthesisContexts.empty()) {
     if (T->canHaveNullability(/*ResultIfUnknown*/ false) &&
-        !T->getNullability()) {
+        !T.getNullability()) {
       if (isVaList(T)) {
         // Record that we've seen a pointer, but do nothing else.
         if (NumPointersRemaining > 0)
           --NumPointersRemaining;
       } else {
         SimplePointerKind pointerKind = SimplePointerKind::Pointer;
         if (T->isBlockPointerType())
           pointerKind = SimplePointerKind::BlockPointer;
         else if (T->isMemberPointerType())
           pointerKind = SimplePointerKind::MemberPointer;
 
         if (auto *attr = inferPointerNullability(
                 pointerKind, D.getDeclSpec().getTypeSpecTypeLoc(),
                 D.getDeclSpec().getEndLoc(),
                 D.getMutableDeclSpec().getAttributes(),
                 D.getMutableDeclSpec().getAttributePool())) {
           T = state.getAttributedType(
               createNullabilityAttr(Context, *attr, *inferNullability), T, T);
         }
       }
     }
 
     if (complainAboutMissingNullability == CAMN_Yes && T->isArrayType() &&
-        !T->getNullability() && !isVaList(T) && D.isPrototypeContext() &&
+        !T.getNullability() && !isVaList(T) && D.isPrototypeContext() &&
         !hasOuterPointerLikeChunk(D, D.getNumTypeObjects())) {
       checkNullabilityConsistency(S, SimplePointerKind::Array,
                                   D.getDeclSpec().getTypeSpecTypeLoc());
     }
   }
 
   bool ExpectNoDerefChunk =
       state.getCurrentAttributes().hasAttribute(ParsedAttr::AT_NoDeref);
while (auto attributed = dyn_cast<AttributedType>(desugared.getTypePtr())) {
 
     desugared = attributed->getModifiedType();
   }
 
   // If there is already a different nullability specifier, complain.
   // This (unlike the code above) looks through typedefs that might
   // have nullability specifiers on them, which means we cannot
   // provide a useful Fix-It.
-  if (auto existingNullability = desugared->getNullability()) {
+  if (auto existingNullability = desugared.getNullability()) {
     if (nullability != *existingNullability) {
       S.Diag(nullabilityLoc, diag::err_nullability_conflicting)
         << DiagNullabilityKind(nullability, isContextSensitive)
         << DiagNullabilityKind(*existingNullability, false);
 
       // Try to find the typedef with the existing nullability specifier.
       if (auto typedefType = desugared->getAs<TypedefType>()) {
         TypedefNameDecl *typedefDecl = typedefType->getDecl();
static bool checkObjCKindOfType(TypeProcessingState &state, QualType &type,
   QualType equivType = S.Context.getObjCObjectType(
       objType->getBaseType(), objType->getTypeArgsAsWritten(),
       objType->getProtocols(),
       /*isKindOf=*/objType->isObjCUnqualifiedId() ? false : true);
 
   // If we started with an object pointer type, rebuild it.
   if (ptrType) {
     equivType = S.Context.getObjCObjectPointerType(equivType);
-    if (auto nullability = type->getNullability()) {
+    if (auto nullability = type.getNullability()) {
       // We create a nullability attribute from the __kindof attribute.
       // Make sure that will make sense.
       assert(attr.getAttributeSpellingListIndex() == 0 &&
              "multiple spellings for __kindof?");
       Attr *A = createNullabilityAttr(S.Context, attr, *nullability);
       A->setImplicit(true);
       equivType = state.getAttributedType(A, equivType, equivType);
     }

clang/tools/libclang/CXType.cpp

unsigned clang_Type_isTransparentTagTypedef(CXType TT){
   return false;
 }
 
 enum CXTypeNullabilityKind clang_Type_getNullability(CXType CT) {
   QualType T = GetQualType(CT);
   if (T.isNull())
     return CXTypeNullability_Invalid;
 
-  if (auto nullability = T->getNullability()) {
+  if (auto nullability = T.getNullability()) {
     switch (*nullability) {
       case NullabilityKind::NonNull:
         return CXTypeNullability_NonNull;
       case NullabilityKind::Nullable:
         return CXTypeNullability_Nullable;
       case NullabilityKind::NullableResult:
         return CXTypeNullability_NullableResult;
       case NullabilityKind::Unspecified: