Use better mocks in modernize-make-unique, and fix matcher.

[angelgarcia]

Summary

Add the second template argument to the unique_ptr mock, and update the matcher so that it only matches against cases where the second argument is the default.

[klimek]

lg

clang-tidy/modernize/MakeUniqueCheck.cpp

 
 void MakeUniqueCheck::registerMatchers(MatchFinder *Finder) {
   if (getLangOpts().CPlusPlus11) {
     Finder->addMatcher(
         cxxBindTemporaryExpr(has(
             cxxConstructExpr(
                 hasType(qualType(hasDeclaration(classTemplateSpecializationDecl(
                     matchesName("::std::unique_ptr"),
+                    templateArgumentCountIs(2),
+                    hasTemplateArgument(0, templateArgument(refersToType(
+                                               qualType().bind(PointerType)))),
+                    hasTemplateArgument(
+                        1, templateArgument(refersToType(qualType(
+                               hasDeclaration(classTemplateSpecializationDecl(
+                                   matchesName("::std::default_delete"),
                                    templateArgumentCountIs(1),
                                    hasTemplateArgument(
-                        0, templateArgument(
-                               refersToType(qualType().bind(PointerType)))))))),
+                                       0, templateArgument(refersToType(
+                                              qualType(equalsBoundNode(
+                                                  PointerType))))))))))))))),
                 argumentCountIs(1),
                 hasArgument(0, cxxNewExpr(hasType(pointsTo(qualType(
                                               equalsBoundNode(PointerType)))))
                                    .bind(NewExpression)))
                 .bind(ConstructorCall))),
         this);
   }
 }

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

 // RUN: %python %S/check_clang_tidy.py %s modernize-make-unique %t
 
 namespace std {
 
-template <typename type>
+template <typename T>
+class default_delete {};
+
+template <typename type, typename Deleter = std::default_delete<type>>
 class unique_ptr {
 public:
   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; }