[clang-tidy] Enhance modernize-make-unique to handle unique_ptr.reset()

[malcolm.parsons]

Summary

Avoid naked new in unique_ptr.reset() by using make_unique

Fixes http://llvm.org/PR27383

[malcolm.parsons]

Correct operator signature.
Remove unused parameter.
Rename method.
Reformat.

[Prazek]

Besides this looks good

test/clang-tidy/modernize-make-shared.cpp

122 ↗

(On Diff #75541)

I think the warning here could be better. The user is using make_shared here.
Maybe ' warning: use std::make_shared with zero arguments ...', but only in this case

129 ↗

(On Diff #75541)

I think it is good to replace it even with auto, like
auto PBase = std::make_shared<Base>(new Derived());

For shared_ptr we can even do better, that we can't do for unique_ptr - we
coud change it to
auto PBase = std::make_shared<Derived>();
because all conversions works.
Of course not in this patch, but it would be good to leave a comment about this here.

[malcolm.parsons]

test/clang-tidy/modernize-make-shared.cpp

122 ↗

(On Diff #75541)

The user isn't using make_shared.

129 ↗

(On Diff #75541)

A smart pointer to Derived cannot be reset with a pointer to Base.

[Prazek]

test/clang-tidy/modernize-make-shared.cpp

122 ↗

(On Diff #75541)

true, I've read that incorectly

129 ↗

(On Diff #75541)

oh yea, I was only thinking about downcasting smart pointer

[aaron.ballman]

clang-tidy/modernize/MakeSmartPtrCheck.cpp

74 ↗

(On Diff #75541)

Can elide the braces for the if and else.

147 ↗

(On Diff #75541)

I kind of wonder if this should be using Twine to avoid a lot of extra allocations and copies.

150 ↗

(On Diff #75541)

Elide braces

[malcolm.parsons]

Remove braces.
Use Twine.

[aaron.ballman]

LGTM!

[malcolm.parsons]

Rebase.

clang-tools-extra/trunk/clang-tidy/modernize/MakeSmartPtrCheck.h

protected:
   /// Returns matcher that match with different smart pointer types.
   ///
   /// Requires to bind pointer type (qualType) with PointerType string declared
   /// in this class.
   virtual SmartPtrTypeMatcher getSmartPointerTypeMatcher() const = 0;
 
   static const char PointerType[];
   static const char ConstructorCall[];
+  static const char ResetCall[];
   static const char NewExpression[];
 
 private:
   std::string makeSmartPtrFunctionName;
+
+  void checkConstruct(SourceManager &SM, const CXXConstructExpr *Construct,
+                      const QualType *Type, const CXXNewExpr *New);
+  void checkReset(SourceManager &SM, const CXXMemberCallExpr *Member,
+                  const CXXNewExpr *New);
+  void replaceNew(DiagnosticBuilder &Diag, const CXXNewExpr *New);
 };
 
 } // namespace modernize
 } // namespace tidy
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MODERNIZE_MAKE_SMART_PTR_H

clang-tools-extra/trunk/clang-tidy/modernize/MakeSmartPtrCheck.cpp

 using namespace clang::ast_matchers;
 
 namespace clang {
 namespace tidy {
 namespace modernize {
 
 const char MakeSmartPtrCheck::PointerType[] = "pointerType";
 const char MakeSmartPtrCheck::ConstructorCall[] = "constructorCall";
+const char MakeSmartPtrCheck::ResetCall[] = "resetCall";
 const char MakeSmartPtrCheck::NewExpression[] = "newExpression";
 
 MakeSmartPtrCheck::MakeSmartPtrCheck(StringRef Name, ClangTidyContext *Context,
                                      std::string makeSmartPtrFunctionName)
     : ClangTidyCheck(Name, Context),
       makeSmartPtrFunctionName(std::move(makeSmartPtrFunctionName)) {}
 
 void MakeSmartPtrCheck::registerMatchers(ast_matchers::MatchFinder *Finder) {
   if (!getLangOpts().CPlusPlus11)
     return;
 
   // Calling make_smart_ptr from within a member function of a type with a
   // private or protected constructor would be ill-formed.
-  auto CanCallCtor = unless(has(ignoringImpCasts(cxxConstructExpr(
-      hasDeclaration(decl(unless(isPublic())))))));
+  auto CanCallCtor = unless(has(ignoringImpCasts(
+      cxxConstructExpr(hasDeclaration(decl(unless(isPublic())))))));
 
   Finder->addMatcher(
       cxxBindTemporaryExpr(has(ignoringParenImpCasts(
           cxxConstructExpr(
               hasType(getSmartPointerTypeMatcher()), argumentCountIs(1),
               hasArgument(0,
                           cxxNewExpr(hasType(pointsTo(qualType(hasCanonicalType(
                                          equalsBoundNode(PointerType))))),
                                      CanCallCtor)
                               .bind(NewExpression)))
               .bind(ConstructorCall)))),
       this);
+
+  Finder->addMatcher(
+      cxxMemberCallExpr(
+          thisPointerType(getSmartPointerTypeMatcher()),
+          callee(cxxMethodDecl(hasName("reset"))),
+          hasArgument(0, cxxNewExpr(CanCallCtor).bind(NewExpression)))
+          .bind(ResetCall),
+      this);
 }
 
 void MakeSmartPtrCheck::check(const MatchFinder::MatchResult &Result) {
   // 'smart_ptr' refers to 'std::shared_ptr' or 'std::unique_ptr' or other
   // pointer, 'make_smart_ptr' refers to 'std::make_shared' or
   // 'std::make_unique' or other function that creates smart_ptr.
 
   SourceManager &SM = *Result.SourceManager;
   const auto *Construct =
       Result.Nodes.getNodeAs<CXXConstructExpr>(ConstructorCall);
+  const auto *Reset = Result.Nodes.getNodeAs<CXXMemberCallExpr>(ResetCall);
   const auto *Type = Result.Nodes.getNodeAs<QualType>(PointerType);
   const auto *New = Result.Nodes.getNodeAs<CXXNewExpr>(NewExpression);
 
   if (New->getNumPlacementArgs() != 0)
     return;
 
+  if (Construct)
+    checkConstruct(SM, Construct, Type, New);
+  else if (Reset)
+    checkReset(SM, Reset, New);
+}
+
+void MakeSmartPtrCheck::checkConstruct(SourceManager &SM,
+                                       const CXXConstructExpr *Construct,
+                                       const QualType *Type,
+                                       const CXXNewExpr *New) {
   SourceLocation ConstructCallStart = Construct->getExprLoc();
 
   bool Invalid = false;
   StringRef ExprStr = Lexer::getSourceText(
       CharSourceRange::getCharRange(
           ConstructCallStart, Construct->getParenOrBraceRange().getBegin()),
       SM, LangOptions(), &Invalid);
   if (Invalid)
Diag << FixItHint::CreateReplacement(
             BraceRange.getBegin(), BraceRange.getBegin().getLocWithOffset(1)),
         "(");
     Diag << FixItHint::CreateReplacement(
         CharSourceRange::getCharRange(BraceRange.getEnd(),
                                       BraceRange.getEnd().getLocWithOffset(1)),
         ")");
   }
 
+  replaceNew(Diag, New);
+}
+
+void MakeSmartPtrCheck::checkReset(SourceManager &SM,
+                                   const CXXMemberCallExpr *Reset,
+                                   const CXXNewExpr *New) {
+  const auto *Expr = cast<MemberExpr>(Reset->getCallee());
+  SourceLocation OperatorLoc = Expr->getOperatorLoc();
+  SourceLocation ResetCallStart = Reset->getExprLoc();
+  SourceLocation ExprStart = Expr->getLocStart();
+  SourceLocation ExprEnd =
+      Lexer::getLocForEndOfToken(Expr->getLocEnd(), 0, SM, getLangOpts());
+
+  auto Diag = diag(ResetCallStart, "use %0 instead")
+              << makeSmartPtrFunctionName;
+
+  Diag << FixItHint::CreateReplacement(
+      CharSourceRange::getCharRange(OperatorLoc, ExprEnd),
+      (llvm::Twine(" = ") + makeSmartPtrFunctionName + "<" +
+       New->getAllocatedType().getAsString(getLangOpts()) + ">")
+          .str());
+
+  if (Expr->isArrow())
+    Diag << FixItHint::CreateInsertion(ExprStart, "*");
+
+  replaceNew(Diag, New);
+}
+
+void MakeSmartPtrCheck::replaceNew(DiagnosticBuilder &Diag,
+                                   const CXXNewExpr *New) {
   SourceLocation NewStart = New->getSourceRange().getBegin();
   SourceLocation NewEnd = New->getSourceRange().getEnd();
   switch (New->getInitializationStyle()) {
   case CXXNewExpr::NoInit: {
     Diag << FixItHint::CreateRemoval(SourceRange(NewStart, NewEnd));
     break;
   }
   case CXXNewExpr::CallInit: {

clang-tools-extra/trunk/docs/ReleaseNotes.rst

 - `misc-pointer-and-integral-operation` check was removed.
 
 - New `misc-use-after-move
   <http://clang.llvm.org/extra/clang-tidy/checks/misc-use-after-move.html>`_ check
 
   Warns if an object is used after it has been moved, without an intervening
   reinitialization.
 
+- `modernize-make-unique
+  <http://clang.llvm.org/extra/clang-tidy/checks/modernize-make-unique.html>`_
+  and `modernize-make-shared
+  <http://clang.llvm.org/extra/clang-tidy/checks/modernize-make-shared.html>`_
+  now handle calls to the smart pointer's reset method.
+
 - The `modernize-use-auto
   <http://clang.llvm.org/extra/clang-tidy/checks/modernize-use-auto.html>`_ check
   now warns about variable declarations that are initialized with a cast.
 
 - New `mpi-buffer-deref
   <http://clang.llvm.org/extra/clang-tidy/checks/mpi-buffer-deref.html>`_ check
 
   Flags buffers which are insufficiently dereferenced when passed to an MPI function call.

clang-tools-extra/trunk/docs/clang-tidy/checks/modernize-make-shared.rst

 .. title:: clang-tidy - modernize-make-shared
 
 modernize-make-shared
 =====================
 
 This check finds the creation of ``std::shared_ptr`` objects by explicitly
 calling the constructor and a ``new`` expression, and replaces it with a call
 to ``std::make_shared``.
 
 .. code-block:: c++
 
   auto my_ptr = std::shared_ptr<MyPair>(new MyPair(1, 2));
 
   // becomes
 
   auto my_ptr = std::make_shared<MyPair>(1, 2);
+
+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 MyPair(1, 2));
+
+  // becomes
+
+  my_ptr = std::make_shared<MyPair>(1, 2);

clang-tools-extra/trunk/docs/clang-tidy/checks/modernize-make-unique.rst

 .. title:: clang-tidy - modernize-make-unique
 
 modernize-make-unique
 =====================
 
 This check finds the creation of ``std::unique_ptr`` objects by explicitly
 calling the constructor and a ``new`` expression, and replaces it with a call
 to ``std::make_unique``, introduced in C++14.
 
 .. code-block:: c++
 
   auto my_ptr = std::unique_ptr<MyPair>(new MyPair(1, 2));
 
   // becomes
 
   auto my_ptr = std::make_unique<MyPair>(1, 2);
+
+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 MyPair(1, 2));
+
+  // becomes
+
+  my_ptr = std::make_unique<MyPair>(1, 2);

clang-tools-extra/trunk/test/clang-tidy/modernize-make-shared.cpp

 // RUN: %check_clang_tidy %s modernize-make-shared %t
 
 namespace std {
 
 template <typename type>
 class shared_ptr {
 public:
+  shared_ptr();
   shared_ptr(type *ptr);
   shared_ptr(const shared_ptr<type> &t) {}
   shared_ptr(shared_ptr<type> &&t) {}
   ~shared_ptr();
   type &operator*() { return *ptr; }
   type *operator->() { return ptr; }
   type *release();
   void reset();
   void reset(type *pt);
+  shared_ptr &operator=(shared_ptr &&);
+  template <typename T>
+  shared_ptr &operator=(shared_ptr<T> &&);
 
 private:
   type *ptr;
 };
 }
 
 struct Base {
   Base();
std::shared_ptr<Base> getPointer() {
   // CHECK-FIXES: return std::make_shared<Base>();
 }
 
 void basic() {
   std::shared_ptr<int> P1 = std::shared_ptr<int>(new int());
   // CHECK-MESSAGES: :[[@LINE-1]]:29: warning: use std::make_shared instead [modernize-make-shared]
   // CHECK-FIXES: std::shared_ptr<int> P1 = std::make_shared<int>();
 
+  P1.reset(new int());
+  // CHECK-MESSAGES: :[[@LINE-1]]:6: warning: use std::make_shared instead [modernize-make-shared]
+  // CHECK-FIXES: P1 = std::make_shared<int>();
+
+  P1 = std::shared_ptr<int>(new int());
+  // CHECK-MESSAGES: :[[@LINE-1]]:8: warning: use std::make_shared instead [modernize-make-shared]
+  // CHECK-FIXES: P1 = std::make_shared<int>();
+
   // Without parenthesis.
   std::shared_ptr<int> P2 = std::shared_ptr<int>(new int);
   // CHECK-MESSAGES: :[[@LINE-1]]:29: warning: use std::make_shared instead [modernize-make-shared]
   // CHECK-FIXES: std::shared_ptr<int> P2 = std::make_shared<int>();
 
+  P2.reset(new int);
+  // CHECK-MESSAGES: :[[@LINE-1]]:6: warning: use std::make_shared instead [modernize-make-shared]
+  // CHECK-FIXES: P2 = std::make_shared<int>();
+
+  P2 = std::shared_ptr<int>(new int);
+  // CHECK-MESSAGES: :[[@LINE-1]]:8: warning: use std::make_shared instead [modernize-make-shared]
+  // CHECK-FIXES: P2 = std::make_shared<int>();
+
   // With auto.
   auto P3 = std::shared_ptr<int>(new int());
   // CHECK-MESSAGES: :[[@LINE-1]]:13: warning: use std::make_shared instead
   // CHECK-FIXES: auto P3 = std::make_shared<int>();
 
   {
     // No std.
     using namespace std;
     shared_ptr<int> Q = shared_ptr<int>(new int());
     // CHECK-MESSAGES: :[[@LINE-1]]:25: warning: use std::make_shared instead
     // CHECK-FIXES: shared_ptr<int> Q = std::make_shared<int>();
+
+    Q = shared_ptr<int>(new int());
+    // CHECK-MESSAGES: :[[@LINE-1]]:9: warning: use std::make_shared instead
+    // CHECK-FIXES: Q = std::make_shared<int>();
   }
 
   std::shared_ptr<int> R(new int());
 
   // Create the shared_ptr as a parameter to a function.
   int T = g(std::shared_ptr<int>(new int()));
   // CHECK-MESSAGES: :[[@LINE-1]]:13: warning: use std::make_shared instead
   // CHECK-FIXES: int T = g(std::make_shared<int>());
 
-  // Only replace if the type in the template is the same than the type returned
+  // 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());
 
+  // OK to replace for reset and assign
+  Pderived.reset(new Derived());
+  // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: use std::make_shared instead
+  // CHECK-FIXES: Pderived = std::make_shared<Derived>();
+
+  Pderived = std::shared_ptr<Derived>(new Derived());
+  // CHECK-MESSAGES: :[[@LINE-1]]:14: warning: use std::make_shared instead
+  // CHECK-FIXES: Pderived = std::make_shared<Derived>();
+
+  // FIXME: OK to replace if assigned to shared_ptr<Base>
+  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());
+
   // The pointer is returned by the function, nothing to do.
   std::shared_ptr<Base> RetPtr = getPointer();
 
   // This emulates std::move.
   std::shared_ptr<int> Move = static_cast<std::shared_ptr<int> &&>(P1);
 
-  // Placemenet arguments should not be removed.
+  // 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});
 }
 
 // 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);
     // CHECK-MESSAGES: :[[@LINE-1]]:24: warning: use std::make_shared instead
     // CHECK-FIXES: auto callsPublic = std::make_shared<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));
     // CHECK-MESSAGES: :[[@LINE-1]]:24: warning: use std::make_shared instead
     // CHECK-FIXES: auto callsPublic = std::make_shared<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));
   // CHECK-MESSAGES: :[[@LINE-1]]:34: warning: use std::make_shared instead
   // CHECK-FIXES: std::shared_ptr<DPair> PDir1 = std::make_shared<DPair>(1, T);
+  PDir1.reset(new DPair(1, T));
+  // CHECK-MESSAGES: :[[@LINE-1]]:9: warning: use std::make_shared instead
+  // CHECK-FIXES: PDir1 = std::make_shared<DPair>(1, T);
 
   // Direct initialization with braces.
   std::shared_ptr<DPair> PDir2 = std::shared_ptr<DPair>(new DPair{2, T});
   // CHECK-MESSAGES: :[[@LINE-1]]:34: warning: use std::make_shared instead
   // CHECK-FIXES: std::shared_ptr<DPair> PDir2 = std::make_shared<DPair>(2, T);
+  PDir2.reset(new DPair{2, T});
+  // CHECK-MESSAGES: :[[@LINE-1]]:9: warning: use std::make_shared instead
+  // CHECK-FIXES: PDir2 = std::make_shared<DPair>(2, T);
 
   // Aggregate initialization.
   std::shared_ptr<APair> PAggr = std::shared_ptr<APair>(new APair{T, 1});
   // CHECK-MESSAGES: :[[@LINE-1]]:34: warning: use std::make_shared instead
   // CHECK-FIXES: std::shared_ptr<APair> PAggr = std::make_shared<APair>(APair{T, 1});
+  PAggr.reset(new APair{T, 1});
+  // CHECK-MESSAGES: :[[@LINE-1]]:9: warning: use std::make_shared instead
+  // CHECK-FIXES: std::make_shared<APair>(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)};
   // CHECK-MESSAGES: :[[@LINE-1]]:34: warning: use std::make_shared instead
   // CHECK-FIXES: std::shared_ptr<DPair> PDir3 = std::make_shared<DPair>(3, T);
void whitespaces() {
   // CHECK-FIXES: auto Spaces = std::make_shared<int>();
   // clang-format on
 }
 
 void nesting() {
   auto Nest = std::shared_ptr<std::shared_ptr<int>>(new std::shared_ptr<int>(new int));
   // CHECK-MESSAGES: :[[@LINE-1]]:15: warning: use std::make_shared instead
   // CHECK-FIXES: auto Nest = std::make_shared<std::shared_ptr<int>>(new int);
+  Nest.reset(new std::shared_ptr<int>(new int));
+  // CHECK-MESSAGES: :[[@LINE-1]]:8: warning: use std::make_shared instead
+  // CHECK-FIXES: Nest = std::make_shared<std::shared_ptr<int>>(new int);
+  Nest->reset(new int);
+  // CHECK-MESSAGES: :[[@LINE-1]]:9: warning: use std::make_shared instead
+  // CHECK-FIXES: *Nest = std::make_shared<int>();
+}
+
+void reset() {
+  std::shared_ptr<int> P;
+  P.reset();
+  P.reset(nullptr);
+  P.reset(new int());
+  // CHECK-MESSAGES: :[[@LINE-1]]:5: warning: use std::make_shared instead
+  // CHECK-FIXES: P = std::make_shared<int>();
+
+  auto Q = &P;
+  Q->reset(new int());
+  // CHECK-MESSAGES: :[[@LINE-1]]:6: warning: use std::make_shared instead
+  // CHECK-FIXES: *Q = std::make_shared<int>();
 }

clang-tools-extra/trunk/test/clang-tidy/modernize-make-unique.cpp

 // RUN: %check_clang_tidy %s modernize-make-unique %t
 
 namespace std {
 
 template <typename T>
 class default_delete {};
 
 template <typename type, typename Deleter = std::default_delete<type>>
 class unique_ptr {
 public:
+  unique_ptr();
   unique_ptr(type *ptr);
   unique_ptr(const unique_ptr<type> &t) = delete;
   unique_ptr(unique_ptr<type> &&t);
   ~unique_ptr();
   type &operator*() { return *ptr; }
   type *operator->() { return ptr; }
   type *release();
   void reset();
   void reset(type *pt);
+  unique_ptr &operator=(unique_ptr &&);
+  template <typename T>
+  unique_ptr &operator=(unique_ptr<T> &&);
 
 private:
   type *ptr;
 };
-
 }
 
 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 unique_ptr_ = std::unique_ptr<T>;
+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);
   // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: use std::make_unique instead
   // CHECK-FIXES: return std::make_unique<Base>();
 }
 
 void basic() {
   std::unique_ptr<int> P1 = std::unique_ptr<int>(new int());
   // CHECK-MESSAGES: :[[@LINE-1]]:29: warning: use std::make_unique instead [modernize-make-unique]
   // CHECK-FIXES: std::unique_ptr<int> P1 = std::make_unique<int>();
 
+  P1.reset(new int());
+  // CHECK-MESSAGES: :[[@LINE-1]]:6: warning: use std::make_unique instead [modernize-make-unique]
+  // CHECK-FIXES: P1 = std::make_unique<int>();
+
+  P1 = std::unique_ptr<int>(new int());
+  // CHECK-MESSAGES: :[[@LINE-1]]:8: warning: use std::make_unique instead [modernize-make-unique]
+  // CHECK-FIXES: P1 = std::make_unique<int>();
+
   // Without parenthesis.
   std::unique_ptr<int> P2 = std::unique_ptr<int>(new int);
   // CHECK-MESSAGES: :[[@LINE-1]]:29: warning: use std::make_unique instead [modernize-make-unique]
   // CHECK-FIXES: std::unique_ptr<int> P2 = std::make_unique<int>();
 
+  P2.reset(new int);
+  // CHECK-MESSAGES: :[[@LINE-1]]:6: warning: use std::make_unique instead [modernize-make-unique]
+  // CHECK-FIXES: P2 = std::make_unique<int>();
+
+  P2 = std::unique_ptr<int>(new int);
+  // CHECK-MESSAGES: :[[@LINE-1]]:8: warning: use std::make_unique instead [modernize-make-unique]
+  // CHECK-FIXES: P2 = std::make_unique<int>();
+
   // With auto.
   auto P3 = std::unique_ptr<int>(new int());
   // CHECK-MESSAGES: :[[@LINE-1]]:13: warning: use std::make_unique instead
   // CHECK-FIXES: auto P3 = std::make_unique<int>();
 
   {
     // No std.
     using namespace std;
     unique_ptr<int> Q = unique_ptr<int>(new int());
     // CHECK-MESSAGES: :[[@LINE-1]]:25: warning: use std::make_unique instead
     // CHECK-FIXES: unique_ptr<int> Q = std::make_unique<int>();
+
+    Q = unique_ptr<int>(new int());
+    // CHECK-MESSAGES: :[[@LINE-1]]:9: warning: use std::make_unique instead
+    // CHECK-FIXES: Q = std::make_unique<int>();
   }
 
   std::unique_ptr<int> R(new int());
 
   // Create the unique_ptr as a parameter to a function.
   int T = g(std::unique_ptr<int>(new int()));
   // CHECK-MESSAGES: :[[@LINE-1]]:13: warning: use std::make_unique instead
   // CHECK-FIXES: int T = g(std::make_unique<int>());
 
-  // Only replace if the type in the template is the same than the type returned
+  // 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());
 
+  // OK to replace for reset and assign
+  Pderived.reset(new Derived());
+  // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: use std::make_unique instead
+  // CHECK-FIXES: Pderived = std::make_unique<Derived>();
+
+  Pderived = std::unique_ptr<Derived>(new Derived());
+  // CHECK-MESSAGES: :[[@LINE-1]]:14: warning: use std::make_unique instead
+  // CHECK-FIXES: Pderived = std::make_unique<Derived>();
+
+  // FIXME: OK to replace if assigned to unique_ptr<Base>
+  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());
+
   // The pointer is returned by the function, nothing to do.
   std::unique_ptr<Base> RetPtr = getPointer();
 
   // This emulates std::move.
-  std::unique_ptr<int> Move = static_cast<std::unique_ptr<int>&&>(P1);
+  std::unique_ptr<int> Move = static_cast<std::unique_ptr<int> &&>(P1);
 
-  // Placemenet arguments should not be removed.
+  // 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});
 }
 
 // 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);
     // CHECK-MESSAGES: :[[@LINE-1]]:24: warning: use std::make_unique instead
     // CHECK-FIXES: auto callsPublic = std::make_unique<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));
     // CHECK-MESSAGES: :[[@LINE-1]]:24: warning: use std::make_unique instead
     // CHECK-FIXES: auto callsPublic = std::make_unique<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));
   // CHECK-MESSAGES: :[[@LINE-1]]:34: warning: use std::make_unique instead
   // CHECK-FIXES: std::unique_ptr<DPair> PDir1 = std::make_unique<DPair>(1, T);
+  PDir1.reset(new DPair(1, T));
+  // CHECK-MESSAGES: :[[@LINE-1]]:9: warning: use std::make_unique instead
+  // CHECK-FIXES: PDir1 = std::make_unique<DPair>(1, T);
 
   // Direct initialization with braces.
   std::unique_ptr<DPair> PDir2 = std::unique_ptr<DPair>(new DPair{2, T});
   // CHECK-MESSAGES: :[[@LINE-1]]:34: warning: use std::make_unique instead
   // CHECK-FIXES: std::unique_ptr<DPair> PDir2 = std::make_unique<DPair>(2, T);
+  PDir2.reset(new DPair{2, T});
+  // CHECK-MESSAGES: :[[@LINE-1]]:9: warning: use std::make_unique instead
+  // CHECK-FIXES: PDir2 = std::make_unique<DPair>(2, T);
 
   // Aggregate initialization.
   std::unique_ptr<APair> PAggr = std::unique_ptr<APair>(new APair{T, 1});
   // CHECK-MESSAGES: :[[@LINE-1]]:34: warning: use std::make_unique instead
   // CHECK-FIXES: std::unique_ptr<APair> PAggr = std::make_unique<APair>(APair{T, 1});
-
+  PAggr.reset(new APair{T, 1});
+  // CHECK-MESSAGES: :[[@LINE-1]]:9: warning: use std::make_unique instead
+  // CHECK-FIXES: std::make_unique<APair>(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)};
   // CHECK-MESSAGES: :[[@LINE-1]]:34: warning: use std::make_unique instead
   // CHECK-FIXES: std::unique_ptr<DPair> PDir3 = std::make_unique<DPair>(3, T);
 
   // Direct initialization with braces.
   std::unique_ptr<DPair> PDir4 = std::unique_ptr<DPair>{new DPair{4, T}};
   // CHECK-MESSAGES: :[[@LINE-1]]:34: warning: use std::make_unique instead
   // CHECK-FIXES: std::unique_ptr<DPair> PDir4 = std::make_unique<DPair>(4, T);
 
   // Aggregate initialization.
   std::unique_ptr<APair> PAggr2 = std::unique_ptr<APair>{new APair{T, 2}};
   // CHECK-MESSAGES: :[[@LINE-1]]:35: warning: use std::make_unique instead
   // CHECK-FIXES: std::unique_ptr<APair> PAggr2 = std::make_unique<APair>(APair{T, 2});
 
-
   // Direct initialization with parenthesis, without arguments.
   std::unique_ptr<DPair> PDir5 = std::unique_ptr<DPair>(new DPair());
   // CHECK-MESSAGES: :[[@LINE-1]]:34: warning: use std::make_unique instead
   // CHECK-FIXES: std::unique_ptr<DPair> PDir5 = std::make_unique<DPair>();
 
   // Direct initialization with braces, without arguments.
   std::unique_ptr<DPair> PDir6 = std::unique_ptr<DPair>(new DPair{});
   // CHECK-MESSAGES: :[[@LINE-1]]:34: warning: use std::make_unique instead
void aliases() {
   typedef std::unique_ptr<bool> BoolPtr;
   BoolPtr BoolType = BoolPtr(new bool);
   // CHECK-MESSAGES: :[[@LINE-1]]:22: warning: use std::make_unique instead
   // CHECK-FIXES: BoolPtr BoolType = std::make_unique<bool>();
 
   // We use 'Base' instead of 'struct Base'.
   typedef std::unique_ptr<Base> BasePtr;
   BasePtr StructType = BasePtr(new Base);
-  // CHECK-MESSAGES: :[[@LINE-1]]:24: warning: use std::make_unique instead
-  // CHECK-FIXES: BasePtr StructType = std::make_unique<Base>();
 
 #define PTR unique_ptr<int>
   std::unique_ptr<int> Macro = std::PTR(new int);
-  // CHECK-MESSAGES: :[[@LINE-1]]:32: warning: use std::make_unique instead
-  // CHECK-FIXES: std::unique_ptr<int> Macro = std::make_unique<int>();
 #undef PTR
 
   std::unique_ptr<int> Using = unique_ptr_<int>(new int);
   // CHECK-MESSAGES: :[[@LINE-1]]:32: warning: use std::make_unique instead
   // CHECK-FIXES: std::unique_ptr<int> Using = std::make_unique<int>();
 }
 
 void whitespaces() {
+  // clang-format off
   auto Space = std::unique_ptr <int>(new int());
   // CHECK-MESSAGES: :[[@LINE-1]]:16: warning: use std::make_unique instead
   // CHECK-FIXES: auto Space = std::make_unique<int>();
 
   auto Spaces = std  ::    unique_ptr  <int>(new int());
   // CHECK-MESSAGES: :[[@LINE-1]]:17: warning: use std::make_unique instead
   // CHECK-FIXES: auto Spaces = std::make_unique<int>();
+  // clang-format on
 }
 
 void nesting() {
   auto Nest = std::unique_ptr<std::unique_ptr<int>>(new std::unique_ptr<int>(new int));
   // CHECK-MESSAGES: :[[@LINE-1]]:15: warning: use std::make_unique instead
   // CHECK-FIXES: auto Nest = std::make_unique<std::unique_ptr<int>>(new int);
+  Nest.reset(new std::unique_ptr<int>(new int));
+  // CHECK-MESSAGES: :[[@LINE-1]]:8: warning: use std::make_unique instead
+  // CHECK-FIXES: Nest = std::make_unique<std::unique_ptr<int>>(new int);
+  Nest->reset(new int);
+  // CHECK-MESSAGES: :[[@LINE-1]]:9: warning: use std::make_unique instead
+  // CHECK-FIXES: *Nest = std::make_unique<int>();
+}
+
+void reset() {
+  std::unique_ptr<int> P;
+  P.reset();
+  P.reset(nullptr);
+  P.reset(new int());
+  // CHECK-MESSAGES: :[[@LINE-1]]:5: warning: use std::make_unique instead
+  // CHECK-FIXES: P = std::make_unique<int>();
+
+  auto Q = &P;
+  Q->reset(new int());
+  // CHECK-MESSAGES: :[[@LINE-1]]:6: warning: use std::make_unique instead
+  // CHECK-FIXES: *Q = std::make_unique<int>();
 }