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

[ymandel]

Summary

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

[gribozavr]

WDYT about clang::transformer? I don't see much point in the intermediate namespace. However, LGTM either way.

[ymandel]

In D68876#1706131, @gribozavr wrote:

WDYT about clang::transformer? I don't see much point in the intermediate namespace. However, LGTM either way.

Thanks for the review. I prefer clang::transformer but wasn't sure about ettiquete of introducing new namespaces under clang. If that's ok, then I'm happy to update.

[ymandel]

I'm now starting to doubt the split into transformer (for combinators) and tooling (for the type decls). I checked and ast_matchers contains both. What do you think of my just putting all of the Transformer types + combis in the single clang::transformer namespace?

[gribozavr]

What do you think of my just putting all of the Transformer types + combis in the single clang::transformer namespace?

That would make sense to me.

[ymandel]

moved all decls to clang::transformer.

[ymandel]

fix using decl.

[ymandel]

remove stray newline and include.

[aprantl]

This broke the modular build since some symbols are now ambiguous within the same Clang module.'

http://green.lab.llvm.org/green/view/LLDB/job/lldb-cmake/2646/consoleFull#25217323649ba4694-19c4-4d7e-bec5-911270d8a58c

FAILED: tools/clang/lib/Tooling/CMakeFiles/obj.clangTooling.dir/AllTUsExecution.cpp.o 
/Users/buildslave/jenkins/workspace/lldb-cmake/host-compiler/bin/clang++  -DGTEST_HAS_RTTI=0 -D_DEBUG -D_GNU_SOURCE -D__STDC_CONSTANT_MACROS -D__STDC_FORMAT_MACROS -D__STDC_LIMIT_MACROS -Itools/clang/lib/Tooling -I/Users/buildslave/jenkins/workspace/lldb-cmake/llvm-project/clang/lib/Tooling -I/Users/buildslave/jenkins/workspace/lldb-cmake/llvm-project/clang/include -Itools/clang/include -I/Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX10.14.sdk/usr/include/libxml2 -Iinclude -I/Users/buildslave/jenkins/workspace/lldb-cmake/llvm-project/llvm/include -Wdocumentation -fPIC -fvisibility-inlines-hidden -Werror=date-time -Werror=unguarded-availability-new -std=c++14 -fmodules -fmodules-cache-path=/Users/buildslave/jenkins/workspace/lldb-cmake/lldb-build/module.cache -fcxx-modules -Wall -Wextra -Wno-unused-parameter -Wwrite-strings -Wcast-qual -Wmissing-field-initializers -pedantic -Wno-long-long -Wimplicit-fallthrough -Wcovered-switch-default -Wno-noexcept-type -Wnon-virtual-dtor -Wdelete-non-virtual-dtor -Wstring-conversion -fdiagnostics-color -fno-common -Woverloaded-virtual -Wno-nested-anon-types -O3  -isysroot /Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX10.14.sdk   -UNDEBUG  -fno-exceptions -fno-rtti -MD -MT tools/clang/lib/Tooling/CMakeFiles/obj.clangTooling.dir/AllTUsExecution.cpp.o -MF tools/clang/lib/Tooling/CMakeFiles/obj.clangTooling.dir/AllTUsExecution.cpp.o.d -o tools/clang/lib/Tooling/CMakeFiles/obj.clangTooling.dir/AllTUsExecution.cpp.o -c /Users/buildslave/jenkins/workspace/lldb-cmake/llvm-project/clang/lib/Tooling/AllTUsExecution.cpp
While building module 'Clang_Tooling' imported from /Users/buildslave/jenkins/workspace/lldb-cmake/llvm-project/clang/lib/Tooling/AllTUsExecution.cpp:9:
In file included from <module-includes>:44:
In file included from /Users/buildslave/jenkins/workspace/lldb-cmake/llvm-project/clang/include/clang/Tooling/Transformer/Transformer.h:14:
/Users/buildslave/jenkins/workspace/lldb-cmake/llvm-project/clang/include/clang/Tooling/Transformer/RewriteRule.h:224:31: error: call to 'text' is ambiguous
  return change(std::move(S), text(""));
                              ^~~~
/Users/buildslave/jenkins/workspace/lldb-cmake/llvm-project/clang/include/clang/Tooling/Transformer/Stencil.h:145:13: note: candidate function
StencilPart text(llvm::StringRef Text);
            ^
