[clang] 820e8d8 - [Analyzer][WebKit] UncountedLambdaCaptureChecker
Jan Korous via cfe-commits
cfe-commits at lists.llvm.org
Wed Aug 5 16:24:23 PDT 2020
Author: Jan Korous
Date: 2020-08-05T15:23:55-08:00
New Revision: 820e8d8656ecf65ba29ea27c794c833f230c2698
URL: https://github.com/llvm/llvm-project/commit/820e8d8656ecf65ba29ea27c794c833f230c2698
DIFF: https://github.com/llvm/llvm-project/commit/820e8d8656ecf65ba29ea27c794c833f230c2698.diff
LOG: [Analyzer][WebKit] UncountedLambdaCaptureChecker
Differential Revision: https://reviews.llvm.org/D82837
Added:
clang/lib/StaticAnalyzer/Checkers/WebKit/UncountedLambdaCapturesChecker.cpp
clang/test/Analysis/Checkers/WebKit/uncounted-lambda-captures.cpp
Modified:
clang/docs/analyzer/checkers.rst
clang/include/clang/StaticAnalyzer/Checkers/Checkers.td
clang/lib/StaticAnalyzer/Checkers/CMakeLists.txt
Removed:
################################################################################
diff --git a/clang/docs/analyzer/checkers.rst b/clang/docs/analyzer/checkers.rst
index 1583da7aff09..3b378f735ebc 100644
--- a/clang/docs/analyzer/checkers.rst
+++ b/clang/docs/analyzer/checkers.rst
@@ -1423,6 +1423,25 @@ Raw pointers and references to uncounted types can't be used as class members. O
// ...
};
+.. _webkit-UncountedLambdaCapturesChecker:
+
+webkit.UncountedLambdaCapturesChecker
+"""""""""""""""""""""""""""""""""""""
+Raw pointers and references to uncounted types can't be captured in lambdas. Only ref-counted types are allowed.
+
+.. code-block:: cpp
+
+ struct RefCntbl {
+ void ref() {}
+ void deref() {}
+ };
+
+ void foo(RefCntbl* a, RefCntbl& b) {
+ [&, a](){ // warn about 'a'
+ do_something(b); // warn about 'b'
+ };
+ };
+
.. _alpha-checkers:
Experimental Checkers
diff --git a/clang/include/clang/StaticAnalyzer/Checkers/Checkers.td b/clang/include/clang/StaticAnalyzer/Checkers/Checkers.td
index cbd925400328..a444843c5006 100644
--- a/clang/include/clang/StaticAnalyzer/Checkers/Checkers.td
+++ b/clang/include/clang/StaticAnalyzer/Checkers/Checkers.td
@@ -1654,6 +1654,10 @@ def NoUncountedMemberChecker : Checker<"NoUncountedMemberChecker">,
HelpText<"Check for no uncounted member variables.">,
Documentation<HasDocumentation>;
+def UncountedLambdaCapturesChecker : Checker<"UncountedLambdaCapturesChecker">,
+ HelpText<"Check uncounted lambda captures.">,
+ Documentation<HasDocumentation>;
+
} // end webkit
let ParentPackage = WebKitAlpha in {
diff --git a/clang/lib/StaticAnalyzer/Checkers/CMakeLists.txt b/clang/lib/StaticAnalyzer/Checkers/CMakeLists.txt
index 9be1fdeb3ebf..31f971e33cb2 100644
--- a/clang/lib/StaticAnalyzer/Checkers/CMakeLists.txt
+++ b/clang/lib/StaticAnalyzer/Checkers/CMakeLists.txt
@@ -127,6 +127,7 @@ add_clang_library(clangStaticAnalyzerCheckers
WebKit/PtrTypesSemantics.cpp
WebKit/RefCntblBaseVirtualDtorChecker.cpp
WebKit/UncountedCallArgsChecker.cpp
+ WebKit/UncountedLambdaCapturesChecker.cpp
LINK_LIBS
clangAST
diff --git a/clang/lib/StaticAnalyzer/Checkers/WebKit/UncountedLambdaCapturesChecker.cpp b/clang/lib/StaticAnalyzer/Checkers/WebKit/UncountedLambdaCapturesChecker.cpp
new file mode 100644
index 000000000000..0a387592d350
--- /dev/null
+++ b/clang/lib/StaticAnalyzer/Checkers/WebKit/UncountedLambdaCapturesChecker.cpp
@@ -0,0 +1,106 @@
+//=======- UncountedLambdaCapturesChecker.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 "DiagOutputUtils.h"
+#include "PtrTypesSemantics.h"
+#include "clang/AST/CXXInheritance.h"
+#include "clang/AST/RecursiveASTVisitor.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"
+
+using namespace clang;
+using namespace ento;
+
+namespace {
+class UncountedLambdaCapturesChecker
+ : public Checker<check::ASTDecl<TranslationUnitDecl>> {
+private:
+ BugType Bug{this, "Lambda capture of uncounted variable",
+ "WebKit coding guidelines"};
+ mutable BugReporter *BR;
+
+public:
+ 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 : public RecursiveASTVisitor<LocalVisitor> {
+ const UncountedLambdaCapturesChecker *Checker;
+ explicit LocalVisitor(const UncountedLambdaCapturesChecker *Checker)
+ : Checker(Checker) {
+ assert(Checker);
+ }
+
+ bool shouldVisitTemplateInstantiations() const { return true; }
+ bool shouldVisitImplicitCode() const { return false; }
+
+ bool VisitLambdaExpr(LambdaExpr *L) {
+ Checker->visitLambdaExpr(L);
+ return true;
+ }
+ };
+
+ LocalVisitor visitor(this);
+ visitor.TraverseDecl(const_cast<TranslationUnitDecl *>(TUD));
+ }
+
+ void visitLambdaExpr(LambdaExpr *L) const {
+ for (const LambdaCapture &C : L->captures()) {
+ if (C.capturesVariable()) {
+ VarDecl *CapturedVar = C.getCapturedVar();
+ if (auto *CapturedVarType = CapturedVar->getType().getTypePtrOrNull()) {
+ if (isUncountedPtr(CapturedVarType)) {
+ reportBug(C, CapturedVar, CapturedVarType);
+ }
+ }
+ }
+ }
+ }
+
+ void reportBug(const LambdaCapture &Capture, VarDecl *CapturedVar,
+ const Type *T) const {
+ assert(CapturedVar);
+
+ SmallString<100> Buf;
+ llvm::raw_svector_ostream Os(Buf);
+
+ if (Capture.isExplicit()) {
+ Os << "Captured ";
+ } else {
+ Os << "Implicitly captured ";
+ }
+ if (T->isPointerType()) {
+ Os << "raw-pointer ";
+ } else {
+ assert(T->isReferenceType());
+ Os << "reference ";
+ }
+
+ printQuotedQualifiedName(Os, Capture.getCapturedVar());
+ Os << " to uncounted type is unsafe.";
+
+ PathDiagnosticLocation BSLoc(Capture.getLocation(), BR->getSourceManager());
+ auto Report = std::make_unique<BasicBugReport>(Bug, Os.str(), BSLoc);
+ BR->emitReport(std::move(Report));
+ }
+};
+} // namespace
+
+void ento::registerUncountedLambdaCapturesChecker(CheckerManager &Mgr) {
+ Mgr.registerChecker<UncountedLambdaCapturesChecker>();
+}
+
+bool ento::shouldRegisterUncountedLambdaCapturesChecker(
+ const CheckerManager &mgr) {
+ return true;
+}
diff --git a/clang/test/Analysis/Checkers/WebKit/uncounted-lambda-captures.cpp b/clang/test/Analysis/Checkers/WebKit/uncounted-lambda-captures.cpp
new file mode 100644
index 000000000000..85dd77f9a877
--- /dev/null
+++ b/clang/test/Analysis/Checkers/WebKit/uncounted-lambda-captures.cpp
@@ -0,0 +1,44 @@
+// RUN: %clang_analyze_cc1 -analyzer-checker=webkit.UncountedLambdaCapturesChecker %s 2>&1 | FileCheck %s --strict-whitespace
+#include "mock-types.h"
+
+void raw_ptr() {
+ RefCountable* ref_countable = nullptr;
+ auto foo1 = [ref_countable](){};
+ // CHECK: warning: Captured raw-pointer 'ref_countable' to uncounted type is unsafe [webkit.UncountedLambdaCapturesChecker]
+ // CHECK-NEXT:{{^}} auto foo1 = [ref_countable](){};
+ // CHECK-NEXT:{{^}} ^
+ auto foo2 = [&ref_countable](){};
+ // CHECK: warning: Captured raw-pointer 'ref_countable' to uncounted type is unsafe [webkit.UncountedLambdaCapturesChecker]
+ auto foo3 = [&](){ ref_countable = nullptr; };
+ // CHECK: warning: Implicitly captured raw-pointer 'ref_countable' to uncounted type is unsafe [webkit.UncountedLambdaCapturesChecker]
+ // CHECK-NEXT:{{^}} auto foo3 = [&](){ ref_countable = nullptr; };
+ // CHECK-NEXT:{{^}} ^
+ auto foo4 = [=](){ (void) ref_countable; };
+ // CHECK: warning: Implicitly captured raw-pointer 'ref_countable' to uncounted type is unsafe [webkit.UncountedLambdaCapturesChecker]
+}
+
+void references() {
+ RefCountable automatic;
+ RefCountable& ref_countable_ref = automatic;
+
+ auto foo1 = [ref_countable_ref](){};
+ // CHECK: warning: Captured reference 'ref_countable_ref' to uncounted type is unsafe [webkit.UncountedLambdaCapturesChecker]
+ auto foo2 = [&ref_countable_ref](){};
+ // CHECK: warning: Captured reference 'ref_countable_ref' to uncounted type is unsafe [webkit.UncountedLambdaCapturesChecker]
+ auto foo3 = [&](){ (void) ref_countable_ref; };
+ // CHECK: warning: Implicitly captured reference 'ref_countable_ref' to uncounted type is unsafe [webkit.UncountedLambdaCapturesChecker]
+ auto foo4 = [=](){ (void) ref_countable_ref; };
+ // CHECK: warning: Implicitly captured reference 'ref_countable_ref' to uncounted type is unsafe [webkit.UncountedLambdaCapturesChecker]
+}
+
+void quiet() {
+// This code is not expected to trigger any warnings.
+ {
+ RefCountable automatic;
+ RefCountable &ref_countable_ref = automatic;
+ }
+
+ auto foo3 = [&]() {};
+ auto foo4 = [=]() {};
+ RefCountable *ref_countable = nullptr;
+}
More information about the cfe-commits
mailing list