[clang-tidy] Add make_unique_for_overwrite/make_shared_for_overwrite check.

[ckennelly]

Summary

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.

[Eugene.Zelenko]

clang-tools-extra/docs/ReleaseNotes.rst

143

Please keep alphabetical order.

146

Please use double back-ticks to highlight language constructs. Same below.

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

6

Please make same as entry in Release Notes.

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

6

Please make same as entry in Release Notes.

[njames93]

I'm definitely of the opinion this should be an option in the modernize-make-(shared|unique) check

clang-tools-extra/clang-tidy/modernize/CMakeLists.txt

 set(LLVM_LINK_COMPONENTS
   FrontendOpenMP
   Support
   )
 
 add_clang_library(clangTidyModernizeModule
   AvoidBindCheck.cpp
   AvoidCArraysCheck.cpp
   ConcatNestedNamespacesCheck.cpp
   DeprecatedHeadersCheck.cpp
   DeprecatedIosBaseAliasesCheck.cpp
   LoopConvertCheck.cpp
   LoopConvertUtils.cpp
   MakeSharedCheck.cpp
+  MakeSharedForOverwriteCheck.cpp
   MakeSmartPtrCheck.cpp
   MakeUniqueCheck.cpp
+  MakeUniqueForOverwriteCheck.cpp
   ModernizeTidyModule.cpp
   PassByValueCheck.cpp
   RawStringLiteralCheck.cpp
   RedundantVoidArgCheck.cpp
   ReplaceAutoPtrCheck.cpp
   ReplaceDisallowCopyAndAssignMacroCheck.cpp
   ReplaceRandomShuffleCheck.cpp
   ReturnBracedInitListCheck.cpp

clang-tools-extra/clang-tidy/modernize/MakeSharedCheck.cpp

 
 using namespace clang::ast_matchers;
 
 namespace clang {
 namespace tidy {
 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 {
   return qualType(hasUnqualifiedDesugaredType(
       recordType(hasDeclaration(classTemplateSpecializationDecl(
           hasName("::std::shared_ptr"), templateArgumentCountIs(1),
           hasTemplateArgument(0, templateArgument(refersToType(
                                      qualType().bind(PointerType)))))))));
 }
 
 } // namespace modernize
 } // namespace tidy
 } // namespace clang

clang-tools-extra/clang-tidy/modernize/MakeSharedForOverwriteCheck.h

+//===--- 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

clang-tools-extra/clang-tidy/modernize/MakeSharedForOverwriteCheck.cpp

-//===--- 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.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-#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;
 
 namespace clang {
 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),
           hasTemplateArgument(0, templateArgument(refersToType(
                                      qualType().bind(PointerType)))))))));
 }
 
+bool MakeSharedForOverwriteCheck::isLanguageVersionSupported(
+    const LangOptions &LangOpts) const {
+  return RequireCPlusPlus20 ? LangOpts.CPlusPlus20 : LangOpts.CPlusPlus11;
+}
+
 } // namespace modernize
 } // namespace tidy
 } // namespace clang

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

 namespace clang {
 namespace tidy {
 namespace modernize {
 
 /// Base class for MakeSharedCheck and MakeUniqueCheck.
 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;
   void check(const ast_matchers::MatchFinder::MatchResult &Result) final;
   void storeOptions(ClangTidyOptions::OptionMap &Opts) override;
 
 protected:
   using SmartPtrTypeMatcher = ast_matchers::internal::BindableMatcher<QualType>;
protected:
   static const char PointerType[];
 
 private:
   utils::IncludeInserter Inserter;
   const std::string MakeSmartPtrFunctionHeader;
   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,
                       const CXXNewExpr *New);
   void checkReset(SourceManager &SM, ASTContext *Ctx,
                   const CXXMemberCallExpr *Member, const CXXNewExpr *New);
 
   /// Returns true when the fixes for replacing CXXNewExpr are generated.

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

std::string GetNewExprName(const CXXNewExpr *NewExpr,
   return WrittenName.str();
 }
 
 } // namespace
 
 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)),
       MakeSmartPtrFunctionHeader(
           Options.get("MakeSmartPtrFunctionHeader", "<memory>")),
       MakeSmartPtrFunctionName(
           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());
   Options.store(Opts, "MakeSmartPtrFunctionHeader", MakeSmartPtrFunctionHeader);
   Options.store(Opts, "MakeSmartPtrFunction", MakeSmartPtrFunctionName);
   Options.store(Opts, "IgnoreMacros", IgnoreMacros);
   Options.store(Opts, "IgnoreDefaultInitialization",
                 IgnoreDefaultInitialization);
