[LibTooling] Update Stencil to use RangeSelector

[ymandel]

Summary

Add support for creating a StencilPart from any RangeSelector, which broadens the scope of Stencil.

Correspondingly, deprecate Stencil's specialized combinators node and sNode in favor of using the appropriate range selector directly.

[ymandel]

Add back node and sNode.

[ymandel]

Adjusted name qualification and added using decls in a handful of places.

[ymandel]

Rebase onto HEAD, fixing previous diff which accidentally included other commits.

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

 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_CLANG_TOOLING_REFACTOR_STENCIL_H_
 #define LLVM_CLANG_TOOLING_REFACTOR_STENCIL_H_
 
 #include "clang/AST/ASTContext.h"
 #include "clang/AST/ASTTypeTraits.h"
 #include "clang/ASTMatchers/ASTMatchFinder.h"
+#include "clang/Tooling/Refactoring/RangeSelector.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/Error.h"
 #include <string>
 #include <vector>
 
 namespace clang {
 namespace tooling {
 
public:
   llvm::Expected<std::string>
   operator()(const ast_matchers::MatchFinder::MatchResult &Result) const {
     return eval(Result);
   }
 
 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;
 };
 
 inline bool operator==(const Stencil &A, const Stencil &B) {
   return A.Parts == B.Parts;
 }
 
 inline bool operator!=(const Stencil &A, const Stencil &B) { return !(A == B); }
 
 // Functions for conveniently building stencils.
 namespace stencil {
 /// Convenience wrapper for Stencil::cat that can be imported with a using decl.
 template <typename... Ts> Stencil cat(Ts &&... Parts) {
   return Stencil::cat(std::forward<Ts>(Parts)...);
 }
 
 /// \returns exactly the text provided.
 StencilPart text(llvm::StringRef Text);
 
+/// \returns the source corresponding to the selected range.
+StencilPart selection(RangeSelector Selector);
+
 /// \returns the source corresponding to the identified node.
-StencilPart node(llvm::StringRef Id);
+/// FIXME: Deprecated. Write `selection(node(Id))` instead.
+inline StencilPart node(llvm::StringRef Id) {
+  return selection(tooling::node(Id));
+}
+
 /// Variant of \c node() that identifies the node as a statement, for purposes
 /// of deciding whether to include any trailing semicolon.  Only relevant for
 /// Expr nodes, which, by default, are *not* considered as statements.
 /// \returns the source corresponding to the identified node, considered as a
 /// statement.
-StencilPart sNode(llvm::StringRef Id);
+/// FIXME: Deprecated. Write `selection(statement(Id))` instead.
+inline StencilPart sNode(llvm::StringRef Id) {
+  return selection(tooling::statement(Id));
+}
 
 /// For debug use only; semantics are not guaranteed.
 ///
 /// \returns the string resulting from calling the node's print() method.
 StencilPart dPrint(llvm::StringRef Id);
 } // namespace stencil
 } // namespace tooling
 } // namespace clang
 #endif // LLVM_CLANG_TOOLING_REFACTOR_STENCIL_H_

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

struct RawTextData {
   std::string Text;
 };
 
 // A debugging operation to dump the AST for a particular (bound) AST node.
 struct DebugPrintNodeOpData {
   explicit DebugPrintNodeOpData(std::string S) : Id(std::move(S)) {}
   std::string Id;
 };
-// Whether to associate a trailing semicolon with a node when identifying it's
-// text.  This flag is needed for expressions (clang::Expr), because their role
-// is ambiguous when they are also complete statements.  When this flag is
-// `Always`, an expression node will be treated like a statement, and will
-// therefore be associated with any trailing semicolon.
-enum class SemiAssociation : bool {
-  Always,
-  Inferred,
-};
 
-// A reference to a particular (bound) AST node.
-struct NodeRefData {
-  explicit NodeRefData(std::string S, SemiAssociation SA)
-      : Id(std::move(S)), SemiAssoc(SA) {}
-  std::string Id;
-  SemiAssociation SemiAssoc;
+// The fragment of code corresponding to the selected range.
+struct SelectorOpData {
+  explicit SelectorOpData(RangeSelector S) : Selector(std::move(S)) {}
+  RangeSelector Selector;
 };
 } // namespace
 
 bool isEqualData(const RawTextData &A, const RawTextData &B) {
   return A.Text == B.Text;
 }
 
 bool isEqualData(const DebugPrintNodeOpData &A, const DebugPrintNodeOpData &B) {
   return A.Id == B.Id;
 }
 