/Users/buildslave/jenkins/workspace/lldb-cmake/llvm-project/clang/include/clang/Tooling/Transformer/RewriteRule.h:35:22: note: candidate function
inline TextGenerator text(std::string M) {
                     ^
/Users/buildslave/jenkins/workspace/lldb-cmake/llvm-project/clang/lib/Tooling/AllTUsExecution.cpp:9:10: fatal error: could not build module 'Clang_Tooling'
#include "clang/Tooling/AllTUsExecution.h"
 ~~~~~~~~^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
2 errors generated.

Can you please fix and/or revert?

[ymandel]

This should be fixed by r375003. Please let me know if that's not the case.

In D68876#1711227, @aprantl wrote:

This broke the modular build since some symbols are now ambiguous within the same Clang module.'

http://green.lab.llvm.org/green/view/LLDB/job/lldb-cmake/2646/consoleFull#25217323649ba4694-19c4-4d7e-bec5-911270d8a58c

FAILED: tools/clang/lib/Tooling/CMakeFiles/obj.clangTooling.dir/AllTUsExecution.cpp.o 
/Users/buildslave/jenkins/workspace/lldb-cmake/host-compiler/bin/clang++  -DGTEST_HAS_RTTI=0 -D_DEBUG -D_GNU_SOURCE -D__STDC_CONSTANT_MACROS -D__STDC_FORMAT_MACROS -D__STDC_LIMIT_MACROS -Itools/clang/lib/Tooling -I/Users/buildslave/jenkins/workspace/lldb-cmake/llvm-project/clang/lib/Tooling -I/Users/buildslave/jenkins/workspace/lldb-cmake/llvm-project/clang/include -Itools/clang/include -I/Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX10.14.sdk/usr/include/libxml2 -Iinclude -I/Users/buildslave/jenkins/workspace/lldb-cmake/llvm-project/llvm/include -Wdocumentation -fPIC -fvisibility-inlines-hidden -Werror=date-time -Werror=unguarded-availability-new -std=c++14 -fmodules -fmodules-cache-path=/Users/buildslave/jenkins/workspace/lldb-cmake/lldb-build/module.cache -fcxx-modules -Wall -Wextra -Wno-unused-parameter -Wwrite-strings -Wcast-qual -Wmissing-field-initializers -pedantic -Wno-long-long -Wimplicit-fallthrough -Wcovered-switch-default -Wno-noexcept-type -Wnon-virtual-dtor -Wdelete-non-virtual-dtor -Wstring-conversion -fdiagnostics-color -fno-common -Woverloaded-virtual -Wno-nested-anon-types -O3  -isysroot /Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX10.14.sdk   -UNDEBUG  -fno-exceptions -fno-rtti -MD -MT tools/clang/lib/Tooling/CMakeFiles/obj.clangTooling.dir/AllTUsExecution.cpp.o -MF tools/clang/lib/Tooling/CMakeFiles/obj.clangTooling.dir/AllTUsExecution.cpp.o.d -o tools/clang/lib/Tooling/CMakeFiles/obj.clangTooling.dir/AllTUsExecution.cpp.o -c /Users/buildslave/jenkins/workspace/lldb-cmake/llvm-project/clang/lib/Tooling/AllTUsExecution.cpp
While building module 'Clang_Tooling' imported from /Users/buildslave/jenkins/workspace/lldb-cmake/llvm-project/clang/lib/Tooling/AllTUsExecution.cpp:9:
In file included from <module-includes>:44:
In file included from /Users/buildslave/jenkins/workspace/lldb-cmake/llvm-project/clang/include/clang/Tooling/Transformer/Transformer.h:14:
/Users/buildslave/jenkins/workspace/lldb-cmake/llvm-project/clang/include/clang/Tooling/Transformer/RewriteRule.h:224:31: error: call to 'text' is ambiguous
  return change(std::move(S), text(""));
                              ^~~~
/Users/buildslave/jenkins/workspace/lldb-cmake/llvm-project/clang/include/clang/Tooling/Transformer/Stencil.h:145:13: note: candidate function
StencilPart text(llvm::StringRef Text);
            ^
/Users/buildslave/jenkins/workspace/lldb-cmake/llvm-project/clang/include/clang/Tooling/Transformer/RewriteRule.h:35:22: note: candidate function
inline TextGenerator text(std::string M) {
                     ^
/Users/buildslave/jenkins/workspace/lldb-cmake/llvm-project/clang/lib/Tooling/AllTUsExecution.cpp:9:10: fatal error: could not build module 'Clang_Tooling'
#include "clang/Tooling/AllTUsExecution.h"
 ~~~~~~~~^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
2 errors generated.

Can you please fix and/or revert?

[aprantl]

It looks like it's still failing: http://green.lab.llvm.org/green/view/LLDB/job/lldb-cmake/2649/console

[ymandel]

In D68876#1711576, @aprantl wrote:

It looks like it's still failing: http://green.lab.llvm.org/green/view/LLDB/job/lldb-cmake/2649/console

That line was fixed in the revision I mentioned: https://reviews.llvm.org/rL375003
Could it be that the bot hasn't picked up the revision yet?

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

 
 #include "clang/AST/ASTTypeTraits.h"
 #include "clang/ASTMatchers/ASTMatchFinder.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/Errc.h"
 #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
 /// than terminating the program) to enable usage in interactive scenarios like
 /// clang-query.
 ///
 /// This is a central abstraction of the Transformer framework.
 template <typename T>

 template <typename T>
 MatchConsumer<T> ifBound(std::string ID, MatchConsumer<T> TrueC,
                          MatchConsumer<T> FalseC) {
   return [=](const ast_matchers::MatchFinder::MatchResult &Result) {
     auto &Map = Result.Nodes.getMap();
     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

 #include "clang/ASTMatchers/ASTMatchFinder.h"
 #include "clang/Basic/SourceLocation.h"
 #include "clang/Tooling/Transformer/MatchConsumer.h"
 #include "llvm/Support/Error.h"
 #include <functional>
 #include <string>
 
 namespace clang {
-namespace tooling {
+namespace transformer {
 using RangeSelector = MatchConsumer<CharSourceRange>;
 
 inline RangeSelector charRange(CharSourceRange R) {
   return [R](const ast_matchers::MatchFinder::MatchResult &)
              -> Expected<CharSourceRange> { return R; };
 }
 
 /// Selects from the start of \p Begin and to the end of \p End.

 /// Given an \IfStmt (bound to \p ID), selects the range of the else branch,
 /// starting from the \c else keyword.
 RangeSelector elseBranch(std::string ID);
 
 /// Selects the range from which `S` was expanded (possibly along with other
 /// 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
 
 #endif // LLVM_CLANG_TOOLING_REFACTOR_RANGE_SELECTOR_H_

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

 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/Support/Error.h"
 #include <functional>
 #include <string>
 #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 &)
              -> Expected<std::string> { return M; };
 }
 
 // Description of a source-code edit, expressed in terms of an AST node.
 // Includes: an ID for the (bound) node, a selector for source related to the

 /// the match.  However, it does not fail in the case of conflicting edits --
 /// conflict handling is left to clients.  We recommend use of the \c
 /// AtomicChange or \c Replacements classes for assistance in detecting such
 /// conflicts.
 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
 
 #endif // LLVM_CLANG_TOOLING_TRANSFORMER_REWRITE_RULE_H_

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

 #include "clang/Tooling/Transformer/MatchConsumer.h"
 #include "clang/Tooling/Transformer/RangeSelector.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/Error.h"
 #include <string>
 #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
 /// on bound nodes.
 ///
 /// Users can create custom Stencil operations by implementing this interface.
 class StencilPartInterface {
 public:

 private:
   static StencilPart wrap(llvm::StringRef Text);
   static StencilPart wrap(RangeSelector Selector);
   static StencilPart wrap(StencilPart Part) { return Part; }
 
   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)...);
 }
 
 /// \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.
-/// 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
 /// wrapped.
 StencilPart expression(llvm::StringRef Id);
 
 /// Constructs an idiomatic dereferencing of the expression bound to \p ExprId.
 /// \p ExprId is wrapped in parentheses, if needed.

 /// Wraps a MatchConsumer in a StencilPart, so that it can be used in a Stencil.
 /// This supports user-defined extensions to the Stencil language.
 StencilPart run(MatchConsumer<std::string> C);
 
 /// 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 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
 #endif // LLVM_CLANG_TOOLING_TRANSFORMER_STENCIL_H_

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

public:
   using ChangeConsumer =
       std::function<void(Expected<clang::tooling::AtomicChange> Change)>;
 
   /// \param Consumer Receives each rewrite or error.  Will not necessarily be
   /// called for each match; for example, if the rewrite is not applicable
   /// 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
   /// be moved after this call.
   void registerMatchers(ast_matchers::MatchFinder *MatchFinder);
 
   /// Not called directly by users -- called by the framework, via base class
   /// pointer.
   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;
 };
 } // namespace tooling
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLING_TRANSFORMER_TRANSFORMER_H_

clang/lib/Tooling/Transformer/RangeSelector.cpp

 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/Errc.h"
 #include "llvm/Support/Error.h"
 #include <string>
 #include <utility>
 #include <vector>
 
 using namespace clang;
-using namespace tooling;
+using namespace transformer;
 
 using ast_matchers::MatchFinder;
 using ast_type_traits::ASTNodeKind;
 using ast_type_traits::DynTypedNode;
 using llvm::Error;
 using llvm::StringError;
 
 using MatchResult = MatchFinder::MatchResult;

 
 static SourceLocation findOpenParen(const CallExpr &E, const SourceManager &SM,
                                     const LangOptions &LangOpts) {
   SourceLocation EndLoc =
       E.getNumArgs() == 0 ? E.getRParenLoc() : E.getArg(0)->getBeginLoc();
   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)
       return SelectedRange.takeError();
     return CharSourceRange::getCharRange(SelectedRange->getBegin());
   };
 }
 
