[clang-tidy] Add proper emplace checks to modernize-use-emplace

[nicovank]

Summary

modernize-use-emplace only recommends going from a push_back to an
emplace_back, but does not provide a recommendation when emplace_back is
improperly used. This adds the functionality of warning the user when
an unecessary temporary is created while calling emplace_back or other "emplacy"
functions from the STL containers.

[nicovank]

As you can see, this will fail some tests as there is one corner case which is tricky to handle:

std::vector<std::tuple<std::tuple<int, int>>> vec;
// This is valid and should not be changed.
vec.emplace_back(std::make_tuple(13, 31));

Does anyone have a suggestion for a good way to handle this?

Ideally, it would be nice to just check that the type of the temporary matches the type of the value_type, but I've tried that with a simple ==, and it then becomes a problem with strings, where for example

std::vector<std::pair<std::string, std::string>> vec;
vec.emplace_back(std::make_pair("foo", "bar"));

would not be changed as it would list the pair as a std::pair<const char*, const char*>, and not match with std::pair<std::string, std::string>.
Is there some way that I couldn't find to check if two clang::Types are "compatible"?

[Eugene.Zelenko]

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

25

Please don't use auto unless type is spelled explicitly in same statement or iterator.

39

Please don't use auto unless type is spelled explicitly in same statement or iterator.

[nicovank]

Fix a couple variable names and explicitely specify a couple types

[Eugene.Zelenko]

Please mark fixed suggestions as done.

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

248

Please don't use auto unless type is spelled explicitly in same statement or iterator.

[nicovank]

Explicitely specify one more type

[nicovank]

Thank you for the feedback, I appreciate it! Let me know if there is any other I missed, AFAIK all auto uses introduced by me should be good now.

[Eugene.Zelenko]

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

29

I'm not sure, but probably braces could be elided in for and if else.

46

I'm not sure, but probably braces could be elided.

57

Please elide braces.

69

Please elide braces.

268

It's not yours, but please fix it, since code was affected by your change.

[kuhar]

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

28

Can you add a comment explaining what this loops tries to do? Ideally, with a short example like some_func<int> --> ::some_func

29

-1 for removing braces in multi-statement loops

46

-1

295

Can you pull this ternary expression into a variable so that it does not have to repeated when the diagnostic is emitted?

[nicovank]

Fix some style comments

[nicovank]

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

295

This is a bit tricky, since MakeCall is a CallExpr and CtorCall is a CXXConstructExpr, and they have no common base class. Even if I pull it out it'll be a lot of repetition.

I think there may be some elegant way to join the previous removal hints with these, but haven't had time to think about it. I'll probably post another update by the end of this week.

[kuhar]

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

44