void MakeSmartPtrCheck::check(const MatchFinder::MatchResult &Result) {
   //    P.reset(new int)    // check fix: P = std::make_unique<int>()
   //    P.reset(new int[5]) // check fix: P = std::make_unique<int []>(5)
   //
   // The fix of the check has side effect, it introduces value initialization
   // which maybe unexpected and cause performance regression.
   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);
   else if (Reset)
     checkReset(SM, Result.Context, Reset, New);
 }
 
 void MakeSmartPtrCheck::checkConstruct(SourceManager &SM, ASTContext *Ctx,

clang-tools-extra/clang-tidy/modernize/MakeUniqueCheck.cpp

 using namespace clang::ast_matchers;
 
 namespace clang {
 namespace tidy {
 namespace modernize {
 
 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
 MakeUniqueCheck::getSmartPointerTypeMatcher() const {
   return qualType(hasUnqualifiedDesugaredType(
       recordType(hasDeclaration(classTemplateSpecializationDecl(
           hasName("::std::unique_ptr"), templateArgumentCountIs(2),
           hasTemplateArgument(

clang-tools-extra/clang-tidy/modernize/MakeUniqueForOverwriteCheck.h

+//===--- 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

clang-tools-extra/clang-tidy/modernize/MakeUniqueForOverwriteCheck.cpp

-//===--- 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.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-#include "MakeUniqueCheck.h"
+#include "MakeUniqueForOverwriteCheck.h"
+#include "clang/AST/ASTContext.h"
+#include "clang/ASTMatchers/ASTMatchFinder.h"
 
 using namespace clang::ast_matchers;
 
 namespace clang {
 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),
           hasTemplateArgument(
               0, templateArgument(refersToType(qualType().bind(PointerType)))),
           hasTemplateArgument(
               1, templateArgument(refersToType(
                      qualType(hasDeclaration(classTemplateSpecializationDecl(
                          hasName("::std::default_delete"),
                          templateArgumentCountIs(1),
                          hasTemplateArgument(
                              0, templateArgument(refersToType(qualType(
                                     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
 
 } // namespace modernize
 } // namespace tidy
 } // namespace clang

clang-tools-extra/clang-tidy/modernize/ModernizeTidyModule.cpp

 #include "../ClangTidyModuleRegistry.h"
 #include "AvoidBindCheck.h"
 #include "AvoidCArraysCheck.h"
 #include "ConcatNestedNamespacesCheck.h"
 #include "DeprecatedHeadersCheck.h"
 #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"
 #include "ReplaceAutoPtrCheck.h"
 #include "ReplaceDisallowCopyAndAssignMacroCheck.h"
 #include "ReplaceRandomShuffleCheck.h"
 #include "ReturnBracedInitListCheck.h"
 #include "ShrinkToFitCheck.h"
void addCheckFactories(ClangTidyCheckFactories &CheckFactories) override {
     CheckFactories.registerCheck<ConcatNestedNamespacesCheck>(
         "modernize-concat-nested-namespaces");
     CheckFactories.registerCheck<DeprecatedHeadersCheck>(
         "modernize-deprecated-headers");
     CheckFactories.registerCheck<DeprecatedIosBaseAliasesCheck>(
         "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");
     CheckFactories.registerCheck<RedundantVoidArgCheck>(
         "modernize-redundant-void-arg");
     CheckFactories.registerCheck<ReplaceAutoPtrCheck>(
         "modernize-replace-auto-ptr");
     CheckFactories.registerCheck<ReplaceDisallowCopyAndAssignMacroCheck>(

clang-tools-extra/docs/ReleaseNotes.rst

- New :doc:`cert-sig30-c
   Alias to the :doc:`bugprone-signal-handler
   <clang-tidy/checks/bugprone-signal-handler>` check.
 
 - New :doc:`performance-no-int-to-ptr
   <clang-tidy/checks/performance-no-int-to-ptr>` check.
 
   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.
 
   Flags functions with Cognitive Complexity metric exceeding the configured limit.
 
 Changes in existing checks
 ^^^^^^^^^^^^^^^^^^^^^^^^^^
 

clang-tools-extra/docs/clang-tidy/checks/list.rst

.. csv-table::
    `misc-unused-using-decls <misc-unused-using-decls.html>`_, "Yes"
    `modernize-avoid-bind <modernize-avoid-bind.html>`_, "Yes"
    `modernize-avoid-c-arrays <modernize-avoid-c-arrays.html>`_,
    `modernize-concat-nested-namespaces <modernize-concat-nested-namespaces.html>`_, "Yes"
    `modernize-deprecated-headers <modernize-deprecated-headers.html>`_, "Yes"
    `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"
    `modernize-replace-auto-ptr <modernize-replace-auto-ptr.html>`_, "Yes"
    `modernize-replace-disallow-copy-and-assign-macro <modernize-replace-disallow-copy-and-assign-macro.html>`_, "Yes"
    `modernize-replace-random-shuffle <modernize-replace-random-shuffle.html>`_, "Yes"
    `modernize-return-braced-init-list <modernize-return-braced-init-list.html>`_, "Yes"
    `modernize-shrink-to-fit <modernize-shrink-to-fit.html>`_, "Yes"

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

+.. 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`.

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

+.. 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`.

clang-tools-extra/test/clang-tidy/checkers/modernize-make-shared-for-overwrite.cpp

+// 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>();
+}

clang-tools-extra/test/clang-tidy/checkers/modernize-make-unique-for-overwrite.cpp

+// 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);
+}