[libTooling] Put all Transformer declarations in a single namespace.

Summary:
This revision introduces a new namespace, `clang::transformer`, to hold
the declarations for the Transformer library.

Reviewers: gribozavr

Subscribers: cfe-commits

Tags: #clang

Differential Revision: https://reviews.llvm.org/D68876

llvm-svn: 374962

clang/include/clang/Tooling/Transformer/MatchConsumer.h

@@ -22,8 +22,7 @@
 #include "llvm/Support/Error.h"
 
 namespace clang {
-namespace tooling {
-
+namespace transformer {
 /// A failable computation over nodes bound by AST matchers.
 ///
 /// The computation should report any errors though its return value (rather
@@ -52,7 +51,12 @@ MatchConsumer<T> ifBound(std::string ID, MatchConsumer<T> TrueC,
     return (Map.find(ID) != Map.end() ? TrueC : FalseC)(Result);
   };
 }
+} // namespace transformer
 
+namespace tooling {
+// DEPRECATED: Temporary alias supporting client migration to the `transformer`
+// namespace.
+using transformer::ifBound;
 } // namespace tooling
 } // namespace clang
 #endif // LLVM_CLANG_TOOLING_TRANSFORMER_MATCH_CONSUMER_H_

clang/include/clang/Tooling/Transformer/RangeSelector.h

