| //=======- RawPtrRefCallArgsChecker.cpp --------------------------*- C++ -*-==// | |
| // | |
| // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. | |
| // See https://llvm.org/LICENSE.txt for license information. | |
| // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception | |
| // | |
| //===----------------------------------------------------------------------===// | |
| #include "ASTUtils.h" | |
| #include "DiagOutputUtils.h" | |
| #include "PtrTypesSemantics.h" | |
| #include "RawPtrRefSafetyModel.h" | |
| #include "clang/AST/Decl.h" | |
| #include "clang/AST/DeclCXX.h" | |
| #include "clang/AST/DynamicRecursiveASTVisitor.h" | |
| #include "clang/Analysis/DomainSpecific/CocoaConventions.h" | |
| #include "clang/Basic/SourceLocation.h" | |
| #include "clang/Lex/Lexer.h" | |
| #include "clang/StaticAnalyzer/Checkers/BuiltinCheckerRegistration.h" | |
| #include "clang/StaticAnalyzer/Core/BugReporter/BugReporter.h" | |
| #include "clang/StaticAnalyzer/Core/BugReporter/BugType.h" | |
| #include "clang/StaticAnalyzer/Core/Checker.h" | |
| #include "llvm/Support/SaveAndRestore.h" | |
| #include <optional> | |
| using namespace clang; | |
| using namespace ento; | |
| namespace { | |
| class RawPtrRefCallArgsChecker | |
| : public Checker<check::ASTDecl<TranslationUnitDecl>> { | |
| BugType Bug; | |
| TrivialFunctionAnalysis TFA; | |
| EnsureFunctionAnalysis EFA; | |
| protected: | |
| mutable BugReporter *BR; | |
| const std::unique_ptr<PtrRefSafetyModel> Model; | |
| public: | |
| RawPtrRefCallArgsChecker(const char *description, | |
| std::unique_ptr<PtrRefSafetyModel> Model) | |
| : Bug(this, description, "WebKit coding guidelines"), | |
| Model(std::move(Model)) {} | |
| void checkASTDecl(const TranslationUnitDecl *TUD, AnalysisManager &MGR, | |
| BugReporter &BRArg) const { | |
| BR = &BRArg; | |
| // The calls to checkAST* from AnalysisConsumer don't | |
| // visit template instantiations or lambda classes. We | |
| // want to visit those, so we make our own RecursiveASTVisitor. | |
| struct LocalVisitor : DynamicRecursiveASTVisitor { | |
| const RawPtrRefCallArgsChecker *Checker; | |
| Decl *DeclWithIssue{nullptr}; | |
| explicit LocalVisitor(const RawPtrRefCallArgsChecker *Checker) | |
| : Checker(Checker) { | |
| assert(Checker); | |
| ShouldVisitTemplateInstantiations = true; | |
| ShouldVisitImplicitCode = false; | |
| } | |
| bool TraverseClassTemplateDecl(ClassTemplateDecl *Decl) override { | |
| if (isSmartPtrClass(safeGetName(Decl))) | |
| return true; | |
| return DynamicRecursiveASTVisitor::TraverseClassTemplateDecl(Decl); | |
| } | |
| bool TraverseDecl(Decl *D) override { | |
| // A template pattern is checked through its instantiations, which are | |
| // traversed from the TemplateDecl itself. In the pattern the callee of | |
| // a call may still be an unresolved overload set and the type of an | |
| // expression may still be dependent, neither of which can be reasoned | |
| // about, so don't enter it at all. | |
| if (D && !isa<TemplateDecl>(D) && D->isTemplated()) | |
| return true; | |
| llvm::SaveAndRestore SavedDecl(DeclWithIssue); | |
| if (D && (isa<FunctionDecl>(D) || isa<ObjCMethodDecl>(D))) | |
| DeclWithIssue = D; | |
| return DynamicRecursiveASTVisitor::TraverseDecl(D); | |
| } | |
| bool TraverseLambdaExpr(LambdaExpr *L) override { | |
| auto *FTD = L->getLambdaClass()->getDependentLambdaCallOperator(); | |
| if (!FTD) | |
| return DynamicRecursiveASTVisitor::TraverseLambdaExpr(L); | |
| // The body of a generic lambda is the pattern of its call operator, | |
| // but it is reached from the LambdaExpr as a statement, so TraverseDecl | |
| // never gets to skip it. Traverse the capture initializers, which are | |
| // evaluated in the enclosing scope, and then the call operator itself, | |
| // of which the pattern is skipped like any other and the instantiations | |
| // are traversed. The initializers are traversed as expressions because | |
| // the variable of an init capture is declared in the pattern. | |
| for (unsigned I = 0, N = L->capture_size(); I != N; ++I) { | |
| if (!(L->capture_begin() + I)->isExplicit()) | |
| continue; | |
| if (auto *Init = L->capture_init_begin()[I]; | |
| Init && !TraverseStmt(Init)) | |
| return false; | |
| } | |
| return TraverseDecl(FTD); | |
| } | |
| bool VisitCallExpr(CallExpr *CE) override { | |
| Checker->visitCallExpr(CE, DeclWithIssue); | |
| return true; | |
| } | |
| bool VisitCXXConstructExpr(CXXConstructExpr *CE) override { | |
| Checker->visitConstructExpr(CE, DeclWithIssue); | |
| return true; | |
| } | |
| bool VisitTypedefDecl(TypedefDecl *TD) override { | |
| if (auto *RTC = Checker->Model->retainTypeChecker()) | |
| RTC->visitTypedef(TD); | |
| return true; | |
| } | |
| bool VisitObjCMessageExpr(ObjCMessageExpr *ObjCMsgExpr) override { | |
| Checker->visitObjCMessageExpr(ObjCMsgExpr, DeclWithIssue); | |
| return true; | |
| } | |
| }; | |
| LocalVisitor visitor(this); | |
| if (auto *RTC = Model->retainTypeChecker()) | |
| RTC->visitTranslationUnitDecl(TUD); | |
| visitor.TraverseDecl(const_cast<TranslationUnitDecl *>(TUD)); | |
| } | |
| template <typename CallOrConstruct> | |
| void visitCallOrConstructExpr(const CallOrConstruct *CE, | |
| const FunctionDecl *F, const Decl *D) const { | |
| if (F) { | |
| unsigned ArgIdx = 0; | |
| if (auto *MemberCallExpr = dyn_cast<CXXMemberCallExpr>(CE)) { | |
| checkThisArg(F, MemberCallExpr, D); | |
| } else if (isa<CXXOperatorCallExpr>(CE) && isa<CXXMethodDecl>(F)) { | |
| // An overloaded member operator (e.g. lambda or std::function call | |
| // operator) receives the receiver object as argument 0; start the | |
| // parameter loop at 1 so we don't match it against the operator's | |
| // first declared parameter. | |
| auto *Receiver = CE->getArg(0); | |
| checkThisArg(F, Receiver, Receiver->getType(), D); | |
| ArgIdx = 1; | |
| } | |
| for (auto P = F->param_begin(); | |
| P < F->param_end() && ArgIdx < CE->getNumArgs(); ++P, ++ArgIdx) { | |
| // TODO: attributes. | |
| // if ((*P)->hasAttr<SafeRefCntblRawPtrAttr>()) | |
| // continue; | |
| checkArg(F, CE->getArg(ArgIdx), (*P)->getType(), *P, D); | |
| } | |
| for (; ArgIdx < CE->getNumArgs(); ++ArgIdx) { | |
| auto *Arg = CE->getArg(ArgIdx); | |
| checkArg(F, Arg, Arg->getType(), nullptr, D); | |
| } | |
| } | |
| } | |
| void visitCallExpr(const CallExpr *CE, const Decl *D) const { | |
| auto *Callee = CE->getDirectCallee(); | |
| if (shouldSkipCall(CE, Callee)) | |
| return; | |
| if (Callee) | |
| visitCallOrConstructExpr(CE, Callee, D); | |
| else if (auto *Decl = CE->getCalleeDecl()) { | |
| if (auto *FnType = Decl->getFunctionType()) { | |
| if (auto *ProtoType = dyn_cast<FunctionProtoType>(FnType)) { | |
| if (auto *MemberCallExpr = dyn_cast<CXXMemberCallExpr>(CE)) | |
| checkThisArg(nullptr, MemberCallExpr, D); | |
| unsigned ArgIdx = 0; | |
| for (auto PT = ProtoType->param_type_begin(); | |
| PT < ProtoType->param_type_end() && ArgIdx < CE->getNumArgs(); | |
| ++PT, ++ArgIdx) | |
| checkArg(nullptr, CE->getArg(ArgIdx), *PT, nullptr, D); | |
| for (; ArgIdx < CE->getNumArgs(); ++ArgIdx) { | |
| auto *Arg = CE->getArg(ArgIdx); | |
| checkArg(nullptr, Arg, Arg->getType(), nullptr, D); | |
| } | |
| } | |
| } | |
| } | |
| } | |
| void visitConstructExpr(const CXXConstructExpr *CE, const Decl *D) const { | |
| auto *Constructor = CE->getConstructor(); | |
| if (shouldSkipCall(CE, Constructor)) | |
| return; | |
| if (Constructor) | |
| visitCallOrConstructExpr(CE, Constructor, D); | |
| } | |
| void visitObjCMessageExpr(const ObjCMessageExpr *E, const Decl *D) const { | |
| if (BR->getSourceManager().isInSystemHeader(E->getExprLoc())) | |
| return; | |
| if (auto *Receiver = E->getInstanceReceiver()) { | |
| std::optional<bool> IsUnsafe = Model->isUnsafePtr(E->getReceiverType()); | |
| const Expr *Origin = nullptr; | |
| if (IsUnsafe && *IsUnsafe && | |
| !isPtrOriginSafe(Receiver, &Origin, E->getReceiverType())) { | |
| if (isAllocInit(E)) | |
| return; | |
| reportBugOnReceiver(E->getMethodDecl(), Receiver, D, Origin); | |
| } | |
| } | |
| auto *MethodDecl = E->getMethodDecl(); | |
| if (!MethodDecl) | |
| return; | |
| auto ArgCount = E->getNumArgs(); | |
| for (unsigned i = 0; i < ArgCount; ++i) { | |
| auto *Arg = E->getArg(i); | |
| bool hasParam = i < MethodDecl->param_size(); | |
| auto *Param = hasParam ? MethodDecl->getParamDecl(i) : nullptr; | |
| auto ArgType = Arg->getType(); | |
| std::optional<bool> IsUnsafe = Model->isUnsafePtr(ArgType); | |
| if (!IsUnsafe || !(*IsUnsafe)) | |
| continue; | |
| const Expr *Origin = nullptr; | |
| if (isPtrOriginSafe(Arg, &Origin, ArgType)) | |
| continue; | |
| reportBug(MethodDecl, Arg, Param, D, Origin); | |
| } | |
| } | |
| static bool isRefCountingOperation(const CXXMethodDecl *MD) { | |
| if (!MD) | |
| return false; | |
| auto name = safeGetName(MD); | |
| return name == "ref" || name == "deref" || | |
| name == "incrementCheckedPtrCount" || | |
| name == "decrementCheckedPtrCount"; | |
| } | |
| void checkThisArg(const NamedDecl *Callee, | |
| const CXXMemberCallExpr *MemberCallExpr, | |
| const Decl *DeclWithIssue) const { | |
| if (isRefCountingOperation(MemberCallExpr->getMethodDecl())) | |
| return; | |
| checkThisArg(Callee, MemberCallExpr->getImplicitObjectArgument(), | |
| MemberCallExpr->getObjectType(), DeclWithIssue); | |
| } | |
| void checkThisArg(const NamedDecl *Callee, const Expr *Receiver, | |
| QualType ReceiverType, const Decl *DeclWithIssue) const { | |
| // There is no ParmVarDecl for the implicit object parameter, so | |
| // synthesize its type ('T&' per [over.match.funcs]) for the model to | |
| // classify. | |
| QualType ParamType = BR->getContext().getLValueReferenceType( | |
| ReceiverType.getCanonicalType()); | |
| std::optional<bool> IsUnsafe = Model->isUnsafePtr(ParamType); | |
| if (!IsUnsafe || !*IsUnsafe) | |
| return; | |
| const Expr *Origin = nullptr; | |
| if (isPtrOriginSafe(Receiver, &Origin, ParamType)) | |
| return; | |
| reportBugOnThis(Callee, Receiver, DeclWithIssue, Origin); | |
| } | |
| void checkArg(const NamedDecl *Callee, const Expr *Arg, QualType ParamType, | |
| const ParmVarDecl *Param, const Decl *DeclWithIssue) const { | |
| std::optional<bool> IsUncounted = Model->isUnsafePtr(ParamType); | |
| if (!IsUncounted || !(*IsUncounted)) | |
| return; | |
| if (auto *DefaultArg = dyn_cast<CXXDefaultArgExpr>(Arg)) | |
| Arg = DefaultArg->getExpr(); | |
| const Expr *Origin = nullptr; | |
| if (isPtrOriginSafe(Arg, &Origin, ParamType)) | |
| return; | |
| reportBug(Callee, Arg, Param, DeclWithIssue, Origin); | |
| } | |
| bool isPtrOriginSafe(const Expr *Arg, const Expr **Origin = nullptr, | |
| QualType SinkType = QualType()) const { | |
| return tryToFindPtrOrigin( | |
| Arg, /*StopAtFirstRefCountedObj=*/true, | |
| Model->checksForInteriorDestruction(), | |
| [&](const clang::CXXRecordDecl *Record) { | |
| return Model->isSafePtr(Record); | |
| }, | |
| [&](const clang::QualType T) { return Model->isSafePtrType(T); }, | |
| [&](const clang::Decl *D) { | |
| return Model->isSafeDecl(D, BR->getSourceManager()); | |
| }, | |
| // A temporary on the path to an argument's origin is safe: the full | |
| // expression does not end until the call returns. | |
| [&](const clang::Expr *ArgOrigin, bool IsSafe, | |
| bool /*OriginDependsOnFullExpressionTemporary*/, | |
| bool PtrIsLifetimeBoundToOrigin) { | |
| if (IsSafe) | |
| return true; | |
| if (isNullPtr(ArgOrigin)) | |
| return true; | |
| if (isa<IntegerLiteral>(ArgOrigin)) { | |
| // FIXME: Check the value. | |
| // foo(123) | |
| return true; | |
| } | |
| if (isa<CXXBoolLiteralExpr>(ArgOrigin)) | |
| return true; | |
| if (isa<ObjCStringLiteral>(ArgOrigin)) | |
| return true; | |
| if (!Model->checksForInteriorDestruction() && | |
| originOutlivesCall(ArgOrigin)) | |
| return true; | |
| if (EFA.isACallToEnsureFn(ArgOrigin)) { | |
| auto *MCE = dyn_cast<CXXMemberCallExpr>(ArgOrigin); | |
| assert(MCE); | |
| if (isPtrOriginSafe(MCE->getImplicitObjectArgument())) | |
| return true; | |
| } | |
| if (Model->isSafeExpr(ArgOrigin, PtrIsLifetimeBoundToOrigin, SinkType, | |
| /*SinkMayEscape=*/false)) | |
| return true; | |
| if (Origin && !*Origin) | |
| *Origin = ArgOrigin; | |
| return false; | |
| }); | |
| } | |
| template <typename CallOrConstruct> | |
| bool shouldSkipCall(const CallOrConstruct *CE, | |
| const FunctionDecl *Callee) const { | |
| if (BR->getSourceManager().isInSystemHeader(CE->getExprLoc())) | |
| return true; | |
| if (Callee && TFA.isTrivial(Callee)) | |
| return true; | |
| if (isTrivialBuiltinFunction(Callee)) | |
| return true; | |
| if (CE->getNumArgs() == 0) | |
| return false; | |
| // If an assignment is problematic we should warn about the sole existence | |
| // of object on LHS. | |
| if (auto *MemberOp = dyn_cast<CXXOperatorCallExpr>(CE)) { | |
| // Note: assignemnt to built-in type isn't derived from CallExpr. | |
| if (MemberOp->getOperator() == | |
| OO_Equal) { // Ignore assignment to Ref/RefPtr. | |
| auto *callee = MemberOp->getDirectCallee(); | |
| if (auto *calleeDecl = dyn_cast<CXXMethodDecl>(callee)) { | |
| if (const CXXRecordDecl *classDecl = calleeDecl->getParent()) { | |
| if (Model->isSafePtr(classDecl)) | |
| return true; | |
| } | |
| } | |
| } | |
| if (MemberOp->isAssignmentOp()) | |
| return false; | |
| } | |
| if (!Callee) | |
| return false; | |
| if (isMethodOnWTFContainerType(Callee)) | |
| return true; | |
| auto overloadedOperatorType = Callee->getOverloadedOperator(); | |
| if (overloadedOperatorType == OO_EqualEqual || | |
| overloadedOperatorType == OO_ExclaimEqual || | |
| overloadedOperatorType == OO_LessEqual || | |
| overloadedOperatorType == OO_GreaterEqual || | |
| overloadedOperatorType == OO_Spaceship || | |
| overloadedOperatorType == OO_AmpAmp || | |
| overloadedOperatorType == OO_PipePipe) | |
| return true; | |
| if (isCtorOfSafePtr(Callee) || isPtrConversion(Callee)) | |
| return true; | |
| auto name = safeGetName(Callee); | |
| if (name == "adoptRef" || name == "getPtr" || name == "WeakPtr" || | |
| name == "is" || name == "equal" || name == "hash" || name == "isType" || | |
| // FIXME: Most/all of these should be implemented via attributes. | |
| name == "CFEqual" || name == "equalIgnoringASCIICase" || | |
| name == "equalIgnoringASCIICaseCommon" || | |
| name == "equalIgnoringNullity" || name == "toString") | |
| return true; | |
| return false; | |
| } | |
| bool isMethodOnWTFContainerType(const FunctionDecl *Decl) const { | |
| if (!isa<CXXMethodDecl>(Decl)) | |
| return false; | |
| auto *ClassDecl = Decl->getParent(); | |
| if (!ClassDecl || !isa<CXXRecordDecl>(ClassDecl)) | |
| return false; | |
| auto *NsDecl = ClassDecl->getParent(); | |
| if (!NsDecl || !isa<NamespaceDecl>(NsDecl)) | |
| return false; | |
| auto MethodName = safeGetName(Decl); | |
| auto ClsNameStr = safeGetName(ClassDecl); | |
| StringRef ClsName = ClsNameStr; // FIXME: Make safeGetName return StringRef. | |
| auto NamespaceName = safeGetName(NsDecl); | |
| // FIXME: These should be implemented via attributes. | |
| return NamespaceName == "WTF" && | |
| (MethodName == "find" || MethodName == "findIf" || | |
| MethodName == "reverseFind" || MethodName == "reverseFindIf" || | |
| MethodName == "findIgnoringASCIICase" || MethodName == "get" || | |
| MethodName == "inlineGet" || MethodName == "contains" || | |
| MethodName == "containsIf" || | |
| MethodName == "containsIgnoringASCIICase" || | |
| MethodName == "startsWith" || MethodName == "endsWith" || | |
| MethodName == "startsWithIgnoringASCIICase" || | |
| MethodName == "endsWithIgnoringASCIICase" || | |
| MethodName == "substring") && | |
| (ClsName.ends_with("Vector") || ClsName.ends_with("Set") || | |
| ClsName.ends_with("Map") || ClsName == "StringImpl" || | |
| ClsName.ends_with("String")); | |
| } | |
| void reportBug(const NamedDecl *Callee, const Expr *CallArg, | |
| const ParmVarDecl *Param, const Decl *DeclWithIssue, | |
| const Expr *Origin) const { | |
| assert(CallArg); | |
| SmallString<100> Buf; | |
| llvm::raw_svector_ostream Os(Buf); | |
| const std::string paramName = safeGetName(Param); | |
| Os << "Function argument"; | |
| printArgument(Os, CallArg); | |
| if (!paramName.empty() || Callee) | |
| Os << " ("; | |
| if (!paramName.empty()) { | |
| Os << "parameter "; | |
| printQuotedQualifiedName(Os, Param); | |
| } | |
| if (Callee) { | |
| if (!paramName.empty()) | |
| Os << " "; | |
| Os << "to "; | |
| printQuotedQualifiedName(Os, Callee); | |
| } | |
| if (!paramName.empty() || Callee) | |
| Os << ")"; | |
| Os << " is a "; | |
| Model->describeHazard(Os, Origin, CallArg->getType()); | |
| bool usesDefaultArgValue = isa<CXXDefaultArgExpr>(CallArg) && Param; | |
| const SourceLocation SrcLocToReport = | |
| usesDefaultArgValue ? Param->getDefaultArg()->getExprLoc() | |
| : CallArg->getSourceRange().getBegin(); | |
| PathDiagnosticLocation BSLoc(SrcLocToReport, BR->getSourceManager()); | |
| auto Report = std::make_unique<BasicBugReport>(Bug, Os.str(), BSLoc); | |
| Report->addRange(CallArg->getSourceRange()); | |
| Report->setDeclWithIssue(DeclWithIssue); | |
| BR->emitReport(std::move(Report)); | |
| } | |
| void reportBugOnThis(const NamedDecl *Callee, const Expr *CallArg, | |
| const Decl *DeclWithIssue, const Expr *Origin) const { | |
| assert(CallArg); | |
| const SourceLocation SrcLocToReport = CallArg->getSourceRange().getBegin(); | |
| SmallString<100> Buf; | |
| llvm::raw_svector_ostream Os(Buf); | |
| Os << "Function argument"; | |
| printArgument(Os, CallArg); | |
| Os << " (parameter 'this'"; | |
| if (Callee) { | |
| Os << " to "; | |
| printQuotedQualifiedName(Os, Callee); | |
| } | |
| Os << ") is a "; | |
| printHazardOrPointerTo(Os, CallArg, Origin); | |
| PathDiagnosticLocation BSLoc(SrcLocToReport, BR->getSourceManager()); | |
| auto Report = std::make_unique<BasicBugReport>(Bug, Os.str(), BSLoc); | |
| Report->addRange(CallArg->getSourceRange()); | |
| Report->setDeclWithIssue(DeclWithIssue); | |
| BR->emitReport(std::move(Report)); | |
| } | |
| void reportBugOnReceiver(const NamedDecl *Callee, const Expr *CallArg, | |
| const Decl *DeclWithIssue, | |
| const Expr *Origin) const { | |
| assert(CallArg); | |
| const SourceLocation SrcLocToReport = CallArg->getSourceRange().getBegin(); | |
| SmallString<100> Buf; | |
| llvm::raw_svector_ostream Os(Buf); | |
| Os << "Receiver"; | |
| printArgument(Os, CallArg); | |
| if (Callee) { | |
| Os << " (to "; | |
| printQuotedQualifiedName(Os, Callee); | |
| Os << ")"; | |
| } | |
| Os << " is a "; | |
| printHazardOrPointerTo(Os, CallArg, Origin); | |
| PathDiagnosticLocation BSLoc(SrcLocToReport, BR->getSourceManager()); | |
| auto Report = std::make_unique<BasicBugReport>(Bug, Os.str(), BSLoc); | |
| Report->addRange(CallArg->getSourceRange()); | |
| Report->setDeclWithIssue(DeclWithIssue); | |
| BR->emitReport(std::move(Report)); | |
| } | |
| void printHazardOrPointerTo(llvm::raw_svector_ostream &Os, | |
| const Expr *CallArg, const Expr *Origin) const { | |
| if (Model->checksForInteriorDestruction()) { | |
| Model->describeHazard(Os, Origin, CallArg->getType()); | |
| return; | |
| } | |
| // 'this' is a pointer even when the call is spelled with '.', so don't | |
| // infer pointer vs reference from the argument type. | |
| Os << "raw pointer to " << Model->typeName() << " "; | |
| printTypeName(Os, CallArg->getType()); | |
| } | |
| void printArgument(llvm::raw_svector_ostream &Os, const Expr *Arg) const { | |
| SmallString<100> Buf; | |
| llvm::raw_svector_ostream ArgOs(Buf); | |
| Arg->printPretty(ArgOs, /*Helper=*/nullptr, | |
| BR->getContext().getPrintingPolicy()); | |
| StringRef ArgCode = ArgOs.str(); | |
| if (ArgCode.contains('\n')) | |
| return; | |
| ArgCode = ArgCode.take_front(50); | |
| if (ArgCode.size() == 50) | |
| Os << " '" << ArgCode << "...'"; | |
| else | |
| Os << " '" << ArgCode << "'"; | |
| } | |
| }; | |
| class UncountedCallArgsChecker final : public RawPtrRefCallArgsChecker { | |
| public: | |
| UncountedCallArgsChecker() | |
| : RawPtrRefCallArgsChecker("Uncounted call argument for a raw " | |
| "pointer/reference parameter", | |
| makeRefPtrSafetyModel()) {} | |
| }; | |
| class UncheckedCallArgsChecker final : public RawPtrRefCallArgsChecker { | |
| public: | |
| UncheckedCallArgsChecker() | |
| : RawPtrRefCallArgsChecker("Unchecked call argument for a raw " | |
| "pointer/reference parameter", | |
| makeCheckedPtrSafetyModel()) {} | |
| }; | |
| class UnretainedCallArgsChecker final : public RawPtrRefCallArgsChecker { | |
| public: | |
| UnretainedCallArgsChecker() | |
| : RawPtrRefCallArgsChecker("Unretained call argument for a raw " | |
| "pointer/reference parameter", | |
| makeRetainPtrSafetyModel()) {} | |
| }; | |
| class UnborrowedCallArgsChecker final : public RawPtrRefCallArgsChecker { | |
| public: | |
| UnborrowedCallArgsChecker() | |
| : RawPtrRefCallArgsChecker("Unborrowed call argument for a raw " | |
| "pointer/reference parameter", | |
| makeBorrowSafetyModel()) {} | |
| }; | |
| } // namespace | |
| void ento::registerUncountedCallArgsChecker(CheckerManager &Mgr) { | |
| Mgr.registerChecker<UncountedCallArgsChecker>(); | |
| } | |
| bool ento::shouldRegisterUncountedCallArgsChecker(const CheckerManager &) { | |
| return true; | |
| } | |
| void ento::registerUncheckedCallArgsChecker(CheckerManager &Mgr) { | |
| Mgr.registerChecker<UncheckedCallArgsChecker>(); | |
| } | |
| bool ento::shouldRegisterUncheckedCallArgsChecker(const CheckerManager &) { | |
| return true; | |
| } | |
| void ento::registerUnretainedCallArgsChecker(CheckerManager &Mgr) { | |
| Mgr.registerChecker<UnretainedCallArgsChecker>(); | |
| } | |
| bool ento::shouldRegisterUnretainedCallArgsChecker(const CheckerManager &) { | |
| return true; | |
| } | |
| void ento::registerUnborrowedCallArgsChecker(CheckerManager &Mgr) { | |
| Mgr.registerChecker<UnborrowedCallArgsChecker>(); | |
| } | |
| bool ento::shouldRegisterUnborrowedCallArgsChecker(const CheckerManager &) { | |
| return true; | |
| } |