-RangeSelector tooling::after(RangeSelector Selector) {
+RangeSelector transformer::after(RangeSelector Selector) {
   return [Selector](const MatchResult &Result) -> Expected<CharSourceRange> {
     Expected<CharSourceRange> SelectedRange = Selector(Result);
     if (!SelectedRange)
       return SelectedRange.takeError();
     if (SelectedRange->isCharRange())
       return CharSourceRange::getCharRange(SelectedRange->getEnd());
     return CharSourceRange::getCharRange(Lexer::getLocForEndOfToken(
         SelectedRange->getEnd(), 0, Result.Context->getSourceManager(),
         Result.Context->getLangOpts()));
   };
 }
 
-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)
       return BeginRange.takeError();
     Expected<CharSourceRange> EndRange = End(Result);
     if (!EndRange)
       return EndRange.takeError();
     SourceLocation B = BeginRange->getBegin();
     SourceLocation E = EndRange->getEnd();
     // Note: we are precluding the possibility of sub-token ranges in the case
     // that EndRange is a token range.
     if (Result.SourceManager->isBeforeInTranslationUnit(E, B)) {
       return invalidArgumentError("Bad range: out of order");
     }
     return CharSourceRange(SourceRange(B, E), EndRange->isTokenRange());
   };
 }
 
