[libTooling] Add `toString` method to the Stencil class

[ymandel]

Summary

toString generates a string representation of the stencil.

Patch by Harshal T. Lehri.

[ymandel]

clang-format

[ymandel]

comment tweaks

[gribozavr]

clang/include/clang/Tooling/Refactoring/Stencil.h

54 ↗

(On Diff #223573)

No space between "run" and backtick.

[ymandel]

fix comment

[ymandel]

The tests broke the build on some platforms because of the use of raw strings in macros. Fixing now...

cfe/trunk/include/clang/Tooling/Refactoring/Stencil.h

public:
 
   /// Evaluates this part to a string and appends it to \c Result.  \c Result is
   /// undefined in the case of an error.
   virtual llvm::Error eval(const ast_matchers::MatchFinder::MatchResult &Match,
                            std::string *Result) const = 0;
 
   virtual bool isEqual(const StencilPartInterface &other) const = 0;
 
+  /// Constructs a string representation of the StencilPart. StencilParts
+  /// generated by the `selection` and `run` functions do not have a unique
+  /// string representation.
+  virtual std::string toString() const = 0;
+
   const void *typeId() const { return TypeId; }
 
 protected:
   StencilPartInterface(const void *DerivedId) : TypeId(DerivedId) {}
 
   // Since this is an abstract class, copying/assigning only make sense for
   // derived classes implementing `clone()`.
   StencilPartInterface(const StencilPartInterface &) = default;
public:
   bool operator==(const StencilPart &Other) const {
     if (Impl == Other.Impl)
       return true;
     if (Impl == nullptr || Other.Impl == nullptr)
       return false;
     return Impl->isEqual(*Other.Impl);
   }
 
+  std::string toString() const {
+    if (Impl == nullptr)
+      return "";
+    return Impl->toString();
+  }
+
 private:
   std::shared_ptr<StencilPartInterface> Impl;
 };
 
 /// A sequence of code fragments, references to parameters and code-generation
 /// operations that together can be evaluated to (a fragment of) source code,
 /// given a match result.
 class Stencil {
public:
 
   // Allow Stencils to operate as std::function, for compatibility with
   // Transformer's TextGenerator.
   llvm::Expected<std::string>
   operator()(const ast_matchers::MatchFinder::MatchResult &Result) const {
     return eval(Result);
   }
 
+  /// Constructs a string representation of the Stencil. The string is not
+  /// guaranteed to be unique.
+  std::string toString() const {
+    std::vector<std::string> PartStrings;
+    PartStrings.reserve(Parts.size());
+    for (const auto &Part : Parts)
+      PartStrings.push_back(Part.toString());
+    return llvm::join(PartStrings, ", ");
+  }
+
 private:
   friend bool operator==(const Stencil &A, const Stencil &B);
   static StencilPart wrap(llvm::StringRef Text);
   static StencilPart wrap(RangeSelector Selector);
   static StencilPart wrap(StencilPart Part) { return Part; }
 
   std::vector<StencilPart> Parts;
 };

cfe/trunk/lib/Tooling/Refactoring/Stencil.cpp

 #include "clang/AST/ASTContext.h"
 #include "clang/AST/ASTTypeTraits.h"
 #include "clang/AST/Expr.h"
 #include "clang/ASTMatchers/ASTMatchFinder.h"
 #include "clang/ASTMatchers/ASTMatchers.h"
 #include "clang/Lex/Lexer.h"
 #include "clang/Tooling/Refactoring/SourceCode.h"
 #include "clang/Tooling/Refactoring/SourceCodeBuilders.h"
+#include "llvm/ADT/Twine.h"
 #include "llvm/Support/Errc.h"
 #include <atomic>
 #include <memory>
 #include <string>
 
 using namespace clang;
 using namespace tooling;
 

 }
 
 // Equality is not defined over MatchConsumers, which are opaque.
 bool isEqualData(const MatchConsumer<std::string> &A,
                  const MatchConsumer<std::string> &B) {
   return false;
 }
 
