[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

git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@374962 91177308-0d34-0410-b5e6-96231b3b80d8

4 files changed, 63 insertions, 59 deletions

diff --git a/lib/Tooling/Transformer/RangeSelector.cpp b/lib/Tooling/Transformer/RangeSelector.cpp
index 496c2d987c..9f81423c90 100644
--- a/lib/Tooling/Transformer/RangeSelector.cpp
+++ b/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)
diff --git a/lib/Tooling/Transformer/RewriteRule.cpp b/lib/Tooling/Transformer/RewriteRule.cpp
index 605b5031ca..6fa558f7b2 100644
--- a/lib/Tooling/Transformer/RewriteRule.cpp
+++ b/lib/Tooling/Transformer/RewriteRule.cpp
@@ -21,7 +21,7 @@
 #include <vector>
 
 using namespace clang;
-using namespace tooling;
+using namespace transformer;
 
 using ast_matchers::MatchFinder;
 using ast_matchers::internal::DynTypedMatcher;
@@ -29,16 +29,16 @@ 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)
@@ -46,7 +46,7 @@ tooling::detail::translateEdits(const MatchResult &Result,
     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));
@@ -54,20 +54,20 @@ tooling::detail::translateEdits(const MatchResult &Result,
   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);
@@ -103,7 +103,7 @@ static std::vector<DynTypedMatcher> taggedMatchers(
 // 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());
@@ -111,7 +111,7 @@ RewriteRule tooling::applyFirst(ArrayRef<RewriteRule> Rules) {
 }
 
 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
@@ -137,17 +137,17 @@ tooling::detail::buildMatchers(const RewriteRule &Rule) {
   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)
@@ -161,7 +161,7 @@ SourceLocation tooling::detail::getRuleMatchLoc(const MatchResult &Result) {
 // 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];
diff --git a/lib/Tooling/Transformer/Stencil.cpp b/lib/Tooling/Transformer/Stencil.cpp
index d252449418..984950a54e 100644
--- a/lib/Tooling/Transformer/Stencil.cpp
+++ b/lib/Tooling/Transformer/Stencil.cpp
@@ -22,7 +22,7 @@
 #include <string>
 
 using namespace clang;
-using namespace tooling;
+using namespace transformer;
 
 using ast_matchers::MatchFinder;
 using ast_type_traits::DynTypedNode;
@@ -171,13 +171,13 @@ Error evalData(const UnaryOperationData &Data,
   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)
@@ -193,7 +193,7 @@ Error evalData(const SelectorData &Data, const MatchFinder::MatchResult &Match,
   auto Range = Data.Selector(Match);
   if (!Range)
     return Range.takeError();
-  *Result += getText(*Range, *Match.Context);
+  *Result += tooling::getText(*Range, *Match.Context);
   return Error::success();
 }
 
@@ -204,9 +204,10 @@ Error evalData(const AccessData &Data, const MatchFinder::MatchResult &Match,
     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>(
@@ -250,11 +251,11 @@ public:
 } // 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) {
@@ -271,46 +272,46 @@ Stencil::eval(const MatchFinder::MatchResult &Match) const {
   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)));
diff --git a/lib/Tooling/Transformer/Transformer.cpp b/lib/Tooling/Transformer/Transformer.cpp
index 3baa1b9ff2..71f0646f4c 100644
--- a/lib/Tooling/Transformer/Transformer.cpp
+++ b/lib/Tooling/Transformer/Transformer.cpp
@@ -21,7 +21,7 @@ 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);
 }
 
@@ -29,8 +29,9 @@ 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;
@@ -38,7 +39,7 @@ void Transformer::run(const MatchFinder::MatchResult &Result) {
 
   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;
@@ -58,10 +59,10 @@ void Transformer::run(const MatchFinder::MatchResult &Result) {
   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;
     }