-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)
       return Node.takeError();
     if (auto *M = Node->get<clang::MemberExpr>())
       return CharSourceRange::getTokenRange(
           M->getMemberNameInfo().getSourceRange());
     return typeError(ID, Node->getNodeKind(), "MemberExpr");
   };
 }
 
-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)
       return N.takeError();
     auto &Node = *N;
     if (const auto *D = Node.get<NamedDecl>()) {
       if (!D->getDeclName().isIdentifier())
         return missingPropertyError(ID, "name", "identifier");
       SourceLocation L = D->getLocation();
       auto R = CharSourceRange::getTokenRange(L, L);
       // Verify that the range covers exactly the name.
       // FIXME: extend this code to support cases like `operator +` or
       // `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;
     }
     if (const auto *E = Node.get<DeclRefExpr>()) {
       if (!E->getNameInfo().getName().isIdentifier())
         return missingPropertyError(ID, "name", "identifier");
       SourceLocation L = E->getLocation();
       return CharSourceRange::getTokenRange(L, L);

 // Returns the range of the statements (all source between the braces).
 CharSourceRange getStatementsRange(const MatchResult &,
                                    const CompoundStmt &CS) {
   return CharSourceRange::getCharRange(CS.getLBracLoc().getLocWithOffset(1),
                                        CS.getRBracLoc());
 }
 } // namespace
 
-RangeSelector tooling::statements(std::string ID) {
+RangeSelector transformer::statements(std::string ID) {
   return RelativeSelector<CompoundStmt, getStatementsRange>(std::move(ID));
 }
 
 namespace {
 // Returns the range of the source between the call's parentheses.
 CharSourceRange getCallArgumentsRange(const MatchResult &Result,
                                       const CallExpr &CE) {
   return CharSourceRange::getCharRange(
       findOpenParen(CE, *Result.SourceManager, Result.Context->getLangOpts())
           .getLocWithOffset(1),
       CE.getRParenLoc());
 }
 } // namespace
 
-RangeSelector tooling::callArgs(std::string ID) {
+RangeSelector transformer::callArgs(std::string ID) {
   return RelativeSelector<CallExpr, getCallArgumentsRange>(std::move(ID));
 }
 
 namespace {
 // Returns the range of the elements of the initializer list. Includes all
 // source between the braces.
 CharSourceRange getElementsRange(const MatchResult &,
                                  const InitListExpr &E) {
   return CharSourceRange::getCharRange(E.getLBraceLoc().getLocWithOffset(1),
                                        E.getRBraceLoc());
 }
 } // 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)
       return SRange.takeError();
     return Result.SourceManager->getExpansionRange(*SRange);
   };
 }

clang/lib/Tooling/Transformer/RewriteRule.cpp

 #include "llvm/Support/Errc.h"
 #include "llvm/Support/Error.h"
 #include <map>
 #include <string>
 #include <utility>
 #include <vector>
 
 using namespace clang;
-using namespace tooling;
+using namespace transformer;
 
 using ast_matchers::MatchFinder;
 using ast_matchers::internal::DynTypedMatcher;
 using ast_type_traits::ASTNodeKind;
 
 using MatchResult = MatchFinder::MatchResult;
 
