Author: Dani Ferreira Franco Moura Date: 2022-12-16T12:22:23+01:00 New Revision: 0da4cecfb6ad14ee0f0f9fa904e685fd6b64be60
URL: https://github.com/llvm/llvm-project/commit/0da4cecfb6ad14ee0f0f9fa904e685fd6b64be60 DIFF: https://github.com/llvm/llvm-project/commit/0da4cecfb6ad14ee0f0f9fa904e685fd6b64be60.diff LOG: [clang][dataflow] Remove unused argument in getNullability This change will allow users to call getNullability() without providing an ASTContext. Reviewed By: gribozavr2 Differential Revision: https://reviews.llvm.org/D140104 Added: Modified: clang-tools-extra/clangd/unittests/DiagnosticsTests.cpp clang/include/clang/AST/ASTContext.h clang/include/clang/AST/Type.h clang/lib/AST/ASTContext.cpp clang/lib/AST/Type.cpp clang/lib/CodeGen/CGCall.cpp clang/lib/CodeGen/CGDecl.cpp clang/lib/CodeGen/CodeGenFunction.cpp clang/lib/Sema/Sema.cpp clang/lib/Sema/SemaChecking.cpp clang/lib/Sema/SemaDecl.cpp clang/lib/Sema/SemaDeclObjC.cpp clang/lib/Sema/SemaExpr.cpp clang/lib/Sema/SemaExprObjC.cpp clang/lib/Sema/SemaLambda.cpp clang/lib/Sema/SemaObjCProperty.cpp clang/lib/Sema/SemaType.cpp clang/tools/libclang/CXType.cpp Removed: ################################################################################ diff --git a/clang-tools-extra/clangd/unittests/DiagnosticsTests.cpp b/clang-tools-extra/clangd/unittests/DiagnosticsTests.cpp index 2b527142f0d26..f3cfee0570fb6 100644 --- a/clang-tools-extra/clangd/unittests/DiagnosticsTests.cpp +++ b/clang-tools-extra/clangd/unittests/DiagnosticsTests.cpp @@ -874,7 +874,7 @@ void foo(int *x); auto AST = TU.build(); EXPECT_THAT(*AST.getDiagnostics(), IsEmpty()); const auto *X = cast<FunctionDecl>(findDecl(AST, "foo")).getParamDecl(0); - ASSERT_TRUE(X->getOriginalType()->getNullability(X->getASTContext()) == + ASSERT_TRUE(X->getOriginalType()->getNullability() == NullabilityKind::NonNull); } @@ -892,10 +892,10 @@ void bar(int *Y); 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(X->getASTContext()) == + ASSERT_TRUE(X->getOriginalType()->getNullability() == NullabilityKind::NonNull); const auto *Y = cast<FunctionDecl>(findDecl(AST, "bar")).getParamDecl(0); - ASSERT_FALSE(Y->getOriginalType()->getNullability(X->getASTContext())); + ASSERT_FALSE(Y->getOriginalType()->getNullability()); } TEST(DiagnosticsTest, InsideMacros) { diff --git a/clang/include/clang/AST/ASTContext.h b/clang/include/clang/AST/ASTContext.h index 63f48d9ae9871..64cdd63db009f 100644 --- a/clang/include/clang/AST/ASTContext.h +++ b/clang/include/clang/AST/ASTContext.h @@ -2548,8 +2548,8 @@ class ASTContext : public RefCountedBase<ASTContext> { bool hasSameNullabilityTypeQualifier(QualType SubT, QualType SuperT, bool IsParam) const { - auto SubTnullability = SubT->getNullability(*this); - auto SuperTnullability = SuperT->getNullability(*this); + auto SubTnullability = SubT->getNullability(); + auto SuperTnullability = SuperT->getNullability(); if (SubTnullability.has_value() == SuperTnullability.has_value()) { // Neither has nullability; return true if (!SubTnullability) diff --git a/clang/include/clang/AST/Type.h b/clang/include/clang/AST/Type.h index 87cb433177dfa..70f2132e0456f 100644 --- a/clang/include/clang/AST/Type.h +++ b/clang/include/clang/AST/Type.h @@ -2547,7 +2547,9 @@ class alignas(8) Type : public ExtQualsTypeCommonBase { /// Note that nullability is only captured as sugar within the type /// system, not as part of the canonical type, so nullability will /// be lost by canonicalization and desugaring. - Optional<NullabilityKind> getNullability(const ASTContext &context) const; + Optional<NullabilityKind> getNullability() const; + // TODO: Remove overload. + Optional<NullabilityKind> getNullability(const ASTContext &) const; /// Determine whether the given type can have a nullability /// specifier applied to it, i.e., if it is any kind of pointer type. diff --git a/clang/lib/AST/ASTContext.cpp b/clang/lib/AST/ASTContext.cpp index 9aaf7cc6565cb..8887789555afb 100644 --- a/clang/lib/AST/ASTContext.cpp +++ b/clang/lib/AST/ASTContext.cpp @@ -6975,7 +6975,7 @@ QualType ASTContext::getArrayDecayedType(QualType Ty) const { PrettyArrayType->getIndexTypeQualifiers()); // int x[_Nullable] -> int * _Nullable - if (auto Nullability = Ty->getNullability(*this)) { + if (auto Nullability = Ty->getNullability()) { Result = const_cast<ASTContext *>(this)->getAttributedType( AttributedType::getNullabilityAttrKind(*Nullability), Result, Result); } diff --git a/clang/lib/AST/Type.cpp b/clang/lib/AST/Type.cpp index 62383c671f92c..fe7bbcd1479dd 100644 --- a/clang/lib/AST/Type.cpp +++ b/clang/lib/AST/Type.cpp @@ -4141,8 +4141,7 @@ LinkageInfo Type::getLinkageAndVisibility() const { return LinkageComputer{}.getTypeLinkageAndVisibility(this); } -Optional<NullabilityKind> -Type::getNullability(const ASTContext &Context) const { +Optional<NullabilityKind> Type::getNullability() const { QualType Type(this, 0); while (const auto *AT = Type->getAs<AttributedType>()) { // Check whether this is an attributed type with nullability @@ -4154,6 +4153,10 @@ Type::getNullability(const ASTContext &Context) const { } return std::nullopt; } +// TODO: Remove overload. +Optional<NullabilityKind> Type::getNullability(const ASTContext &) const { + return getNullability(); +} bool Type::canHaveNullability(bool ResultIfUnknown) const { QualType type = getCanonicalTypeInternal(); diff --git a/clang/lib/CodeGen/CGCall.cpp b/clang/lib/CodeGen/CGCall.cpp index b94bf401d1949..41c694bc9a542 100644 --- a/clang/lib/CodeGen/CGCall.cpp +++ b/clang/lib/CodeGen/CGCall.cpp @@ -4126,7 +4126,7 @@ void CodeGenFunction::EmitNonNullArgCheck(RValue RV, QualType ArgType, bool CanCheckNullability = false; if (SanOpts.has(SanitizerKind::NullabilityArg) && !NNAttr && PVD) { - auto Nullability = PVD->getType()->getNullability(getContext()); + auto Nullability = PVD->getType()->getNullability(); CanCheckNullability = Nullability && *Nullability == NullabilityKind::NonNull && PVD->getTypeSourceInfo(); diff --git a/clang/lib/CodeGen/CGDecl.cpp b/clang/lib/CodeGen/CGDecl.cpp index cc9a6cf4e174d..02e3790a45ebc 100644 --- a/clang/lib/CodeGen/CGDecl.cpp +++ b/clang/lib/CodeGen/CGDecl.cpp @@ -758,7 +758,7 @@ void CodeGenFunction::EmitNullabilityCheck(LValue LHS, llvm::Value *RHS, if (!SanOpts.has(SanitizerKind::NullabilityAssign)) return; - auto Nullability = LHS.getType()->getNullability(getContext()); + auto Nullability = LHS.getType()->getNullability(); if (!Nullability || *Nullability != NullabilityKind::NonNull) return; @@ -2615,7 +2615,7 @@ void CodeGenFunction::EmitParmDecl(const VarDecl &D, ParamValue Arg, // 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(getContext()); + auto Nullability = Ty->getNullability(); if (Nullability && *Nullability == NullabilityKind::NonNull) { SanitizerScope SanScope(this); RetValNullabilityPrecondition = diff --git a/clang/lib/CodeGen/CodeGenFunction.cpp b/clang/lib/CodeGen/CodeGenFunction.cpp index ad5ffece8cae3..874a0835f212f 100644 --- a/clang/lib/CodeGen/CodeGenFunction.cpp +++ b/clang/lib/CodeGen/CodeGenFunction.cpp @@ -956,7 +956,7 @@ void CodeGenFunction::StartFunction(GlobalDecl GD, QualType RetTy, // 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(getContext()); + auto Nullability = FnRetTy->getNullability(); if (Nullability && *Nullability == NullabilityKind::NonNull) { if (!(SanOpts.has(SanitizerKind::ReturnsNonnullAttribute) && CurCodeDecl && CurCodeDecl->getAttr<ReturnsNonNullAttr>())) diff --git a/clang/lib/Sema/Sema.cpp b/clang/lib/Sema/Sema.cpp index ab5db04a4994c..4666809ce86f0 100644 --- a/clang/lib/Sema/Sema.cpp +++ b/clang/lib/Sema/Sema.cpp @@ -564,12 +564,12 @@ void Sema::PrintStats() const { void Sema::diagnoseNullableToNonnullConversion(QualType DstType, QualType SrcType, SourceLocation Loc) { - Optional<NullabilityKind> ExprNullability = SrcType->getNullability(Context); + Optional<NullabilityKind> ExprNullability = SrcType->getNullability(); if (!ExprNullability || (*ExprNullability != NullabilityKind::Nullable && *ExprNullability != NullabilityKind::NullableResult)) return; - Optional<NullabilityKind> TypeNullability = DstType->getNullability(Context); + Optional<NullabilityKind> TypeNullability = DstType->getNullability(); if (!TypeNullability || *TypeNullability != NullabilityKind::NonNull) return; diff --git a/clang/lib/Sema/SemaChecking.cpp b/clang/lib/Sema/SemaChecking.cpp index 97345a8a75f19..9f0c8491ad666 100644 --- a/clang/lib/Sema/SemaChecking.cpp +++ b/clang/lib/Sema/SemaChecking.cpp @@ -5544,8 +5544,7 @@ bool Sema::getFormatStringInfo(const FormatAttr *Format, bool IsCXXMember, /// 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(S.Context)) { + if (auto nullability = Expr->IgnoreImplicit()->getType()->getNullability()) { if (*nullability == NullabilityKind::NonNull) return false; } @@ -5629,8 +5628,8 @@ DiagnoseCStringFormatDirectiveInCFAPI(Sema &S, } /// Determine whether the given type has a non-null nullability annotation. -static bool isNonNullType(ASTContext &ctx, QualType type) { - if (auto nullability = type->getNullability(ctx)) +static bool isNonNullType(QualType type) { + if (auto nullability = type->getNullability()) return *nullability == NullabilityKind::NonNull; return false; @@ -5683,8 +5682,7 @@ static void CheckNonNullArguments(Sema &S, for (ArrayRef<ParmVarDecl*>::iterator I = parms.begin(), E = parms.end(); I != E; ++I, ++ParamIndex) { const ParmVarDecl *PVD = *I; - if (PVD->hasAttr<NonNullAttr>() || - isNonNullType(S.Context, PVD->getType())) { + if (PVD->hasAttr<NonNullAttr>() || isNonNullType(PVD->getType())) { if (NonNullArgs.empty()) NonNullArgs.resize(Args.size()); @@ -5713,7 +5711,7 @@ static void CheckNonNullArguments(Sema &S, if (Proto) { unsigned Index = 0; for (auto paramType : Proto->getParamTypes()) { - if (isNonNullType(S.Context, paramType)) { + if (isNonNullType(paramType)) { if (NonNullArgs.empty()) NonNullArgs.resize(Args.size()); @@ -12026,7 +12024,7 @@ Sema::CheckReturnValExpr(Expr *RetValExp, QualType lhsType, const FunctionDecl *FD) { // Check if the return value is null but should not be. if (((Attrs && hasSpecificAttr<ReturnsNonNullAttr>(*Attrs)) || - (!isObjCMethod && isNonNullType(Context, lhsType))) && + (!isObjCMethod && isNonNullType(lhsType))) && CheckNonNullExpr(*this, RetValExp)) Diag(ReturnLoc, diag::warn_null_ret) << (isObjCMethod ? 1 : 0) << RetValExp->getSourceRange(); diff --git a/clang/lib/Sema/SemaDecl.cpp b/clang/lib/Sema/SemaDecl.cpp index 9c0df162a8b9e..6e5c026167230 100644 --- a/clang/lib/Sema/SemaDecl.cpp +++ b/clang/lib/Sema/SemaDecl.cpp @@ -3398,8 +3398,8 @@ static bool EquivalentArrayTypes(QualType Old, QualType New, static void mergeParamDeclTypes(ParmVarDecl *NewParam, const ParmVarDecl *OldParam, Sema &S) { - if (auto Oldnullability = OldParam->getType()->getNullability(S.Context)) { - if (auto Newnullability = NewParam->getType()->getNullability(S.Context)) { + 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( diff --git a/clang/lib/Sema/SemaDeclObjC.cpp b/clang/lib/Sema/SemaDeclObjC.cpp index 0cd764552b932..a7443f736e363 100644 --- a/clang/lib/Sema/SemaDeclObjC.cpp +++ b/clang/lib/Sema/SemaDeclObjC.cpp @@ -2361,21 +2361,17 @@ static bool CheckMethodOverrideReturn(Sema &S, !S.Context.hasSameNullabilityTypeQualifier(MethodImpl->getReturnType(), MethodDecl->getReturnType(), false)) { - auto nullabilityMethodImpl = - *MethodImpl->getReturnType()->getNullability(S.Context); - auto nullabilityMethodDecl = - *MethodDecl->getReturnType()->getNullability(S.Context); - 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)); - S.Diag(MethodDecl->getLocation(), diag::note_previous_declaration); + 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)); + S.Diag(MethodDecl->getLocation(), diag::note_previous_declaration); } if (S.Context.hasSameUnqualifiedType(MethodImpl->getReturnType(), @@ -2453,14 +2449,12 @@ static bool CheckMethodOverrideParam(Sema &S, !S.Context.hasSameNullabilityTypeQualifier(ImplTy, IfaceTy, true)) { S.Diag(ImplVar->getLocation(), diag::warn_conflicting_nullability_attr_overriding_param_types) - << DiagNullabilityKind( - *ImplTy->getNullability(S.Context), - ((ImplVar->getObjCDeclQualifier() & Decl::OBJC_TQ_CSNullability) - != 0)) - << DiagNullabilityKind( - *IfaceTy->getNullability(S.Context), - ((IfaceVar->getObjCDeclQualifier() & Decl::OBJC_TQ_CSNullability) - != 0)); + << DiagNullabilityKind(*ImplTy->getNullability(), + ((ImplVar->getObjCDeclQualifier() & + Decl::OBJC_TQ_CSNullability) != 0)) + << DiagNullabilityKind(*IfaceTy->getNullability(), + ((IfaceVar->getObjCDeclQualifier() & + Decl::OBJC_TQ_CSNullability) != 0)); S.Diag(IfaceVar->getLocation(), diag::note_previous_declaration); } if (S.Context.hasSameUnqualifiedType(ImplTy, IfaceTy)) @@ -4543,8 +4537,8 @@ static QualType mergeTypeNullabilityForRedecl(Sema &S, SourceLocation loc, QualType prevType, bool prevUsesCSKeyword) { // Determine the nullability of both types. - auto nullability = type->getNullability(S.Context); - auto prevNullability = prevType->getNullability(S.Context); + auto nullability = type->getNullability(); + auto prevNullability = prevType->getNullability(); // Easy case: both have nullability. if (nullability.has_value() == prevNullability.has_value()) { diff --git a/clang/lib/Sema/SemaExpr.cpp b/clang/lib/Sema/SemaExpr.cpp index e16f07d418112..ccb1e3e21caea 100644 --- a/clang/lib/Sema/SemaExpr.cpp +++ b/clang/lib/Sema/SemaExpr.cpp @@ -9070,7 +9070,7 @@ static QualType computeConditionalNullability(QualType ResTy, bool IsBin, return ResTy; auto GetNullability = [&Ctx](QualType Ty) { - Optional<NullabilityKind> Kind = Ty->getNullability(Ctx); + Optional<NullabilityKind> Kind = Ty->getNullability(); if (Kind) { // For our purposes, treat _Nullable_result as _Nullable. if (*Kind == NullabilityKind::NullableResult) @@ -9107,7 +9107,7 @@ static QualType computeConditionalNullability(QualType ResTy, bool IsBin, return ResTy; // Strip all nullability from ResTy. - while (ResTy->getNullability(Ctx)) + while (ResTy->getNullability()) ResTy = ResTy.getSingleStepDesugaredType(Ctx); // Create a new AttributedType with the new nullability kind. diff --git a/clang/lib/Sema/SemaExprObjC.cpp b/clang/lib/Sema/SemaExprObjC.cpp index 3a672741fb477..848e9c63e1b81 100644 --- a/clang/lib/Sema/SemaExprObjC.cpp +++ b/clang/lib/Sema/SemaExprObjC.cpp @@ -592,7 +592,7 @@ ExprResult Sema::BuildObjCBoxedExpr(SourceRange SR, Expr *ValueExpr) { BoxedType = NSStringPointer; // Transfer the nullability from method's return type. Optional<NullabilityKind> Nullability = - BoxingMethod->getReturnType()->getNullability(Context); + BoxingMethod->getReturnType()->getNullability(); if (Nullability) BoxedType = Context.getAttributedType( AttributedType::getNullabilityAttrKind(*Nullability), BoxedType, @@ -1466,8 +1466,8 @@ static QualType getBaseMessageSendResultType(Sema &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(Context)){ + if (auto nullability = + Method->getSendResultType(ReceiverType)->getNullability()) { // Strip off any outer nullability sugar from the provided type. (void)AttributedType::stripOuterNullability(type); @@ -1546,7 +1546,7 @@ QualType Sema::getMessageSendResultType(const Expr *Receiver, assert(MD->isClassMethod() && "expected a class method"); QualType NewResultType = Context.getObjCObjectPointerType( Context.getObjCInterfaceType(MD->getClassInterface())); - if (auto Nullability = resultType->getNullability(Context)) + if (auto Nullability = resultType->getNullability()) NewResultType = Context.getAttributedType( AttributedType::getNullabilityAttrKind(*Nullability), NewResultType, NewResultType); @@ -1563,16 +1563,14 @@ QualType Sema::getMessageSendResultType(const Expr *Receiver, // Map the nullability of the result into a table index. unsigned receiverNullabilityIdx = 0; - if (Optional<NullabilityKind> nullability = - ReceiverType->getNullability(Context)) { + if (Optional<NullabilityKind> nullability = ReceiverType->getNullability()) { if (*nullability == NullabilityKind::NullableResult) nullability = NullabilityKind::Nullable; receiverNullabilityIdx = 1 + static_cast<unsigned>(*nullability); } unsigned resultNullabilityIdx = 0; - if (Optional<NullabilityKind> nullability = - resultType->getNullability(Context)) { + if (Optional<NullabilityKind> nullability = resultType->getNullability()) { if (*nullability == NullabilityKind::NullableResult) nullability = NullabilityKind::Nullable; resultNullabilityIdx = 1 + static_cast<unsigned>(*nullability); @@ -1605,7 +1603,7 @@ QualType Sema::getMessageSendResultType(const Expr *Receiver, } else { resultType = resultType.getDesugaredType(Context); } - } while (resultType->getNullability(Context)); + } while (resultType->getNullability()); // Add nullability back if needed. if (newResultNullabilityIdx > 0) { diff --git a/clang/lib/Sema/SemaLambda.cpp b/clang/lib/Sema/SemaLambda.cpp index bdca002e740e9..62f312fa8fd24 100644 --- a/clang/lib/Sema/SemaLambda.cpp +++ b/clang/lib/Sema/SemaLambda.cpp @@ -775,8 +775,8 @@ void Sema::deduceClosureReturnType(CapturingScopeInfo &CSI) { if (Context.getCanonicalFunctionResultType(ReturnType) == Context.getCanonicalFunctionResultType(CSI.ReturnType)) { // Use the return type with the strictest possible nullability annotation. - auto RetTyNullability = ReturnType->getNullability(Ctx); - auto BlockNullability = CSI.ReturnType->getNullability(Ctx); + auto RetTyNullability = ReturnType->getNullability(); + auto BlockNullability = CSI.ReturnType->getNullability(); if (BlockNullability && (!RetTyNullability || hasWeakerNullability(*RetTyNullability, *BlockNullability))) diff --git a/clang/lib/Sema/SemaObjCProperty.cpp b/clang/lib/Sema/SemaObjCProperty.cpp index 159daca6a6421..584c4a31793cb 100644 --- a/clang/lib/Sema/SemaObjCProperty.cpp +++ b/clang/lib/Sema/SemaObjCProperty.cpp @@ -2754,7 +2754,7 @@ void Sema::CheckObjCPropertyAttributes(Decl *PDecl, if (Attributes & ObjCPropertyAttribute::kind_weak) { // 'weak' and 'nonnull' are mutually exclusive. - if (auto nullability = PropertyTy->getNullability(Context)) { + if (auto nullability = PropertyTy->getNullability()) { if (*nullability == NullabilityKind::NonNull) Diag(Loc, diag::err_objc_property_attr_mutually_exclusive) << "nonnull" << "weak"; diff --git a/clang/lib/Sema/SemaType.cpp b/clang/lib/Sema/SemaType.cpp index e7be7db890885..35161474bb640 100644 --- a/clang/lib/Sema/SemaType.cpp +++ b/clang/lib/Sema/SemaType.cpp @@ -4701,8 +4701,8 @@ static TypeSourceInfo *GetFullTypeForDeclarator(TypeProcessingState &state, // inner pointers. complainAboutMissingNullability = CAMN_InnerPointers; - if (T->canHaveNullability(/*ResultIfUnknown*/false) && - !T->getNullability(S.Context)) { + if (T->canHaveNullability(/*ResultIfUnknown*/ false) && + !T->getNullability()) { // Note that we allow but don't require nullability on dependent types. ++NumPointersRemaining; } @@ -4923,8 +4923,8 @@ static TypeSourceInfo *GetFullTypeForDeclarator(TypeProcessingState &state, // 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(S.Context)) { + if (T->canHaveNullability(/*ResultIfUnknown*/ false) && + !T->getNullability()) { if (isVaList(T)) { // Record that we've seen a pointer, but do nothing else. if (NumPointersRemaining > 0) @@ -4947,9 +4947,8 @@ static TypeSourceInfo *GetFullTypeForDeclarator(TypeProcessingState &state, } } - if (complainAboutMissingNullability == CAMN_Yes && - T->isArrayType() && !T->getNullability(S.Context) && !isVaList(T) && - D.isPrototypeContext() && + if (complainAboutMissingNullability == CAMN_Yes && T->isArrayType() && + !T->getNullability() && !isVaList(T) && D.isPrototypeContext() && !hasOuterPointerLikeChunk(D, D.getNumTypeObjects())) { checkNullabilityConsistency(S, SimplePointerKind::Array, D.getDeclSpec().getTypeSpecTypeLoc()); @@ -7389,7 +7388,7 @@ static bool checkNullabilityTypeSpecifier(TypeProcessingState &state, // 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(S.Context)) { + if (auto existingNullability = desugared->getNullability()) { if (nullability != *existingNullability) { S.Diag(nullabilityLoc, diag::err_nullability_conflicting) << DiagNullabilityKind(nullability, isContextSensitive) @@ -7488,7 +7487,7 @@ static bool checkObjCKindOfType(TypeProcessingState &state, QualType &type, // If we started with an object pointer type, rebuild it. if (ptrType) { equivType = S.Context.getObjCObjectPointerType(equivType); - if (auto nullability = type->getNullability(S.Context)) { + if (auto nullability = type->getNullability()) { // We create a nullability attribute from the __kindof attribute. // Make sure that will make sense. assert(attr.getAttributeSpellingListIndex() == 0 && diff --git a/clang/tools/libclang/CXType.cpp b/clang/tools/libclang/CXType.cpp index a97a4e6896047..21a7724d7fdd5 100644 --- a/clang/tools/libclang/CXType.cpp +++ b/clang/tools/libclang/CXType.cpp @@ -1330,8 +1330,7 @@ enum CXTypeNullabilityKind clang_Type_getNullability(CXType CT) { if (T.isNull()) return CXTypeNullability_Invalid; - ASTContext &Ctx = cxtu::getASTUnit(GetTU(CT))->getASTContext(); - if (auto nullability = T->getNullability(Ctx)) { + if (auto nullability = T->getNullability()) { switch (*nullability) { case NullabilityKind::NonNull: return CXTypeNullability_NonNull; _______________________________________________ cfe-commits mailing list cfe-commits@lists.llvm.org https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
