[clang-tidy] Fix descriptions for modernize-make-unique/shared checks.

[hokein]

As discussed offline, we don't need a separate fix description for this check, as the check warning message clearly implies what the fix will do.

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

private:
 
   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.
-  bool replaceNew(DiagnosticBuilder &Diag, const CXXNewExpr *New,
-                  SourceManager &SM, ASTContext *Ctx);
+  bool replaceNew(const CXXNewExpr *New, SourceManager &SM, ASTContext *Ctx,
+                  std::vector<FixItHint> &Fixes);
   void insertHeader(DiagnosticBuilder &Diag, FileID FD);
 };
 
 } // namespace modernize
 } // namespace tidy
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MODERNIZE_MAKE_SMART_PTR_H

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

void MakeSmartPtrCheck::checkConstruct(SourceManager &SM, ASTContext *Ctx,
   bool Invalid = false;
   StringRef ExprStr = Lexer::getSourceText(
       CharSourceRange::getCharRange(
           ConstructCallStart, Construct->getParenOrBraceRange().getBegin()),
       SM, getLangOpts(), &Invalid);
   if (Invalid)
     return;
 
-  auto Diag = diag(ConstructCallStart, "use %0 instead")
-              << MakeSmartPtrFunctionName;
+  diag(ConstructCallStart, "use %0 instead") << MakeSmartPtrFunctionName;
 
   // Disable the fix in macros.
   if (InMacro) {
     return;
   }
 
-  if (!replaceNew(Diag, New, SM, Ctx)) {
+  std::vector<FixItHint> Fixes;
+  if (!replaceNew(New, SM, Ctx, Fixes)) {
     return;
   }
+  auto FixDiag = diag(ConstructCallStart, "change to %0", DiagnosticIDs::Note)
+                 << MakeSmartPtrFunctionName;
+
+  for (const auto &Fix : Fixes)
+    FixDiag << Fix;
 
   // Find the location of the template's left angle.
   size_t LAngle = ExprStr.find("<");
   SourceLocation ConstructCallEnd;
   if (LAngle == StringRef::npos) {
     // If the template argument is missing (because it is part of the alias)
     // we have to add it back.
     ConstructCallEnd = ConstructCallStart.getLocWithOffset(ExprStr.size());
-    Diag << FixItHint::CreateInsertion(
-        ConstructCallEnd,
-        "<" + GetNewExprName(New, SM, getLangOpts()) + ">");
+    FixDiag << FixItHint::CreateInsertion(
+        ConstructCallEnd, "<" + GetNewExprName(New, SM, getLangOpts()) + ">");
   } else {
     ConstructCallEnd = ConstructCallStart.getLocWithOffset(LAngle);
   }
 
-  Diag << FixItHint::CreateReplacement(
+  FixDiag << FixItHint::CreateReplacement(
       CharSourceRange::getCharRange(ConstructCallStart, ConstructCallEnd),
       MakeSmartPtrFunctionName);
 
   // If the smart_ptr is built with brace enclosed direct initialization, use
   // parenthesis instead.
   if (Construct->isListInitialization()) {
     SourceRange BraceRange = Construct->getParenOrBraceRange();
-    Diag << FixItHint::CreateReplacement(
+    FixDiag << FixItHint::CreateReplacement(
         CharSourceRange::getCharRange(
             BraceRange.getBegin(), BraceRange.getBegin().getLocWithOffset(1)),
         "(");
-    Diag << FixItHint::CreateReplacement(
+    FixDiag << FixItHint::CreateReplacement(
         CharSourceRange::getCharRange(BraceRange.getEnd(),
                                       BraceRange.getEnd().getLocWithOffset(1)),
         ")");
   }
 
-  insertHeader(Diag, SM.getFileID(ConstructCallStart));
+  insertHeader(FixDiag, SM.getFileID(ConstructCallStart));
 }
 
 void MakeSmartPtrCheck::checkReset(SourceManager &SM, ASTContext *Ctx,
                                    const CXXMemberCallExpr *Reset,
                                    const CXXNewExpr *New) {
   const auto *Expr = cast<MemberExpr>(Reset->getCallee());
   SourceLocation OperatorLoc = Expr->getOperatorLoc();
   SourceLocation ResetCallStart = Reset->getExprLoc();
void MakeSmartPtrCheck::checkReset(SourceManager &SM, ASTContext *Ctx,
 
   // There are some cases where we don't have operator ("." or "->") of the
   // "reset" expression, e.g. call "reset()" method directly in the subclass of
   // "std::unique_ptr<>". We skip these cases.
   if (OperatorLoc.isInvalid()) {
     return;
   }
 
-  auto Diag = diag(ResetCallStart, "use %0 instead")
-              << MakeSmartPtrFunctionName;
+  diag(ResetCallStart, "use %0 instead") << MakeSmartPtrFunctionName;
 
   // Disable the fix in macros.
   if (InMacro) {
     return;
   }
 
-  if (!replaceNew(Diag, New, SM, Ctx)) {
+  std::vector<FixItHint> Fixes;
+  if (!replaceNew(New, SM, Ctx, Fixes))
     return;
-  }
 
-  Diag << FixItHint::CreateReplacement(
+  auto FixDiag = diag(ResetCallStart, "change to %0", DiagnosticIDs::Note)
+                 << MakeSmartPtrFunctionName;
+  for (const auto &Fix : Fixes)
+    FixDiag << Fix;
+
+  FixDiag << FixItHint::CreateReplacement(
       CharSourceRange::getCharRange(OperatorLoc, ExprEnd),
       (llvm::Twine(" = ") + MakeSmartPtrFunctionName + "<" +
        GetNewExprName(New, SM, getLangOpts()) + ">")
           .str());
 
   if (Expr->isArrow())
-    Diag << FixItHint::CreateInsertion(ExprStart, "*");
+    FixDiag << FixItHint::CreateInsertion(ExprStart, "*");
 
-  insertHeader(Diag, SM.getFileID(OperatorLoc));
+  insertHeader(FixDiag, SM.getFileID(OperatorLoc));
 }
 
-bool MakeSmartPtrCheck::replaceNew(DiagnosticBuilder &Diag,
-                                   const CXXNewExpr *New, SourceManager &SM,
-                                   ASTContext *Ctx) {
+bool MakeSmartPtrCheck::replaceNew(const CXXNewExpr *New, SourceManager &SM,
+                                   ASTContext *Ctx,
+                                   std::vector<FixItHint> &Fixes) {
   auto SkipParensParents = [&](const Expr *E) {
     for (const Expr *OldE = nullptr; E != OldE;) {
       OldE = E;
       for (const auto &Node : Ctx->getParents(*E)) {
         if (const Expr *Parent = Node.get<ParenExpr>()) {
           E = Parent;
           break;
         }
for (const auto *Arg : CE->arguments()) {
           return true;
       }
     }
     return false;
   };
   switch (New->getInitializationStyle()) {
   case CXXNewExpr::NoInit: {
     if (ArraySizeExpr.empty()) {
-      Diag << FixItHint::CreateRemoval(SourceRange(NewStart, NewEnd));
+      Fixes.push_back(FixItHint::CreateRemoval(SourceRange(NewStart, NewEnd)));
     } else {
       // New array expression without written initializer:
       //   smart_ptr<Foo[]>(new Foo[5]);
-      Diag << FixItHint::CreateReplacement(SourceRange(NewStart, NewEnd),
-                                           ArraySizeExpr);
+      Fixes.push_back(FixItHint::CreateReplacement(
+          SourceRange(NewStart, NewEnd), ArraySizeExpr));
     }
     break;
   }
   case CXXNewExpr::CallInit: {
     // FIXME: Add fixes for constructors with parameters that can be created
     // with a C++11 braced-init-list (e.g. std::vector, std::map).
     // Unlike ordinal cases, braced list can not be deduced in
     // std::make_smart_ptr, we need to specify the type explicitly in the fixes:
case CXXNewExpr::CallInit: {
     //   std::make_smart_ptr<S2>(std::vector<int>({1}));
     //   std::make_smart_ptr<S3>(S2{1, 2}, 3);
     if (const auto *CE = New->getConstructExpr()) {
       if (HasListIntializedArgument(CE))
         return false;
     }
     if (ArraySizeExpr.empty()) {
       SourceRange InitRange = New->getDirectInitRange();
-      Diag << FixItHint::CreateRemoval(
-          SourceRange(NewStart, InitRange.getBegin()));
-      Diag << FixItHint::CreateRemoval(SourceRange(InitRange.getEnd(), NewEnd));
+      Fixes.push_back(FixItHint::CreateRemoval(
+          SourceRange(NewStart, InitRange.getBegin())));
+      Fixes.push_back(
+          FixItHint::CreateRemoval(SourceRange(InitRange.getEnd(), NewEnd)));
     }
     else {
       // New array expression with default/value initialization:
       //   smart_ptr<Foo[]>(new int[5]());
       //   smart_ptr<Foo[]>(new Foo[5]());
-      Diag << FixItHint::CreateReplacement(SourceRange(NewStart, NewEnd),
-                                           ArraySizeExpr);
+      Fixes.push_back(FixItHint::CreateReplacement(
+          SourceRange(NewStart, NewEnd), ArraySizeExpr));
     }
     break;
   }
   case CXXNewExpr::ListInit: {
     // Range of the substring that we do not want to remove.
     SourceRange InitRange;
     if (const auto *NewConstruct = New->getConstructExpr()) {
       if (NewConstruct->isStdInitListInitialization() ||
if (const auto *NewConstruct = New->getConstructExpr()) {
             }) != RD->ctor_end()) {
           return false;
         }
       }
       InitRange = SourceRange(
           New->getAllocatedTypeSourceInfo()->getTypeLoc().getBeginLoc(),
           New->getInitializer()->getSourceRange().getEnd());
     }
-    Diag << FixItHint::CreateRemoval(
-        CharSourceRange::getCharRange(NewStart, InitRange.getBegin()));
-    Diag << FixItHint::CreateRemoval(
-        SourceRange(InitRange.getEnd().getLocWithOffset(1), NewEnd));
+    Fixes.push_back(FixItHint::CreateRemoval(
+        CharSourceRange::getCharRange(NewStart, InitRange.getBegin())));
+    Fixes.push_back(FixItHint::CreateRemoval(
+        SourceRange(InitRange.getEnd().getLocWithOffset(1), NewEnd)));
     break;
   }
   }
   return true;
 }
 
 void MakeSmartPtrCheck::insertHeader(DiagnosticBuilder &Diag, FileID FD) {
   if (MakeSmartPtrFunctionHeader.empty()) {

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

 
 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);
   // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: use std::make_shared instead
+  // CHECK-MESSAGES: :[[@LINE-2]]:10: note: change to std::make_shared
   // 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-MESSAGES: :[[@LINE-2]]:6: note: change to std::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);

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

 
 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-MESSAGES: :[[@LINE-2]]:10: note: change to std::make_unique
   // 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>();
 
void basic() {
 
   // 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-MESSAGES: :[[@LINE-2]]:12: note: change to std::make_unique
   // 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());
void initialization(int T, Base b) {
   //============================================================================
   //  NOTE: For initlializer-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});
   // CHECK-MESSAGES: :[[@LINE-1]]:28: warning: use std::make_unique instead
+  // CHECK-MESSAGES-NOT: :[[@LINE-2]]:28: note: change to std::make_unique
   // CHECK-FIXES: std::unique_ptr<E> PE2 = std::unique_ptr<E>(new E{1, 2});
   PE2.reset(new E{1, 2});
   // CHECK-MESSAGES: :[[@LINE-1]]:7: warning: use std::make_unique instead
   // CHECK-FIXES: PE2.reset(new E{1, 2});
 
   // Initialization with default constructor.
   std::unique_ptr<F> PF1 = std::unique_ptr<F>(new F());
   // CHECK-MESSAGES: :[[@LINE-1]]:28: warning: use std::make_unique instead