nit: StringRef( seems unnecessary on the rhs of =

[nicovank]

Update!

1. Rebased.
2. Fixed a minor bug which occasionaly caused false negatives.
3. Cleared up fix/hint generation and another nit following comments.
4. Re-organized and added a couple tests.
5. Made a note of this extension in documentation.

This check has been enabled internally as Facebook (pre-changes discussed above) for a bit over a year, with no reported issues.
It should be safe and ready to be upstreamed at this point.
Please let me know of any issues, let's get this landed!

[nicovank]

Fix formatting issues

[kuhar]

LGTM but please get a second approval before submitting.

[ivanmurashko]

LGTM, thank you a lot for the useful modification!

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

public:
   void storeOptions(ClangTidyOptions::OptionMap &Opts) override;
 
 private:
   const bool IgnoreImplicitConstructors;
   const std::vector<StringRef> ContainersWithPushBack;
   const std::vector<StringRef> SmartPointers;
   const std::vector<StringRef> TupleTypes;
   const std::vector<StringRef> TupleMakeFunctions;
+  const std::vector<StringRef> EmplacyFunctions;
 };
 
 } // namespace modernize
 } // namespace tidy
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MODERNIZE_USE_EMPLACE_H

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

 #include "../utils/OptionsUtils.h"
 using namespace clang::ast_matchers;
 
 namespace clang {
 namespace tidy {
 namespace modernize {
 
 namespace {
+// Identical to hasAnyName, except it does not take template specifiers into
+// account. This is used to match the functions names as in
+// DefaultEmplacyFunctions below without caring about the template types of the
+// containers.
+AST_MATCHER_P(NamedDecl, hasAnyNameIgnoringTemplates, std::vector<StringRef>,
+              Names) {
+  const std::string FullName = "::" + Node.getQualifiedNameAsString();
+
+  // This loop removes template specifiers by only keeping characters not within
+  // template brackets. We keep a depth count to handle nested templates. For
+  // example, it'll transform a::b<c<d>>::e<f> to simply a::b::e.
+  std::string FullNameTrimmed;
+  int Depth = 0;
+  for (const auto &Character : FullName) {
+    if (Character == '<') {
+      ++Depth;
+    } else if (Character == '>') {
+      --Depth;
+    } else if (Depth == 0) {
+      FullNameTrimmed.append(1, Character);
+    }
+  }
+
+  // This loop is taken from HasNameMatcher::matchesNodeFullSlow in
+  // clang/lib/ASTMatchers/ASTMatchersInternal.cpp and checks whether
+  // FullNameTrimmed matches any of the given Names.
+  const StringRef FullNameTrimmedRef = FullNameTrimmed;
+  for (const StringRef Pattern : Names) {
+    if (Pattern.startswith("::")) {
+      if (FullNameTrimmed == Pattern)
+        return true;
+    } else if (FullNameTrimmedRef.endswith(Pattern) &&
+               FullNameTrimmedRef.drop_back(Pattern.size()).endswith("::")) {
+      return true;
+    }
+  }
+
+  return false;
+}
+
+// Checks if the given matcher is the last argument of the given CallExpr.
+AST_MATCHER_P(CallExpr, hasLastArgument,
+              clang::ast_matchers::internal::Matcher<Expr>, InnerMatcher) {
+  if (Node.getNumArgs() == 0)
+    return false;
+
+  return InnerMatcher.matches(*Node.getArg(Node.getNumArgs() - 1), Finder,
+                              Builder);
+}
+
+// Checks if the given member call has the same number of arguments as the
+// function had parameters defined (this is useful to check if there is only one
+// variadic argument).
+AST_MATCHER(CXXMemberCallExpr, hasSameNumArgsAsDeclNumParams) {
+  if (Node.getMethodDecl()->isFunctionTemplateSpecialization())
+    return Node.getNumArgs() == Node.getMethodDecl()
+                                    ->getPrimaryTemplate()
+                                    ->getTemplatedDecl()
+                                    ->getNumParams();
+
+  return Node.getNumArgs() == Node.getMethodDecl()->getNumParams();
+}
+
 AST_MATCHER(DeclRefExpr, hasExplicitTemplateArgs) {
   return Node.hasExplicitTemplateArgs();
 }
 
 const auto DefaultContainersWithPushBack =
     "::std::vector; ::std::list; ::std::deque";
 const auto DefaultSmartPointers =
     "::std::shared_ptr; ::std::unique_ptr; ::std::auto_ptr; ::std::weak_ptr";
 const auto DefaultTupleTypes = "::std::pair; ::std::tuple";
 const auto DefaultTupleMakeFunctions = "::std::make_pair; ::std::make_tuple";
+const auto DefaultEmplacyFunctions =
+    "vector::emplace_back; vector::emplace;"
+    "deque::emplace; deque::emplace_front; deque::emplace_back;"
+    "forward_list::emplace_after; forward_list::emplace_front;"
+    "list::emplace; list::emplace_back; list::emplace_front;"
+    "set::emplace; set::emplace_hint;"
+    "map::emplace; map::emplace_hint;"
+    "multiset::emplace; multiset::emplace_hint;"
+    "multimap::emplace; multimap::emplace_hint;"
+    "unordered_set::emplace; unordered_set::emplace_hint;"
+    "unordered_map::emplace; unordered_map::emplace_hint;"
+    "unordered_multiset::emplace; unordered_multiset::emplace_hint;"
+    "unordered_multimap::emplace; unordered_multimap::emplace_hint;"
+    "stack::emplace; queue::emplace; priority_queue::emplace";
 } // namespace
 
 UseEmplaceCheck::UseEmplaceCheck(StringRef Name, ClangTidyContext *Context)
     : ClangTidyCheck(Name, Context), IgnoreImplicitConstructors(Options.get(
                                          "IgnoreImplicitConstructors", false)),
       ContainersWithPushBack(utils::options::parseStringList(Options.get(
           "ContainersWithPushBack", DefaultContainersWithPushBack))),
       SmartPointers(utils::options::parseStringList(
           Options.get("SmartPointers", DefaultSmartPointers))),
       TupleTypes(utils::options::parseStringList(
           Options.get("TupleTypes", DefaultTupleTypes))),
       TupleMakeFunctions(utils::options::parseStringList(
-          Options.get("TupleMakeFunctions", DefaultTupleMakeFunctions))) {}
+          Options.get("TupleMakeFunctions", DefaultTupleMakeFunctions))),
+      EmplacyFunctions(utils::options::parseStringList(
+          Options.get("EmplacyFunctions", DefaultEmplacyFunctions))) {}
 
 void UseEmplaceCheck::registerMatchers(MatchFinder *Finder) {
   // FIXME: Bunch of functionality that could be easily added:
   // + add handling of `push_front` for std::forward_list, std::list
   // and std::deque.
   // + add handling of `push` for std::stack, std::queue, std::priority_queue
   // + add handling of `insert` for stl associative container, but be careful
   // because this requires special treatment (it could cause performance
   // regression)
   // + match for emplace calls that should be replaced with insertion
   auto CallPushBack = cxxMemberCallExpr(
       hasDeclaration(functionDecl(hasName("push_back"))),
       on(hasType(cxxRecordDecl(hasAnyName(ContainersWithPushBack)))));
 
+  auto CallEmplacy = cxxMemberCallExpr(
+      hasDeclaration(
+          functionDecl(hasAnyNameIgnoringTemplates(EmplacyFunctions))),
+      on(hasType(cxxRecordDecl(has(typedefNameDecl(
+          hasName("value_type"), hasType(type(hasUnqualifiedDesugaredType(
+                                     recordType().bind("value_type"))))))))));
+
   // We can't replace push_backs of smart pointer because
   // if emplacement fails (f.e. bad_alloc in vector) we will have leak of
   // passed pointer because smart pointer won't be constructed
   // (and destructed) as in push_back case.
   auto IsCtorOfSmartPtr =
       hasDeclaration(cxxConstructorDecl(ofClass(hasAnyName(SmartPointers))));
 
   // Bitfields binds only to consts and emplace_back take it by universal ref.
   auto BitFieldAsArgument = hasAnyArgument(
       ignoringImplicit(memberExpr(hasDeclaration(fieldDecl(isBitField())))));
 
   // Initializer list can't be passed to universal reference.
   auto InitializerListAsArgument = hasAnyArgument(
       ignoringImplicit(cxxConstructExpr(isListInitialization())));
 
   // We could have leak of resource.
   auto NewExprAsArgument = hasAnyArgument(ignoringImplicit(cxxNewExpr()));
   // We would call another constructor.
   auto ConstructingDerived =
       hasParent(implicitCastExpr(hasCastKind(CastKind::CK_DerivedToBase)));
 
-  // emplace_back can't access private constructor.
-  auto IsPrivateCtor = hasDeclaration(cxxConstructorDecl(isPrivate()));
+  // emplace_back can't access private or protected constructors.
+  auto IsPrivateOrProtectedCtor =
+      hasDeclaration(cxxConstructorDecl(anyOf(isPrivate(), isProtected())));
 
   auto HasInitList = anyOf(has(ignoringImplicit(initListExpr())),
                            has(cxxStdInitializerListExpr()));
 
   // FIXME: Discard 0/NULL (as nullptr), static inline const data members,
   // overloaded functions and template names.
   auto SoughtConstructExpr =
       cxxConstructExpr(
           unless(anyOf(IsCtorOfSmartPtr, HasInitList, BitFieldAsArgument,
                        InitializerListAsArgument, NewExprAsArgument,
-                       ConstructingDerived, IsPrivateCtor)))
+                       ConstructingDerived, IsPrivateOrProtectedCtor)))
           .bind("ctor");
   auto HasConstructExpr = has(ignoringImplicit(SoughtConstructExpr));
 
   auto MakeTuple = ignoringImplicit(
       callExpr(callee(expr(ignoringImplicit(declRefExpr(
                    unless(hasExplicitTemplateArgs()),
                    to(functionDecl(hasAnyName(TupleMakeFunctions))))))))
           .bind("make"));
 
   // make_something can return type convertible to container's element type.
   // Allow the conversion only on containers of pairs.
   auto MakeTupleCtor = ignoringImplicit(cxxConstructExpr(
       has(materializeTemporaryExpr(MakeTuple)),
       hasDeclaration(cxxConstructorDecl(ofClass(hasAnyName(TupleTypes))))));
 
   auto SoughtParam = materializeTemporaryExpr(
-      anyOf(has(MakeTuple), has(MakeTupleCtor),
-            HasConstructExpr, has(cxxFunctionalCastExpr(HasConstructExpr))));
+      anyOf(has(MakeTuple), has(MakeTupleCtor), HasConstructExpr,
+            has(cxxFunctionalCastExpr(HasConstructExpr))));
+
+  auto HasConstructExprWithValueTypeType =
+      has(ignoringImplicit(cxxConstructExpr(
+          SoughtConstructExpr, hasType(type(hasUnqualifiedDesugaredType(
+                                   type(equalsBoundNode("value_type"))))))));
+
+  auto HasConstructExprWithValueTypeTypeAsLastArgument =
+      hasLastArgument(materializeTemporaryExpr(anyOf(
+          HasConstructExprWithValueTypeType,
+          has(cxxFunctionalCastExpr(HasConstructExprWithValueTypeType)))));
 
   Finder->addMatcher(
       traverse(TK_AsIs, cxxMemberCallExpr(CallPushBack, has(SoughtParam),
                                           unless(isInTemplateInstantiation()))
-                            .bind("call")),
+                            .bind("push_back_call")),
+      this);
+
+  Finder->addMatcher(
+      traverse(TK_AsIs,
+               cxxMemberCallExpr(
+                   CallEmplacy, HasConstructExprWithValueTypeTypeAsLastArgument,
+                   hasSameNumArgsAsDeclNumParams(),
+                   unless(isInTemplateInstantiation()))
+                   .bind("emplacy_call")),
+      this);
+
+  Finder->addMatcher(
+      traverse(
+          TK_AsIs,
+          cxxMemberCallExpr(
+              CallEmplacy,
+              on(hasType(cxxRecordDecl(has(typedefNameDecl(
+                  hasName("value_type"),
+                  hasType(type(
+                      hasUnqualifiedDesugaredType(recordType(hasDeclaration(
+                          cxxRecordDecl(hasAnyName(SmallVector<StringRef, 2>(
+                              TupleTypes.begin(), TupleTypes.end()))))))))))))),
+              has(MakeTuple), hasSameNumArgsAsDeclNumParams(),
+              unless(isInTemplateInstantiation()))
+              .bind("emplacy_call")),
       this);
 }
 
 void UseEmplaceCheck::check(const MatchFinder::MatchResult &Result) {
-  const auto *Call = Result.Nodes.getNodeAs<CXXMemberCallExpr>("call");
+  const auto *PushBackCall =
+      Result.Nodes.getNodeAs<CXXMemberCallExpr>("push_back_call");
+  const auto *EmplacyCall =
+      Result.Nodes.getNodeAs<CXXMemberCallExpr>("emplacy_call");
   const auto *CtorCall = Result.Nodes.getNodeAs<CXXConstructExpr>("ctor");
   const auto *MakeCall = Result.Nodes.getNodeAs<CallExpr>("make");
+
+  assert((PushBackCall || EmplacyCall) && "No call matched");
   assert((CtorCall || MakeCall) && "No push_back parameter matched");
 
+  const CXXMemberCallExpr *Call = PushBackCall ? PushBackCall : EmplacyCall;
+
   if (IgnoreImplicitConstructors && CtorCall && CtorCall->getNumArgs() >= 1 &&
       CtorCall->getArg(0)->getSourceRange() == CtorCall->getSourceRange())
     return;
 
   const auto FunctionNameSourceRange = CharSourceRange::getCharRange(
       Call->getExprLoc(), Call->getArg(0)->getExprLoc());
 
-  auto Diag = diag(Call->getExprLoc(), "use emplace_back instead of push_back");
+  auto Diag =
+      PushBackCall
+          ? diag(Call->getExprLoc(), "use emplace_back instead of push_back")
+          : diag(CtorCall ? CtorCall->getBeginLoc() : MakeCall->getBeginLoc(),
+                 "unnecessary temporary object created while calling " +
+                     Call->getMethodDecl()->getName().str());
 
   if (FunctionNameSourceRange.getBegin().isMacroID())
     return;
 
-  const auto *EmplacePrefix = MakeCall ? "emplace_back" : "emplace_back(";
-  Diag << FixItHint::CreateReplacement(FunctionNameSourceRange, EmplacePrefix);
+  if (PushBackCall) {
+    const char *EmplacePrefix = MakeCall ? "emplace_back" : "emplace_back(";
+    Diag << FixItHint::CreateReplacement(FunctionNameSourceRange,
+                                         EmplacePrefix);
+  }
 
   const SourceRange CallParensRange =
       MakeCall ? SourceRange(MakeCall->getCallee()->getEndLoc(),
                              MakeCall->getRParenLoc())
                : CtorCall->getParenOrBraceRange();
 
   // Finish if there is no explicit constructor call.
   if (CallParensRange.getBegin().isInvalid())
     return;
 
   const SourceLocation ExprBegin =
-      MakeCall ? MakeCall->getExprLoc() : CtorCall->getExprLoc();
+      CtorCall ? CtorCall->getExprLoc() : MakeCall->getExprLoc();
 
   // Range for constructor name and opening brace.
   const auto ParamCallSourceRange =
       CharSourceRange::getTokenRange(ExprBegin, CallParensRange.getBegin());
 
   Diag << FixItHint::CreateRemoval(ParamCallSourceRange)
        << FixItHint::CreateRemoval(CharSourceRange::getTokenRange(
               CallParensRange.getEnd(), CallParensRange.getEnd()));
+
+  if (MakeCall && EmplacyCall) {
+    // Remove extra left parenthesis
+    Diag << FixItHint::CreateRemoval(
+        CharSourceRange::getCharRange(MakeCall->getCallee()->getEndLoc(),
+                                      MakeCall->getArg(0)->getBeginLoc()));
+  }
 }
 
 void UseEmplaceCheck::storeOptions(ClangTidyOptions::OptionMap &Opts) {
   Options.store(Opts, "IgnoreImplicitConstructors", IgnoreImplicitConstructors);
   Options.store(Opts, "ContainersWithPushBack",
                 utils::options::serializeStringList(ContainersWithPushBack));
   Options.store(Opts, "SmartPointers",
                 utils::options::serializeStringList(SmartPointers));
   Options.store(Opts, "TupleTypes",
                 utils::options::serializeStringList(TupleTypes));
   Options.store(Opts, "TupleMakeFunctions",
                 utils::options::serializeStringList(TupleMakeFunctions));
+  Options.store(Opts, "EmplacyFunctions",
+                utils::options::serializeStringList(EmplacyFunctions));
 }
 
 } // namespace modernize
 } // namespace tidy
 } // namespace clang

