[clang-tidy] Fixed a std::bind() transformation

[oleg.smolsky]

Summary

There was an extra semicolon that was somehow working in some contexts.

[JonasToth]

LGTM, was there a bug report for that issue?

[oleg.smolsky]

:) I thought it would be more productive to post a fix than file a bug.

[JonasToth]

Definitly! I just asked because it would be better to mention it in the message ;)
Do you have commit rights?

[oleg.smolsky]

Jonas, could you commit the fix please? (I don't have the rights)

[JonasToth]

@oleg.smolsky I can commit for you. Please note, that LLVM changed its license recently and this patch will land under the new license.
Please confirm that this is ok for you (more info on the license see https://llvm.org/docs/DeveloperPolicy.html#relicensing). I will wait so long :)

[oleg.smolsky]

Sure, I'm OK with the license change. Please go ahead and commit the fix.

[JonasToth]

Landed in rL353389. Thank you for the patch!

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

bool HasCapturedArgument = llvm::any_of(
       Args, [](const BindArgument &B) { return B.Kind == BK_Other; });
   const auto *Ref = Result.Nodes.getNodeAs<DeclRefExpr>("ref");
   Stream << "[" << (HasCapturedArgument ? "=" : "") << "]";
   addPlaceholderArgs(Args, Stream);
   Stream << " { return ";
   Ref->printPretty(Stream, nullptr, Result.Context->getPrintingPolicy());
   Stream << "(";
   addFunctionCallArgs(Args, Stream);
-  Stream << "); };";
+  Stream << "); }";
 
   Diag << FixItHint::CreateReplacement(MatchedDecl->getSourceRange(),
                                        Stream.str());
 }
 
 } // namespace modernize
 } // namespace tidy
 } // namespace clang

clang-tools-extra/test/clang-tidy/modernize-avoid-bind.cpp

namespace C {
   int add(int x, int y){ return x + y; }
 }
 
 void n() {
   auto clj = std::bind(C::add, 1, 1);
   // CHECK-MESSAGES: :[[@LINE-1]]:14: warning: prefer a lambda to std::bind
   // CHECK-FIXES: auto clj = [] { return C::add(1, 1); };
 }
+
+// Let's fake a minimal std::function-like facility.
+namespace std {
+template <typename _Tp>
+_Tp declval();
+
+template <typename _Functor, typename... _ArgTypes>
+struct __res {
+  template <typename... _Args>
+  static decltype(declval<_Functor>()(_Args()...)) _S_test(int);
+
+  template <typename...>
+  static void _S_test(...);
+
+  using type = decltype(_S_test<_ArgTypes...>(0));
+};
+
+template <typename>
+struct function;
+
+template <typename... _ArgTypes>
+struct function<void(_ArgTypes...)> {
+  template <typename _Functor,
+            typename = typename __res<_Functor, _ArgTypes...>::type>
+  function(_Functor) {}
+};
+} // namespace std
+
+struct Thing {};
+void UseThing(Thing *);
+
+struct Callback {
+  Callback();
+  Callback(std::function<void()>);
+  void Reset(std::function<void()>);
+};
+
+void test(Thing *t) {
+  Callback cb;
+  if (t)
+    cb.Reset(std::bind(UseThing, t));
+  // CHECK-MESSAGES: :[[@LINE-1]]:14: warning: prefer a lambda to std::bind
+  // CHECK-FIXES: cb.Reset([=] { return UseThing(t); });
+}