r374962 - [libTooling] Put all Transformer declarations in a single namespace.
Yitzhak Mandelbaum via cfe-commits
cfe-commits at lists.llvm.org
Tue Oct 15 18:06:46 PDT 2019
Author: ymandel
Date: Tue Oct 15 18:06:46 2019
New Revision: 374962
URL: http://llvm.org/viewvc/llvm-project?rev=374962&view=rev
Log:
[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
Modified:
cfe/trunk/include/clang/Tooling/Transformer/MatchConsumer.h
cfe/trunk/include/clang/Tooling/Transformer/RangeSelector.h
cfe/trunk/include/clang/Tooling/Transformer/RewriteRule.h
cfe/trunk/include/clang/Tooling/Transformer/Stencil.h
cfe/trunk/include/clang/Tooling/Transformer/Transformer.h
cfe/trunk/lib/Tooling/Transformer/RangeSelector.cpp
cfe/trunk/lib/Tooling/Transformer/RewriteRule.cpp
cfe/trunk/lib/Tooling/Transformer/Stencil.cpp
cfe/trunk/lib/Tooling/Transformer/Transformer.cpp
cfe/trunk/unittests/Tooling/RangeSelectorTest.cpp
cfe/trunk/unittests/Tooling/StencilTest.cpp
cfe/trunk/unittests/Tooling/TransformerTest.cpp
Modified: cfe/trunk/include/clang/Tooling/Transformer/MatchConsumer.h
URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/include/clang/Tooling/Transformer/MatchConsumer.h?rev=374962&r1=374961&r2=374962&view=diff
==============================================================================
--- cfe/trunk/include/clang/Tooling/Transformer/MatchConsumer.h (original)
+++ cfe/trunk/include/clang/Tooling/Transformer/MatchConsumer.h Tue Oct 15 18:06:46 2019
@@ -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,
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_
Modified: cfe/trunk/include/clang/Tooling/Transformer/RangeSelector.h
URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/include/clang/Tooling/Transformer/RangeSelector.h?rev=374962&r1=374961&r2=374962&view=diff
==============================================================================
--- cfe/trunk/include/clang/Tooling/Transformer/RangeSelector.h (original)
+++ cfe/trunk/include/clang/Tooling/Transformer/RangeSelector.h Tue Oct 15 18:06:46 2019
@@ -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
Modified: cfe/trunk/include/clang/Tooling/Transformer/RewriteRule.h
URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/include/clang/Tooling/Transformer/RewriteRule.h?rev=374962&r1=374961&r2=374962&view=diff
==============================================================================
--- cfe/trunk/include/clang/Tooling/Transformer/RewriteRule.h (original)
+++ cfe/trunk/include/clang/Tooling/Transformer/RewriteRule.h Tue Oct 15 18:06:46 2019
@@ -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
Modified: cfe/trunk/include/clang/Tooling/Transformer/Stencil.h
URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/include/clang/Tooling/Transformer/Stencil.h?rev=374962&r1=374961&r2=374962&view=diff
==============================================================================
--- cfe/trunk/include/clang/Tooling/Transformer/Stencil.h (original)
+++ cfe/trunk/include/clang/Tooling/Transformer/Stencil.h Tue Oct 15 18:06:46 2019
@@ -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 @@ private:
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::strin
///
/// \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
Modified: cfe/trunk/include/clang/Tooling/Transformer/Transformer.h
URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/include/clang/Tooling/Transformer/Transformer.h?rev=374962&r1=374961&r2=374962&view=diff
==============================================================================
--- cfe/trunk/include/clang/Tooling/Transformer/Transformer.h (original)
+++ cfe/trunk/include/clang/Tooling/Transformer/Transformer.h Tue Oct 15 18:06:46 2019
@@ -30,7 +30,7 @@ public:
/// 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 @@ public:
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;
};
Modified: cfe/trunk/lib/Tooling/Transformer/RangeSelector.cpp
URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/Tooling/Transformer/RangeSelector.cpp?rev=374962&r1=374961&r2=374962&view=diff
==============================================================================
--- cfe/trunk/lib/Tooling/Transformer/RangeSelector.cpp (original)
+++ cfe/trunk/lib/Tooling/Transformer/RangeSelector.cpp Tue Oct 15 18:06:46 2019
@@ -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(cons
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(RangeSelec
};
}
-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(RangeSelect
};
}
-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(RangeSelect
};
}
-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::strin
};
}
-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
// `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
}
} // 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(co
}
} // 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 M
}
} // 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)
Modified: cfe/trunk/lib/Tooling/Transformer/RewriteRule.cpp
URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/Tooling/Transformer/RewriteRule.cpp?rev=374962&r1=374961&r2=374962&view=diff
==============================================================================
--- cfe/trunk/lib/Tooling/Transformer/RewriteRule.cpp (original)
+++ cfe/trunk/lib/Tooling/Transformer/RewriteRule.cpp Tue Oct 15 18:06:46 2019
@@ -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 Ma
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 Ma
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> tagg
// 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
}
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 Rew
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::getRuleM
// 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];
Modified: cfe/trunk/lib/Tooling/Transformer/Stencil.cpp
URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/Tooling/Transformer/Stencil.cpp?rev=374962&r1=374961&r2=374962&view=diff
==============================================================================
--- cfe/trunk/lib/Tooling/Transformer/Stencil.cpp (original)
+++ cfe/trunk/lib/Tooling/Transformer/Stencil.cpp Tue Oct 15 18:06:46 2019
@@ -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
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,
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, c
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::MatchRe
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)));
Modified: cfe/trunk/lib/Tooling/Transformer/Transformer.cpp
URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/Tooling/Transformer/Transformer.cpp?rev=374962&r1=374961&r2=374962&view=diff
==============================================================================
--- cfe/trunk/lib/Tooling/Transformer/Transformer.cpp (original)
+++ cfe/trunk/lib/Tooling/Transformer/Transformer.cpp Tue Oct 15 18:06:46 2019
@@ -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:
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:
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:
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;
}
Modified: cfe/trunk/unittests/Tooling/RangeSelectorTest.cpp
URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/unittests/Tooling/RangeSelectorTest.cpp?rev=374962&r1=374961&r2=374962&view=diff
==============================================================================
--- cfe/trunk/unittests/Tooling/RangeSelectorTest.cpp (original)
+++ cfe/trunk/unittests/Tooling/RangeSelectorTest.cpp Tue Oct 15 18:06:46 2019
@@ -9,15 +9,15 @@
#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 {
@@ -40,7 +40,7 @@ struct TestMatch {
};
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();
@@ -59,7 +59,7 @@ Expected<StringRef> select(RangeSelector
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
Modified: cfe/trunk/unittests/Tooling/StencilTest.cpp
URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/unittests/Tooling/StencilTest.cpp?rev=374962&r1=374961&r2=374962&view=diff
==============================================================================
--- cfe/trunk/unittests/Tooling/StencilTest.cpp (original)
+++ cfe/trunk/unittests/Tooling/StencilTest.cpp Tue Oct 15 18:06:46 2019
@@ -16,7 +16,7 @@
#include "gtest/gtest.h"
using namespace clang;
-using namespace tooling;
+using namespace transformer;
using namespace ast_matchers;
namespace {
@@ -27,15 +27,6 @@ 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) {
@@ -64,7 +55,7 @@ struct TestMatch {
// `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;
Modified: cfe/trunk/unittests/Tooling/TransformerTest.cpp
URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/unittests/Tooling/TransformerTest.cpp?rev=374962&r1=374961&r2=374962&view=diff
==============================================================================
--- cfe/trunk/unittests/Tooling/TransformerTest.cpp (original)
+++ cfe/trunk/unittests/Tooling/TransformerTest.cpp Tue Oct 15 18:06:46 2019
@@ -18,9 +18,10 @@
using namespace clang;
using namespace tooling;
using namespace ast_matchers;
-
namespace {
using ::testing::IsEmpty;
+using transformer::RewriteRule;
+using transformer::text;
constexpr char KHeaderContents[] = R"cc(
struct string {
@@ -208,7 +209,7 @@ TEST_F(TransformerTest, AddIncludeQuoted
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);
@@ -559,7 +560,7 @@ TEST_F(TransformerTest, OrderedRuleMulti
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);
}
@@ -795,11 +796,11 @@ TEST_F(TransformerTest, NoPartialRewrite
// 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
More information about the cfe-commits
mailing list