@@ -23,7 +23,7 @@
 #include <string>
 
 namespace clang {
-namespace tooling {
+namespace transformer {
 using RangeSelector = MatchConsumer<CharSourceRange>;
 
 inline RangeSelector charRange(CharSourceRange R) {
@@ -87,6 +87,24 @@ RangeSelector elseBranch(std::string ID);
 /// source), if `S` is an expansion, and `S` itself, otherwise.  Corresponds to
 /// `SourceManager::getExpansionRange`.
 RangeSelector expansion(RangeSelector S);
+} // namespace transformer
+
+namespace tooling {
+// DEPRECATED: These are temporary aliases supporting client migration to the
+// `transformer` namespace.
+using transformer::after;
+using transformer::before;
+using transformer::callArgs;
+using transformer::charRange;
+using transformer::elseBranch;
+using transformer::expansion;
+using transformer::initListElements;
+using transformer::member;
+using transformer::name;
+using transformer::node;
+using transformer::range;
+using transformer::statement;
+using transformer::statements;
 } // namespace tooling
 } // namespace clang
 

clang/include/clang/Tooling/Transformer/RewriteRule.h

@@ -29,9 +29,8 @@
 #include <utility>
 
 namespace clang {
-namespace tooling {
+namespace transformer {
 using TextGenerator = MatchConsumer<std::string>;
-
 /// Wraps a string as a TextGenerator.
 inline TextGenerator text(std::string M) {
   return [M](const ast_matchers::MatchFinder::MatchResult &)
@@ -282,6 +281,24 @@ Expected<SmallVector<Transformation, 1>>
 translateEdits(const ast_matchers::MatchFinder::MatchResult &Result,
                llvm::ArrayRef<ASTEdit> Edits);
 } // namespace detail
+} // namespace transformer
+
+namespace tooling {
+// DEPRECATED: These are temporary aliases supporting client migration to the
+// `transformer` namespace.
+using transformer::addInclude;
+using transformer::applyFirst;
+using transformer::change;
+using transformer::insertAfter;
+using transformer::insertBefore;
+using transformer::makeRule;
+using transformer::remove;
+using transformer::text;
+using transformer::RewriteRule;
+using transformer::IncludeFormat;
+namespace detail {
+using namespace transformer::detail;
+} // namespace detail
 } // namespace tooling
 } // namespace clang
 

clang/include/clang/Tooling/Transformer/Stencil.h

@@ -31,8 +31,7 @@
 #include <vector>
 
 namespace clang {
-namespace tooling {
-
+namespace transformer {
 /// A stencil is represented as a sequence of "parts" that can each individually
 /// generate a code string based on a match result.  The different kinds of
 /// parts include (raw) text, references to bound nodes and assorted operations
@@ -133,8 +132,10 @@ class Stencil {
   std::vector<StencilPart> Parts;
 };
 
+//
 // 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)...);
@@ -146,12 +147,6 @@ 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.
-/// FIXME: Deprecated. Write `selection(node(Id))` instead.
-inline StencilPart node(llvm::StringRef Id) {
-  return selection(tooling::node(Id));
-}
-
 /// Generates the source of the expression bound to \p Id, wrapping it in
 /// parentheses if it may parse differently depending on context. For example, a
 /// binary operation is always wrapped, while a variable reference is never
@@ -197,6 +192,27 @@ StencilPart run(MatchConsumer<std::string> C);
 ///
 /// \returns the string resulting from calling the node's print() method.
 StencilPart dPrint(llvm::StringRef Id);
+} // namespace transformer
+
+namespace tooling {
+namespace stencil {
+// DEPRECATED: These are temporary aliases supporting client migration to the
+// `transformer` namespace.
+using transformer::access;
+using transformer::addressOf;
+using transformer::cat;
+using transformer::deref;
+using transformer::dPrint;
+using transformer::expression;
+using transformer::ifBound;
+using transformer::run;
+using transformer::selection;
+using transformer::text;
+/// \returns the source corresponding to the identified node.
+/// FIXME: Deprecated. Write `selection(node(Id))` instead.
+inline transformer::StencilPart node(llvm::StringRef Id) {
+  return selection(tooling::node(Id));
+}
 } // namespace stencil
 } // namespace tooling
 } // namespace clang

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

@@ -30,7 +30,7 @@ class Transformer : public ast_matchers::MatchFinder::MatchCallback {
   /// because of macros, but doesn't fail.  Note that clients are responsible
   /// for handling the case that independent \c AtomicChanges conflict with each
   /// other.
-  Transformer(RewriteRule Rule, ChangeConsumer Consumer)
+  Transformer(transformer::RewriteRule Rule, ChangeConsumer Consumer)
       : Rule(std::move(Rule)), Consumer(std::move(Consumer)) {}
 
   /// N.B. Passes `this` pointer to `MatchFinder`.  So, this object should not
@@ -42,7 +42,7 @@ class Transformer : public ast_matchers::MatchFinder::MatchCallback {
   void run(const ast_matchers::MatchFinder::MatchResult &Result) override;
 
 private:
-  RewriteRule Rule;
+  transformer::RewriteRule Rule;
   /// Receives each successful rewrites as an \c AtomicChange.
   ChangeConsumer Consumer;
 };

clang/lib/Tooling/Transformer/RangeSelector.cpp

@@ -20,7 +20,7 @@
 #include <vector>
 
 using namespace clang;
-using namespace tooling;
+using namespace transformer;
 
 using ast_matchers::MatchFinder;
 using ast_type_traits::ASTNodeKind;
@@ -104,7 +104,7 @@ static SourceLocation findOpenParen(const CallExpr &E, const SourceManager &SM,
   return findPreviousTokenKind(EndLoc, SM, LangOpts, tok::TokenKind::l_paren);
 }
 
-RangeSelector tooling::before(RangeSelector Selector) {
+RangeSelector transformer::before(RangeSelector Selector) {
   return [Selector](const MatchResult &Result) -> Expected<CharSourceRange> {
     Expected<CharSourceRange> SelectedRange = Selector(Result);
     if (!SelectedRange)
@@ -113,7 +113,7 @@ RangeSelector tooling::before(RangeSelector Selector) {
   };
 }
 
-RangeSelector tooling::after(RangeSelector Selector) {
+RangeSelector transformer::after(RangeSelector Selector) {
   return [Selector](const MatchResult &Result) -> Expected<CharSourceRange> {
     Expected<CharSourceRange> SelectedRange = Selector(Result);
     if (!SelectedRange)
@@ -126,27 +126,29 @@ RangeSelector tooling::after(RangeSelector Selector) {
   };
 }
 
-RangeSelector tooling::node(std::string ID) {
+RangeSelector transformer::node(std::string ID) {
   return [ID](const MatchResult &Result) -> Expected<CharSourceRange> {
     Expected<DynTypedNode> Node = getNode(Result.Nodes, ID);
     if (!Node)
       return Node.takeError();
     return Node->get<Stmt>() != nullptr && Node->get<Expr>() == nullptr
-               ? getExtendedRange(*Node, tok::TokenKind::semi, *Result.Context)
+               ? tooling::getExtendedRange(*Node, tok::TokenKind::semi,
+                                           *Result.Context)
                : CharSourceRange::getTokenRange(Node->getSourceRange());
   };
 }
 
-RangeSelector tooling::statement(std::string ID) {
+RangeSelector transformer::statement(std::string ID) {
   return [ID](const MatchResult &Result) -> Expected<CharSourceRange> {
     Expected<DynTypedNode> Node = getNode(Result.Nodes, ID);
     if (!Node)
       return Node.takeError();
-    return getExtendedRange(*Node, tok::TokenKind::semi, *Result.Context);
+    return tooling::getExtendedRange(*Node, tok::TokenKind::semi,
+                                     *Result.Context);
   };
 }
 
-RangeSelector tooling::range(RangeSelector Begin, RangeSelector End) {
+RangeSelector transformer::range(RangeSelector Begin, RangeSelector End) {
   return [Begin, End](const MatchResult &Result) -> Expected<CharSourceRange> {
     Expected<CharSourceRange> BeginRange = Begin(Result);
     if (!BeginRange)
@@ -165,11 +167,11 @@ RangeSelector tooling::range(RangeSelector Begin, RangeSelector End) {
   };
 }
 
-RangeSelector tooling::range(std::string BeginID, std::string EndID) {
-  return tooling::range(node(std::move(BeginID)), node(std::move(EndID)));
+RangeSelector transformer::range(std::string BeginID, std::string EndID) {
+  return transformer::range(node(std::move(BeginID)), node(std::move(EndID)));
 }
 
-RangeSelector tooling::member(std::string ID) {
+RangeSelector transformer::member(std::string ID) {
   return [ID](const MatchResult &Result) -> Expected<CharSourceRange> {
     Expected<DynTypedNode> Node = getNode(Result.Nodes, ID);
     if (!Node)
@@ -181,7 +183,7 @@ RangeSelector tooling::member(std::string ID) {
   };
 }
 
-RangeSelector tooling::name(std::string ID) {
+RangeSelector transformer::name(std::string ID) {
   return [ID](const MatchResult &Result) -> Expected<CharSourceRange> {
     Expected<DynTypedNode> N = getNode(Result.Nodes, ID);
     if (!N)
@@ -197,7 +199,7 @@ RangeSelector tooling::name(std::string ID) {
       // `foo<int>` for which this range will be too short.  Doing so will
       // require subcasing `NamedDecl`, because it doesn't provide virtual
       // access to the \c DeclarationNameInfo.
-      if (getText(R, *Result.Context) != D->getName())
+      if (tooling::getText(R, *Result.Context) != D->getName())
         return CharSourceRange();
       return R;
     }
@@ -256,7 +258,7 @@ CharSourceRange getStatementsRange(const MatchResult &,
 }
 } // namespace
 
-RangeSelector tooling::statements(std::string ID) {
+RangeSelector transformer::statements(std::string ID) {
   return RelativeSelector<CompoundStmt, getStatementsRange>(std::move(ID));
 }
 
@@ -271,7 +273,7 @@ CharSourceRange getCallArgumentsRange(const MatchResult &Result,
 }
 } // namespace
 
-RangeSelector tooling::callArgs(std::string ID) {
+RangeSelector transformer::callArgs(std::string ID) {
   return RelativeSelector<CallExpr, getCallArgumentsRange>(std::move(ID));
 }
 
@@ -285,24 +287,24 @@ CharSourceRange getElementsRange(const MatchResult &,
 }
 } // namespace
 
-RangeSelector tooling::initListElements(std::string ID) {
+RangeSelector transformer::initListElements(std::string ID) {
   return RelativeSelector<InitListExpr, getElementsRange>(std::move(ID));
 }
 
 namespace {
 // Returns the range of the else branch, including the `else` keyword.
 CharSourceRange getElseRange(const MatchResult &Result, const IfStmt &S) {
-  return maybeExtendRange(
+  return tooling::maybeExtendRange(
       CharSourceRange::getTokenRange(S.getElseLoc(), S.getEndLoc()),
       tok::TokenKind::semi, *Result.Context);
 }
 } // namespace
 
-RangeSelector tooling::elseBranch(std::string ID) {
+RangeSelector transformer::elseBranch(std::string ID) {
   return RelativeSelector<IfStmt, getElseRange>(std::move(ID));
 }
 
-RangeSelector tooling::expansion(RangeSelector S) {
+RangeSelector transformer::expansion(RangeSelector S) {
   return [S](const MatchResult &Result) -> Expected<CharSourceRange> {
     Expected<CharSourceRange> SRange = S(Result);
     if (!SRange)