clang-tools-extra/docs/clang-tidy/checks/modernize-use-emplace.rst

 Right now the check doesn't support ``push_front`` and ``insert``.
 It also doesn't support ``insert`` functions for associative containers
 because replacing ``insert`` with ``emplace`` may result in
 `speed regression <https://htmlpreview.github.io/?https://github.com/HowardHinnant/papers/blob/master/insert_vs_emplace.html>`_, but it might get support with some addition flag in the future.
 
 By default only ``std::vector``, ``std::deque``, ``std::list`` are considered.
 This list can be modified using the :option:`ContainersWithPushBack` option.
 
+This check also reports when an ``emplace``-like method is improperly used,
+for example using ``emplace_back`` while also calling a constructor. This
+creates a temporary that requires at best a move and at worst a copy. Almost all
+``emplace``-like functions in the STL are covered by this, with ``try_emplace``
+on ``std::map`` and ``std::unordered_map`` being the exception as it behaves
+slightly differently than all the others. More containers can be added with the
+:option:`EmplacyFunctions` option, so long as the container defines a
+``value_type`` type, and the ``emplace``-like functions construct a
+``value_type`` object.
+
 Before:
 
 .. code-block:: c++
 
     std::vector<MyClass> v;
     v.push_back(MyClass(21, 37));