-bool isEqualData(const NodeRefData &A, const NodeRefData &B) {
-  return A.Id == B.Id && A.SemiAssoc == B.SemiAssoc;
-}
+// Equality is not (yet) defined for \c RangeSelector.
+bool isEqualData(const SelectorOpData &, const SelectorOpData &) { return false; }
 
 // 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 evalData(const DebugPrintNodeOpData &Data,
                const MatchFinder::MatchResult &Match, std::string *Result) {
   std::string Output;
   llvm::raw_string_ostream Os(Output);
   auto NodeOrErr = getNode(Match.Nodes, Data.Id);
   if (auto Err = NodeOrErr.takeError())
     return Err;
   NodeOrErr->print(Os, PrintingPolicy(Match.Context->getLangOpts()));
   *Result += Os.str();
   return Error::success();
 }
 
-Error evalData(const NodeRefData &Data, const MatchFinder::MatchResult &Match,
+Error evalData(const SelectorOpData &Data, const MatchFinder::MatchResult &Match,
                std::string *Result) {
-  auto NodeOrErr = getNode(Match.Nodes, Data.Id);
-  if (auto Err = NodeOrErr.takeError())
-    return Err;
-  auto &Node = *NodeOrErr;
-  switch (Data.SemiAssoc) {
-  case SemiAssociation::Inferred:
-    // Include the semicolon for non-expression statements:
-    *Result += Node.get<Stmt>() != nullptr && Node.get<Expr>() == nullptr
-                   ? getExtendedText(NodeOrErr.get(), tok::TokenKind::semi,
-                                     *Match.Context)
-                   : getText(NodeOrErr.get(), *Match.Context);
-    break;
-  case SemiAssociation::Always:
-    *Result +=
-        getExtendedText(NodeOrErr.get(), tok::TokenKind::semi, *Match.Context);
-    break;
-  }
+  auto Range = Data.Selector(Match);
+  if (!Range)
+    return Range.takeError();
+  *Result += getText(*Range, *Match.Context);
   return Error::success();
 }
 
 template <typename T>
 class StencilPartImpl : public StencilPartInterface {
   T Data;
 
 public:
if (const auto *OtherPtr = down_cast<StencilPartImpl>(&Other))
       return isEqualData(Data, OtherPtr->Data);
     return false;
   }
 };
 
 namespace {
 using RawText = StencilPartImpl<RawTextData>;
 using DebugPrintNodeOp = StencilPartImpl<DebugPrintNodeOpData>;
-using NodeRef = StencilPartImpl<NodeRefData>;
+using SelectorOp = StencilPartImpl<SelectorOpData>;
 } // namespace
 
 StencilPart Stencil::wrap(StringRef Text) {
   return stencil::text(Text);
 }
 
+StencilPart Stencil::wrap(RangeSelector Selector) {
+  return stencil::selection(std::move(Selector));
+}
+
 void Stencil::append(Stencil OtherStencil) {
   for (auto &Part : OtherStencil.Parts)
     Parts.push_back(std::move(Part));
 }
 
 llvm::Expected<std::string>
 Stencil::eval(const MatchFinder::MatchResult &Match) const {
   std::string Result;
   for (const auto &Part : Parts)
     if (auto Err = Part.eval(Match, &Result))
       return std::move(Err);
   return Result;
 }
 
 StencilPart stencil::text(StringRef Text) {
   return StencilPart(std::make_shared<RawText>(Text));
 }
 