-Expected<SmallVector<tooling::detail::Transformation, 1>>
-tooling::detail::translateEdits(const MatchResult &Result,
+Expected<SmallVector<transformer::detail::Transformation, 1>>
+transformer::detail::translateEdits(const MatchResult &Result,
                                 llvm::ArrayRef<ASTEdit> Edits) {
-  SmallVector<tooling::detail::Transformation, 1> Transformations;
+  SmallVector<transformer::detail::Transformation, 1> Transformations;
   for (const auto &Edit : Edits) {
     Expected<CharSourceRange> Range = Edit.TargetRange(Result);
     if (!Range)
       return Range.takeError();
     llvm::Optional<CharSourceRange> EditRange =
-        getRangeForEdit(*Range, *Result.Context);
+        tooling::getRangeForEdit(*Range, *Result.Context);
     // FIXME: let user specify whether to treat this case as an error or ignore
     // it as is currently done.
     if (!EditRange)
       return SmallVector<Transformation, 0>();
     auto Replacement = Edit.Replacement(Result);
     if (!Replacement)
       return Replacement.takeError();
-    tooling::detail::Transformation T;
+    transformer::detail::Transformation T;
     T.Range = *EditRange;
     T.Replacement = std::move(*Replacement);
     Transformations.push_back(std::move(T));
   }
   return Transformations;
 }
 
-ASTEdit tooling::change(RangeSelector S, TextGenerator Replacement) {
+ASTEdit transformer::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,
+RewriteRule transformer::makeRule(DynTypedMatcher M, SmallVector<ASTEdit, 1> Edits,
                               TextGenerator Explanation) {
   return RewriteRule{{RewriteRule::Case{
       std::move(M), std::move(Edits), std::move(Explanation), {}}}};
 }
 
-void tooling::addInclude(RewriteRule &Rule, StringRef Header,
+void transformer::addInclude(RewriteRule &Rule, StringRef Header,
                          IncludeFormat Format) {
   for (auto &Case : Rule.Cases)
     Case.AddedIncludes.emplace_back(Header.str(), Format);
 }
 
 #ifndef NDEBUG
 // Filters for supported matcher kinds. FIXME: Explicitly list the allowed kinds
 // (all node matcher types except for `QualType` and `Type`), rather than just
for (const auto &Case : Cases) {
     Matchers.push_back(*std::move(M));
   }
   return Matchers;
 }
 
 // Simply gathers the contents of the various rules into a single rule. The
 // actual work to combine these into an ordered choice is deferred to matcher
 // registration.
-RewriteRule tooling::applyFirst(ArrayRef<RewriteRule> Rules) {
+RewriteRule transformer::applyFirst(ArrayRef<RewriteRule> Rules) {
   RewriteRule R;
   for (auto &Rule : Rules)
     R.Cases.append(Rule.Cases.begin(), Rule.Cases.end());
   return R;
 }
 
 std::vector<DynTypedMatcher>
-tooling::detail::buildMatchers(const RewriteRule &Rule) {
+transformer::detail::buildMatchers(const RewriteRule &Rule) {
   // Map the cases into buckets of matchers -- one for each "root" AST kind,
   // which guarantees that they can be combined in a single anyOf matcher. Each
   // case is paired with an identifying number that is converted to a string id
   // in `taggedMatchers`.
   std::map<ASTNodeKind, SmallVector<std::pair<size_t, RewriteRule::Case>, 1>>
       Buckets;
   const SmallVectorImpl<RewriteRule::Case> &Cases = Rule.Cases;
   for (int I = 0, N = Cases.size(); I < N; ++I) {
DynTypedMatcher M = DynTypedMatcher::constructVariadic(
         taggedMatchers("Tag", Bucket.second));
     M.setAllowBind(true);
     // `tryBind` is guaranteed to succeed, because `AllowBind` was set to true.
     Matchers.push_back(*M.tryBind(RewriteRule::RootID));
   }
   return Matchers;
 }
 
-DynTypedMatcher tooling::detail::buildMatcher(const RewriteRule &Rule) {
+DynTypedMatcher transformer::detail::buildMatcher(const RewriteRule &Rule) {
   std::vector<DynTypedMatcher> Ms = buildMatchers(Rule);
   assert(Ms.size() == 1 && "Cases must have compatible matchers.");
   return Ms[0];
 }
 
-SourceLocation tooling::detail::getRuleMatchLoc(const MatchResult &Result) {
+SourceLocation transformer::detail::getRuleMatchLoc(const MatchResult &Result) {
   auto &NodesMap = Result.Nodes.getMap();
   auto Root = NodesMap.find(RewriteRule::RootID);
   assert(Root != NodesMap.end() && "Transformation failed: missing root node.");
-  llvm::Optional<CharSourceRange> RootRange = getRangeForEdit(
+  llvm::Optional<CharSourceRange> RootRange = tooling::getRangeForEdit(
       CharSourceRange::getTokenRange(Root->second.getSourceRange()),
       *Result.Context);
   if (RootRange)
     return RootRange->getBegin();
   // The match doesn't have a coherent range, so fall back to the expansion
   // location as the "beginning" of the match.
   return Result.SourceManager->getExpansionLoc(
       Root->second.getSourceRange().getBegin());
 }
 
 // Finds the case that was "selected" -- that is, whose matcher triggered the
 // `MatchResult`.
 const RewriteRule::Case &
-tooling::detail::findSelectedCase(const MatchResult &Result,
+transformer::detail::findSelectedCase(const MatchResult &Result,
                                   const RewriteRule &Rule) {
   if (Rule.Cases.size() == 1)
     return Rule.Cases[0];
 
   auto &NodesMap = Result.Nodes.getMap();
   for (size_t i = 0, N = Rule.Cases.size(); i < N; ++i) {
     std::string Tag = ("Tag" + Twine(i)).str();
     if (NodesMap.find(Tag) != NodesMap.end())
       return Rule.Cases[i];
   }
   llvm_unreachable("No tag found for this rule.");
 }
 
 constexpr llvm::StringLiteral RewriteRule::RootID;

clang/lib/Tooling/Transformer/Stencil.cpp

 #include "clang/Tooling/Transformer/SourceCodeBuilders.h"
 #include "llvm/ADT/Twine.h"
 #include "llvm/Support/Errc.h"
 #include <atomic>
 #include <memory>
 #include <string>
 
 using namespace clang;
-using namespace tooling;
+using namespace transformer;
 
 using ast_matchers::MatchFinder;
 using ast_type_traits::DynTypedNode;
 using llvm::errc;
 using llvm::Error;
 using llvm::Expected;
 using llvm::StringError;
 
Error evalData(const UnaryOperationData &Data,
                const MatchFinder::MatchResult &Match, std::string *Result) {
   const auto *E = Match.Nodes.getNodeAs<Expr>(Data.Id);
   if (E == nullptr)
     return llvm::make_error<StringError>(
         errc::invalid_argument, "Id not bound or not Expr: " + Data.Id);
   llvm::Optional<std::string> Source;
   switch (Data.Op) {
   case UnaryNodeOperator::Parens:
-    Source = buildParens(*E, *Match.Context);
+    Source = tooling::buildParens(*E, *Match.Context);
     break;
   case UnaryNodeOperator::Deref:
-    Source = buildDereference(*E, *Match.Context);
+    Source = tooling::buildDereference(*E, *Match.Context);
     break;
   case UnaryNodeOperator::Address:
-    Source = buildAddressOf(*E, *Match.Context);
+    Source = tooling::buildAddressOf(*E, *Match.Context);
     break;
   }
   if (!Source)
     return llvm::make_error<StringError>(
         errc::invalid_argument,
         "Could not construct expression source from ID: " + Data.Id);
   *Result += *Source;
   return Error::success();
 }
 
 Error evalData(const SelectorData &Data, const MatchFinder::MatchResult &Match,
                std::string *Result) {
   auto Range = Data.Selector(Match);
   if (!Range)
     return Range.takeError();
-  *Result += getText(*Range, *Match.Context);
+  *Result += tooling::getText(*Range, *Match.Context);
   return Error::success();
 }
 
 Error evalData(const AccessData &Data, const MatchFinder::MatchResult &Match,
                std::string *Result) {
   const auto *E = Match.Nodes.getNodeAs<Expr>(Data.BaseId);
   if (E == nullptr)
     return llvm::make_error<StringError>(errc::invalid_argument,
                                          "Id not bound: " + Data.BaseId);
   if (!E->isImplicitCXXThis()) {
-    if (llvm::Optional<std::string> S = E->getType()->isAnyPointerType()
-                                            ? buildArrow(*E, *Match.Context)
-                                            : buildDot(*E, *Match.Context))
+    if (llvm::Optional<std::string> S =
+            E->getType()->isAnyPointerType()
+                ? tooling::buildArrow(*E, *Match.Context)
+                : tooling::buildDot(*E, *Match.Context))
       *Result += *S;
     else
       return llvm::make_error<StringError>(
           errc::invalid_argument,
           "Could not construct object text from ID: " + Data.BaseId);
   }
   return Data.Member.eval(Match, Result);
 }
Error eval(const MatchFinder::MatchResult &Match,
     return evalData(Data, Match, Result);
   }
 
   std::string toString() const override { return toStringData(Data); }
 };
 } // namespace
 
 StencilPart Stencil::wrap(StringRef Text) {
-  return stencil::text(Text);
+  return transformer::text(Text);
 }
 
 StencilPart Stencil::wrap(RangeSelector Selector) {
-  return stencil::selection(std::move(Selector));
+  return transformer::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) {
+StencilPart transformer::text(StringRef Text) {
   return StencilPart(std::make_shared<StencilPartImpl<RawTextData>>(Text));
 }
 
-StencilPart stencil::selection(RangeSelector Selector) {
+StencilPart transformer::selection(RangeSelector Selector) {
   return StencilPart(
       std::make_shared<StencilPartImpl<SelectorData>>(std::move(Selector)));
 }
 
-StencilPart stencil::dPrint(StringRef Id) {
+StencilPart transformer::dPrint(StringRef Id) {
   return StencilPart(std::make_shared<StencilPartImpl<DebugPrintNodeData>>(Id));
 }
 
-StencilPart stencil::expression(llvm::StringRef Id) {
+StencilPart transformer::expression(llvm::StringRef Id) {
   return StencilPart(std::make_shared<StencilPartImpl<UnaryOperationData>>(
       UnaryNodeOperator::Parens, Id));
 }
 
-StencilPart stencil::deref(llvm::StringRef ExprId) {
+StencilPart transformer::deref(llvm::StringRef ExprId) {
   return StencilPart(std::make_shared<StencilPartImpl<UnaryOperationData>>(
       UnaryNodeOperator::Deref, ExprId));
 }
 
-StencilPart stencil::addressOf(llvm::StringRef ExprId) {
+StencilPart transformer::addressOf(llvm::StringRef ExprId) {
   return StencilPart(std::make_shared<StencilPartImpl<UnaryOperationData>>(
       UnaryNodeOperator::Address, ExprId));
 }
 
-StencilPart stencil::access(StringRef BaseId, StencilPart Member) {
+StencilPart transformer::access(StringRef BaseId, StencilPart Member) {
   return StencilPart(
       std::make_shared<StencilPartImpl<AccessData>>(BaseId, std::move(Member)));
 }
 
-StencilPart stencil::ifBound(StringRef Id, StencilPart TruePart,
+StencilPart transformer::ifBound(StringRef Id, StencilPart TruePart,
                              StencilPart FalsePart) {
   return StencilPart(std::make_shared<StencilPartImpl<IfBoundData>>(
       Id, std::move(TruePart), std::move(FalsePart)));
 }
 
-StencilPart stencil::run(MatchConsumer<std::string> Fn) {
+StencilPart transformer::run(MatchConsumer<std::string> Fn) {
   return StencilPart(
       std::make_shared<StencilPartImpl<MatchConsumer<std::string>>>(
           std::move(Fn)));
 }

clang/lib/Tooling/Transformer/Transformer.cpp

 #include <vector>
 
 using namespace clang;
 using namespace tooling;
 
 using ast_matchers::MatchFinder;
 
 void Transformer::registerMatchers(MatchFinder *MatchFinder) {
-  for (auto &Matcher : tooling::detail::buildMatchers(Rule))
+  for (auto &Matcher : transformer::detail::buildMatchers(Rule))
     MatchFinder->addDynamicMatcher(Matcher, this);
 }
 
 void Transformer::run(const MatchFinder::MatchResult &Result) {
   if (Result.Context->getDiagnostics().hasErrorOccurred())
     return;
 
-  RewriteRule::Case Case = tooling::detail::findSelectedCase(Result, Rule);
-  auto Transformations = tooling::detail::translateEdits(Result, Case.Edits);
+  transformer::RewriteRule::Case Case =
+      transformer::detail::findSelectedCase(Result, Rule);
+  auto Transformations = transformer::detail::translateEdits(Result, Case.Edits);
   if (!Transformations) {
     Consumer(Transformations.takeError());
     return;
   }
 
   if (Transformations->empty()) {
     // No rewrite applied (but no error encountered either).
-    tooling::detail::getRuleMatchLoc(Result).print(
+    transformer::detail::getRuleMatchLoc(Result).print(
         llvm::errs() << "note: skipping match at loc ", *Result.SourceManager);
     llvm::errs() << "\n";
     return;
   }
 
   // Record the results in the AtomicChange, anchored at the location of the
   // first change.
   AtomicChange AC(*Result.SourceManager,
                   (*Transformations)[0].Range.getBegin());
   for (const auto &T : *Transformations) {
     if (auto Err = AC.replace(*Result.SourceManager, T.Range, T.Replacement)) {
       Consumer(std::move(Err));
       return;
     }
   }
 
   for (const auto &I : Case.AddedIncludes) {
     auto &Header = I.first;
     switch (I.second) {
-    case IncludeFormat::Quoted:
+    case transformer::IncludeFormat::Quoted:
       AC.addHeader(Header);
       break;
-    case IncludeFormat::Angled:
+    case transformer::IncludeFormat::Angled:
       AC.addHeader((llvm::Twine("<") + Header + ">").str());
       break;
     }
   }
 
   Consumer(std::move(AC));
 }

clang/unittests/Tooling/RangeSelectorTest.cpp

 //===- unittest/Tooling/RangeSelectorTest.cpp -----------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "clang/Tooling/Transformer/RangeSelector.h"
 #include "clang/ASTMatchers/ASTMatchers.h"
 #include "clang/Frontend/ASTUnit.h"
 #include "clang/Tooling/FixIt.h"
 #include "clang/Tooling/Tooling.h"
+#include "clang/Tooling/Transformer/SourceCode.h"
 #include "llvm/Support/Error.h"
 #include "llvm/Testing/Support/Error.h"
 #include "gmock/gmock.h"
 #include "gtest/gtest.h"
 
 using namespace clang;
-using namespace tooling;
+using namespace transformer;
 using namespace ast_matchers;
 
 namespace {
 using ::llvm::Expected;
 using ::llvm::Failed;
 using ::llvm::HasValue;
 using ::llvm::StringError;
 using ::testing::AllOf;
 using ::testing::HasSubstr;
 using ::testing::Property;
 
 using MatchResult = MatchFinder::MatchResult;
 
 struct TestMatch {
   // The AST unit from which `result` is built. We bundle it because it backs
   // the result. Users are not expected to access it.
   std::unique_ptr<clang::ASTUnit> ASTUnit;
   // The result to use in the test. References `ast_unit`.
   MatchResult Result;
 };
 
 template <typename M> TestMatch matchCode(StringRef Code, M Matcher) {
-  auto ASTUnit = buildASTFromCode(Code);
+  auto ASTUnit = tooling::buildASTFromCode(Code);
   assert(ASTUnit != nullptr && "AST construction failed");
 
   ASTContext &Context = ASTUnit->getASTContext();
   assert(!Context.getDiagnostics().hasErrorOccurred() && "Compilation error");
 
   auto Matches = ast_matchers::match(Matcher, Context);
   // We expect a single, exact match.
   assert(Matches.size() != 0 && "no matches found");
   assert(Matches.size() == 1 && "too many matches");
 
   return TestMatch{std::move(ASTUnit), MatchResult(Matches[0], &Context)};
 }
 
 // Applies \p Selector to \p Match and, on success, returns the selected source.
 Expected<StringRef> select(RangeSelector Selector, const TestMatch &Match) {
   Expected<CharSourceRange> Range = Selector(Match.Result);
   if (!Range)
     return Range.takeError();
-  return fixit::internal::getText(*Range, *Match.Result.Context);
+  return tooling::getText(*Range, *Match.Result.Context);
 }
 
 // Applies \p Selector to a trivial match with only a single bound node with id
 // "bound_node_id".  For use in testing unbound-node errors.
 Expected<CharSourceRange> selectFromTrivial(const RangeSelector &Selector) {
   // We need to bind the result to something, or the match will fail. Use a
   // binding that is not used in the unbound node tests.
   TestMatch Match =

clang/unittests/Tooling/StencilTest.cpp

 #include "clang/Tooling/FixIt.h"
 #include "clang/Tooling/Tooling.h"
 #include "llvm/Support/Error.h"
 #include "llvm/Testing/Support/Error.h"
 #include "gmock/gmock.h"
 #include "gtest/gtest.h"
 
 using namespace clang;
-using namespace tooling;
+using namespace transformer;
 using namespace ast_matchers;
 
 namespace {
 using ::llvm::Failed;
 using ::llvm::HasValue;
 using ::llvm::StringError;
 using ::testing::AllOf;
 using ::testing::Eq;
 using ::testing::HasSubstr;
 using MatchResult = MatchFinder::MatchResult;
-using stencil::access;
-using stencil::addressOf;
-using stencil::cat;
-using stencil::deref;
-using stencil::dPrint;
-using stencil::expression;
-using stencil::ifBound;
-using stencil::run;
-using stencil::text;
 
 // Create a valid translation-unit from a statement.
 static std::string wrapSnippet(StringRef StatementCode) {
   return ("struct S { int field; }; auto stencil_test_snippet = []{" +
           StatementCode + "};")
       .str();
 }
 

 
 // Matches `Matcher` against the statement `StatementCode` and returns the
 // result. Handles putting the statement inside a function and modifying the
 // matcher correspondingly. `Matcher` should match one of the statements in
 // `StatementCode` exactly -- that is, produce exactly one match. However,
 // `StatementCode` may contain other statements not described by `Matcher`.
 static llvm::Optional<TestMatch> matchStmt(StringRef StatementCode,
                                            StatementMatcher Matcher) {
-  auto AstUnit = buildASTFromCode(wrapSnippet(StatementCode));
+  auto AstUnit = tooling::buildASTFromCode(wrapSnippet(StatementCode));
   if (AstUnit == nullptr) {
     ADD_FAILURE() << "AST construction failed";
     return llvm::None;
   }
   ASTContext &Context = AstUnit->getASTContext();
   auto Matches = ast_matchers::match(wrapMatcher(Matcher), Context);
   // We expect a single, exact match for the statement.
   if (Matches.size() != 1) {

clang/unittests/Tooling/TransformerTest.cpp

 #include "llvm/Support/Errc.h"
 #include "llvm/Support/Error.h"
 #include "gmock/gmock.h"
 #include "gtest/gtest.h"
 
 using namespace clang;
 using namespace tooling;
 using namespace ast_matchers;
-
 namespace {
 using ::testing::IsEmpty;
+using transformer::RewriteRule;
+using transformer::value;
 
 constexpr char KHeaderContents[] = R"cc(
   struct string {
     string(const char*);
     char* c_str();
     int size();
   };
   int strlen(const char*);
TEST_F(TransformerTest, AddIncludeQuoted) {
   )cc";
 
   testRule(Rule, Input, Expected);
 }
 
 TEST_F(TransformerTest, AddIncludeAngled) {
   RewriteRule Rule = makeRule(callExpr(callee(functionDecl(hasName("f")))),
                               change(text("other()")));
-  addInclude(Rule, "clang/OtherLib.h", IncludeFormat::Angled);
+  addInclude(Rule, "clang/OtherLib.h", transformer::IncludeFormat::Angled);
 
   std::string Input = R"cc(
     int f(int x);
     int h(int x) { return f(x); }
   )cc";
   std::string Expected = R"cc(#include <clang/OtherLib.h>
 
     int f(int x);
RewriteRule ReplaceF1 =
                change(text("REPLACE_F1")));
   RewriteRule ReplaceF1OrF2 =
       makeRule(callExpr(callee(functionDecl(hasAnyName("f1", "f2")))),
                change(text("REPLACE_F1_OR_F2")));
   RewriteRule DeclRule = makeRule(functionDecl(hasName("f2")).bind("fun"),
                                   change(name("fun"), text("DECL_RULE")));
 
   RewriteRule Rule = applyFirst({ReplaceF1, DeclRule, ReplaceF1OrF2});
-  EXPECT_EQ(tooling::detail::buildMatchers(Rule).size(), 2UL);
+  EXPECT_EQ(transformer::detail::buildMatchers(Rule).size(), 2UL);
   testRule(Rule, Input, Expected);
 }
 
 //
 // Negative tests (where we expect no transformation to occur).
 //
 
 // Tests for a conflict in edits from a single match for a rule.
#define MACRO(str) 1 + NESTED(strlen((str).c_str()))
   testRule(ruleStrlenSize(), Input, Input);
 }
 
 #if !defined(NDEBUG) && GTEST_HAS_DEATH_TEST
 // Verifies that `Type` and `QualType` are not allowed as top-level matchers in
 // rules.
 TEST(TransformerDeathTest, OrderedRuleTypes) {
   RewriteRule QualTypeRule = makeRule(qualType(), change(text("Q")));
-  EXPECT_DEATH(tooling::detail::buildMatchers(QualTypeRule),
+  EXPECT_DEATH(transformer::detail::buildMatchers(QualTypeRule),
                "Matcher must be.*node matcher");
 
   RewriteRule TypeRule = makeRule(arrayType(), change(text("T")));
-  EXPECT_DEATH(tooling::detail::buildMatchers(TypeRule),
+  EXPECT_DEATH(transformer::detail::buildMatchers(TypeRule),
                "Matcher must be.*node matcher");
 }
 #endif
 } // namespace