[clang-tidy] Add <utility> include to misc-uniqueptr-reset-release

[njames93]

Summary

This is the only remaining check that creates std::move includes but doesn't add a <utility> include.

[Eugene.Zelenko]

clang-tools-extra/clang-tidy/misc/UniqueptrResetReleaseCheck.cpp

22

I think it'll be reasonable to try to get default from .clang-format. Same in other checks.

[njames93]

clang-tools-extra/clang-tidy/misc/UniqueptrResetReleaseCheck.cpp

22

There isn't a nice way to get the default from .clang-format as the FormatStyle doesn't have a nice field that says if llvm or google style is used(because it's more flexible than that). Besides that, If there is a .clang-format config. clang-tidy will reformat all changes using that style, which in turn would reorder any added includes even if they were of the wrong style.

[njames93]

Rebase.

[njames93]

Ping

[aaron.ballman]

LGTM, thanks!

[njames93]

Add store options method.

clang-tools-extra/clang-tidy/misc/UniqueptrResetReleaseCheck.h

 //===--- UniqueptrResetReleaseCheck.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_MISC_UNIQUEPTRRESETRELEASECHECK_H
 #define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_UNIQUEPTRRESETRELEASECHECK_H
 
 #include "../ClangTidyCheck.h"
+#include "../utils/IncludeInserter.h"
 
 namespace clang {
 namespace tidy {
 namespace misc {
 
 /// Find and replace `unique_ptr::reset(release())` with `std::move()`.
 ///
 /// Example:
 ///
 /// \code
 ///   std::unique_ptr<Foo> x, y;
 ///   x.reset(y.release()); -> x = std::move(y);
 /// \endcode
 ///
 /// If `y` is already rvalue, `std::move()` is not added.  `x` and `y` can also
 /// be `std::unique_ptr<Foo>*`.
 class UniqueptrResetReleaseCheck : public ClangTidyCheck {
 public:
-  UniqueptrResetReleaseCheck(StringRef Name, ClangTidyContext *Context)
-      : ClangTidyCheck(Name, Context) {}
+  UniqueptrResetReleaseCheck(StringRef Name, ClangTidyContext *Context);
 
   bool isLanguageVersionSupported(const LangOptions &LangOpts) const override {
     // Only register the matchers for C++11; the functionality currently does
     // not
     // provide any benefit to other languages, despite being benign.
     return LangOpts.CPlusPlus11;
   }
+  void registerPPCallbacks(const SourceManager &SM, Preprocessor *PP,
+                           Preprocessor *ModuleExpanderPP) override;
   void registerMatchers(ast_matchers::MatchFinder *Finder) override;
   void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
+  void storeOptions(ClangTidyOptions::OptionMap &Opts) override;
+
+private:
+  utils::IncludeInserter Inserter;
 };
 
 } // namespace misc
 } // namespace tidy
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_UNIQUEPTRRESETRELEASECHECK_H

clang-tools-extra/clang-tidy/misc/UniqueptrResetReleaseCheck.cpp

 #include "clang/Lex/Lexer.h"
 
 using namespace clang::ast_matchers;
 
 namespace clang {
 namespace tidy {
 namespace misc {
 
+UniqueptrResetReleaseCheck::UniqueptrResetReleaseCheck(
+    StringRef Name, ClangTidyContext *Context)
+    : ClangTidyCheck(Name, Context),
+      Inserter(Options.getLocalOrGlobal("IncludeStyle",
+                                        utils::IncludeSorter::IS_LLVM)) {}
+
+void UniqueptrResetReleaseCheck::storeOptions(
+    ClangTidyOptions::OptionMap &Opts) {
+  Options.store(Opts, "IncludeStyle", Inserter.getStyle());
+}
+
+void UniqueptrResetReleaseCheck::registerPPCallbacks(
+    const SourceManager &SM, Preprocessor *PP, Preprocessor *ModuleExpanderPP) {
+  Inserter.registerPreprocessor(PP);
+}
+
 void UniqueptrResetReleaseCheck::registerMatchers(MatchFinder *Finder) {
   Finder->addMatcher(
       cxxMemberCallExpr(
           callee(memberExpr(
                      member(cxxMethodDecl(
                          hasName("reset"),
                          ofClass(cxxRecordDecl(hasName("::std::unique_ptr"),
                                                decl().bind("left_class"))))))
void UniqueptrResetReleaseCheck::check(const MatchFinder::MatchResult &Result) {
   const auto *ReleaseMember =
       Result.Nodes.getNodeAs<MemberExpr>("release_member");
   const auto *Right = Result.Nodes.getNodeAs<Expr>("right");
   const auto *ResetCall =
       Result.Nodes.getNodeAs<CXXMemberCallExpr>("reset_call");
 
   StringRef AssignmentText = " = ";
   StringRef TrailingText = "";
+  bool NeedsUtilityInclude = false;
   if (ReleaseMember->isArrow()) {
     AssignmentText = " = std::move(*";
     TrailingText = ")";
+    NeedsUtilityInclude = true;
   } else if (!Right->isRValue()) {
     AssignmentText = " = std::move(";
     TrailingText = ")";
+    NeedsUtilityInclude = true;
   }
 
   auto D = diag(ResetMember->getExprLoc(),
                 "prefer 'unique_ptr<>' assignment over 'release' and 'reset'");
   if (ResetMember->isArrow())
     D << FixItHint::CreateInsertion(ResetMember->getBeginLoc(), "*");
   D << FixItHint::CreateReplacement(
            CharSourceRange::getCharRange(ResetMember->getOperatorLoc(),
                                          Right->getBeginLoc()),
            AssignmentText)
     << FixItHint::CreateReplacement(
            CharSourceRange::getTokenRange(ReleaseMember->getOperatorLoc(),
                                           ResetCall->getEndLoc()),
            TrailingText);
+  if (NeedsUtilityInclude)
+    D << Inserter.createIncludeInsertion(
+        Result.SourceManager->getFileID(ResetMember->getBeginLoc()),
+        "<utility>");
 }
-
 } // namespace misc
 } // namespace tidy
 } // namespace clang

clang-tools-extra/docs/clang-tidy/checks/misc-uniqueptr-reset-release.rst

 .. title:: clang-tidy - misc-uniqueptr-reset-release
 
 misc-uniqueptr-reset-release
 ============================
 
 Find and replace ``unique_ptr::reset(release())`` with ``std::move()``.
 
 Example:
 
 .. code-block:: c++
 
   std::unique_ptr<Foo> x, y;
   x.reset(y.release()); -> x = std::move(y);
 
 If ``y`` is already rvalue, ``std::move()`` is not added. ``x`` and ``y`` can
 also be ``std::unique_ptr<Foo>*``.
+
+Options
+-------
+
+.. option:: IncludeStyle
+
+   A string specifying which include-style is used, `llvm` or `google`. Default
+   is `llvm`.

clang-tools-extra/test/clang-tidy/checkers/misc-uniqueptr-reset-release.cpp

 // RUN: %check_clang_tidy %s misc-uniqueptr-reset-release %t
 
+// CHECK-FIXES: #include <utility>
+
 namespace std {
 
 template <typename T>
 struct default_delete {};
 
 template <typename T, class Deleter = std::default_delete<T>>
 struct unique_ptr {
   unique_ptr();