[clang][transformer] Fix crash on replacement-less ASTEdit.

[courbet]

Summary

Given that we provide an EditGenerator edit(ASTEdit), we can't ever be
sure that the user won't give us an empty replacement.

clang-tools-extra/unittests/clang-tidy/TransformerClangTidyCheckTest.cpp

TEST(TransformerClangTidyCheckTest, DiagnosticsCorrectlyGenerated) {
   EXPECT_EQ(Errors.size(), 1U);
   EXPECT_EQ(Errors[0].Message.Message, "message");
   EXPECT_THAT(Errors[0].Message.Ranges, testing::IsEmpty());
 
   // The diagnostic is anchored to the match, "return 5".
   EXPECT_EQ(Errors[0].Message.FileOffset, 10U);
 }
 
+transformer::ASTEdit noReplacementEdit(transformer::RangeSelector Target) {
+  transformer::ASTEdit E;
+  E.TargetRange = std::move(Target);
+  return E;
+}
+
+TEST(TransformerClangTidyCheckTest, EmptyReplacement) {
+  class DiagOnlyCheck : public TransformerClangTidyCheck {
+  public:
+    DiagOnlyCheck(StringRef Name, ClangTidyContext *Context)
+        : TransformerClangTidyCheck(
+              makeRule(returnStmt(), edit(noReplacementEdit(node(RootID))),
+                       cat("message")),
+              Name, Context) {}
+  };
+  std::string Input = "int h() { return 5; }";
+  std::vector<ClangTidyError> Errors;
+  EXPECT_EQ("int h() { }", test::runCheckOnCode<DiagOnlyCheck>(Input, &Errors));
+  EXPECT_EQ(Errors.size(), 1U);
+  EXPECT_EQ(Errors[0].Message.Message, "message");
+  EXPECT_THAT(Errors[0].Message.Ranges, testing::IsEmpty());
+
+  // The diagnostic is anchored to the match, "return 5".
+  EXPECT_EQ(Errors[0].Message.FileOffset, 10U);
+}
+
 TEST(TransformerClangTidyCheckTest, DiagnosticMessageEscaped) {
   class GiveDiagWithPercentSymbol : public TransformerClangTidyCheck {
   public:
     GiveDiagWithPercentSymbol(StringRef Name, ClangTidyContext *Context)
         : TransformerClangTidyCheck(makeRule(returnStmt(),
                                              noopEdit(node(RootID)),
                                              cat("bad code: x % y % z")),
                                     Name, Context) {}

clang/lib/Tooling/Transformer/RewriteRule.cpp

for (const auto &E : ASTEdits) {
     // it as is currently done. This behavior is problematic in that it hides
     // failures from bad ranges. Also, the behavior here differs from
     // `flatten`. Here, we abort (without error), whereas flatten, if it hits an
     // empty list, does not abort. As a result, `editList({A,B})` is not
     // equivalent to `flatten(edit(A), edit(B))`. The former will abort if `A`
     // produces a bad range, whereas the latter will simply ignore A.
     if (!EditRange)
       return SmallVector<Edit, 0>();
+    transformer::Edit T;
+    T.Kind = E.Kind;
+    T.Range = *EditRange;
+    if (E.Replacement) {
       auto Replacement = E.Replacement->eval(Result);
       if (!Replacement)
         return Replacement.takeError();
+      T.Replacement = std::move(*Replacement);
+    }
+    if (E.Metadata) {
       auto Metadata = E.Metadata(Result);
       if (!Metadata)
         return Metadata.takeError();
-    transformer::Edit T;
-    T.Kind = E.Kind;
-    T.Range = *EditRange;
-    T.Replacement = std::move(*Replacement);
       T.Metadata = std::move(*Metadata);
+    }
     Edits.push_back(std::move(T));
   }
   return Edits;
 }
 
 EditGenerator transformer::editList(SmallVector<ASTEdit, 1> Edits) {
   return [Edits = std::move(Edits)](const MatchResult &Result) {
     return translateEdits(Result, Edits);