+std::string toStringData(const RawTextData &Data) {
+  std::string Result;
+  llvm::raw_string_ostream OS(Result);
+  OS << "\"";
+  OS.write_escaped(Data.Text);
+  OS << "\"";
+  OS.flush();
+  return Result;
+}
+
+std::string toStringData(const DebugPrintNodeData &Data) {
+  return (llvm::Twine("dPrint(\"") + Data.Id + "\")").str();
+}
+
+std::string toStringData(const UnaryOperationData &Data) {
+  StringRef OpName;
+  switch (Data.Op) {
+  case UnaryNodeOperator::Parens:
+    OpName = "expression";
+    break;
+  case UnaryNodeOperator::Deref:
+    OpName = "deref";
+    break;
+  case UnaryNodeOperator::Address:
+    OpName = "addressOf";
+    break;
+  }
+  return (OpName + "(\"" + Data.Id + "\")").str();
+}
+
+std::string toStringData(const SelectorData &) { return "SelectorData()"; }
+
+std::string toStringData(const AccessData &Data) {
+  return (llvm::Twine("access(\"") + Data.BaseId + "\", " +
+          Data.Member.toString() + ")")
+      .str();
+}
+
+std::string toStringData(const IfBoundData &Data) {
+  return (llvm::Twine("ifBound(\"") + Data.Id + "\", " +
+          Data.TruePart.toString() + ", " + Data.FalsePart.toString() + ")")
+      .str();
+}
+
+std::string toStringData(const MatchConsumer<std::string> &) {
+  return "MatchConsumer<std::string>()";
+}
+
 // The `evalData()` overloads evaluate the given stencil data to a string, given
 // the match result, and append it to `Result`. We define an overload for each
 // type of stencil data.
 
 Error evalData(const RawTextData &Data, const MatchFinder::MatchResult &,
                std::string *Result) {
   Result->append(Data.Text);
   return Error::success();
Error eval(const MatchFinder::MatchResult &Match,
     return evalData(Data, Match, Result);
   }
 
   bool isEqual(const StencilPartInterface &Other) const override {
     if (const auto *OtherPtr = down_cast<StencilPartImpl>(&Other))
       return isEqualData(Data, OtherPtr->Data);
     return false;
   }
+
+  std::string toString() const override { return toStringData(Data); }
 };
 } // namespace
 
 StencilPart Stencil::wrap(StringRef Text) {
   return stencil::text(Text);
 }
 
 StencilPart Stencil::wrap(RangeSelector Selector) {

cfe/trunk/unittests/Tooling/StencilTest.cpp

 
 // `run` is opaque.
 TEST(StencilEqualityTest, InEqualityRun) {
   auto F = [](const MatchResult &R) { return "foo"; };
   auto S1 = cat(run(F));
   auto S2 = cat(run(F));
   EXPECT_NE(S1, S2);
 }
+
+TEST(StencilToStringTest, RawTextOp) {
+  auto S = cat("foo bar baz");
+  EXPECT_EQ(S.toString(), R"("foo bar baz")");
+}
+
+TEST(StencilToStringTest, RawTextOpEscaping) {
+  auto S = cat("foo \"bar\" baz\\n");
+  EXPECT_EQ(S.toString(), R"("foo \"bar\" baz\\n")");
+}
+
+TEST(StencilToStringTest, DebugPrintNodeOp) {
+  auto S = cat(dPrint("Id"));
+  EXPECT_EQ(S.toString(), R"repr(dPrint("Id"))repr");
+}
+
+TEST(StencilToStringTest, ExpressionOp) {
+  auto S = cat(expression("Id"));
+  EXPECT_EQ(S.toString(), R"repr(expression("Id"))repr");
+}
+
+TEST(StencilToStringTest, DerefOp) {
+  auto S = cat(deref("Id"));
+  EXPECT_EQ(S.toString(), R"repr(deref("Id"))repr");
+}
+
+TEST(StencilToStringTest, AddressOfOp) {
+  auto S = cat(addressOf("Id"));
+  EXPECT_EQ(S.toString(), R"repr(addressOf("Id"))repr");
+}
+
+TEST(StencilToStringTest, AccessOp) {
+  auto S = cat(access("Id", text("memberData")));
+  EXPECT_EQ(S.toString(), R"repr(access("Id", "memberData"))repr");
+}
+
+TEST(StencilToStringTest, AccessOpStencilPart) {
+  auto S = cat(access("Id", access("subId", "memberData")));
+  EXPECT_EQ(S.toString(),
+            R"repr(access("Id", access("subId", "memberData")))repr");
+}
+
+TEST(StencilToStringTest, IfBoundOp) {
+  auto S = cat(ifBound("Id", text("trueText"), access("exprId", "memberData")));
+  EXPECT_EQ(
+      S.toString(),
+      R"repr(ifBound("Id", "trueText", access("exprId", "memberData")))repr");
+}
+
+TEST(StencilToStringTest, MultipleOp) {
+  auto S = cat("foo", access("x", "m()"), "bar",
+               ifBound("x", text("t"), access("e", "f")));
+  EXPECT_EQ(S.toString(), R"repr("foo", access("x", "m()"), "bar", )repr"
+                          R"repr(ifBound("x", "t", access("e", "f")))repr");
+}
 } // namespace