+    v.emplace_back(MyClass(21, 37));
 
     std::vector<std::pair<int, int>> w;
 
     w.push_back(std::pair<int, int>(21, 37));
     w.push_back(std::make_pair(21L, 37L));
+    w.emplace_back(std::make_pair(21L, 37L));
 
 After:
 
 .. code-block:: c++
 
     std::vector<MyClass> v;
     v.emplace_back(21, 37);
+    v.emplace_back(21, 37);
 
     std::vector<std::pair<int, int>> w;
     w.emplace_back(21, 37);
     w.emplace_back(21L, 37L);
+    w.emplace_back(21L, 37L);
 
 By default, the check is able to remove unnecessary ``std::make_pair`` and
 ``std::make_tuple`` calls from ``push_back`` calls on containers of
 ``std::pair`` and ``std::tuple``. Custom tuple-like types can be modified by
 the :option:`TupleTypes` option; custom make functions can be modified by the
 :option:`TupleMakeFunctions` option.
 
 The other situation is when we pass arguments that will be converted to a type
.. option:: TupleTypes
     Semicolon-separated list of ``std::tuple``-like class names.
 
 .. option:: TupleMakeFunctions
 
     Semicolon-separated list of ``std::make_tuple``-like function names. Those
     function calls will be removed from ``push_back`` calls and turned into
     ``emplace_back``.
 
+.. option:: EmplacyFunctions
+
+    Semicolon-separated list of containers without their template parameters
+    and some ``emplace``-like method of the container. Example:
+    ``vector::emplace_back``. Those methods will be checked for improper use and
+    the check will report when a temporary is unnecessarily created.
+
 Example
 ^^^^^^^
 
 .. code-block:: c++
 
   std::vector<MyTuple<int, bool, char>> x;
   x.push_back(MakeMyTuple(1, false, 'x'));
+  x.emplace_back(MakeMyTuple(1, false, 'x'));
 
 transforms to:
 
 .. code-block:: c++
 
   std::vector<MyTuple<int, bool, char>> x;
   x.emplace_back(1, false, 'x');
+  x.emplace_back(1, false, 'x');
 
-when :option:`TupleTypes` is set to ``MyTuple`` and :option:`TupleMakeFunctions`
-is set to ``MakeMyTuple``.
+when :option:`TupleTypes` is set to ``MyTuple``, :option:`TupleMakeFunctions`
+is set to ``MakeMyTuple``, and :option:`EmplacyFunctions` is set to
+``vector::emplace_back``.

