ckennelly created this revision.
ckennelly added reviewers: hokein, njames93, alexfh, aaron.ballman.
Herald added subscribers: xazax.hun, mgorny.
ckennelly requested review of this revision.
Herald added a project: clang.
Herald added a subscriber: cfe-commits.
std::make_unique_for_overwrite and std::make_shared_for_overwrite were
introduced in C++20.
These default initialize the values, unlike std::make_unique /
std::make_shared, which value initialize. The latter can cause
unexpected performance regressions when trivial types (such as int) are
subsequently value initialized.
Repository:
rG LLVM Github Monorepo
https://reviews.llvm.org/D92992
Files:
clang-tools-extra/clang-tidy/modernize/CMakeLists.txt
clang-tools-extra/clang-tidy/modernize/MakeSharedCheck.cpp
clang-tools-extra/clang-tidy/modernize/MakeSharedForOverwriteCheck.cpp
clang-tools-extra/clang-tidy/modernize/MakeSharedForOverwriteCheck.h
clang-tools-extra/clang-tidy/modernize/MakeSmartPtrCheck.cpp
clang-tools-extra/clang-tidy/modernize/MakeSmartPtrCheck.h
clang-tools-extra/clang-tidy/modernize/MakeUniqueCheck.cpp
clang-tools-extra/clang-tidy/modernize/MakeUniqueForOverwriteCheck.cpp
clang-tools-extra/clang-tidy/modernize/MakeUniqueForOverwriteCheck.h
clang-tools-extra/clang-tidy/modernize/ModernizeTidyModule.cpp
clang-tools-extra/docs/ReleaseNotes.rst
clang-tools-extra/docs/clang-tidy/checks/list.rst
clang-tools-extra/docs/clang-tidy/checks/modernize-make-shared-for-overwrite.rst
clang-tools-extra/docs/clang-tidy/checks/modernize-make-unique-for-overwrite.rst
clang-tools-extra/test/clang-tidy/checkers/modernize-make-shared-for-overwrite.cpp
clang-tools-extra/test/clang-tidy/checkers/modernize-make-unique-for-overwrite.cpp
Index: clang-tools-extra/test/clang-tidy/checkers/modernize-make-unique-for-overwrite.cpp
===================================================================
--- /dev/null
+++ clang-tools-extra/test/clang-tidy/checkers/modernize-make-unique-for-overwrite.cpp
@@ -0,0 +1,476 @@
+// RUN: %check_clang_tidy -std=c++20-or-later %s modernize-make-unique-for-overwrite %t -- -- -I %S/Inputs/modernize-smart-ptr
+
+#include "initializer_list.h"
+#include "unique_ptr.h"
+// CHECK-FIXES: #include <memory>
+
+struct Base {
+ Base();
+ Base(int, int);
+};
+
+struct Derived : public Base {
+ Derived();
+ Derived(int, int);
+};
+
+struct APair {
+ int a, b;
+};
+
+struct DPair {
+ DPair() : a(0), b(0) {}
+ DPair(int x, int y) : a(y), b(x) {}
+ int a, b;
+};
+
+template <typename T>
+struct MyVector {
+ MyVector(std::initializer_list<T>);
+};
+
+struct Empty {};
+
+struct E {
+ E(std::initializer_list<int>);
+ E();
+};
+
+struct F {
+ F(std::initializer_list<int>);
+ F();
+ int a;
+};
+
+struct G {
+ G(std::initializer_list<int>);
+ G(int);
+};
+
+struct H {
+ H(std::vector<int>);
+ H(std::vector<int> &, double);
+ H(MyVector<int>, int);
+};
+
+struct I {
+ I(G);
+};
+
+struct J {
+ J(E e, int);
+};
+
+namespace {
+class Foo {};
+} // namespace
+
+namespace bar {
+class Bar {};
+} // namespace bar
+
+template <class T>
+using unique_ptr_ = std::unique_ptr<T>;
+
+void *operator new(__SIZE_TYPE__ Count, void *Ptr);
+
+int g(std::unique_ptr<int> P);
+
+std::unique_ptr<Base> getPointer() {
+ return std::unique_ptr<Base>(new Base);
+}
+
+std::unique_ptr<Base> getPointerValue() {
+ return std::unique_ptr<Base>(new Base());
+}
+
+void basic() {
+ std::unique_ptr<int> P1 = std::unique_ptr<int>(new int());
+ std::unique_ptr<int> P2 = std::unique_ptr<int>(new int);
+ // CHECK-MESSAGES: :[[@LINE-1]]:29: warning: use std::make_unique_for_overwrite instead [modernize-make-unique-for-overwrite]
+ // CHECK-FIXES: std::unique_ptr<int> P2 = std::make_unique_for_overwrite<int>();
+
+ P1.reset(new int());
+ P2.reset(new int);
+ // CHECK-MESSAGES: :[[@LINE-1]]:6: warning: use std::make_unique_for_overwrite instead [modernize-make-unique-for-overwrite]
+ // CHECK-FIXES: P2 = std::make_unique_for_overwrite<int>();
+
+ P1 = std::unique_ptr<int>(new int());
+ P2 = std::unique_ptr<int>(new int);
+ // CHECK-MESSAGES: :[[@LINE-1]]:8: warning: use std::make_unique_for_overwrite instead [modernize-make-unique-for-overwrite]
+ // CHECK-FIXES: P2 = std::make_unique_for_overwrite<int>();
+
+ P1.reset(new int());
+ P2.reset(new int);
+ // CHECK-MESSAGES: :[[@LINE-1]]:6: warning: use std::make_unique_for_overwrite instead [modernize-make-unique-for-overwrite]
+ // CHECK-FIXES: P2 = std::make_unique_for_overwrite<int>();
+
+ // With auto.
+ auto P4 = std::unique_ptr<int>(new int());
+ auto P5 = std::unique_ptr<int>(new int);
+ // CHECK-MESSAGES: :[[@LINE-1]]:13: warning: use std::make_unique_for_overwrite instead
+ // CHECK-FIXES: auto P5 = std::make_unique_for_overwrite<int>();
+
+ std::unique_ptr<int> P6 = std::unique_ptr<int>((new int()));
+ std::unique_ptr<int> P7 = std::unique_ptr<int>((new int));
+ // CHECK-MESSAGES: :[[@LINE-1]]:29: warning: use std::make_unique_for_overwrite instead [modernize-make-unique-for-overwrite]
+ // CHECK-FIXES: std::unique_ptr<int> P7 = std::make_unique_for_overwrite<int>();
+
+ P4.reset((new int()));
+ P5.reset((new int));
+ // CHECK-MESSAGES: :[[@LINE-1]]:6: warning: use std::make_unique_for_overwrite instead [modernize-make-unique-for-overwrite]
+ // CHECK-FIXES: P5 = std::make_unique_for_overwrite<int>();
+
+ std::unique_ptr<int> P8 = std::unique_ptr<int>((((new int()))));
+ std::unique_ptr<int> P9 = std::unique_ptr<int>((((new int))));
+ // CHECK-MESSAGES: :[[@LINE-1]]:29: warning: use std::make_unique_for_overwrite instead [modernize-make-unique-for-overwrite]
+ // CHECK-FIXES: std::unique_ptr<int> P9 = std::make_unique_for_overwrite<int>();
+
+ P5.reset(((((new int())))));
+ P6.reset(((((new int)))));
+ // CHECK-MESSAGES: :[[@LINE-1]]:6: warning: use std::make_unique_for_overwrite instead [modernize-make-unique-for-overwrite]
+ // CHECK-FIXES: P6 = std::make_unique_for_overwrite<int>();
+
+ {
+ // No std.
+ using namespace std;
+ unique_ptr<int> Q = unique_ptr<int>(new int());
+ unique_ptr<int> P = unique_ptr<int>(new int);
+ // CHECK-MESSAGES: :[[@LINE-1]]:25: warning: use std::make_unique_for_overwrite instead
+ // CHECK-FIXES: unique_ptr<int> P = std::make_unique_for_overwrite<int>();
+
+ Q = unique_ptr<int>(new int());
+ P = unique_ptr<int>(new int);
+ // CHECK-MESSAGES: :[[@LINE-1]]:9: warning: use std::make_unique_for_overwrite instead
+ // CHECK-FIXES: P = std::make_unique_for_overwrite<int>();
+ }
+
+ std::unique_ptr<int> R(new int());
+ std::unique_ptr<int> S(new int);
+
+ // Create the unique_ptr as a parameter to a function.
+ int T = g(std::unique_ptr<int>(new int()));
+ T = g(std::unique_ptr<int>(new int));
+ // CHECK-MESSAGES: :[[@LINE-1]]:9: warning: use std::make_unique_for_overwrite instead
+ // CHECK-FIXES: T = g(std::make_unique_for_overwrite<int>());
+
+ // Only replace if the type in the template is the same as the type returned
+ // by the new operator.
+ auto Pderived = std::unique_ptr<Base>(new Derived());
+ auto PderivedNoparen = std::unique_ptr<Base>(new Derived);
+
+ // OK to replace for reset and assign
+ Pderived.reset(new Derived());
+ PderivedNoparen.reset(new Derived);
+
+ Pderived = std::unique_ptr<Derived>(new Derived());
+ PderivedNoparen = std::unique_ptr<Derived>(new Derived);
+
+ // FIXME: OK to replace if assigned to unique_ptr<Base>
+ Pderived = std::unique_ptr<Base>(new Derived());
+ Pderived = std::unique_ptr<Base>(new Derived);
+
+ // FIXME: OK to replace when auto is not used
+ std::unique_ptr<Base> PBase = std::unique_ptr<Base>(new Derived());
+ std::unique_ptr<Base> PBaseNoparen = std::unique_ptr<Base>(new Derived);
+
+ // The pointer is returned by the function, nothing to do.
+ std::unique_ptr<Base> RetPtr = getPointer();
+ RetPtr = getPointerValue();
+
+ // This emulates std::move.
+ std::unique_ptr<int> Move = static_cast<std::unique_ptr<int> &&>(P1);
+
+ // Placement arguments should not be removed.
+ int *PInt = new int;
+ std::unique_ptr<int> Placement = std::unique_ptr<int>(new (PInt) int{3});
+ Placement.reset(new (PInt) int{3});
+ Placement = std::unique_ptr<int>(new (PInt) int{3});
+
+ std::unique_ptr<int> PlacementNoparen = std::unique_ptr<int>(new (PInt) int);
+ PlacementNoparen.reset(new (PInt) int);
+ PlacementNoparen = std::unique_ptr<int>(new (PInt) int);
+}
+
+// Calling make_smart_ptr from within a member function of a type with a
+// private or protected constructor would be ill-formed.
+class Private {
+private:
+ Private(int z) {}
+
+public:
+ Private() {}
+ void create() {
+ auto callsPublic = std::unique_ptr<Private>(new Private);
+ auto ptr = std::unique_ptr<Private>(new Private(42));
+ ptr.reset(new Private(42));
+ ptr = std::unique_ptr<Private>(new Private(42));
+ }
+
+ virtual ~Private();
+};
+
+class Protected {
+protected:
+ Protected() {}
+
+public:
+ Protected(int, int) {}
+ void create() {
+ auto callsPublic = std::unique_ptr<Protected>(new Protected(1, 2));
+ auto ptr = std::unique_ptr<Protected>(new Protected);
+ ptr.reset(new Protected);
+ ptr = std::unique_ptr<Protected>(new Protected);
+ }
+};
+
+void initialization(int T, Base b) {
+ // Test different kinds of initialization of the pointee.
+
+ // Direct initialization with parenthesis.
+ std::unique_ptr<DPair> PDir1 = std::unique_ptr<DPair>(new DPair(1, T));
+ PDir1.reset(new DPair(1, T));
+
+ // Direct initialization with braces.
+ std::unique_ptr<DPair> PDir2 = std::unique_ptr<DPair>(new DPair{2, T});
+ PDir2.reset(new DPair{2, T});
+
+ // Aggregate initialization.
+ std::unique_ptr<APair> PAggr = std::unique_ptr<APair>(new APair{T, 1});
+ PAggr.reset(new APair{T, 1});
+
+ // Check aggregate init with intermediate temporaries.
+ std::unique_ptr<APair> PAggrTemp = std::unique_ptr<APair>(new APair({T, 1}));
+ PAggrTemp.reset(new APair({T, 1}));
+
+ // Test different kinds of initialization of the pointee, when the unique_ptr
+ // is initialized with braces.
+
+ // Direct initialization with parenthesis.
+ std::unique_ptr<DPair> PDir3 = std::unique_ptr<DPair>{new DPair(3, T)};
+
+ // Direct initialization with braces.
+ std::unique_ptr<DPair> PDir4 = std::unique_ptr<DPair>{new DPair{4, T}};
+
+ // Aggregate initialization.
+ std::unique_ptr<APair> PAggr2 = std::unique_ptr<APair>{new APair{T, 2}};
+
+ // Direct initialization with parenthesis, without arguments.
+ std::unique_ptr<DPair> PDir5 = std::unique_ptr<DPair>(new DPair());
+
+ // Direct initialization with braces, without arguments.
+ std::unique_ptr<DPair> PDir6 = std::unique_ptr<DPair>(new DPair{});
+
+ // Aggregate initialization without arguments.
+ std::unique_ptr<Empty> PEmpty = std::unique_ptr<Empty>(new Empty{});
+
+ // Initialization with default constructor.
+ std::unique_ptr<E> PE1 = std::unique_ptr<E>(new E{});
+ PE1.reset(new E{});
+
+ // No warnings for `auto` new expression.
+ PE1.reset(new auto(E()));
+
+ //============================================================================
+ // NOTE: For initializer-list constructors, the check only gives warnings,
+ // and no fixes are generated.
+ //============================================================================
+
+ // Initialization with the initializer-list constructor.
+ std::unique_ptr<E> PE2 = std::unique_ptr<E>(new E{1, 2});
+ PE2.reset(new E{1, 2});
+
+ // Initialization with default constructor.
+ std::unique_ptr<F> PF1 = std::unique_ptr<F>(new F());
+ PF1.reset(new F());
+
+ // Initialization with default constructor.
+ std::unique_ptr<F> PF2 = std::unique_ptr<F>(new F{});
+ PF2.reset(new F());
+
+ // Initialization with the initializer-list constructor.
+ std::unique_ptr<F> PF3 = std::unique_ptr<F>(new F{1});
+ PF3.reset(new F{1});
+
+ // Initialization with the initializer-list constructor.
+ std::unique_ptr<F> PF4 = std::unique_ptr<F>(new F{1, 2});
+
+ // Initialization with the initializer-list constructor.
+ std::unique_ptr<F> PF5 = std::unique_ptr<F>(new F({1, 2}));
+
+ // Initialization with the initializer-list constructor as the default
+ // constructor is not present.
+ std::unique_ptr<G> PG1 = std::unique_ptr<G>(new G{});
+ PG1.reset(new G{});
+
+ // Initialization with the initializer-list constructor.
+ std::unique_ptr<G> PG2 = std::unique_ptr<G>(new G{1});
+
+ // Initialization with the initializer-list constructor.
+ std::unique_ptr<G> PG3 = std::unique_ptr<G>(new G{1, 2});
+
+ std::unique_ptr<H> PH1 = std::unique_ptr<H>(new H({1, 2, 3}));
+ PH1.reset(new H({1, 2, 3}));
+
+ std::unique_ptr<H> PH2 = std::unique_ptr<H>(new H({1, 2, 3}, 1));
+ PH2.reset(new H({1, 2, 3}, 1));
+
+ std::unique_ptr<H> PH3 = std::unique_ptr<H>(new H({1, 2, 3}, 1.0));
+ PH3.reset(new H({1, 2, 3}, 1.0));
+
+ std::unique_ptr<I> PI1 = std::unique_ptr<I>(new I(G({1, 2, 3})));
+ PI1.reset(new I(G({1, 2, 3})));
+
+ std::unique_ptr<J> PJ1 = std::unique_ptr<J>(new J({1, 2}, 1));
+ PJ1.reset(new J({1, 2}, 1));
+
+ std::unique_ptr<J> PJ2 = std::unique_ptr<J>(new J(E{1, 2}, 1));
+ PJ2.reset(new J(E{1, 2}, 1));
+
+ std::unique_ptr<J> PJ3 = std::unique_ptr<J>(new J{{1, 2}, 1});
+ PJ3.reset(new J{{1, 2}, 1});
+
+ std::unique_ptr<J> PJ4 = std::unique_ptr<J>(new J{E{1, 2}, 1});
+ PJ4.reset(new J{E{1, 2}, 1});
+
+ std::unique_ptr<Foo> FF = std::unique_ptr<Foo>(new Foo());
+ FF.reset(new Foo());
+
+ std::unique_ptr<bar::Bar> BB = std::unique_ptr<bar::Bar>(new bar::Bar());
+ BB.reset(new bar::Bar());
+
+ std::unique_ptr<Foo[]> FFs;
+ FFs.reset(new Foo[5]);
+ FFs.reset(new Foo[5]());
+ const int Num = 1;
+ FFs.reset(new Foo[Num]);
+ int Num2 = 1;
+
+ // The check doesn't give warnings and fixes for cases where the original new
+ // expression does value initialization.
+ std::unique_ptr<int[]> FI;
+ FI.reset(new int[5]());
+
+ FI.reset(new int[5]);
+ // CHECK-MESSAGES: :[[@LINE-1]]:6: warning:
+ // CHECK-FIXES: FI = std::make_unique_for_overwrite<int[]>(5);
+ FI.reset(new int[Num]);
+ // CHECK-MESSAGES: :[[@LINE-1]]:6: warning:
+ // CHECK-FIXES: FI = std::make_unique_for_overwrite<int[]>(Num);
+ FI.reset(new int[Num2]);
+ // CHECK-MESSAGES: :[[@LINE-1]]:6: warning:
+ // CHECK-FIXES: FI = std::make_unique_for_overwrite<int[]>(Num2);
+}
+
+void aliases() {
+ typedef std::unique_ptr<int> IntPtr;
+ IntPtr Typedef = IntPtr(new int());
+ IntPtr Typedef2 = IntPtr(new int);
+ // CHECK-MESSAGES: :[[@LINE-1]]:21: warning: use std::make_unique_for_overwrite instead
+ // CHECK-FIXES: IntPtr Typedef2 = std::make_unique_for_overwrite<int>();
+
+ // We use 'bool' instead of '_Bool'.
+ typedef std::unique_ptr<bool> BoolPtr;
+ BoolPtr BoolType = BoolPtr(new bool());
+ BoolPtr BoolType2 = BoolPtr(new bool);
+ // CHECK-MESSAGES: :[[@LINE-1]]:23: warning: use std::make_unique_for_overwrite instead
+ // CHECK-FIXES: BoolPtr BoolType2 = std::make_unique_for_overwrite<bool>();
+
+ // We use 'Base' instead of 'struct Base'.
+ typedef std::unique_ptr<Base> BasePtr;
+ BasePtr StructType = BasePtr(new Base);
+
+#define PTR unique_ptr<int>
+ std::unique_ptr<int> Macro = std::PTR(new int());
+ std::unique_ptr<int> Macro2 = std::PTR(new int);
+ // CHECK-MESSAGES: :[[@LINE-1]]:33: warning: use std::make_unique_for_overwrite instead
+ // CHECK-FIXES: std::unique_ptr<int> Macro2 = std::make_unique_for_overwrite<int>();
+#undef PTR
+
+ std::unique_ptr<int> Using = unique_ptr_<int>(new int());
+ std::unique_ptr<int> Using2 = unique_ptr_<int>(new int);
+ // CHECK-MESSAGES: :[[@LINE-1]]:33: warning: use std::make_unique_for_overwrite instead
+ // CHECK-FIXES: std::unique_ptr<int> Using2 = std::make_unique_for_overwrite<int>();
+}
+
+void whitespaces() {
+ // clang-format off
+ auto Space = std::unique_ptr <int>(new int());
+ auto Space2 = std::unique_ptr <int>(new int);
+ // CHECK-MESSAGES: :[[@LINE-1]]:17: warning: use std::make_unique_for_overwrite instead
+ // CHECK-FIXES: auto Space2 = std::make_unique_for_overwrite<int>();
+
+ auto Spaces = std :: unique_ptr <int>(new int());
+ auto Spaces2 = std :: unique_ptr <int>(new int);
+ // CHECK-MESSAGES: :[[@LINE-1]]:18: warning: use std::make_unique_for_overwrite instead
+ // CHECK-FIXES: auto Spaces2 = std::make_unique_for_overwrite<int>();
+ // clang-format on
+}
+
+void nesting() {
+ auto Nest = std::unique_ptr<std::unique_ptr<int>>(new std::unique_ptr<int>(new int));
+ Nest.reset(new std::unique_ptr<int>(new int));
+ Nest->reset(new int());
+ Nest->reset(new int);
+ // CHECK-MESSAGES: :[[@LINE-1]]:9: warning: use std::make_unique_for_overwrite instead
+ // CHECK-FIXES: *Nest = std::make_unique_for_overwrite<int>();
+}
+
+void reset() {
+ std::unique_ptr<int> P;
+ P.reset();
+ P.reset(nullptr);
+ P.reset(new int());
+ P.reset(new int);
+ // CHECK-MESSAGES: :[[@LINE-1]]:5: warning: use std::make_unique_for_overwrite instead
+ // CHECK-FIXES: P = std::make_unique_for_overwrite<int>();
+
+ auto Q = &P;
+ Q->reset(new int());
+ Q->reset(new int);
+ // CHECK-MESSAGES: :[[@LINE-1]]:6: warning: use std::make_unique_for_overwrite instead
+ // CHECK-FIXES: *Q = std::make_unique_for_overwrite<int>();
+}
+
+#define DEFINE(...) __VA_ARGS__
+template <typename T>
+void g2(std::unique_ptr<Foo> *t) {
+ DEFINE(auto p = std::unique_ptr<Foo>(new Foo); t->reset(new Foo););
+}
+void macro() {
+ std::unique_ptr<Foo> *t;
+ g2<bar::Bar>(t);
+}
+#undef DEFINE
+
+class UniqueFoo : public std::unique_ptr<Foo> {
+public:
+ void foo() {
+ reset(new Foo);
+ this->reset(new Foo);
+ this->reset(new Foo());
+ (*this).reset(new Foo);
+ (*this).reset(new Foo());
+ }
+};
+
+// Ignore statements inside a template instantiation.
+template <typename T>
+void template_fun(T *t) {
+ std::unique_ptr<T> t2 = std::unique_ptr<T>(new T);
+ std::unique_ptr<T> t3 = std::unique_ptr<T>(new T());
+ t2.reset(new T);
+ t3.reset(new T());
+}
+
+void invoke_template() {
+ Foo *foo;
+ template_fun(foo);
+}
+
+void no_fix_for_invalid_new_loc() {
+ // FIXME: Although the code is valid, the end location of `new struct Base` is
+ // invalid. Correct it once https://bugs.llvm.org/show_bug.cgi?id=35952 is
+ // fixed.
+ auto T = std::unique_ptr<Base>(new struct Base);
+}
Index: clang-tools-extra/test/clang-tidy/checkers/modernize-make-shared-for-overwrite.cpp
===================================================================
--- /dev/null
+++ clang-tools-extra/test/clang-tidy/checkers/modernize-make-shared-for-overwrite.cpp
@@ -0,0 +1,288 @@
+// RUN: %check_clang_tidy -std=c++20-or-later %s modernize-make-shared-for-overwrite %t -- -- -I %S/Inputs/modernize-smart-ptr
+
+#include "shared_ptr.h"
+// CHECK-FIXES: #include <memory>
+
+struct Base {
+ Base();
+ Base(int, int);
+};
+
+struct Derived : public Base {
+ Derived();
+ Derived(int, int);
+};
+
+struct APair {
+ int a, b;
+};
+
+struct DPair {
+ DPair() : a(0), b(0) {}
+ DPair(int x, int y) : a(y), b(x) {}
+ int a, b;
+};
+
+struct Empty {};
+
+template <class T>
+using shared_ptr_ = std::shared_ptr<T>;
+
+void *operator new(__SIZE_TYPE__ Count, void *Ptr);
+
+int g(std::shared_ptr<int> P);
+
+std::shared_ptr<Base> getPointer() {
+ return std::shared_ptr<Base>(new Base);
+}
+
+std::shared_ptr<Base> getPointerValue() {
+ return std::shared_ptr<Base>(new Base());
+}
+
+void basic() {
+ std::shared_ptr<int> P1 = std::shared_ptr<int>(new int());
+ std::shared_ptr<int> P2 = std::shared_ptr<int>(new int);
+ // CHECK-MESSAGES: :[[@LINE-1]]:29: warning: use std::make_shared_for_overwrite instead [modernize-make-shared-for-overwrite]
+ // CHECK-FIXES: std::shared_ptr<int> P2 = std::make_shared_for_overwrite<int>();
+
+ P1.reset(new int());
+ P2.reset(new int);
+ // CHECK-MESSAGES: :[[@LINE-1]]:6: warning: use std::make_shared_for_overwrite instead [modernize-make-shared-for-overwrite]
+ // CHECK-FIXES: P2 = std::make_shared_for_overwrite<int>();
+
+ P1 = std::shared_ptr<int>(new int());
+ P2 = std::shared_ptr<int>(new int);
+ // CHECK-MESSAGES: :[[@LINE-1]]:8: warning: use std::make_shared_for_overwrite instead [modernize-make-shared-for-overwrite]
+ // CHECK-FIXES: P2 = std::make_shared_for_overwrite<int>();
+
+ P2.reset(new int());
+ P2.reset(new int);
+ // CHECK-MESSAGES: :[[@LINE-1]]:6: warning: use std::make_shared_for_overwrite instead [modernize-make-shared-for-overwrite]
+ // CHECK-FIXES: P2 = std::make_shared_for_overwrite<int>();
+
+ P2 = std::shared_ptr<int>(new int());
+ P2 = std::shared_ptr<int>(new int);
+ // CHECK-MESSAGES: :[[@LINE-1]]:8: warning: use std::make_shared_for_overwrite instead [modernize-make-shared-for-overwrite]
+ // CHECK-FIXES: P2 = std::make_shared_for_overwrite<int>();
+
+ // With auto.
+ auto P4 = std::shared_ptr<int>(new int());
+ auto P5 = std::shared_ptr<int>(new int);
+ // CHECK-MESSAGES: :[[@LINE-1]]:13: warning: use std::make_shared_for_overwrite instead
+ // CHECK-FIXES: auto P5 = std::make_shared_for_overwrite<int>();
+
+ std::shared_ptr<int> P6 = std::shared_ptr<int>((new int()));
+ std::shared_ptr<int> P7 = std::shared_ptr<int>((new int));
+ // CHECK-MESSAGES: :[[@LINE-1]]:29: warning: use std::make_shared_for_overwrite instead [modernize-make-shared-for-overwrite]
+ // CHECK-FIXES: std::shared_ptr<int> P7 = std::make_shared_for_overwrite<int>();
+
+ P4.reset((((new int()))));
+ P4.reset((((new int))));
+ // CHECK-MESSAGES: :[[@LINE-1]]:6: warning: use std::make_shared_for_overwrite instead [modernize-make-shared-for-overwrite]
+ // CHECK-FIXES: P4 = std::make_shared_for_overwrite<int>();
+
+ P4 = std::shared_ptr<int>(((new int())));
+ P4 = std::shared_ptr<int>(((new int)));
+ // CHECK-MESSAGES: :[[@LINE-1]]:8: warning: use std::make_shared_for_overwrite instead [modernize-make-shared-for-overwrite]
+ // CHECK-FIXES: P4 = std::make_shared_for_overwrite<int>();
+
+ {
+ // No std.
+ using namespace std;
+ shared_ptr<int> Q = shared_ptr<int>(new int());
+ shared_ptr<int> P = shared_ptr<int>(new int);
+ // CHECK-MESSAGES: :[[@LINE-1]]:25: warning: use std::make_shared_for_overwrite instead
+ // CHECK-FIXES: shared_ptr<int> P = std::make_shared_for_overwrite<int>();
+
+ Q = shared_ptr<int>(new int());
+ Q = shared_ptr<int>(new int);
+ // CHECK-MESSAGES: :[[@LINE-1]]:9: warning: use std::make_shared_for_overwrite instead
+ // CHECK-FIXES: Q = std::make_shared_for_overwrite<int>();
+ }
+
+ std::shared_ptr<int> R(new int());
+ std::shared_ptr<int> S(new int);
+
+ // Create the shared_ptr as a parameter to a function.
+ int T = g(std::shared_ptr<int>(new int()));
+ T = g(std::shared_ptr<int>(new int));
+ // CHECK-MESSAGES: :[[@LINE-1]]:9: warning: use std::make_shared_for_overwrite instead
+ // CHECK-FIXES: T = g(std::make_shared_for_overwrite<int>());
+
+ // Only replace if the type in the template is the same as the type returned
+ // by the new operator.
+ auto Pderived = std::shared_ptr<Base>(new Derived());
+ auto PderivedNoparen = std::shared_ptr<Base>(new Derived);
+
+ // OK to replace for reset and assign
+ Pderived.reset(new Derived());
+ Pderived.reset(new Derived);
+
+ Pderived = std::shared_ptr<Derived>(new Derived());
+ Pderived = std::shared_ptr<Derived>(new Derived);
+
+ // FIXME: OK to replace if assigned to shared_ptr<Base>
+ Pderived = std::shared_ptr<Base>(new Derived());
+ Pderived = std::shared_ptr<Base>(new Derived);
+
+ // FIXME: OK to replace when auto is not used
+ std::shared_ptr<Base> PBase = std::shared_ptr<Base>(new Derived());
+ std::shared_ptr<Base> PBase2 = std::shared_ptr<Base>(new Derived);
+
+ // The pointer is returned by the function, nothing to do.
+ std::shared_ptr<Base> RetPtr = getPointer();
+ std::shared_ptr<Base> RetPtr2 = getPointerValue();
+
+ // This emulates std::move.
+ std::shared_ptr<int> Move = static_cast<std::shared_ptr<int> &&>(P1);
+
+ // Placement arguments should not be removed.
+ int *PInt = new int;
+ std::shared_ptr<int> Placement = std::shared_ptr<int>(new (PInt) int{3});
+ Placement.reset(new (PInt) int{3});
+ Placement = std::shared_ptr<int>(new (PInt) int{3});
+
+ std::shared_ptr<int> PlacementNoparen = std::shared_ptr<int>(new (PInt) int);
+ PlacementNoparen.reset(new (PInt) int);
+ PlacementNoparen = std::shared_ptr<int>(new (PInt) int);
+}
+
+// Calling make_smart_ptr from within a member function of a type with a
+// private or protected constructor would be ill-formed.
+class Private {
+private:
+ Private(int z) {}
+
+public:
+ Private() {}
+ void create() {
+ auto callsPublic = std::shared_ptr<Private>(new Private);
+ auto ptr = std::shared_ptr<Private>(new Private(42));
+ ptr.reset(new Private(42));
+ ptr = std::shared_ptr<Private>(new Private(42));
+ }
+
+ virtual ~Private();
+};
+
+class Protected {
+protected:
+ Protected() {}
+
+public:
+ Protected(int, int) {}
+ void create() {
+ auto callsPublic = std::shared_ptr<Protected>(new Protected(1, 2));
+ auto ptr = std::shared_ptr<Protected>(new Protected);
+ ptr.reset(new Protected);
+ ptr = std::shared_ptr<Protected>(new Protected);
+ }
+};
+
+void initialization(int T, Base b) {
+ // Test different kinds of initialization of the pointee.
+
+ // Direct initialization with parenthesis.
+ std::shared_ptr<DPair> PDir1 = std::shared_ptr<DPair>(new DPair(1, T));
+ PDir1.reset(new DPair(1, T));
+
+ // Direct initialization with braces.
+ std::shared_ptr<DPair> PDir2 = std::shared_ptr<DPair>(new DPair{2, T});
+ PDir2.reset(new DPair{2, T});
+
+ // Aggregate initialization.
+ std::shared_ptr<APair> PAggr = std::shared_ptr<APair>(new APair{T, 1});
+ PAggr.reset(new APair{T, 1});
+
+ // Test different kinds of initialization of the pointee, when the shared_ptr
+ // is initialized with braces.
+
+ // Direct initialization with parenthesis.
+ std::shared_ptr<DPair> PDir3 = std::shared_ptr<DPair>{new DPair(3, T)};
+
+ // Direct initialization with braces.
+ std::shared_ptr<DPair> PDir4 = std::shared_ptr<DPair>{new DPair{4, T}};
+
+ // Aggregate initialization.
+ std::shared_ptr<APair> PAggr2 = std::shared_ptr<APair>{new APair{T, 2}};
+
+ // Direct initialization with parenthesis, without arguments.
+ std::shared_ptr<DPair> PDir5 = std::shared_ptr<DPair>(new DPair());
+
+ // Direct initialization with braces, without arguments.
+ std::shared_ptr<DPair> PDir6 = std::shared_ptr<DPair>(new DPair{});
+
+ // Aggregate initialization without arguments.
+ std::shared_ptr<Empty> PEmpty = std::shared_ptr<Empty>(new Empty{});
+}
+
+void aliases() {
+ typedef std::shared_ptr<int> IntPtr;
+ IntPtr Typedef = IntPtr(new int());
+ IntPtr Typedef2 = IntPtr(new int);
+ // CHECK-MESSAGES: :[[@LINE-1]]:21: warning: use std::make_shared_for_overwrite instead
+ // CHECK-FIXES: IntPtr Typedef2 = std::make_shared_for_overwrite<int>();
+
+ // We use 'bool' instead of '_Bool'.
+ typedef std::shared_ptr<bool> BoolPtr;
+ BoolPtr BoolType = BoolPtr(new bool());
+ BoolPtr BoolType2 = BoolPtr(new bool);
+ // CHECK-MESSAGES: :[[@LINE-1]]:23: warning: use std::make_shared_for_overwrite instead
+ // CHECK-FIXES: BoolPtr BoolType2 = std::make_shared_for_overwrite<bool>();
+
+ // We use 'Base' instead of 'struct Base'.
+ typedef std::shared_ptr<Base> BasePtr;
+ BasePtr StructType = BasePtr(new Base);
+
+#define PTR shared_ptr<int>
+ std::shared_ptr<int> Macro = std::PTR(new int());
+ std::shared_ptr<int> Macro2 = std::PTR(new int);
+ // CHECK-MESSAGES: :[[@LINE-1]]:33: warning: use std::make_shared_for_overwrite instead
+ // CHECK-FIXES: std::shared_ptr<int> Macro2 = std::make_shared_for_overwrite<int>();
+#undef PTR
+
+ std::shared_ptr<int> Using = shared_ptr_<int>(new int());
+ std::shared_ptr<int> Using2 = shared_ptr_<int>(new int);
+ // CHECK-MESSAGES: :[[@LINE-1]]:33: warning: use std::make_shared_for_overwrite instead
+ // CHECK-FIXES: std::shared_ptr<int> Using2 = std::make_shared_for_overwrite<int>();
+}
+
+void whitespaces() {
+ // clang-format off
+ auto Space = std::shared_ptr <int>(new int());
+ auto Space2 = std::shared_ptr <int>(new int);
+ // CHECK-MESSAGES: :[[@LINE-1]]:17: warning: use std::make_shared_for_overwrite instead
+ // CHECK-FIXES: auto Space2 = std::make_shared_for_overwrite<int>();
+
+ auto Spaces = std :: shared_ptr <int>(new int());
+ auto Spaces2 = std :: shared_ptr <int>(new int);
+ // CHECK-MESSAGES: :[[@LINE-1]]:18: warning: use std::make_shared_for_overwrite instead
+ // CHECK-FIXES: auto Spaces2 = std::make_shared_for_overwrite<int>();
+ // clang-format on
+}
+
+void nesting() {
+ auto Nest = std::shared_ptr<std::shared_ptr<int>>(new std::shared_ptr<int>(new int));
+ Nest.reset(new std::shared_ptr<int>(new int));
+ Nest->reset(new int());
+ Nest->reset(new int);
+ // CHECK-MESSAGES: :[[@LINE-1]]:9: warning: use std::make_shared_for_overwrite instead
+ // CHECK-FIXES: *Nest = std::make_shared_for_overwrite<int>();
+}
+
+void reset() {
+ std::shared_ptr<int> P;
+ P.reset();
+ P.reset(nullptr);
+ P.reset(new int());
+ P.reset(new int);
+ // CHECK-MESSAGES: :[[@LINE-1]]:5: warning: use std::make_shared_for_overwrite instead
+ // CHECK-FIXES: P = std::make_shared_for_overwrite<int>();
+
+ auto Q = &P;
+ Q->reset(new int());
+ Q->reset(new int);
+ // CHECK-MESSAGES: :[[@LINE-1]]:6: warning: use std::make_shared_for_overwrite instead
+ // CHECK-FIXES: *Q = std::make_shared_for_overwrite<int>();
+}
Index: clang-tools-extra/docs/clang-tidy/checks/modernize-make-unique-for-overwrite.rst
===================================================================
--- /dev/null
+++ clang-tools-extra/docs/clang-tidy/checks/modernize-make-unique-for-overwrite.rst
@@ -0,0 +1,51 @@
+.. title:: clang-tidy - modernize-make-unique-for-overwrite
+
+modernize-make-unique-for-overwrite
+=====================
+
+This check finds the creation of ``std::unique_ptr`` objects by explicitly
+calling the constructor and a ``new`` expression where default initialization
+occurs, and replaces it with a call to ``std::make_unique_for_overwrite``,
+introduced in C++20.
+
+.. code-block:: c++
+
+ auto my_ptr = std::unique_ptr<int>(new int);
+
+ // becomes
+
+ auto my_ptr = std::make_unique_for_overwrite<int>();
+
+This check also finds calls to ``std::unique_ptr::reset()`` with a ``new``
+expression, and replaces it with a call to ``std::make_unique``.
+
+.. code-block:: c++
+
+ my_ptr.reset(new int);
+
+ // becomes
+
+ my_ptr = std::make_unique_for_overwrite<int>();
+
+Options
+-------
+
+.. option:: MakeSmartPtrFunction
+
+ A string specifying the name of make-unique-ptr-for-overwrite function. Default is
+ `std::make_unique_for_overwrite`.
+
+.. option:: MakeSmartPtrFunctionHeader
+
+ A string specifying the corresponding header of make-unique-ptr-for-overwrite function.
+ Default is `<memory>`.
+
+.. option:: IncludeStyle
+
+ A string specifying which include-style is used, `llvm` or `google`. Default
+ is `llvm`.
+
+.. option:: IgnoreMacros
+
+ If set to `true`, the check will not give warnings inside macros. Default
+ is `true`.
Index: clang-tools-extra/docs/clang-tidy/checks/modernize-make-shared-for-overwrite.rst
===================================================================
--- /dev/null
+++ clang-tools-extra/docs/clang-tidy/checks/modernize-make-shared-for-overwrite.rst
@@ -0,0 +1,51 @@
+.. title:: clang-tidy - modernize-make-shared-for-overwrite
+
+modernize-make-shared-for-overwrite
+=====================
+
+This check finds the creation of ``std::shared_ptr`` objects by explicitly
+calling the constructor and a ``new`` expression where default initialization
+occurs, and replaces it with a call to ``std::make_shared_for_overwrite``,
+introduced in C++20.
+
+.. code-block:: c++
+
+ auto my_ptr = std::shared_ptr<int>(new int);
+
+ // becomes
+
+ auto my_ptr = std::make_shared_for_overwrite<int>();
+
+This check also finds calls to ``std::shared_ptr::reset()`` with a ``new``
+expression, and replaces it with a call to ``std::make_shared``.
+
+.. code-block:: c++
+
+ my_ptr.reset(new int);
+
+ // becomes
+
+ my_ptr = std::make_shared_for_overwrite<int>();
+
+Options
+-------
+
+.. option:: MakeSmartPtrFunction
+
+ A string specifying the name of make-shared-ptr-for-overwrite function. Default is
+ `std::make_shared_for_overwrite`.
+
+.. option:: MakeSmartPtrFunctionHeader
+
+ A string specifying the corresponding header of make-shared-ptr-for-overwrite function.
+ Default is `<memory>`.
+
+.. option:: IncludeStyle
+
+ A string specifying which include-style is used, `llvm` or `google`. Default
+ is `llvm`.
+
+.. option:: IgnoreMacros
+
+ If set to `true`, the check will not give warnings inside macros. Default
+ is `true`.
Index: clang-tools-extra/docs/clang-tidy/checks/list.rst
===================================================================
--- clang-tools-extra/docs/clang-tidy/checks/list.rst
+++ clang-tools-extra/docs/clang-tidy/checks/list.rst
@@ -221,7 +221,9 @@
`modernize-deprecated-ios-base-aliases <modernize-deprecated-ios-base-aliases.html>`_, "Yes"
`modernize-loop-convert <modernize-loop-convert.html>`_, "Yes"
`modernize-make-shared <modernize-make-shared.html>`_, "Yes"
+ `modernize-make-shared-for-overwrite <modernize-make-shared-for-overwrite.html>`_, "Yes"
`modernize-make-unique <modernize-make-unique.html>`_, "Yes"
+ `modernize-make-unique-for-overwrite <modernize-make-unique-for-overwrite.html>`_, "Yes"
`modernize-pass-by-value <modernize-pass-by-value.html>`_, "Yes"
`modernize-raw-string-literal <modernize-raw-string-literal.html>`_, "Yes"
`modernize-redundant-void-arg <modernize-redundant-void-arg.html>`_, "Yes"
Index: clang-tools-extra/docs/ReleaseNotes.rst
===================================================================
--- clang-tools-extra/docs/ReleaseNotes.rst
+++ clang-tools-extra/docs/ReleaseNotes.rst
@@ -140,6 +140,18 @@
Diagnoses every integer to pointer cast.
+- New :doc:`modernize-make-shared-for-overwrite
+ <clang-tidy/checks/modernize-make-shared-for-overwrite>` check.
+
+ Replaces default initialized objects in `new` expressions with a call to
+ `std::make_shared_for_overwrite` introduced in C++20.
+
+- New :doc:`modernize-make-unique-for-overwrite
+ <clang-tidy/checks/modernize-make-unique-for-overwrite>` check.
+
+ Replaces default initialized objects in `new` expressions with a call to
+ `std::make_unique_for_overwrite` introduced in C++20.
+
- New :doc:`readability-function-cognitive-complexity
<clang-tidy/checks/readability-function-cognitive-complexity>` check.
Index: clang-tools-extra/clang-tidy/modernize/ModernizeTidyModule.cpp
===================================================================
--- clang-tools-extra/clang-tidy/modernize/ModernizeTidyModule.cpp
+++ clang-tools-extra/clang-tidy/modernize/ModernizeTidyModule.cpp
@@ -16,7 +16,9 @@
#include "DeprecatedIosBaseAliasesCheck.h"
#include "LoopConvertCheck.h"
#include "MakeSharedCheck.h"
+#include "MakeSharedForOverwriteCheck.h"
#include "MakeUniqueCheck.h"
+#include "MakeUniqueForOverwriteCheck.h"
#include "PassByValueCheck.h"
#include "RawStringLiteralCheck.h"
#include "RedundantVoidArgCheck.h"
@@ -60,7 +62,11 @@
"modernize-deprecated-ios-base-aliases");
CheckFactories.registerCheck<LoopConvertCheck>("modernize-loop-convert");
CheckFactories.registerCheck<MakeSharedCheck>("modernize-make-shared");
+ CheckFactories.registerCheck<MakeSharedForOverwriteCheck>(
+ "modernize-make-shared-for-overwrite");
CheckFactories.registerCheck<MakeUniqueCheck>("modernize-make-unique");
+ CheckFactories.registerCheck<MakeUniqueForOverwriteCheck>(
+ "modernize-make-unique-for-overwrite");
CheckFactories.registerCheck<PassByValueCheck>("modernize-pass-by-value");
CheckFactories.registerCheck<RawStringLiteralCheck>(
"modernize-raw-string-literal");
Index: clang-tools-extra/clang-tidy/modernize/MakeUniqueForOverwriteCheck.h
===================================================================
--- /dev/null
+++ clang-tools-extra/clang-tidy/modernize/MakeUniqueForOverwriteCheck.h
@@ -0,0 +1,44 @@
+//===--- MakeUniqueForOverwriteCheck.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_MODERNIZE_MAKEUNIQUEFOROVERWRITECHECK_H
+#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MODERNIZE_MAKEUNIQUEFOROVERWRITECHECK_H
+
+#include "MakeSmartPtrCheck.h"
+
+namespace clang {
+namespace tidy {
+namespace modernize {
+
+/// Replace the pattern:
+/// \code
+/// std::unique_ptr<type>(new type)
+/// \endcode
+///
+/// With the C++20 version:
+/// \code
+/// std::make_unique_for_overwrite<type>()
+/// \endcode
+class MakeUniqueForOverwriteCheck : public MakeSmartPtrCheck {
+public:
+ MakeUniqueForOverwriteCheck(StringRef Name, ClangTidyContext *Context);
+
+protected:
+ SmartPtrTypeMatcher getSmartPointerTypeMatcher() const override;
+
+ bool isLanguageVersionSupported(const LangOptions &LangOpts) const override;
+
+private:
+ const bool RequireCPlusPlus20;
+};
+
+} // namespace modernize
+} // namespace tidy
+} // namespace clang
+
+#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MODERNIZE_MAKEUNIQUEFOROVERWRITECHECK_H
Index: clang-tools-extra/clang-tidy/modernize/MakeUniqueForOverwriteCheck.cpp
===================================================================
--- clang-tools-extra/clang-tidy/modernize/MakeUniqueForOverwriteCheck.cpp
+++ clang-tools-extra/clang-tidy/modernize/MakeUniqueForOverwriteCheck.cpp
@@ -1,4 +1,4 @@
-//===--- MakeUniqueCheck.cpp - clang-tidy----------------------------------===//
+//===--- MakeUniqueForOverwriteCheck.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.
@@ -6,7 +6,9 @@
//
//===----------------------------------------------------------------------===//
-#include "MakeUniqueCheck.h"
+#include "MakeUniqueForOverwriteCheck.h"
+#include "clang/AST/ASTContext.h"
+#include "clang/ASTMatchers/ASTMatchFinder.h"
using namespace clang::ast_matchers;
@@ -14,13 +16,13 @@
namespace tidy {
namespace modernize {
-MakeUniqueCheck::MakeUniqueCheck(StringRef Name,
- clang::tidy::ClangTidyContext *Context)
- : MakeSmartPtrCheck(Name, Context, "std::make_unique"),
- RequireCPlusPlus14(Options.get("MakeSmartPtrFunction", "").empty()) {}
+MakeUniqueForOverwriteCheck::MakeUniqueForOverwriteCheck(
+ StringRef Name, clang::tidy::ClangTidyContext *Context)
+ : MakeSmartPtrCheck(Name, Context, "std::make_unique_for_overwrite", false),
+ RequireCPlusPlus20(Options.get("MakeSmartPtrFunction", "").empty()) {}
-MakeUniqueCheck::SmartPtrTypeMatcher
-MakeUniqueCheck::getSmartPointerTypeMatcher() const {
+MakeUniqueForOverwriteCheck::SmartPtrTypeMatcher
+MakeUniqueForOverwriteCheck::getSmartPointerTypeMatcher() const {
return qualType(hasUnqualifiedDesugaredType(
recordType(hasDeclaration(classTemplateSpecializationDecl(
hasName("::std::unique_ptr"), templateArgumentCountIs(2),
@@ -36,9 +38,9 @@
equalsBoundNode(PointerType))))))))))))))));
}
-bool MakeUniqueCheck::isLanguageVersionSupported(
+bool MakeUniqueForOverwriteCheck::isLanguageVersionSupported(
const LangOptions &LangOpts) const {
- return RequireCPlusPlus14 ? LangOpts.CPlusPlus14 : LangOpts.CPlusPlus11;
+ return RequireCPlusPlus20 ? LangOpts.CPlusPlus20 : LangOpts.CPlusPlus11;
}
// FixItHint is done by MakeSmartPtrCheck
Index: clang-tools-extra/clang-tidy/modernize/MakeUniqueCheck.cpp
===================================================================
--- clang-tools-extra/clang-tidy/modernize/MakeUniqueCheck.cpp
+++ clang-tools-extra/clang-tidy/modernize/MakeUniqueCheck.cpp
@@ -16,7 +16,7 @@
MakeUniqueCheck::MakeUniqueCheck(StringRef Name,
clang::tidy::ClangTidyContext *Context)
- : MakeSmartPtrCheck(Name, Context, "std::make_unique"),
+ : MakeSmartPtrCheck(Name, Context, "std::make_unique", true),
RequireCPlusPlus14(Options.get("MakeSmartPtrFunction", "").empty()) {}
MakeUniqueCheck::SmartPtrTypeMatcher
Index: clang-tools-extra/clang-tidy/modernize/MakeSmartPtrCheck.h
===================================================================
--- clang-tools-extra/clang-tidy/modernize/MakeSmartPtrCheck.h
+++ clang-tools-extra/clang-tidy/modernize/MakeSmartPtrCheck.h
@@ -24,7 +24,7 @@
class MakeSmartPtrCheck : public ClangTidyCheck {
public:
MakeSmartPtrCheck(StringRef Name, ClangTidyContext *Context,
- StringRef MakeSmartPtrFunctionName);
+ StringRef MakeSmartPtrFunctionName, bool ValueInitializes);
void registerMatchers(ast_matchers::MatchFinder *Finder) final;
void registerPPCallbacks(const SourceManager &SM, Preprocessor *PP,
Preprocessor *ModuleExpanderPP) override;
@@ -51,6 +51,7 @@
const std::string MakeSmartPtrFunctionName;
const bool IgnoreMacros;
const bool IgnoreDefaultInitialization;
+ const bool ValueInitializes;
void checkConstruct(SourceManager &SM, ASTContext *Ctx,
const CXXConstructExpr *Construct, const QualType *Type,
Index: clang-tools-extra/clang-tidy/modernize/MakeSmartPtrCheck.cpp
===================================================================
--- clang-tools-extra/clang-tidy/modernize/MakeSmartPtrCheck.cpp
+++ clang-tools-extra/clang-tidy/modernize/MakeSmartPtrCheck.cpp
@@ -42,7 +42,8 @@
const char MakeSmartPtrCheck::PointerType[] = "pointerType";
MakeSmartPtrCheck::MakeSmartPtrCheck(StringRef Name, ClangTidyContext *Context,
- StringRef MakeSmartPtrFunctionName)
+ StringRef MakeSmartPtrFunctionName,
+ bool ValueInitializes)
: ClangTidyCheck(Name, Context),
Inserter(Options.getLocalOrGlobal("IncludeStyle",
utils::IncludeSorter::IS_LLVM)),
@@ -52,7 +53,9 @@
Options.get("MakeSmartPtrFunction", MakeSmartPtrFunctionName)),
IgnoreMacros(Options.getLocalOrGlobal("IgnoreMacros", true)),
IgnoreDefaultInitialization(
- Options.get("IgnoreDefaultInitialization", true)) {}
+ !ValueInitializes ||
+ Options.get("IgnoreDefaultInitialization", true)),
+ ValueInitializes(ValueInitializes) {}
void MakeSmartPtrCheck::storeOptions(ClangTidyOptions::OptionMap &Opts) {
Options.store(Opts, "IncludeStyle", Inserter.getStyle());
@@ -136,7 +139,7 @@
bool Initializes = New->hasInitializer() ||
!utils::type_traits::isTriviallyDefaultConstructible(
New->getAllocatedType(), *Result.Context);
- if (!Initializes && IgnoreDefaultInitialization)
+ if (Initializes != ValueInitializes && IgnoreDefaultInitialization)
return;
if (Construct)
checkConstruct(SM, Result.Context, Construct, Type, New);
Index: clang-tools-extra/clang-tidy/modernize/MakeSharedForOverwriteCheck.h
===================================================================
--- /dev/null
+++ clang-tools-extra/clang-tidy/modernize/MakeSharedForOverwriteCheck.h
@@ -0,0 +1,44 @@
+//===--- MakeSharedForOverwriteCheck.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_MODERNIZE_MAKESHAREDFOROVERWRITECHECK_H
+#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MODERNIZE_MAKESHAREDFOROVERWRITECHECK_H
+
+#include "MakeSmartPtrCheck.h"
+
+namespace clang {
+namespace tidy {
+namespace modernize {
+
+/// Replace the pattern:
+/// \code
+/// std::shared_ptr<type>(new type)
+/// \endcode
+///
+/// With the C++20 version:
+/// \code
+/// std::make_shared_for_overwrite<type>()
+/// \endcode
+class MakeSharedForOverwriteCheck : public MakeSmartPtrCheck {
+public:
+ MakeSharedForOverwriteCheck(StringRef Name, ClangTidyContext *Context);
+
+protected:
+ SmartPtrTypeMatcher getSmartPointerTypeMatcher() const override;
+
+ bool isLanguageVersionSupported(const LangOptions &LangOpts) const override;
+
+private:
+ const bool RequireCPlusPlus20;
+};
+
+} // namespace modernize
+} // namespace tidy
+} // namespace clang
+
+#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MODERNIZE_MAKESHAREDFOROVERWRITECHECK_H
Index: clang-tools-extra/clang-tidy/modernize/MakeSharedForOverwriteCheck.cpp
===================================================================
--- clang-tools-extra/clang-tidy/modernize/MakeSharedForOverwriteCheck.cpp
+++ clang-tools-extra/clang-tidy/modernize/MakeSharedForOverwriteCheck.cpp
@@ -1,4 +1,4 @@
-//===--- MakeSharedCheck.cpp - clang-tidy----------------------------------===//
+//===--- MakeSharedForOverwriteCheck.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.
@@ -6,10 +6,9 @@
//
//===----------------------------------------------------------------------===//
-#include "MakeSharedCheck.h"
-
-// FixItHint - Hint to check documentation script to mark this check as
-// providing a FixIt.
+#include "MakeSharedForOverwriteCheck.h"
+#include "clang/AST/ASTContext.h"
+#include "clang/ASTMatchers/ASTMatchFinder.h"
using namespace clang::ast_matchers;
@@ -17,11 +16,13 @@
namespace tidy {
namespace modernize {
-MakeSharedCheck::MakeSharedCheck(StringRef Name, ClangTidyContext *Context)
- : MakeSmartPtrCheck(Name, Context, "std::make_shared") {}
+MakeSharedForOverwriteCheck::MakeSharedForOverwriteCheck(
+ StringRef Name, ClangTidyContext *Context)
+ : MakeSmartPtrCheck(Name, Context, "std::make_shared_for_overwrite", false),
+ RequireCPlusPlus20(Options.get("MakeSmartPtrFunction", "").empty()) {}
-MakeSharedCheck::SmartPtrTypeMatcher
-MakeSharedCheck::getSmartPointerTypeMatcher() const {
+MakeSharedForOverwriteCheck::SmartPtrTypeMatcher
+MakeSharedForOverwriteCheck::getSmartPointerTypeMatcher() const {
return qualType(hasUnqualifiedDesugaredType(
recordType(hasDeclaration(classTemplateSpecializationDecl(
hasName("::std::shared_ptr"), templateArgumentCountIs(1),
@@ -29,6 +30,11 @@
qualType().bind(PointerType)))))))));
}
+bool MakeSharedForOverwriteCheck::isLanguageVersionSupported(
+ const LangOptions &LangOpts) const {
+ return RequireCPlusPlus20 ? LangOpts.CPlusPlus20 : LangOpts.CPlusPlus11;
+}
+
} // namespace modernize
} // namespace tidy
} // namespace clang
Index: clang-tools-extra/clang-tidy/modernize/MakeSharedCheck.cpp
===================================================================
--- clang-tools-extra/clang-tidy/modernize/MakeSharedCheck.cpp
+++ clang-tools-extra/clang-tidy/modernize/MakeSharedCheck.cpp
@@ -18,7 +18,7 @@
namespace modernize {
MakeSharedCheck::MakeSharedCheck(StringRef Name, ClangTidyContext *Context)
- : MakeSmartPtrCheck(Name, Context, "std::make_shared") {}
+ : MakeSmartPtrCheck(Name, Context, "std::make_shared", true) {}
MakeSharedCheck::SmartPtrTypeMatcher
MakeSharedCheck::getSmartPointerTypeMatcher() const {
Index: clang-tools-extra/clang-tidy/modernize/CMakeLists.txt
===================================================================
--- clang-tools-extra/clang-tidy/modernize/CMakeLists.txt
+++ clang-tools-extra/clang-tidy/modernize/CMakeLists.txt
@@ -12,8 +12,10 @@
LoopConvertCheck.cpp
LoopConvertUtils.cpp
MakeSharedCheck.cpp
+ MakeSharedForOverwriteCheck.cpp
MakeSmartPtrCheck.cpp
MakeUniqueCheck.cpp
+ MakeUniqueForOverwriteCheck.cpp
ModernizeTidyModule.cpp
PassByValueCheck.cpp
RawStringLiteralCheck.cpp
_______________________________________________
cfe-commits mailing list
cfe-commits@lists.llvm.org
https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
