[LibTooling] Add Explanation parameter to `makeRule`.

[ymandel]

Summary

Conceptually, a single-case RewriteRule has a matcher, edit(s) and an (optional)
explanation. makeRule previously only took the matcher and edit(s). This
change adds (optional) support for the explanation.

[ilya-biryukov]

LGTM. Much nicer now!

clang/include/clang/Tooling/Refactoring/Transformer.h

struct RewriteRule {
 
   // ID used as the default target of each match. The node described by the
   // matcher is should always be bound to this id.
   static constexpr llvm::StringLiteral RootID = "___root___";
 };
 
 /// Convenience function for constructing a simple \c RewriteRule.
 RewriteRule makeRule(ast_matchers::internal::DynTypedMatcher M,
-                     SmallVector<ASTEdit, 1> Edits);
+                     SmallVector<ASTEdit, 1> Edits,
+                     TextGenerator Explanation = nullptr);
 
 /// Convenience overload of \c makeRule for common case of only one edit.
 inline RewriteRule makeRule(ast_matchers::internal::DynTypedMatcher M,
-                            ASTEdit Edit) {
+                            ASTEdit Edit,
+                            TextGenerator Explanation = nullptr) {
   SmallVector<ASTEdit, 1> Edits;
   Edits.emplace_back(std::move(Edit));
-  return makeRule(std::move(M), std::move(Edits));
+  return makeRule(std::move(M), std::move(Edits), std::move(Explanation));
 }
 
 /// Applies the first rule whose pattern matches; other rules are ignored.
 ///
 /// N.B. All of the rules must use the same kind of matcher (that is, share a
 /// base class in the AST hierarchy).  However, this constraint is caused by an
 /// implementation detail and should be lifted in the future.
 //

clang/lib/Tooling/Refactoring/Transformer.cpp

 
 ASTEdit tooling::change(RangeSelector S, TextGenerator Replacement) {
   ASTEdit E;
   E.TargetRange = std::move(S);
   E.Replacement = std::move(Replacement);
   return E;
 }
 
-RewriteRule tooling::makeRule(DynTypedMatcher M,
-                              SmallVector<ASTEdit, 1> Edits) {
-  return RewriteRule{
-      {RewriteRule::Case{std::move(M), std::move(Edits), nullptr}}};
+RewriteRule tooling::makeRule(DynTypedMatcher M, SmallVector<ASTEdit, 1> Edits,
+                              TextGenerator Explanation) {
+  return RewriteRule{{RewriteRule::Case{std::move(M), std::move(Edits),
+                                        std::move(Explanation)}}};
 }
 
 // Determines whether A is a base type of B in the class hierarchy, including
 // the implicit relationship of Type and QualType.
 static bool isBaseOf(ASTNodeKind A, ASTNodeKind B) {
   static auto TypeKind = ASTNodeKind::getFromNodeKind<Type>();
   static auto QualKind = ASTNodeKind::getFromNodeKind<QualType>();
   /// Mimic the implicit conversions of Matcher<>.

clang/unittests/Tooling/TransformerTest.cpp

static RewriteRule ruleStrlenSize() {
   StringRef StringExpr = "strexpr";
   auto StringType = namedDecl(hasAnyName("::basic_string", "::string"));
   auto R = makeRule(
       callExpr(callee(functionDecl(hasName("strlen"))),
                hasArgument(0, cxxMemberCallExpr(
                                   on(expr(hasType(isOrPointsTo(StringType)))
                                          .bind(StringExpr)),
                                   callee(cxxMethodDecl(hasName("c_str")))))),
-      change(text("REPLACED")));
-  R.Cases[0].Explanation = text("Use size() method directly on string.");
+      change(text("REPLACED")), text("Use size() method directly on string."));
   return R;
 }
 
 TEST_F(TransformerTest, StrlenSize) {
   std::string Input = "int f(string s) { return strlen(s.c_str()); }";
   std::string Expected = "int f(string s) { return REPLACED; }";
   testRule(ruleStrlenSize(), Input, Expected);
 }