[clang] [clang-tidy] Add performance-move-smart-pointer-contents check. (PR #66139)
via cfe-commits
cfe-commits at lists.llvm.org
Tue Sep 12 16:25:17 PDT 2023
https://github.com/pizzud updated https://github.com/llvm/llvm-project/pull/66139:
>From b699129b21c95571410a809d16fdf8cfcf1526c5 Mon Sep 17 00:00:00 2001
From: David Pizzuto <pizzud at google.com>
Date: Tue, 12 Sep 2023 13:24:48 -0700
Subject: [PATCH 1/2] [clang-tidy] Add performance-move-smart-pointer-contents
check.
This check detects moves of the contents of a smart pointer as opposed to the
smart pointer itself. For unique_ptr this is a performance issue, as the underlying
type is presumably not cheap to move, but for shared_ptr it's actually dangerous
as other code that also has access to the shared_ptr is probably not expecting the
move.
The set of "unique" and "shared" pointer classes are configurable via options to
allow individual projects to add additional classes of each type.
---
.../clang-tidy/performance/CMakeLists.txt | 1 +
.../MoveSmartPointerContentsCheck.cpp | 80 ++++++++++++
.../MoveSmartPointerContentsCheck.h | 39 ++++++
.../performance/PerformanceTidyModule.cpp | 3 +
clang-tools-extra/docs/ReleaseNotes.rst | 5 +
.../docs/clang-tidy/checks/list.rst | 1 +
.../move-smart-pointer-contents.rst | 23 ++++
.../move-smart-pointer-contents.cpp | 119 ++++++++++++++++++
8 files changed, 271 insertions(+)
create mode 100644 clang-tools-extra/clang-tidy/performance/MoveSmartPointerContentsCheck.cpp
create mode 100644 clang-tools-extra/clang-tidy/performance/MoveSmartPointerContentsCheck.h
create mode 100644 clang-tools-extra/docs/clang-tidy/checks/performance/move-smart-pointer-contents.rst
create mode 100644 clang-tools-extra/test/clang-tidy/checkers/performance/move-smart-pointer-contents.cpp
diff --git a/clang-tools-extra/clang-tidy/performance/CMakeLists.txt b/clang-tools-extra/clang-tidy/performance/CMakeLists.txt
index 81128ff086021ed..35435a951c0717b 100644
--- a/clang-tools-extra/clang-tidy/performance/CMakeLists.txt
+++ b/clang-tools-extra/clang-tidy/performance/CMakeLists.txt
@@ -14,6 +14,7 @@ add_clang_library(clangTidyPerformanceModule
InefficientVectorOperationCheck.cpp
MoveConstArgCheck.cpp
MoveConstructorInitCheck.cpp
+ MoveSmartPointerContentsCheck.cpp
NoAutomaticMoveCheck.cpp
NoIntToPtrCheck.cpp
NoexceptDestructorCheck.cpp
diff --git a/clang-tools-extra/clang-tidy/performance/MoveSmartPointerContentsCheck.cpp b/clang-tools-extra/clang-tidy/performance/MoveSmartPointerContentsCheck.cpp
new file mode 100644
index 000000000000000..8c1170641e5c718
--- /dev/null
+++ b/clang-tools-extra/clang-tidy/performance/MoveSmartPointerContentsCheck.cpp
@@ -0,0 +1,80 @@
+//===--- MoveSmartPointerContentsCheck.cpp - clang-tidy -------------------===//
+//
+// 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 <string>
+
+#include "MoveSmartPointerContentsCheck.h"
+#include "../utils/Matchers.h"
+#include "../utils/OptionsUtils.h"
+#include "clang/AST/ASTContext.h"
+#include "clang/ASTMatchers/ASTMatchFinder.h"
+#include "clang/Lex/Lexer.h"
+
+using namespace clang::ast_matchers;
+
+namespace clang::tidy::performance {
+
+MoveSmartPointerContentsCheck::MoveSmartPointerContentsCheck(
+ StringRef Name, ClangTidyContext *Context)
+ : ClangTidyCheck(Name, Context),
+ UniquePointerClasses(utils::options::parseStringList(
+ Options.get("UniquePointerClasses", "std::unique_ptr"))),
+ IsAUniquePointer(namedDecl(hasAnyName(UniquePointerClasses))),
+ SharedPointerClasses(utils::options::parseStringList(
+ Options.get("SharedPointerClasses", "std::shared_ptr"))),
+ IsASharedPointer(namedDecl(hasAnyName(SharedPointerClasses))) {}
+
+void MoveSmartPointerContentsCheck::storeOptions(
+ ClangTidyOptions::OptionMap &Opts) {
+ Options.store(Opts, "UniquePtrClasses",
+ utils::options::serializeStringList(UniquePointerClasses));
+ Options.store(Opts, "SharedPtrClasses",
+ utils::options::serializeStringList(SharedPointerClasses));
+}
+
+void MoveSmartPointerContentsCheck::registerMatchers(MatchFinder *Finder) {
+ Finder->addMatcher(
+ callExpr(
+ callee(functionDecl(hasName("std::move"))),
+ hasArgument(0, cxxOperatorCallExpr(hasOperatorName("*"),
+ hasDeclaration(cxxMethodDecl(ofClass(IsAUniquePointer)))).bind("unique_op")))
+ .bind("unique_call"),
+ this);
+
+ Finder->addMatcher(
+ callExpr(
+ callee(functionDecl(hasName("std::move"))),
+ hasArgument(0, cxxOperatorCallExpr(hasOperatorName("*"),
+ hasDeclaration(cxxMethodDecl(ofClass(IsASharedPointer)))).bind("shared_op")))
+ .bind("shared_call"),
+ this);
+}
+
+void MoveSmartPointerContentsCheck::check(
+ const MatchFinder::MatchResult &Result) {
+ const auto *UniqueCall = Result.Nodes.getNodeAs<CallExpr>("unique_call");
+ const auto *SharedCall = Result.Nodes.getNodeAs<CallExpr>("shared_call");
+
+ if (UniqueCall) {
+ const auto* UniqueOp = Result.Nodes.getNodeAs<Expr>("unique_op");
+
+ diag(UniqueCall->getBeginLoc(),
+ "prefer to move the smart pointer rather than its contents") << FixItHint::CreateInsertion(UniqueCall->getBeginLoc(), "*")
+ << FixItHint::CreateRemoval(UniqueOp->getBeginLoc());
+ }
+ if (SharedCall) {
+ const auto* SharedOp = Result.Nodes.getNodeAs<Expr>("shared_op");
+
+ diag(SharedCall->getBeginLoc(),
+ "don't move the contents out of a shared pointer, as other accessors "
+ "expect them to remain in a determinate state") << FixItHint::CreateInsertion(SharedCall->getBeginLoc(), "*")
+ << FixItHint::CreateRemoval(SharedOp->getBeginLoc());
+ }
+}
+
+} // namespace clang::tidy::performance
diff --git a/clang-tools-extra/clang-tidy/performance/MoveSmartPointerContentsCheck.h b/clang-tools-extra/clang-tidy/performance/MoveSmartPointerContentsCheck.h
new file mode 100644
index 000000000000000..65bede0e164afc7
--- /dev/null
+++ b/clang-tools-extra/clang-tidy/performance/MoveSmartPointerContentsCheck.h
@@ -0,0 +1,39 @@
+//===--- MoveSmartPointerContentsCheck.h - clang-tidy -----------*- 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
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_PERFORMANCE_MOVESMARTPOINTERCONTENTSCHECK_H
+#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_PERFORMANCE_MOVESMARTPOINTERCONTENTSCHECK_H
+
+#include <vector>
+
+#include "../ClangTidyCheck.h"
+
+namespace clang::tidy::performance {
+
+/// Checks that std::move is not called on the contents of a smart pointer and
+/// suggests moving out of the pointer instead.
+///
+/// For the user-facing documentation see:
+/// http://clang.llvm.org/extra/clang-tidy/checks/performance/move-smart-pointer-contents.html
+class MoveSmartPointerContentsCheck : public ClangTidyCheck {
+public:
+ MoveSmartPointerContentsCheck(StringRef Name, ClangTidyContext *Context);
+ void registerMatchers(ast_matchers::MatchFinder *Finder) override;
+ void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
+ void storeOptions(ClangTidyOptions::OptionMap &Opts) override;
+
+private:
+ const std::vector<StringRef> UniquePointerClasses;
+ const ast_matchers::internal::Matcher<RecordDecl> IsAUniquePointer;
+ const std::vector<StringRef> SharedPointerClasses;
+ const ast_matchers::internal::Matcher<RecordDecl> IsASharedPointer;
+};
+
+} // namespace clang::tidy::performance
+
+#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_PERFORMANCE_MOVESMARTPOINTERCONTENTSCHECK_H
diff --git a/clang-tools-extra/clang-tidy/performance/PerformanceTidyModule.cpp b/clang-tools-extra/clang-tidy/performance/PerformanceTidyModule.cpp
index 9e0fa6f88b36a00..53842dfe4c2bd59 100644
--- a/clang-tools-extra/clang-tidy/performance/PerformanceTidyModule.cpp
+++ b/clang-tools-extra/clang-tidy/performance/PerformanceTidyModule.cpp
@@ -19,6 +19,7 @@
#include "InefficientVectorOperationCheck.h"
#include "MoveConstArgCheck.h"
#include "MoveConstructorInitCheck.h"
+#include "MoveSmartPointerContentsCheck.h"
#include "NoAutomaticMoveCheck.h"
#include "NoIntToPtrCheck.h"
#include "NoexceptDestructorCheck.h"
@@ -53,6 +54,8 @@ class PerformanceModule : public ClangTidyModule {
"performance-move-const-arg");
CheckFactories.registerCheck<MoveConstructorInitCheck>(
"performance-move-constructor-init");
+ CheckFactories.registerCheck<MoveSmartPointerContentsCheck>(
+ "performance-move-smart-pointer-contents");
CheckFactories.registerCheck<NoAutomaticMoveCheck>(
"performance-no-automatic-move");
CheckFactories.registerCheck<NoIntToPtrCheck>("performance-no-int-to-ptr");
diff --git a/clang-tools-extra/docs/ReleaseNotes.rst b/clang-tools-extra/docs/ReleaseNotes.rst
index 19c977977f9044c..27c1b996c6ca049 100644
--- a/clang-tools-extra/docs/ReleaseNotes.rst
+++ b/clang-tools-extra/docs/ReleaseNotes.rst
@@ -168,6 +168,11 @@ New checks
Recommends the smallest possible underlying type for an ``enum`` or ``enum``
class based on the range of its enumerators.
+- New :doc:`performance-move-smart-pointer-contents
+ <clang-tidy/checks/performance/move-smart-pointer-contents>` check.
+
+ Recommends moving a smart pointer rather than its contents.
+
- New :doc:`readability-reference-to-constructed-temporary
<clang-tidy/checks/readability/reference-to-constructed-temporary>` check.
diff --git a/clang-tools-extra/docs/clang-tidy/checks/list.rst b/clang-tools-extra/docs/clang-tidy/checks/list.rst
index 75a86431d264412..7c6770e17250203 100644
--- a/clang-tools-extra/docs/clang-tidy/checks/list.rst
+++ b/clang-tools-extra/docs/clang-tidy/checks/list.rst
@@ -317,6 +317,7 @@ Clang-Tidy Checks
:doc:`performance-inefficient-vector-operation <performance/inefficient-vector-operation>`, "Yes"
:doc:`performance-move-const-arg <performance/move-const-arg>`, "Yes"
:doc:`performance-move-constructor-init <performance/move-constructor-init>`,
+ :doc:`performance-move-smart-pointer-contents <performance/move-smart-pointer-contents>`, "Yes"
:doc:`performance-no-automatic-move <performance/no-automatic-move>`,
:doc:`performance-no-int-to-ptr <performance/no-int-to-ptr>`,
:doc:`performance-noexcept-destructor <performance/noexcept-destructor>`, "Yes"
diff --git a/clang-tools-extra/docs/clang-tidy/checks/performance/move-smart-pointer-contents.rst b/clang-tools-extra/docs/clang-tidy/checks/performance/move-smart-pointer-contents.rst
new file mode 100644
index 000000000000000..03d72d7250ff7a2
--- /dev/null
+++ b/clang-tools-extra/docs/clang-tidy/checks/performance/move-smart-pointer-contents.rst
@@ -0,0 +1,23 @@
+.. title:: clang-tidy - performance-move-smart-pointer-contents
+
+performance-move-smart-pointer-contents
+=======================================
+
+Given a smart pointer containing a movable type, such as a
+`std::unique_ptr<SomeProtocolBuffer>`, it's possible to move the contents of the
+pointer rather than the pointer itself (ie `std::move(*p)` rather than
+`*std::move(p)`). Doing so is a pessimization, as if the type could be efficiently
+moved we wouldn't need to put it in a `unique_ptr` to begin with.
+
+Options
+-------
+
+.. option :: UniquePointerClasses
+
+ A semicolon-separated list of class names that should be treated as unique
+ pointers. By default only `std::unique_ptr` is included.
+
+.. option :: SharedPointerClasses
+
+ A semicolon-separated list of class names that should be treated as shared
+ pointers. By default only `std::shared_ptr` is included.
diff --git a/clang-tools-extra/test/clang-tidy/checkers/performance/move-smart-pointer-contents.cpp b/clang-tools-extra/test/clang-tidy/checkers/performance/move-smart-pointer-contents.cpp
new file mode 100644
index 000000000000000..ebc4dc683fb16d4
--- /dev/null
+++ b/clang-tools-extra/test/clang-tidy/checkers/performance/move-smart-pointer-contents.cpp
@@ -0,0 +1,119 @@
+// RUN: %check_clang_tidy %s performance-move-smart-pointer-contents %t -- \
+// RUN: -config="{CheckOptions: \
+// RUN: {performance-move-smart-pointer-contents.UniquePointerClasses: \
+// RUN: 'std::unique_ptr; my::OtherUniquePtr;',\
+// RUN: performance-move-smart-pointer-contents.SharedPointerClasses: \
+// RUN: 'std::shared_ptr;my::OtherSharedPtr;'}}"
+
+// Some dummy definitions we'll need.
+
+namespace std {
+
+using size_t = int;
+
+template <typename> struct remove_reference;
+template <typename _Tp> struct remove_reference { typedef _Tp type; };
+template <typename _Tp> struct remove_reference<_Tp &> { typedef _Tp type; };
+template <typename _Tp> struct remove_reference<_Tp &&> { typedef _Tp type; };
+
+template <typename _Tp>
+constexpr typename std::remove_reference<_Tp>::type &&move(_Tp &&__t) {
+ return static_cast<typename std::remove_reference<_Tp>::type &&>(__t);
+}
+
+template <typename T>
+struct unique_ptr {
+ unique_ptr();
+ T *get() const;
+ explicit operator bool() const;
+ void reset(T *ptr);
+ T &operator*() const;
+ T *operator->() const;
+ T& operator[](size_t i) const;
+};
+
+template <typename T>
+struct shared_ptr {
+ shared_ptr();
+ T *get() const;
+ explicit operator bool() const;
+ void reset(T *ptr);
+ T &operator*() const;
+ T *operator->() const;
+};
+
+} // namespace std
+
+namespace my {
+template <typename T>
+using OtherUniquePtr = std::unique_ptr<T>;
+template <typename T>
+using OtherSharedPtr = std::shared_ptr<T>;
+} // namespace my
+
+void correctUnique() {
+ std::unique_ptr<int> p;
+ int x = *std::move(p);
+}
+
+void simpleFindingUnique() {
+ std::unique_ptr<int> p;
+ int x = std::move(*p);
+}
+// CHECK-MESSAGES: :[[@LINE-2]]:11: warning: prefer to move the smart pointer rather than its contents [performance-move-smart-pointer-contents]
+// CHECK-FIXES: *std::move(p)
+
+void aliasedUniqueType() {
+ using int_ptr = std::unique_ptr<int>;
+ int_ptr p;
+ int x = std::move(*p);
+}
+// CHECK-MESSAGES: :[[@LINE-2]]:11: warning: prefer to move the smart pointer rather than its contents [performance-move-smart-pointer-contents]
+// CHECK-FIXES: *std::move(p)
+
+void configWorksUnique() {
+ my::OtherUniquePtr<int> p;
+ int x = std::move(*p);
+}
+// CHECK-MESSAGES: :[[@LINE-2]]:11: warning: prefer to move the smart pointer rather than its contents [performance-move-smart-pointer-contents]
+// CHECK-FIXES: *std::move(p)
+
+void multiStarsUnique() {
+ std::unique_ptr<int> p;
+ int x = 2 * std::move(*p) * 3;
+}
+// CHECK-MESSAGES: :[[@LINE-2]]:15: warning: prefer to move the smart pointer rather than its contents [performance-move-smart-pointer-contents]
+// CHECK-FIXES: *std::move(p)
+
+void correctShared() {
+ std::shared_ptr<int> p;
+ int x = *std::move(p);
+}
+
+void simpleFindingShared() {
+ std::shared_ptr<int> p;
+ int y = std::move(*p);
+}
+// CHECK-MESSAGES: :[[@LINE-2]]:11: warning: don't move the contents out of a shared pointer, as other accessors expect them to remain in a determinate state [performance-move-smart-pointer-contents]
+
+void aliasedSharedType() {
+ using int_ptr = std::shared_ptr<int>;
+ int_ptr p;
+ int x = std::move(*p);
+}
+// CHECK-MESSAGES: :[[@LINE-2]]:11: warning: don't move the contents out of a shared pointer, as other accessors expect them to remain in a determinate state [performance-move-smart-pointer-contents]
+// CHECK-FIXES: *std::move(p)
+
+void configWorksShared() {
+ my::OtherSharedPtr<int> p;
+ int x = std::move(*p);
+}
+// CHECK-MESSAGES: :[[@LINE-2]]:11: warning: don't move the contents out of a shared pointer, as other accessors expect them to remain in a determinate state [performance-move-smart-pointer-contents]
+// CHECK-FIXES: *std::move(p)
+
+void multiStarsShared() {
+ std::shared_ptr<int> p;
+ int x = 2 * std::move(*p) * 3;
+}
+// CHECK-MESSAGES: :[[@LINE-2]]:15: warning: don't move the contents out of a shared pointer, as other accessors expect them to remain in a determinate state [performance-move-smart-pointer-contents]
+// CHECK-FIXES: *std::move(p)
>From ca5c9bb013d0012b2900af78c21eb7391436774d Mon Sep 17 00:00:00 2001
From: David Pizzuto <pizzud at google.com>
Date: Tue, 12 Sep 2023 13:24:48 -0700
Subject: [PATCH 2/2] [clang-tidy] Add performance-move-smart-pointer-contents
check.
This check detects moves of the contents of a smart pointer as opposed to the
smart pointer itself. For unique_ptr this is a performance issue, as the underlying
type is presumably not cheap to move, but for shared_ptr it's actually dangerous
as other code that also has access to the shared_ptr is probably not expecting the
move.
The set of "unique" and "shared" pointer classes are configurable via options to
allow individual projects to add additional classes of each type.
---
.../MoveSmartPointerContentsCheck.cpp | 73 +++++++++++--------
.../MoveSmartPointerContentsCheck.h | 3 +-
2 files changed, 45 insertions(+), 31 deletions(-)
diff --git a/clang-tools-extra/clang-tidy/performance/MoveSmartPointerContentsCheck.cpp b/clang-tools-extra/clang-tidy/performance/MoveSmartPointerContentsCheck.cpp
index 8c1170641e5c718..2a1f16b39362983 100644
--- a/clang-tools-extra/clang-tidy/performance/MoveSmartPointerContentsCheck.cpp
+++ b/clang-tools-extra/clang-tidy/performance/MoveSmartPointerContentsCheck.cpp
@@ -8,9 +8,15 @@
#include <string>
+<<<<<<< HEAD
#include "MoveSmartPointerContentsCheck.h"
#include "../utils/Matchers.h"
#include "../utils/OptionsUtils.h"
+=======
+#include "../utils/Matchers.h"
+#include "../utils/OptionsUtils.h"
+#include "MoveSmartPointerContentsCheck.h"
+>>>>>>> b0179a7f3cac ([clang-tidy] Add performance-move-smart-pointer-contents check.)
#include "clang/AST/ASTContext.h"
#include "clang/ASTMatchers/ASTMatchFinder.h"
#include "clang/Lex/Lexer.h"
@@ -19,15 +25,23 @@ using namespace clang::ast_matchers;
namespace clang::tidy::performance {
+bool MoveSmartPointerContentsCheck::isLanguageVersionSupported(
+ const LangOptions &LangOptions) const {
+ if (!LangOptions.CPlusPlus) {
+ return false;
+ }
+
+ // Anything after C++11 is fine.
+ return LangOptions.CPlusPlus11;
+}
+
MoveSmartPointerContentsCheck::MoveSmartPointerContentsCheck(
StringRef Name, ClangTidyContext *Context)
: ClangTidyCheck(Name, Context),
UniquePointerClasses(utils::options::parseStringList(
Options.get("UniquePointerClasses", "std::unique_ptr"))),
- IsAUniquePointer(namedDecl(hasAnyName(UniquePointerClasses))),
SharedPointerClasses(utils::options::parseStringList(
- Options.get("SharedPointerClasses", "std::shared_ptr"))),
- IsASharedPointer(namedDecl(hasAnyName(SharedPointerClasses))) {}
+ Options.get("SharedPointerClasses", "std::shared_ptr"))) {}
void MoveSmartPointerContentsCheck::storeOptions(
ClangTidyOptions::OptionMap &Opts) {
@@ -41,39 +55,40 @@ void MoveSmartPointerContentsCheck::registerMatchers(MatchFinder *Finder) {
Finder->addMatcher(
callExpr(
callee(functionDecl(hasName("std::move"))),
- hasArgument(0, cxxOperatorCallExpr(hasOperatorName("*"),
- hasDeclaration(cxxMethodDecl(ofClass(IsAUniquePointer)))).bind("unique_op")))
- .bind("unique_call"),
- this);
-
- Finder->addMatcher(
- callExpr(
- callee(functionDecl(hasName("std::move"))),
- hasArgument(0, cxxOperatorCallExpr(hasOperatorName("*"),
- hasDeclaration(cxxMethodDecl(ofClass(IsASharedPointer)))).bind("shared_op")))
- .bind("shared_call"),
+ hasArgument(
+ 0,
+ anyOf(cxxOperatorCallExpr(hasOperatorName("*"),
+ hasDeclaration(cxxMethodDecl(namedDecl(
+ matchers::matchesAnyListedName(
+ UniquePointerClasses)))))
+ .bind("unique_op"),
+ cxxOperatorCallExpr(hasOperatorName("*"),
+ hasDeclaration(cxxMethodDecl(namedDecl(
+ matchers::matchesAnyListedName(
+ SharedPointerClasses)))))
+ .bind("shared_op"))))
+ .bind("call"),
this);
}
-
+
void MoveSmartPointerContentsCheck::check(
const MatchFinder::MatchResult &Result) {
- const auto *UniqueCall = Result.Nodes.getNodeAs<CallExpr>("unique_call");
- const auto *SharedCall = Result.Nodes.getNodeAs<CallExpr>("shared_call");
-
- if (UniqueCall) {
- const auto* UniqueOp = Result.Nodes.getNodeAs<Expr>("unique_op");
+ const auto *Call = Result.Nodes.getNodeAs<CallExpr>("call");
+ const auto *UniqueOp = Result.Nodes.getNodeAs<Expr>("unique_op");
+ const auto *SharedOp = Result.Nodes.getNodeAs<Expr>("shared_op");
- diag(UniqueCall->getBeginLoc(),
- "prefer to move the smart pointer rather than its contents") << FixItHint::CreateInsertion(UniqueCall->getBeginLoc(), "*")
- << FixItHint::CreateRemoval(UniqueOp->getBeginLoc());
+ if (UniqueOp) {
+ diag(Call->getBeginLoc(),
+ "prefer to move the smart pointer rather than its contents")
+ << FixItHint::CreateInsertion(Call->getBeginLoc(), "*")
+ << FixItHint::CreateRemoval(UniqueOp->getBeginLoc());
}
- if (SharedCall) {
- const auto* SharedOp = Result.Nodes.getNodeAs<Expr>("shared_op");
-
- diag(SharedCall->getBeginLoc(),
+ if (SharedOp) {
+ diag(Call->getBeginLoc(),
"don't move the contents out of a shared pointer, as other accessors "
- "expect them to remain in a determinate state") << FixItHint::CreateInsertion(SharedCall->getBeginLoc(), "*")
- << FixItHint::CreateRemoval(SharedOp->getBeginLoc());
+ "expect them to remain in a determinate state")
+ << FixItHint::CreateInsertion(Call->getBeginLoc(), "*")
+ << FixItHint::CreateRemoval(SharedOp->getBeginLoc());
}
}
diff --git a/clang-tools-extra/clang-tidy/performance/MoveSmartPointerContentsCheck.h b/clang-tools-extra/clang-tidy/performance/MoveSmartPointerContentsCheck.h
index 65bede0e164afc7..8b9e8e9d2b3065d 100644
--- a/clang-tools-extra/clang-tidy/performance/MoveSmartPointerContentsCheck.h
+++ b/clang-tools-extra/clang-tidy/performance/MoveSmartPointerContentsCheck.h
@@ -26,12 +26,11 @@ class MoveSmartPointerContentsCheck : public ClangTidyCheck {
void registerMatchers(ast_matchers::MatchFinder *Finder) override;
void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
void storeOptions(ClangTidyOptions::OptionMap &Opts) override;
+ bool isLanguageVersionSupported(const LangOptions &LangOpts) const override;
private:
const std::vector<StringRef> UniquePointerClasses;
- const ast_matchers::internal::Matcher<RecordDecl> IsAUniquePointer;
const std::vector<StringRef> SharedPointerClasses;
- const ast_matchers::internal::Matcher<RecordDecl> IsASharedPointer;
};
} // namespace clang::tidy::performance
More information about the cfe-commits
mailing list