-StencilPart stencil::node(StringRef Id) {
-  return StencilPart(std::make_shared<NodeRef>(Id, SemiAssociation::Inferred));
-}
-
-StencilPart stencil::sNode(StringRef Id) {
-  return StencilPart(std::make_shared<NodeRef>(Id, SemiAssociation::Always));
+StencilPart stencil::selection(RangeSelector Selector) {
+  return StencilPart(std::make_shared<SelectorOp>(std::move(Selector)));
 }
 
 StencilPart stencil::dPrint(StringRef Id) {
   return StencilPart(std::make_shared<DebugPrintNodeOp>(Id));
 }

cfe/trunk/unittests/Tooling/StencilTest.cpp

 using namespace tooling;
 using namespace ast_matchers;
 
 namespace {
 using ::testing::AllOf;
 using ::testing::Eq;
 using ::testing::HasSubstr;
 using MatchResult = MatchFinder::MatchResult;
-using tooling::stencil::node;
-using tooling::stencil::sNode;
-using tooling::stencil::text;
+using stencil::cat;
+using stencil::dPrint;
+using stencil::text;
 
 // In tests, we can't directly match on llvm::Expected since its accessors
 // mutate the object. So, we collapse it to an Optional.
 static llvm::Optional<std::string> toOptional(llvm::Expected<std::string> V) {
   if (V)
     return *V;
   ADD_FAILURE() << "Losing error in conversion to IsSomething: "
                 << llvm::toString(V.takeError());
const std::string Snippet = R"cc(
     else
       return 0;
   )cc";
   auto StmtMatch = matchStmt(
       Snippet, ifStmt(hasCondition(expr().bind(Condition)),
                       hasThen(stmt().bind(Then)), hasElse(stmt().bind(Else))));
   ASSERT_TRUE(StmtMatch);
   // Invert the if-then-else.
-  auto Stencil = Stencil::cat("if (!", node(Condition), ") ", sNode(Else),
-                              " else ", sNode(Then));
+  auto Stencil = cat("if (!", node(Condition), ") ", statement(Else), " else ",
+                     statement(Then));
   EXPECT_THAT(toOptional(Stencil.eval(StmtMatch->Result)),
               IsSomething(Eq("if (!true) return 0; else return 1;")));
 }
 
 TEST_F(StencilTest, SingleStatementCallOperator) {
   StringRef Condition("C"), Then("T"), Else("E");
   const std::string Snippet = R"cc(
     if (true)
       return 1;
     else
       return 0;
   )cc";
   auto StmtMatch = matchStmt(
       Snippet, ifStmt(hasCondition(expr().bind(Condition)),
                       hasThen(stmt().bind(Then)), hasElse(stmt().bind(Else))));
   ASSERT_TRUE(StmtMatch);
   // Invert the if-then-else.
-  Stencil S = Stencil::cat("if (!", node(Condition), ") ", sNode(Else),
-                              " else ", sNode(Then));
+  Stencil S = cat("if (!", node(Condition), ") ", statement(Else), " else ",
+                  statement(Then));
   EXPECT_THAT(toOptional(S(StmtMatch->Result)),
               IsSomething(Eq("if (!true) return 0; else return 1;")));
 }
 
 TEST_F(StencilTest, UnboundNode) {
   const std::string Snippet = R"cc(
     if (true)
       return 1;
     else
       return 0;
   )cc";
   auto StmtMatch = matchStmt(Snippet, ifStmt(hasCondition(stmt().bind("a1")),
                                              hasThen(stmt().bind("a2"))));
   ASSERT_TRUE(StmtMatch);
-  auto Stencil = Stencil::cat("if(!", sNode("a1"), ") ", node("UNBOUND"), ";");
+  auto Stencil = cat("if(!", node("a1"), ") ", node("UNBOUND"), ";");
   auto ResultOrErr = Stencil.eval(StmtMatch->Result);
   EXPECT_TRUE(llvm::errorToBool(ResultOrErr.takeError()))
       << "Expected unbound node, got " << *ResultOrErr;
 }
 
 // Tests that a stencil with a single parameter (`Id`) evaluates to the expected
 // string, when `Id` is bound to the expression-statement in `Snippet`.
 void testExpr(StringRef Id, StringRef Snippet, const Stencil &Stencil,
               StringRef Expected) {
   auto StmtMatch = matchStmt(Snippet, expr().bind(Id));
   ASSERT_TRUE(StmtMatch);
   EXPECT_THAT(toOptional(Stencil.eval(StmtMatch->Result)),
               IsSomething(Expected));
 }
 
-TEST_F(StencilTest, NodeOp) {
-  StringRef Id = "id";
-  testExpr(Id, "3;", Stencil::cat(node(Id)), "3");
-}
-
-TEST_F(StencilTest, SNodeOp) {
+TEST_F(StencilTest, SelectionOp) {
   StringRef Id = "id";
-  testExpr(Id, "3;", Stencil::cat(sNode(Id)), "3;");
+  testExpr(Id, "3;", cat(node(Id)), "3");
 }
 
 TEST(StencilEqualityTest, Equality) {
-  using stencil::dPrint;
-  auto Lhs = Stencil::cat("foo", node("node"), dPrint("dprint_id"));
-  auto Rhs = Lhs;
+  auto Lhs = cat("foo", dPrint("dprint_id"));
+  auto Rhs = cat("foo", dPrint("dprint_id"));
   EXPECT_EQ(Lhs, Rhs);
 }
 
 TEST(StencilEqualityTest, InEqualityDifferentOrdering) {
-  auto Lhs = Stencil::cat("foo", node("node"));
-  auto Rhs = Stencil::cat(node("node"), "foo");
+  auto Lhs = cat("foo", dPrint("node"));
+  auto Rhs = cat(dPrint("node"), "foo");
   EXPECT_NE(Lhs, Rhs);
 }
 
 TEST(StencilEqualityTest, InEqualityDifferentSizes) {
-  auto Lhs = Stencil::cat("foo", node("node"), "bar", "baz");
-  auto Rhs = Stencil::cat("foo", node("node"), "bar");
+  auto Lhs = cat("foo", dPrint("node"), "bar", "baz");
+  auto Rhs = cat("foo", dPrint("node"), "bar");
   EXPECT_NE(Lhs, Rhs);
 }
+
+// node is opaque and therefore cannot be examined for equality.
+TEST(StencilEqualityTest, InEqualitySelection) {
+  auto S1 = cat(node("node"));
+  auto S2 = cat(node("node"));
+  EXPECT_NE(S1, S2);
+}
 } // namespace