clang-tools-extra/test/clang-tidy/checkers/modernize-use-emplace.cpp

 // RUN: %check_clang_tidy %s modernize-use-emplace %t -- \
 // RUN:   -config="{CheckOptions: \
 // RUN:             [{key: modernize-use-emplace.ContainersWithPushBack, \
 // RUN:               value: '::std::vector; ::std::list; ::std::deque; llvm::LikeASmallVector'}, \
 // RUN:              {key: modernize-use-emplace.TupleTypes, \
 // RUN:               value: '::std::pair; std::tuple; ::test::Single'}, \
 // RUN:              {key: modernize-use-emplace.TupleMakeFunctions, \
 // RUN:               value: '::std::make_pair; ::std::make_tuple; ::test::MakeSingle'}] \
 // RUN:             }"
 
 namespace std {
 template <typename>
-class initializer_list
-{
+class initializer_list {
 public:
   initializer_list() noexcept {}
 };
 
+template <typename T1, typename T2>
+class pair {
+public:
+  pair() = default;
+  pair(const pair &) = default;
+  pair(pair &&) = default;
+
+  pair(const T1 &, const T2 &) {}
+  pair(T1 &&, T2 &&) {}
+
+  template <typename U1, typename U2>
+  pair(const pair<U1, U2> &){};
+  template <typename U1, typename U2>
+  pair(pair<U1, U2> &&){};
+};
+
 template <typename T>
 class vector {
 public:
+  using value_type = T;
+
+  class iterator {};
+  class const_iterator {};
+  const_iterator begin() { return const_iterator{}; }
+
   vector() = default;
   vector(initializer_list<T>) {}
 
   void push_back(const T &) {}
   void push_back(T &&) {}
 
   template <typename... Args>
   void emplace_back(Args &&... args){};
+  template <typename... Args>
+  iterator emplace(const_iterator pos, Args &&...args){};
   ~vector();
 };
+
 template <typename T>
 class list {
 public:
+  using value_type = T;
+
+  class iterator {};
+  class const_iterator {};
+  const_iterator begin() { return const_iterator{}; }
+
   void push_back(const T &) {}
   void push_back(T &&) {}
 
   template <typename... Args>
+  iterator emplace(const_iterator pos, Args &&...args){};
+  template <typename... Args>
   void emplace_back(Args &&... args){};
+  template <typename... Args>
+  void emplace_front(Args &&...args){};
   ~list();
 };
 
 template <typename T>
 class deque {
 public:
+  using value_type = T;
+
+  class iterator {};
+  class const_iterator {};
+  const_iterator begin() { return const_iterator{}; }
+
   void push_back(const T &) {}
   void push_back(T &&) {}
 
   template <typename... Args>
+  iterator emplace(const_iterator pos, Args &&...args){};
+  template <typename... Args>
   void emplace_back(Args &&... args){};
+  template <typename... Args>
+  void emplace_front(Args &&...args){};
   ~deque();
 };
 
-template <typename T> struct remove_reference { using type = T; };
-template <typename T> struct remove_reference<T &> { using type = T; };
-template <typename T> struct remove_reference<T &&> { using type = T; };
+template <typename T>
+class forward_list {
+public:
+  using value_type = T;
 
-template <typename T1, typename T2> class pair {
+  class iterator {};
+  class const_iterator {};
+  const_iterator begin() { return const_iterator{}; }
+
+  template <typename... Args>
+  void emplace_front(Args &&...args){};
+  template <typename... Args>
+  iterator emplace_after(const_iterator pos, Args &&...args){};
+};
+
+template <typename T>
+class set {
 public:
-  pair() = default;
-  pair(const pair &) = default;
-  pair(pair &&) = default;
+  using value_type = T;
 
-  pair(const T1 &, const T2 &) {}
-  pair(T1 &&, T2 &&) {}
+  class iterator {};
+  class const_iterator {};
+  const_iterator begin() { return const_iterator{}; }
+
+  template <typename... Args>
+  void emplace(Args &&...args){};
+  template <typename... Args>
+  iterator emplace_hint(const_iterator pos, Args &&...args){};
+};
+
+template <typename Key, typename T>
+class map {
+public:
+  using value_type = std::pair<Key, T>;
+
+  class iterator {};
+  class const_iterator {};
+  const_iterator begin() { return const_iterator{}; }
+
+  template <typename... Args>
+  void emplace(Args &&...args){};
+  template <typename... Args>
+  iterator emplace_hint(const_iterator pos, Args &&...args){};
+};
 
-  template <typename U1, typename U2> pair(const pair<U1, U2> &){};
-  template <typename U1, typename U2> pair(pair<U1, U2> &&){};
+template <typename T>
+class multiset {
+public:
+  using value_type = T;
+
+  class iterator {};
+  class const_iterator {};
+  const_iterator begin() { return const_iterator{}; }
+
+  template <typename... Args>
+  void emplace(Args &&...args){};
+  template <typename... Args>
+  iterator emplace_hint(const_iterator pos, Args &&...args){};
 };
 
+template <typename Key, typename T>
+class multimap {
+public:
+  using value_type = std::pair<Key, T>;
+
+  class iterator {};
+  class const_iterator {};
+  const_iterator begin() { return const_iterator{}; }
+
+  template <typename... Args>
+  void emplace(Args &&...args){};
+  template <typename... Args>
+  iterator emplace_hint(const_iterator pos, Args &&...args){};
+};
+
+template <typename T>
+class unordered_set {
+public:
+  using value_type = T;
+
+  class iterator {};
+  class const_iterator {};
+  const_iterator begin() { return const_iterator{}; }
+
+  template <typename... Args>
+  void emplace(Args &&...args){};
+  template <typename... Args>
+  iterator emplace_hint(const_iterator pos, Args &&...args){};
+};
+
+template <typename Key, typename T>
+class unordered_map {
+public:
+  using value_type = std::pair<Key, T>;
+
+  class iterator {};
+  class const_iterator {};
+  const_iterator begin() { return const_iterator{}; }
+
+  template <typename... Args>
+  void emplace(Args &&...args){};
+  template <typename... Args>
+  iterator emplace_hint(const_iterator pos, Args &&...args){};
+};
+
+template <typename T>
+class unordered_multiset {
+public:
+  using value_type = T;
+
+  class iterator {};
+  class const_iterator {};
+  const_iterator begin() { return const_iterator{}; }
+
+  template <typename... Args>
+  void emplace(Args &&...args){};
+  template <typename... Args>
+  iterator emplace_hint(const_iterator pos, Args &&...args){};
+};
+
+template <typename Key, typename T>
+class unordered_multimap {
+public:
+  using value_type = std::pair<Key, T>;
+
+  class iterator {};
+  class const_iterator {};
+  const_iterator begin() { return const_iterator{}; }
+
+  template <typename... Args>
+  void emplace(Args &&...args){};
+  template <typename... Args>
+  iterator emplace_hint(const_iterator pos, Args &&...args){};
+};
+
+template <typename T>
+class stack {
+public:
+  using value_type = T;
+
+  template <typename... Args>
+  void emplace(Args &&...args){};
+};
+
+template <typename T>
+class queue {
+public:
+  using value_type = T;
+
+  template <typename... Args>
+  void emplace(Args &&...args){};
+};
+
+template <typename T>
+class priority_queue {
+public:
+  using value_type = T;
+
+  template <typename... Args>
+  void emplace(Args &&...args){};
+};
+
+template <typename T>
+struct remove_reference { using type = T; };
+template <typename T>
+struct remove_reference<T &> { using type = T; };
+template <typename T>
+struct remove_reference<T &&> { using type = T; };
+
 template <typename T1, typename T2>
 pair<typename remove_reference<T1>::type, typename remove_reference<T2>::type>
 make_pair(T1 &&, T2 &&) {
   return {};
 };
 
-template <typename... Ts> class tuple {
+template <typename... Ts>
+class tuple {
 public:
   tuple() = default;
   tuple(const tuple &) = default;
   tuple(tuple &&) = default;
 
   tuple(const Ts &...) {}
   tuple(Ts &&...) {}
 
-  template <typename... Us> tuple(const tuple<Us...> &){};
-  template <typename... Us> tuple(tuple<Us...> &&) {}
+  template <typename... Us>
+  tuple(const tuple<Us...> &){};
+  template <typename... Us>
+  tuple(tuple<Us...> &&) {}
 
-  template <typename U1, typename U2> tuple(const pair<U1, U2> &) {
+  template <typename U1, typename U2>
+  tuple(const pair<U1, U2> &) {
     static_assert(sizeof...(Ts) == 2, "Wrong tuple size");
   };
-  template <typename U1, typename U2> tuple(pair<U1, U2> &&) {
+  template <typename U1, typename U2>
+  tuple(pair<U1, U2> &&) {
     static_assert(sizeof...(Ts) == 2, "Wrong tuple size");
   };
 };
 
 template <typename... Ts>
 tuple<typename remove_reference<Ts>::type...> make_tuple(Ts &&...) {
   return {};
 }

 public:
   void push_back(const T &) {}
   void push_back(T &&) {}
 
   template <typename... Args>
   void emplace_back(Args &&... args){};
 };
 
-} // llvm
+} // namespace llvm
 
 void testInts() {
   std::vector<int> v;
   v.push_back(42);
   v.push_back(int(42));
   v.push_back(int{42});
   v.push_back(42.0);
   int z;
void testMakePair() {
   };
   std::vector<X> x;
   x.push_back(std::make_pair(1, 2));
   // CHECK-MESSAGES: :[[@LINE-1]]:5: warning: use emplace_back
   // CHECK-FIXES: x.emplace_back(std::make_pair(1, 2));
   // make_pair cannot be removed here, as X is not constructible with two ints.
 
   struct Y {
-    Y(std::pair<int, int>&&) {}
+    Y(std::pair<int, int> &&) {}
   };
   std::vector<Y> y;
   y.push_back(std::make_pair(2, 3));
   // CHECK-MESSAGES: :[[@LINE-1]]:5: warning: use emplace_back
   // CHECK-FIXES: y.emplace_back(std::make_pair(2, 3));
   // make_pair cannot be removed here, as Y is not constructible with two ints.
 }
 
void testMakeTuple() {
   v.push_back(std::make_tuple<long long, int, int>(3LL, 1, 0));
   // CHECK-MESSAGES: :[[@LINE-1]]:5: warning: use emplace_back
   // CHECK-FIXES: v.emplace_back(std::make_tuple<long long, int, int>(3LL, 1, 0));
   // make_tuple is not removed when there are explicit template
   // arguments provided.
 }
 
 namespace test {
-template <typename T> struct Single {
+template <typename T>
+struct Single {
   Single() = default;
   Single(const Single &) = default;
   Single(Single &&) = default;
 
   Single(const T &) {}
   Single(T &&) {}
 
-  template <typename U> Single(const Single<U> &) {}
-  template <typename U> Single(Single<U> &&) {}
-
-  template <typename U> Single(const std::tuple<U> &) {}
-  template <typename U> Single(std::tuple<U> &&) {}
+  template <typename U>
+  Single(const Single<U> &) {}
+  template <typename U>
+  Single(Single<U> &&) {}
+
+  template <typename U>
+  Single(const std::tuple<U> &) {}
+  template <typename U>
+  Single(std::tuple<U> &&) {}
 };
 
 template <typename T>
 Single<typename std::remove_reference<T>::type> MakeSingle(T &&) {
   return {};
 }
 } // namespace test
 
void testInitializerList() {
 
   v.push_back({{2}});
 
   using PairIntVector = std::pair<int, std::vector<int>>;
   std::vector<PairIntVector> x;
   x.push_back(PairIntVector(3, {4}));
   x.push_back({5, {6}});
 }
+
+class Foo {
+public:
+  Foo(){};
+  Foo(int){};
+  Foo(int, int){};
+  Foo(std::pair<int, int>){};
+
+protected:
+  Foo(char *) : Foo(){};
+};
+
+void testSomeEmplaceCases() {
+  std::vector<std::pair<char *, char *>> v1;
+  std::vector<Foo> v2;
+  std::unordered_map<int, char *> m1;
+
+  v1.emplace_back(std::make_pair("foo", "bar"));
+  // CHECK-MESSAGES: :[[@LINE-1]]:19: warning: unnecessary temporary object created while calling emplace_back
+  // CHECK-FIXES: v1.emplace_back("foo", "bar");
+
+  char *foo = "bar";
+  v1.emplace_back(std::make_pair(foo, "bar"));
+  // CHECK-MESSAGES: :[[@LINE-1]]:19: warning: unnecessary temporary object created while calling emplace_back
+  // CHECK-FIXES: v1.emplace_back(foo, "bar");
+
+  v1.emplace(v1.begin(), std::make_pair("foo", "bar"));
+  // CHECK-MESSAGES: :[[@LINE-1]]:26: warning: unnecessary temporary object created while calling emplace
+  // CHECK-FIXES: v1.emplace(v1.begin(), "foo", "bar");
+
+  v2.emplace_back(Foo());
+  // CHECK-MESSAGES: :[[@LINE-1]]:19: warning: unnecessary temporary object created while calling emplace_back
+  // CHECK-FIXES: v2.emplace_back();
+
+  v2.emplace_back(Foo(13));
+  // CHECK-MESSAGES: :[[@LINE-1]]:19: warning: unnecessary temporary object created while calling emplace_back
+  // CHECK-FIXES: v2.emplace_back(13);
+
+  v2.emplace_back(Foo{13});
+  // CHECK-MESSAGES: :[[@LINE-1]]:19: warning: unnecessary temporary object created while calling emplace_back
+  // CHECK-FIXES: v2.emplace_back(13);
+
+  int a = 31;
+  v2.emplace_back(Foo(13, a));
+  // CHECK-MESSAGES: :[[@LINE-1]]:19: warning: unnecessary temporary object created while calling emplace_back
+  // CHECK-FIXES: v2.emplace_back(13, a);
+
+  v2.emplace_back(std::make_pair(3, 3));
+
+  m1.emplace(std::make_pair(13, "foo"));
+  // CHECK-MESSAGES: :[[@LINE-1]]:14: warning: unnecessary temporary object created while calling emplace
+  // CHECK-FIXES: m1.emplace(13, "foo");
+
+  std::vector<std::pair<int, int>> v3;
+  v3.emplace_back(std::pair<int, int>(13, 71));
+  // CHECK-MESSAGES: :[[@LINE-1]]:19: warning: unnecessary temporary object created while calling emplace_back
+  v3.emplace_back(std::make_pair(13, 71));
+  // CHECK-MESSAGES: :[[@LINE-1]]:19: warning: unnecessary temporary object created while calling emplace_back
+
+  std::vector<std::tuple<int, int, int>> v4;
+  v4.emplace_back(std::tuple<int, int, int>(13, 31, 71));
+  // CHECK-MESSAGES: :[[@LINE-1]]:19: warning: unnecessary temporary object created while calling emplace_back
+  v4.emplace_back(std::make_tuple(13, 31, 71));
+  // CHECK-MESSAGES: :[[@LINE-1]]:19: warning: unnecessary temporary object created while calling emplace_back
+
+  std::vector<test::Single<int>> v5;
+  v5.emplace_back(test::Single<int>(13));
+  // CHECK-MESSAGES: :[[@LINE-1]]:19: warning: unnecessary temporary object created while calling emplace_back
+  v5.emplace_back(test::MakeSingle(13));
+  // CHECK-MESSAGES: :[[@LINE-1]]:19: warning: unnecessary temporary object created while calling emplace_back
+}
+
+void testAllSTLEmplacyFunctions() {
+  std::vector<Foo> vector;
+  std::deque<Foo> deque;
+  std::forward_list<Foo> forward_list;
+  std::list<Foo> list;
+  std::set<Foo> set;
+  std::map<int, Foo> map;
+  std::multiset<Foo> multiset;
+  std::multimap<int, Foo> multimap;
+  std::unordered_set<Foo> unordered_set;
+  std::unordered_map<int, Foo> unordered_map;
+  std::unordered_multiset<Foo> unordered_multiset;
+  std::unordered_multimap<int, Foo> unordered_multimap;
+  std::stack<Foo> stack;
+  std::queue<Foo> queue;
+  std::priority_queue<Foo> priority_queue;
+
+  vector.emplace_back(Foo(13));
+  // CHECK-MESSAGES: :[[@LINE-1]]:23: warning: unnecessary temporary object created while calling emplace_back
+  // CHECK-FIXES: vector.emplace_back(13);
+
+  vector.emplace(vector.begin(), Foo(13));
+  // CHECK-MESSAGES: :[[@LINE-1]]:34: warning: unnecessary temporary object created while calling emplace
+  // CHECK-FIXES: vector.emplace(vector.begin(), 13);
+
+  deque.emplace(deque.begin(), Foo(13));
+  // CHECK-MESSAGES: :[[@LINE-1]]:32: warning: unnecessary temporary object created while calling emplace
+  // CHECK-FIXES: deque.emplace(deque.begin(), 13);
+
+  deque.emplace_front(Foo(13));
+  // CHECK-MESSAGES: :[[@LINE-1]]:23: warning: unnecessary temporary object created while calling emplace_front
+  // CHECK-FIXES: deque.emplace_front(13);
+
+  deque.emplace_back(Foo(13));
+  // CHECK-MESSAGES: :[[@LINE-1]]:22: warning: unnecessary temporary object created while calling emplace_back
+  // CHECK-FIXES: deque.emplace_back(13);
+
+  forward_list.emplace_after(forward_list.begin(), Foo(13));
+  // CHECK-MESSAGES: :[[@LINE-1]]:52: warning: unnecessary temporary object created while calling emplace_after
+  // CHECK-FIXES: forward_list.emplace_after(forward_list.begin(), 13);
+
+  forward_list.emplace_front(Foo(13));
+  // CHECK-MESSAGES: :[[@LINE-1]]:30: warning: unnecessary temporary object created while calling emplace_front
+  // CHECK-FIXES: forward_list.emplace_front(13);
+
+  list.emplace(list.begin(), Foo(13));
+  // CHECK-MESSAGES: :[[@LINE-1]]:30: warning: unnecessary temporary object created while calling emplace
+  // CHECK-FIXES: list.emplace(list.begin(), 13);
+
+  list.emplace_back(Foo(13));
+  // CHECK-MESSAGES: :[[@LINE-1]]:21: warning: unnecessary temporary object created while calling emplace_back
+  // CHECK-FIXES: list.emplace_back(13);
+
+  list.emplace_front(Foo(13));
+  // CHECK-MESSAGES: :[[@LINE-1]]:22: warning: unnecessary temporary object created while calling emplace_front
+  // CHECK-FIXES: list.emplace_front(13);
+
+  set.emplace(Foo(13));
+  // CHECK-MESSAGES: :[[@LINE-1]]:15: warning: unnecessary temporary object created while calling emplace
+  // CHECK-FIXES: set.emplace(13);
+
+  set.emplace_hint(set.begin(), Foo(13));
+  // CHECK-MESSAGES: :[[@LINE-1]]:33: warning: unnecessary temporary object created while calling emplace_hint
+  // CHECK-FIXES: set.emplace_hint(set.begin(), 13);
+
+  map.emplace(std::make_pair(13, Foo(13)));
+  // CHECK-MESSAGES: :[[@LINE-1]]:15: warning: unnecessary temporary object created while calling emplace
+  // CHECK-FIXES: map.emplace(13, Foo(13));
+
+  map.emplace_hint(map.begin(), std::make_pair(13, Foo(13)));
+  // CHECK-MESSAGES: :[[@LINE-1]]:33: warning: unnecessary temporary object created while calling emplace_hint
+  // CHECK-FIXES: map.emplace_hint(map.begin(), 13, Foo(13));
+
+  multiset.emplace(Foo(13));
+  // CHECK-MESSAGES: :[[@LINE-1]]:20: warning: unnecessary temporary object created while calling emplace
+  // CHECK-FIXES: multiset.emplace(13);
+
+  multiset.emplace_hint(multiset.begin(), Foo(13));
+  // CHECK-MESSAGES: :[[@LINE-1]]:43: warning: unnecessary temporary object created while calling emplace_hint
+  // CHECK-FIXES: multiset.emplace_hint(multiset.begin(), 13);
+
+  multimap.emplace(std::make_pair(13, Foo(13)));
+  // CHECK-MESSAGES: :[[@LINE-1]]:20: warning: unnecessary temporary object created while calling emplace
+  // CHECK-FIXES: multimap.emplace(13, Foo(13));
+
+  multimap.emplace_hint(multimap.begin(), std::make_pair(13, Foo(13)));
+  // CHECK-MESSAGES: :[[@LINE-1]]:43: warning: unnecessary temporary object created while calling emplace_hint
+  // CHECK-FIXES: multimap.emplace_hint(multimap.begin(), 13, Foo(13));
+
+  unordered_set.emplace(Foo(13));
+  // CHECK-MESSAGES: :[[@LINE-1]]:25: warning: unnecessary temporary object created while calling emplace
+  // CHECK-FIXES: unordered_set.emplace(13);
+
+  unordered_set.emplace_hint(unordered_set.begin(), Foo(13));
+  // CHECK-MESSAGES: :[[@LINE-1]]:53: warning: unnecessary temporary object created while calling emplace_hint
+  // CHECK-FIXES: unordered_set.emplace_hint(unordered_set.begin(), 13);
+
+  unordered_map.emplace(std::make_pair(13, Foo(13)));
+  // CHECK-MESSAGES: :[[@LINE-1]]:25: warning: unnecessary temporary object created while calling emplace
+  // CHECK-FIXES: unordered_map.emplace(13, Foo(13));
+
+  unordered_map.emplace_hint(unordered_map.begin(), std::make_pair(13, Foo(13)));
+  // CHECK-MESSAGES: :[[@LINE-1]]:53: warning: unnecessary temporary object created while calling emplace_hint
+  // CHECK-FIXES: unordered_map.emplace_hint(unordered_map.begin(), 13, Foo(13));
+
+  unordered_multiset.emplace(Foo(13));
+  // CHECK-MESSAGES: :[[@LINE-1]]:30: warning: unnecessary temporary object created while calling emplace
+  // CHECK-FIXES: unordered_multiset.emplace(13);
+  unordered_multiset.emplace_hint(unordered_multiset.begin(), Foo(13));
+  // CHECK-MESSAGES: :[[@LINE-1]]:63: warning: unnecessary temporary object created while calling emplace_hint
+  // CHECK-FIXES: unordered_multiset.emplace_hint(unordered_multiset.begin(), 13);
+
+  unordered_multimap.emplace(std::make_pair(13, Foo(13)));
+  // CHECK-MESSAGES: :[[@LINE-1]]:30: warning: unnecessary temporary object created while calling emplace
+  // CHECK-FIXES: unordered_multimap.emplace(13, Foo(13));
+  unordered_multimap.emplace_hint(unordered_multimap.begin(), std::make_pair(13, Foo(13)));
+  // CHECK-MESSAGES: :[[@LINE-1]]:63: warning: unnecessary temporary object created while calling emplace_hint
+  // CHECK-FIXES: unordered_multimap.emplace_hint(unordered_multimap.begin(), 13, Foo(13));
+
+  stack.emplace(Foo(13));
+  // CHECK-MESSAGES: :[[@LINE-1]]:17: warning: unnecessary temporary object created while calling emplace
+  // CHECK-FIXES: stack.emplace(13);
+
+  queue.emplace(Foo(13));
+  // CHECK-MESSAGES: :[[@LINE-1]]:17: warning: unnecessary temporary object created while calling emplace
+  // CHECK-FIXES: queue.emplace(13);
+
+  priority_queue.emplace(Foo(13));
+  // CHECK-MESSAGES: :[[@LINE-1]]:26: warning: unnecessary temporary object created while calling emplace
+  // CHECK-FIXES: priority_queue.emplace(13);
+}
+
+struct Bar {
+public:
+  Bar(){};
+  void testWithPrivateAndProtectedCtor() {
+    std::vector<Bar> vec;
+
+    vec.emplace_back(Bar(13));
+    vec.emplace_back(Bar(13, 13));
+  }
+
+protected:
+  Bar(int){};
+
+private:
+  Bar(int, int){};
+};
+
+void testPossibleFalsePositives() {
+  struct Y {
+    Y(std::pair<int, int> &&) {}
+  };
+  std::vector<Y> y;
+  y.emplace_back(std::make_pair(2, 3));
+
+  std::vector<std::pair<int, int>> v;
+  v.emplace_back(std::make_pair<char, char>(0, 3));
+
+  struct D {
+    D(...) {}
+    operator char() const { return 0; }
+  };
+  v.emplace_back(std::make_pair<D, int>(Something(), 2));
+}