[clang-tidy] Don't turn .push_back({1, 2}) into .emplace_back(1, 2) for pairs

[kuhar]

Summary

This patch prevents modernize-use-emplace from changing push_backs of brace initialized pairs (.push_back({1, 2})) to .emplace_back(1, 2).
Pair's constructor doesn't have any interesting logic and basically performs aggregate initialization. There also doesn't seem to be much win
in terms of making code more concise, thus is makes little sense to turn such push_back calls into emplace_backs.

The change is inspired by the recent discussion on changing and enforcing coding guidelines:
[llvm-dev] [cfe-dev] Modernizing LLVM Coding Style Guide and enforcing Clang-tidy
http://lists.llvm.org/pipermail/llvm-dev/2016-December/108559.html

clang-tidy/modernize/UseEmplaceCheck.h

public:
   UseEmplaceCheck(StringRef Name, ClangTidyContext *Context);
   void registerMatchers(ast_matchers::MatchFinder *Finder) override;
   void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
   void storeOptions(ClangTidyOptions::OptionMap &Opts) override;
 
 private:
   std::vector<std::string> ContainersWithPushBack;
   std::vector<std::string> SmartPointers;
+  std::vector<std::string> PairTypes;
 };
 
 } // namespace modernize
 } // namespace tidy
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MODERNIZE_USE_EMPLACE_H

clang-tidy/modernize/UseEmplaceCheck.cpp

 namespace clang {
 namespace tidy {
 namespace modernize {
 
 static const auto DefaultContainersWithPushBack =
     "::std::vector; ::std::list; ::std::deque";
 static const auto DefaultSmartPointers =
     "::std::shared_ptr; ::std::unique_ptr; ::std::auto_ptr; ::std::weak_ptr";
+static const auto DefaultPairTypes = "::std::pair";
 
 UseEmplaceCheck::UseEmplaceCheck(StringRef Name, ClangTidyContext *Context)
     : ClangTidyCheck(Name, Context),
       ContainersWithPushBack(utils::options::parseStringList(Options.get(
           "ContainersWithPushBack", DefaultContainersWithPushBack))),
       SmartPointers(utils::options::parseStringList(
-          Options.get("SmartPointers", DefaultSmartPointers))) {}
+          Options.get("SmartPointers", DefaultSmartPointers))),
+      PairTypes(utils::options::parseStringList(
+          Options.get("PairTypes", DefaultPairTypes))) {}
 
 void UseEmplaceCheck::registerMatchers(MatchFinder *Finder) {
   if (!getLangOpts().CPlusPlus11)
     return;
 
   // FIXME: Bunch of functionality that could be easily added:
   // + add handling of `push_front` for std::forward_list, std::list
   // and std::deque.
auto constructingDerived =
       hasParent(implicitCastExpr(hasCastKind(CastKind::CK_DerivedToBase)));
 
   // emplace_back can't access private constructor.
   auto isPrivateCtor = hasDeclaration(cxxConstructorDecl(isPrivate()));
 
   auto hasInitList = has(ignoringImplicit(initListExpr()));
   // FIXME: Discard 0/NULL (as nullptr), static inline const data members,
   // overloaded functions and template names.
+
+  // Ignore push_back({first, second}) for pair types (eg. std::pair).
+  auto isPairBraceInit = expr(allOf(cxxConstructExpr(hasDeclaration(
+      cxxConstructorDecl(ofClass(hasAnyName(SmallVector<StringRef, 2>(
+          PairTypes.begin(), PairTypes.end())))))),
+                                    unless(cxxTemporaryObjectExpr())),
+                              unless(hasParent(implicitCastExpr())));
+
   auto soughtConstructExpr =
       cxxConstructExpr(
           unless(anyOf(isCtorOfSmartPtr, hasInitList, bitFieldAsArgument,
                        initializerListAsArgument, newExprAsArgument,
-                       constructingDerived, isPrivateCtor)))
+                       constructingDerived, isPrivateCtor, isPairBraceInit)))
           .bind("ctor");
   auto hasConstructExpr = has(ignoringImplicit(soughtConstructExpr));
 
   auto ctorAsArgument = materializeTemporaryExpr(
       anyOf(hasConstructExpr, has(cxxFunctionalCastExpr(hasConstructExpr))));
 
   Finder->addMatcher(cxxMemberCallExpr(callPushBack, has(ctorAsArgument),
                                        unless(isInTemplateInstantiation()))

test/clang-tidy/modernize-use-emplace.cpp

struct GetPair {
   std::pair<int, long> getPair();
 };
 void testPair() {
   std::vector<std::pair<int, int>> v;
   v.push_back(std::pair<int, int>(1, 2));
   // CHECK-MESSAGES: :[[@LINE-1]]:5: warning: use emplace_back
   // CHECK-FIXES: v.emplace_back(1, 2);
 
+  v.push_back({1, 2});
+  v.push_back(std::pair<int, int>{1, 2});
+  // CHECK-MESSAGES: :[[@LINE-1]]:5: warning: use emplace_back
+  // CHECK-FIXES: v.emplace_back(1, 2);
+
   GetPair g;
   v.push_back(g.getPair());
   // CHECK-MESSAGES: :[[@LINE-1]]:5: warning: use emplace_back
   // CHECK-FIXES: v.emplace_back(g.getPair());
 
   std::vector<std::pair<Something, Zoz>> v2;
   v2.push_back(std::pair<Something, Zoz>(Something(42, 42), Zoz(Something(21, 37))));
   // CHECK-MESSAGES: :[[@LINE-1]]:6: warning: use emplace_back