[clang] ba41a0f - [SyntaxTree][NFC] remove redundant namespace-specifiers
Eduardo Caldas via cfe-commits
cfe-commits at lists.llvm.org
Fri Aug 7 01:45:40 PDT 2020
Author: Eduardo Caldas
Date: 2020-08-07T08:45:29Z
New Revision: ba41a0f7339c8cbd065f032cc5f8c1d87a74e124
URL: https://github.com/llvm/llvm-project/commit/ba41a0f7339c8cbd065f032cc5f8c1d87a74e124
DIFF: https://github.com/llvm/llvm-project/commit/ba41a0f7339c8cbd065f032cc5f8c1d87a74e124.diff
LOG: [SyntaxTree][NFC] remove redundant namespace-specifiers
Differential Revision: https://reviews.llvm.org/D85427
Added:
Modified:
clang/include/clang/Tooling/Syntax/Nodes.h
clang/include/clang/Tooling/Syntax/Tree.h
clang/lib/Tooling/Syntax/BuildTree.cpp
clang/lib/Tooling/Syntax/Nodes.cpp
clang/lib/Tooling/Syntax/Tree.cpp
clang/unittests/Tooling/Syntax/TreeTest.cpp
Removed:
################################################################################
diff --git a/clang/include/clang/Tooling/Syntax/Nodes.h b/clang/include/clang/Tooling/Syntax/Nodes.h
index 8a873f9d5273..a5972a394583 100644
--- a/clang/include/clang/Tooling/Syntax/Nodes.h
+++ b/clang/include/clang/Tooling/Syntax/Nodes.h
@@ -100,7 +100,7 @@ enum class NodeKind : uint16_t {
UnqualifiedId
};
/// For debugging purposes.
-llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, NodeKind K);
+raw_ostream &operator<<(raw_ostream &OS, NodeKind K);
/// A relation between a parent and child node, e.g. 'left-hand-side of
/// a binary expression'. Used for implementing accessors.
@@ -170,7 +170,7 @@ enum class NodeRole : uint8_t {
ParenExpression_subExpression
};
/// For debugging purposes.
-llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, NodeRole R);
+raw_ostream &operator<<(raw_ostream &OS, NodeRole R);
class SimpleDeclarator;
@@ -212,7 +212,7 @@ class NestedNameSpecifier final : public Tree {
static bool classof(const Node *N) {
return N->kind() <= NodeKind::NestedNameSpecifier;
}
- std::vector<syntax::NameSpecifier *> specifiers();
+ std::vector<NameSpecifier *> specifiers();
};
/// Models an `unqualified-id`. C++ [expr.prim.id.unqual]
@@ -238,10 +238,10 @@ class IdExpression final : public Expression {
static bool classof(const Node *N) {
return N->kind() == NodeKind::IdExpression;
}
- syntax::NestedNameSpecifier *qualifier();
+ NestedNameSpecifier *qualifier();
// TODO after expose `id-expression` from `DependentScopeDeclRefExpr`:
// Add accessor for `template_opt`.
- syntax::UnqualifiedId *unqualifiedId();
+ UnqualifiedId *unqualifiedId();
};
/// An expression of an unknown kind, i.e. one not currently handled by the
@@ -262,9 +262,9 @@ class ParenExpression final : public Expression {
static bool classof(const Node *N) {
return N->kind() == NodeKind::ParenExpression;
}
- syntax::Leaf *openParen();
- syntax::Expression *subExpression();
- syntax::Leaf *closeParen();
+ Leaf *openParen();
+ Expression *subExpression();
+ Leaf *closeParen();
};
/// Expression for literals. C++ [lex.literal]
@@ -283,7 +283,7 @@ class LiteralExpression : public Expression {
N->kind() == NodeKind::CharUserDefinedLiteralExpression ||
N->kind() == NodeKind::StringUserDefinedLiteralExpression;
}
- syntax::Leaf *literalToken();
+ Leaf *literalToken();
};
/// Expression for integer literals. C++ [lex.icon]
@@ -418,8 +418,8 @@ class UnaryOperatorExpression : public Expression {
return N->kind() == NodeKind::PrefixUnaryOperatorExpression ||
N->kind() == NodeKind::PostfixUnaryOperatorExpression;
}
- syntax::Leaf *operatorToken();
- syntax::Expression *operand();
+ Leaf *operatorToken();
+ Expression *operand();
};
/// <operator> <operand>
@@ -467,9 +467,9 @@ class BinaryOperatorExpression final : public Expression {
static bool classof(const Node *N) {
return N->kind() == NodeKind::BinaryOperatorExpression;
}
- syntax::Expression *lhs();
- syntax::Leaf *operatorToken();
- syntax::Expression *rhs();
+ Expression *lhs();
+ Leaf *operatorToken();
+ Expression *rhs();
};
/// An abstract node for C++ statements, e.g. 'while', 'if', etc.
@@ -518,8 +518,8 @@ class SwitchStatement final : public Statement {
static bool classof(const Node *N) {
return N->kind() == NodeKind::SwitchStatement;
}
- syntax::Leaf *switchKeyword();
- syntax::Statement *body();
+ Leaf *switchKeyword();
+ Statement *body();
};
/// case <value>: <body>
@@ -529,9 +529,9 @@ class CaseStatement final : public Statement {
static bool classof(const Node *N) {
return N->kind() == NodeKind::CaseStatement;
}
- syntax::Leaf *caseKeyword();
- syntax::Expression *value();
- syntax::Statement *body();
+ Leaf *caseKeyword();
+ Expression *value();
+ Statement *body();
};
/// default: <body>
@@ -541,8 +541,8 @@ class DefaultStatement final : public Statement {
static bool classof(const Node *N) {
return N->kind() == NodeKind::DefaultStatement;
}
- syntax::Leaf *defaultKeyword();
- syntax::Statement *body();
+ Leaf *defaultKeyword();
+ Statement *body();
};
/// if (cond) <then-statement> else <else-statement>
@@ -553,10 +553,10 @@ class IfStatement final : public Statement {
static bool classof(const Node *N) {
return N->kind() == NodeKind::IfStatement;
}
- syntax::Leaf *ifKeyword();
- syntax::Statement *thenStatement();
- syntax::Leaf *elseKeyword();
- syntax::Statement *elseStatement();
+ Leaf *ifKeyword();
+ Statement *thenStatement();
+ Leaf *elseKeyword();
+ Statement *elseStatement();
};
/// for (<init>; <cond>; <increment>) <body>
@@ -566,8 +566,8 @@ class ForStatement final : public Statement {
static bool classof(const Node *N) {
return N->kind() == NodeKind::ForStatement;
}
- syntax::Leaf *forKeyword();
- syntax::Statement *body();
+ Leaf *forKeyword();
+ Statement *body();
};
/// while (<cond>) <body>
@@ -577,8 +577,8 @@ class WhileStatement final : public Statement {
static bool classof(const Node *N) {
return N->kind() == NodeKind::WhileStatement;
}
- syntax::Leaf *whileKeyword();
- syntax::Statement *body();
+ Leaf *whileKeyword();
+ Statement *body();
};
/// continue;
@@ -588,7 +588,7 @@ class ContinueStatement final : public Statement {
static bool classof(const Node *N) {
return N->kind() == NodeKind::ContinueStatement;
}
- syntax::Leaf *continueKeyword();
+ Leaf *continueKeyword();
};
/// break;
@@ -598,7 +598,7 @@ class BreakStatement final : public Statement {
static bool classof(const Node *N) {
return N->kind() == NodeKind::BreakStatement;
}
- syntax::Leaf *breakKeyword();
+ Leaf *breakKeyword();
};
/// return <expr>;
@@ -609,8 +609,8 @@ class ReturnStatement final : public Statement {
static bool classof(const Node *N) {
return N->kind() == NodeKind::ReturnStatement;
}
- syntax::Leaf *returnKeyword();
- syntax::Expression *value();
+ Leaf *returnKeyword();
+ Expression *value();
};
/// for (<decl> : <init>) <body>
@@ -620,8 +620,8 @@ class RangeBasedForStatement final : public Statement {
static bool classof(const Node *N) {
return N->kind() == NodeKind::RangeBasedForStatement;
}
- syntax::Leaf *forKeyword();
- syntax::Statement *body();
+ Leaf *forKeyword();
+ Statement *body();
};
/// Expression in a statement position, e.g. functions calls inside compound
@@ -632,7 +632,7 @@ class ExpressionStatement final : public Statement {
static bool classof(const Node *N) {
return N->kind() == NodeKind::ExpressionStatement;
}
- syntax::Expression *expression();
+ Expression *expression();
};
/// { statement1; statement2; … }
@@ -642,10 +642,10 @@ class CompoundStatement final : public Statement {
static bool classof(const Node *N) {
return N->kind() == NodeKind::CompoundStatement;
}
- syntax::Leaf *lbrace();
+ Leaf *lbrace();
/// FIXME: use custom iterator instead of 'vector'.
- std::vector<syntax::Statement *> statements();
- syntax::Leaf *rbrace();
+ std::vector<Statement *> statements();
+ Leaf *rbrace();
};
/// A declaration that can appear at the top-level. Note that this does *not*
@@ -687,8 +687,8 @@ class StaticAssertDeclaration final : public Declaration {
static bool classof(const Node *N) {
return N->kind() == NodeKind::StaticAssertDeclaration;
}
- syntax::Expression *condition();
- syntax::Expression *message();
+ Expression *condition();
+ Expression *message();
};
/// extern <string-literal> declaration
@@ -712,7 +712,7 @@ class SimpleDeclaration final : public Declaration {
return N->kind() == NodeKind::SimpleDeclaration;
}
/// FIXME: use custom iterator instead of 'vector'.
- std::vector<syntax::SimpleDeclarator *> declarators();
+ std::vector<SimpleDeclarator *> declarators();
};
/// template <template-parameters> <declaration>
@@ -722,8 +722,8 @@ class TemplateDeclaration final : public Declaration {
static bool classof(const Node *N) {
return N->kind() == NodeKind::TemplateDeclaration;
}
- syntax::Leaf *templateKeyword();
- syntax::Declaration *declaration();
+ Leaf *templateKeyword();
+ Declaration *declaration();
};
/// template <declaration>
@@ -738,9 +738,9 @@ class ExplicitTemplateInstantiation final : public Declaration {
static bool classof(const Node *N) {
return N->kind() == NodeKind::ExplicitTemplateInstantiation;
}
- syntax::Leaf *templateKeyword();
- syntax::Leaf *externKeyword();
- syntax::Declaration *declaration();
+ Leaf *templateKeyword();
+ Leaf *externKeyword();
+ Declaration *declaration();
};
/// namespace <name> { <decls> }
@@ -830,8 +830,8 @@ class ParenDeclarator final : public Declarator {
static bool classof(const Node *N) {
return N->kind() == NodeKind::ParenDeclarator;
}
- syntax::Leaf *lparen();
- syntax::Leaf *rparen();
+ Leaf *lparen();
+ Leaf *rparen();
};
/// Array size specified inside a declarator.
@@ -845,9 +845,9 @@ class ArraySubscript final : public Tree {
return N->kind() == NodeKind::ArraySubscript;
}
// TODO: add an accessor for the "static" keyword.
- syntax::Leaf *lbracket();
- syntax::Expression *sizeExpression();
- syntax::Leaf *rbracket();
+ Leaf *lbracket();
+ Expression *sizeExpression();
+ Leaf *rbracket();
};
/// Trailing return type after the parameter list, including the arrow token.
@@ -859,8 +859,8 @@ class TrailingReturnType final : public Tree {
return N->kind() == NodeKind::TrailingReturnType;
}
// TODO: add accessors for specifiers.
- syntax::Leaf *arrowToken();
- syntax::SimpleDeclarator *declarator();
+ Leaf *arrowToken();
+ SimpleDeclarator *declarator();
};
/// Parameter list for a function type and a trailing return type, if the
@@ -880,11 +880,11 @@ class ParametersAndQualifiers final : public Tree {
static bool classof(const Node *N) {
return N->kind() == NodeKind::ParametersAndQualifiers;
}
- syntax::Leaf *lparen();
+ Leaf *lparen();
/// FIXME: use custom iterator instead of 'vector'.
- std::vector<syntax::SimpleDeclaration *> parameters();
- syntax::Leaf *rparen();
- syntax::TrailingReturnType *trailingReturn();
+ std::vector<SimpleDeclaration *> parameters();
+ Leaf *rparen();
+ TrailingReturnType *trailingReturn();
};
/// Member pointer inside a declarator
diff --git a/clang/include/clang/Tooling/Syntax/Tree.h b/clang/include/clang/Tooling/Syntax/Tree.h
index dd51e0a74070..d35bc6467bcc 100644
--- a/clang/include/clang/Tooling/Syntax/Tree.h
+++ b/clang/include/clang/Tooling/Syntax/Tree.h
@@ -50,7 +50,7 @@ class Arena {
/// Add \p Buffer to the underlying source manager, tokenize it and store the
/// resulting tokens. Useful when there is a need to materialize tokens that
/// were not written in user code.
- std::pair<FileID, llvm::ArrayRef<syntax::Token>>
+ std::pair<FileID, ArrayRef<Token>>
lexBuffer(std::unique_ptr<llvm::MemoryBuffer> Buffer);
private:
@@ -58,7 +58,7 @@ class Arena {
const LangOptions &LangOpts;
const TokenBuffer &Tokens;
/// IDs and storage for additional tokenized files.
- llvm::DenseMap<FileID, std::vector<syntax::Token>> ExtraTokens;
+ llvm::DenseMap<FileID, std::vector<Token>> ExtraTokens;
/// Keeps all the allocated nodes and their intermediate data structures.
llvm::BumpPtrAllocator Allocator;
};
@@ -139,13 +139,13 @@ class Node {
/// A leaf node points to a single token inside the expanded token stream.
class Leaf final : public Node {
public:
- Leaf(const syntax::Token *T);
+ Leaf(const Token *T);
static bool classof(const Node *N);
- const syntax::Token *token() const { return Tok; }
+ const Token *token() const { return Tok; }
private:
- const syntax::Token *Tok;
+ const Token *Tok;
};
/// A node that has children and represents a syntactic language construct.
@@ -167,7 +167,7 @@ class Tree : public Node {
protected:
/// Find the first node with a corresponding role.
- syntax::Node *findChild(NodeRole R);
+ Node *findChild(NodeRole R);
private:
/// Prepend \p Child to the list of children and and sets the parent pointer.
diff --git a/clang/lib/Tooling/Syntax/BuildTree.cpp b/clang/lib/Tooling/Syntax/BuildTree.cpp
index 15b7c8fab198..29b1a9d7394f 100644
--- a/clang/lib/Tooling/Syntax/BuildTree.cpp
+++ b/clang/lib/Tooling/Syntax/BuildTree.cpp
@@ -45,7 +45,7 @@
using namespace clang;
LLVM_ATTRIBUTE_UNUSED
-static bool isImplicitExpr(clang::Expr *E) { return E->IgnoreImplicit() != E; }
+static bool isImplicitExpr(Expr *E) { return E->IgnoreImplicit() != E; }
namespace {
/// Get start location of the Declarator from the TypeLoc.
@@ -275,15 +275,13 @@ class syntax::TreeBuilder {
/// Populate children for \p New node, assuming it covers tokens from \p
/// Range.
- void foldNode(llvm::ArrayRef<syntax::Token> Range, syntax::Tree *New,
- ASTPtr From) {
+ void foldNode(ArrayRef<syntax::Token> Range, syntax::Tree *New, ASTPtr From) {
assert(New);
Pending.foldChildren(Arena, Range, New);
if (From)
Mapping.add(From, New);
}
- void foldNode(llvm::ArrayRef<syntax::Token> Range, syntax::Tree *New,
- TypeLoc L) {
+ void foldNode(ArrayRef<syntax::Token> Range, syntax::Tree *New, TypeLoc L) {
// FIXME: add mapping for TypeLocs
foldNode(Range, New, nullptr);
}
@@ -329,7 +327,7 @@ class syntax::TreeBuilder {
const syntax::Token *findToken(SourceLocation L) const;
/// Finds the syntax tokens corresponding to the \p SourceRange.
- llvm::ArrayRef<syntax::Token> getRange(SourceRange Range) const {
+ ArrayRef<syntax::Token> getRange(SourceRange Range) const {
assert(Range.isValid());
return getRange(Range.getBegin(), Range.getEnd());
}
@@ -337,8 +335,8 @@ class syntax::TreeBuilder {
/// Finds the syntax tokens corresponding to the passed source locations.
/// \p First is the start position of the first token and \p Last is the start
/// position of the last token.
- llvm::ArrayRef<syntax::Token> getRange(SourceLocation First,
- SourceLocation Last) const {
+ ArrayRef<syntax::Token> getRange(SourceLocation First,
+ SourceLocation Last) const {
assert(First.isValid());
assert(Last.isValid());
assert(First == Last ||
@@ -346,7 +344,7 @@ class syntax::TreeBuilder {
return llvm::makeArrayRef(findToken(First), std::next(findToken(Last)));
}
- llvm::ArrayRef<syntax::Token>
+ ArrayRef<syntax::Token>
getTemplateRange(const ClassTemplateSpecializationDecl *D) const {
auto Tokens = getRange(D->getSourceRange());
return maybeAppendSemicolon(Tokens, D);
@@ -366,7 +364,7 @@ class syntax::TreeBuilder {
if (Next == nullptr) {
return true;
}
- const auto *NextT = llvm::dyn_cast<T>(Next);
+ const auto *NextT = dyn_cast<T>(Next);
// Next sibling is not the same type, this one is responsible.
if (NextT == nullptr) {
@@ -383,23 +381,23 @@ class syntax::TreeBuilder {
return false;
}
- llvm::ArrayRef<syntax::Token> getDeclarationRange(Decl *D) {
- llvm::ArrayRef<clang::syntax::Token> Tokens;
+ ArrayRef<syntax::Token> getDeclarationRange(Decl *D) {
+ ArrayRef<syntax::Token> Tokens;
// We want to drop the template parameters for specializations.
- if (const auto *S = llvm::dyn_cast<TagDecl>(D))
+ if (const auto *S = dyn_cast<TagDecl>(D))
Tokens = getRange(S->TypeDecl::getBeginLoc(), S->getEndLoc());
else
Tokens = getRange(D->getSourceRange());
return maybeAppendSemicolon(Tokens, D);
}
- llvm::ArrayRef<syntax::Token> getExprRange(const Expr *E) const {
+ ArrayRef<syntax::Token> getExprRange(const Expr *E) const {
return getRange(E->getSourceRange());
}
/// Find the adjusted range for the statement, consuming the trailing
/// semicolon when needed.
- llvm::ArrayRef<syntax::Token> getStmtRange(const Stmt *S) const {
+ ArrayRef<syntax::Token> getStmtRange(const Stmt *S) const {
auto Tokens = getRange(S->getSourceRange());
if (isa<CompoundStmt>(S))
return Tokens;
@@ -412,10 +410,9 @@ class syntax::TreeBuilder {
}
private:
- llvm::ArrayRef<syntax::Token>
- maybeAppendSemicolon(llvm::ArrayRef<syntax::Token> Tokens,
- const Decl *D) const {
- if (llvm::isa<NamespaceDecl>(D))
+ ArrayRef<syntax::Token> maybeAppendSemicolon(ArrayRef<syntax::Token> Tokens,
+ const Decl *D) const {
+ if (isa<NamespaceDecl>(D))
return Tokens;
if (DeclsWithoutSemicolons.count(D))
return Tokens;
@@ -424,8 +421,8 @@ class syntax::TreeBuilder {
return withTrailingSemicolon(Tokens);
}
- llvm::ArrayRef<syntax::Token>
- withTrailingSemicolon(llvm::ArrayRef<syntax::Token> Tokens) const {
+ ArrayRef<syntax::Token>
+ withTrailingSemicolon(ArrayRef<syntax::Token> Tokens) const {
assert(!Tokens.empty());
assert(Tokens.back().kind() != tok::eof);
// We never consume 'eof', so looking at the next token is ok.
@@ -459,8 +456,7 @@ class syntax::TreeBuilder {
}
}
- void assignRole(llvm::ArrayRef<syntax::Token> Range,
- syntax::NodeRole Role) {
+ void assignRole(ArrayRef<syntax::Token> Range, syntax::NodeRole Role) {
assert(!Range.empty());
auto It = Trees.lower_bound(Range.begin());
assert(It != Trees.end() && "no node found");
@@ -474,8 +470,7 @@ class syntax::TreeBuilder {
}
/// Add \p Node to the forest and attach child nodes based on \p Tokens.
- void foldChildren(const syntax::Arena &A,
- llvm::ArrayRef<syntax::Token> Tokens,
+ void foldChildren(const syntax::Arena &A, ArrayRef<syntax::Token> Tokens,
syntax::Tree *Node) {
// Attach children to `Node`.
assert(Node->firstChild() == nullptr && "node already has children");
@@ -523,9 +518,9 @@ class syntax::TreeBuilder {
? (std::next(It)->first - It->first)
: A.tokenBuffer().expandedTokens().end() - It->first;
- R += std::string(llvm::formatv(
- "- '{0}' covers '{1}'+{2} tokens\n", It->second->kind(),
- It->first->text(A.sourceManager()), CoveredTokens));
+ R += std::string(
+ formatv("- '{0}' covers '{1}'+{2} tokens\n", It->second->kind(),
+ It->first->text(A.sourceManager()), CoveredTokens));
R += It->second->dump(A);
}
return R;
@@ -623,7 +618,7 @@ class BuildTreeVisitor : public RecursiveASTVisitor<BuildTreeVisitor> {
foldTemplateDeclaration(R, TemplateKW, DeclarationRange, nullptr);
DeclarationRange = R;
};
- if (auto *S = llvm::dyn_cast<ClassTemplatePartialSpecializationDecl>(C))
+ if (auto *S = dyn_cast<ClassTemplatePartialSpecializationDecl>(C))
ConsumeTemplateParameters(*S->getTemplateParameters());
for (unsigned I = C->getNumTemplateParameterLists(); 0 < I; --I)
ConsumeTemplateParameters(*C->getTemplateParameterList(I - 1));
@@ -677,11 +672,11 @@ class BuildTreeVisitor : public RecursiveASTVisitor<BuildTreeVisitor> {
}
bool TraverseStmt(Stmt *S) {
- if (auto *DS = llvm::dyn_cast_or_null<DeclStmt>(S)) {
+ if (auto *DS = dyn_cast_or_null<DeclStmt>(S)) {
// We want to consume the semicolon, make sure SimpleDeclaration does not.
for (auto *D : DS->decls())
Builder.noticeDeclWithoutSemicolon(D);
- } else if (auto *E = llvm::dyn_cast_or_null<Expr>(S)) {
+ } else if (auto *E = dyn_cast_or_null<Expr>(S)) {
return RecursiveASTVisitor::TraverseStmt(E->IgnoreImplicit());
}
return RecursiveASTVisitor::TraverseStmt(S);
@@ -722,16 +717,16 @@ class BuildTreeVisitor : public RecursiveASTVisitor<BuildTreeVisitor> {
syntax::UserDefinedLiteralExpression *
buildUserDefinedLiteral(UserDefinedLiteral *S) {
switch (S->getLiteralOperatorKind()) {
- case clang::UserDefinedLiteral::LOK_Integer:
+ case UserDefinedLiteral::LOK_Integer:
return new (allocator()) syntax::IntegerUserDefinedLiteralExpression;
- case clang::UserDefinedLiteral::LOK_Floating:
+ case UserDefinedLiteral::LOK_Floating:
return new (allocator()) syntax::FloatUserDefinedLiteralExpression;
- case clang::UserDefinedLiteral::LOK_Character:
+ case UserDefinedLiteral::LOK_Character:
return new (allocator()) syntax::CharUserDefinedLiteralExpression;
- case clang::UserDefinedLiteral::LOK_String:
+ case UserDefinedLiteral::LOK_String:
return new (allocator()) syntax::StringUserDefinedLiteralExpression;
- case clang::UserDefinedLiteral::LOK_Raw:
- case clang::UserDefinedLiteral::LOK_Template:
+ case UserDefinedLiteral::LOK_Raw:
+ case UserDefinedLiteral::LOK_Template:
// For raw literal operator and numeric literal operator template we
// cannot get the type of the operand in the semantic AST. We get this
// information from the token. As integer and floating point have the same
@@ -1183,7 +1178,7 @@ class BuildTreeVisitor : public RecursiveASTVisitor<BuildTreeVisitor> {
if (IsAnonymous)
return SourceLocation();
- if (const auto *DD = llvm::dyn_cast<DeclaratorDecl>(D)) {
+ if (const auto *DD = dyn_cast<DeclaratorDecl>(D)) {
if (DD->getQualifierLoc()) {
return DD->getQualifierLoc().getBeginLoc();
}
@@ -1193,7 +1188,7 @@ class BuildTreeVisitor : public RecursiveASTVisitor<BuildTreeVisitor> {
}
SourceRange getInitializerRange(Decl *D) {
- if (auto *V = llvm::dyn_cast<VarDecl>(D)) {
+ if (auto *V = dyn_cast<VarDecl>(D)) {
auto *I = V->getInit();
// Initializers in range-based-for are not part of the declarator
if (I && !V->isCXXForRangeDecl())
diff --git a/clang/lib/Tooling/Syntax/Nodes.cpp b/clang/lib/Tooling/Syntax/Nodes.cpp
index eced68fa2443..47af2c467b1d 100644
--- a/clang/lib/Tooling/Syntax/Nodes.cpp
+++ b/clang/lib/Tooling/Syntax/Nodes.cpp
@@ -10,7 +10,7 @@
using namespace clang;
-llvm::raw_ostream &syntax::operator<<(llvm::raw_ostream &OS, NodeKind K) {
+raw_ostream &syntax::operator<<(raw_ostream &OS, NodeKind K) {
switch (K) {
case NodeKind::Leaf:
return OS << "Leaf";
@@ -124,7 +124,7 @@ llvm::raw_ostream &syntax::operator<<(llvm::raw_ostream &OS, NodeKind K) {
llvm_unreachable("unknown node kind");
}
-llvm::raw_ostream &syntax::operator<<(llvm::raw_ostream &OS, NodeRole R) {
+raw_ostream &syntax::operator<<(raw_ostream &OS, NodeRole R) {
switch (R) {
case syntax::NodeRole::Detached:
return OS << "Detached";
@@ -200,202 +200,197 @@ std::vector<syntax::NameSpecifier *> syntax::NestedNameSpecifier::specifiers() {
std::vector<syntax::NameSpecifier *> Children;
for (auto *C = firstChild(); C; C = C->nextSibling()) {
assert(C->role() == syntax::NodeRole::NestedNameSpecifier_specifier);
- Children.push_back(llvm::cast<syntax::NameSpecifier>(C));
+ Children.push_back(cast<syntax::NameSpecifier>(C));
}
return Children;
}
syntax::NestedNameSpecifier *syntax::IdExpression::qualifier() {
- return llvm::cast_or_null<syntax::NestedNameSpecifier>(
+ return cast_or_null<syntax::NestedNameSpecifier>(
findChild(syntax::NodeRole::IdExpression_qualifier));
}
syntax::UnqualifiedId *syntax::IdExpression::unqualifiedId() {
- return llvm::cast_or_null<syntax::UnqualifiedId>(
+ return cast_or_null<syntax::UnqualifiedId>(
findChild(syntax::NodeRole::IdExpression_id));
}
syntax::Leaf *syntax::ParenExpression::openParen() {
- return llvm::cast_or_null<syntax::Leaf>(
- findChild(syntax::NodeRole::OpenParen));
+ return cast_or_null<syntax::Leaf>(findChild(syntax::NodeRole::OpenParen));
}
syntax::Expression *syntax::ParenExpression::subExpression() {
- return llvm::cast_or_null<syntax::Expression>(
+ return cast_or_null<syntax::Expression>(
findChild(syntax::NodeRole::ParenExpression_subExpression));
}
syntax::Leaf *syntax::ParenExpression::closeParen() {
- return llvm::cast_or_null<syntax::Leaf>(
- findChild(syntax::NodeRole::CloseParen));
+ return cast_or_null<syntax::Leaf>(findChild(syntax::NodeRole::CloseParen));
}
syntax::Leaf *syntax::LiteralExpression::literalToken() {
- return llvm::cast_or_null<syntax::Leaf>(
- findChild(syntax::NodeRole::LiteralToken));
+ return cast_or_null<syntax::Leaf>(findChild(syntax::NodeRole::LiteralToken));
}
syntax::Expression *syntax::BinaryOperatorExpression::lhs() {
- return llvm::cast_or_null<syntax::Expression>(
+ return cast_or_null<syntax::Expression>(
findChild(syntax::NodeRole::BinaryOperatorExpression_leftHandSide));
}
syntax::Leaf *syntax::UnaryOperatorExpression::operatorToken() {
- return llvm::cast_or_null<syntax::Leaf>(
+ return cast_or_null<syntax::Leaf>(
findChild(syntax::NodeRole::OperatorExpression_operatorToken));
}
syntax::Expression *syntax::UnaryOperatorExpression::operand() {
- return llvm::cast_or_null<syntax::Expression>(
+ return cast_or_null<syntax::Expression>(
findChild(syntax::NodeRole::UnaryOperatorExpression_operand));
}
syntax::Leaf *syntax::BinaryOperatorExpression::operatorToken() {
- return llvm::cast_or_null<syntax::Leaf>(
+ return cast_or_null<syntax::Leaf>(
findChild(syntax::NodeRole::OperatorExpression_operatorToken));
}
syntax::Expression *syntax::BinaryOperatorExpression::rhs() {
- return llvm::cast_or_null<syntax::Expression>(
+ return cast_or_null<syntax::Expression>(
findChild(syntax::NodeRole::BinaryOperatorExpression_rightHandSide));
}
syntax::Leaf *syntax::SwitchStatement::switchKeyword() {
- return llvm::cast_or_null<syntax::Leaf>(
+ return cast_or_null<syntax::Leaf>(
findChild(syntax::NodeRole::IntroducerKeyword));
}
syntax::Statement *syntax::SwitchStatement::body() {
- return llvm::cast_or_null<syntax::Statement>(
+ return cast_or_null<syntax::Statement>(
findChild(syntax::NodeRole::BodyStatement));
}
syntax::Leaf *syntax::CaseStatement::caseKeyword() {
- return llvm::cast_or_null<syntax::Leaf>(
+ return cast_or_null<syntax::Leaf>(
findChild(syntax::NodeRole::IntroducerKeyword));
}
syntax::Expression *syntax::CaseStatement::value() {
- return llvm::cast_or_null<syntax::Expression>(
+ return cast_or_null<syntax::Expression>(
findChild(syntax::NodeRole::CaseStatement_value));
}
syntax::Statement *syntax::CaseStatement::body() {
- return llvm::cast_or_null<syntax::Statement>(
+ return cast_or_null<syntax::Statement>(
findChild(syntax::NodeRole::BodyStatement));
}
syntax::Leaf *syntax::DefaultStatement::defaultKeyword() {
- return llvm::cast_or_null<syntax::Leaf>(
+ return cast_or_null<syntax::Leaf>(
findChild(syntax::NodeRole::IntroducerKeyword));
}
syntax::Statement *syntax::DefaultStatement::body() {
- return llvm::cast_or_null<syntax::Statement>(
+ return cast_or_null<syntax::Statement>(
findChild(syntax::NodeRole::BodyStatement));
}
syntax::Leaf *syntax::IfStatement::ifKeyword() {
- return llvm::cast_or_null<syntax::Leaf>(
+ return cast_or_null<syntax::Leaf>(
findChild(syntax::NodeRole::IntroducerKeyword));
}
syntax::Statement *syntax::IfStatement::thenStatement() {
- return llvm::cast_or_null<syntax::Statement>(
+ return cast_or_null<syntax::Statement>(
findChild(syntax::NodeRole::IfStatement_thenStatement));
}
syntax::Leaf *syntax::IfStatement::elseKeyword() {
- return llvm::cast_or_null<syntax::Leaf>(
+ return cast_or_null<syntax::Leaf>(
findChild(syntax::NodeRole::IfStatement_elseKeyword));
}
syntax::Statement *syntax::IfStatement::elseStatement() {
- return llvm::cast_or_null<syntax::Statement>(
+ return cast_or_null<syntax::Statement>(
findChild(syntax::NodeRole::IfStatement_elseStatement));
}
syntax::Leaf *syntax::ForStatement::forKeyword() {
- return llvm::cast_or_null<syntax::Leaf>(
+ return cast_or_null<syntax::Leaf>(
findChild(syntax::NodeRole::IntroducerKeyword));
}
syntax::Statement *syntax::ForStatement::body() {
- return llvm::cast_or_null<syntax::Statement>(
+ return cast_or_null<syntax::Statement>(
findChild(syntax::NodeRole::BodyStatement));
}
syntax::Leaf *syntax::WhileStatement::whileKeyword() {
- return llvm::cast_or_null<syntax::Leaf>(
+ return cast_or_null<syntax::Leaf>(
findChild(syntax::NodeRole::IntroducerKeyword));
}
syntax::Statement *syntax::WhileStatement::body() {
- return llvm::cast_or_null<syntax::Statement>(
+ return cast_or_null<syntax::Statement>(
findChild(syntax::NodeRole::BodyStatement));
}
syntax::Leaf *syntax::ContinueStatement::continueKeyword() {
- return llvm::cast_or_null<syntax::Leaf>(
+ return cast_or_null<syntax::Leaf>(
findChild(syntax::NodeRole::IntroducerKeyword));
}
syntax::Leaf *syntax::BreakStatement::breakKeyword() {
- return llvm::cast_or_null<syntax::Leaf>(
+ return cast_or_null<syntax::Leaf>(
findChild(syntax::NodeRole::IntroducerKeyword));
}
syntax::Leaf *syntax::ReturnStatement::returnKeyword() {
- return llvm::cast_or_null<syntax::Leaf>(
+ return cast_or_null<syntax::Leaf>(
findChild(syntax::NodeRole::IntroducerKeyword));
}
syntax::Expression *syntax::ReturnStatement::value() {
- return llvm::cast_or_null<syntax::Expression>(
+ return cast_or_null<syntax::Expression>(
findChild(syntax::NodeRole::ReturnStatement_value));
}
syntax::Leaf *syntax::RangeBasedForStatement::forKeyword() {
- return llvm::cast_or_null<syntax::Leaf>(
+ return cast_or_null<syntax::Leaf>(
findChild(syntax::NodeRole::IntroducerKeyword));
}
syntax::Statement *syntax::RangeBasedForStatement::body() {
- return llvm::cast_or_null<syntax::Statement>(
+ return cast_or_null<syntax::Statement>(
findChild(syntax::NodeRole::BodyStatement));
}
syntax::Expression *syntax::ExpressionStatement::expression() {
- return llvm::cast_or_null<syntax::Expression>(
+ return cast_or_null<syntax::Expression>(
findChild(syntax::NodeRole::ExpressionStatement_expression));
}
syntax::Leaf *syntax::CompoundStatement::lbrace() {
- return llvm::cast_or_null<syntax::Leaf>(
- findChild(syntax::NodeRole::OpenParen));
+ return cast_or_null<syntax::Leaf>(findChild(syntax::NodeRole::OpenParen));
}
std::vector<syntax::Statement *> syntax::CompoundStatement::statements() {
std::vector<syntax::Statement *> Children;
for (auto *C = firstChild(); C; C = C->nextSibling()) {
assert(C->role() == syntax::NodeRole::CompoundStatement_statement);
- Children.push_back(llvm::cast<syntax::Statement>(C));
+ Children.push_back(cast<syntax::Statement>(C));
}
return Children;
}
syntax::Leaf *syntax::CompoundStatement::rbrace() {
- return llvm::cast_or_null<syntax::Leaf>(
- findChild(syntax::NodeRole::CloseParen));
+ return cast_or_null<syntax::Leaf>(findChild(syntax::NodeRole::CloseParen));
}
syntax::Expression *syntax::StaticAssertDeclaration::condition() {
- return llvm::cast_or_null<syntax::Expression>(
+ return cast_or_null<syntax::Expression>(
findChild(syntax::NodeRole::StaticAssertDeclaration_condition));
}
syntax::Expression *syntax::StaticAssertDeclaration::message() {
- return llvm::cast_or_null<syntax::Expression>(
+ return cast_or_null<syntax::Expression>(
findChild(syntax::NodeRole::StaticAssertDeclaration_message));
}
@@ -404,74 +399,67 @@ syntax::SimpleDeclaration::declarators() {
std::vector<syntax::SimpleDeclarator *> Children;
for (auto *C = firstChild(); C; C = C->nextSibling()) {
if (C->role() == syntax::NodeRole::SimpleDeclaration_declarator)
- Children.push_back(llvm::cast<syntax::SimpleDeclarator>(C));
+ Children.push_back(cast<syntax::SimpleDeclarator>(C));
}
return Children;
}
syntax::Leaf *syntax::TemplateDeclaration::templateKeyword() {
- return llvm::cast_or_null<syntax::Leaf>(
+ return cast_or_null<syntax::Leaf>(
findChild(syntax::NodeRole::IntroducerKeyword));
}
syntax::Declaration *syntax::TemplateDeclaration::declaration() {
- return llvm::cast_or_null<syntax::Declaration>(
+ return cast_or_null<syntax::Declaration>(
findChild(syntax::NodeRole::TemplateDeclaration_declaration));
}
syntax::Leaf *syntax::ExplicitTemplateInstantiation::templateKeyword() {
- return llvm::cast_or_null<syntax::Leaf>(
+ return cast_or_null<syntax::Leaf>(
findChild(syntax::NodeRole::IntroducerKeyword));
}
syntax::Leaf *syntax::ExplicitTemplateInstantiation::externKeyword() {
- return llvm::cast_or_null<syntax::Leaf>(
- findChild(syntax::NodeRole::ExternKeyword));
+ return cast_or_null<syntax::Leaf>(findChild(syntax::NodeRole::ExternKeyword));
}
syntax::Declaration *syntax::ExplicitTemplateInstantiation::declaration() {
- return llvm::cast_or_null<syntax::Declaration>(
+ return cast_or_null<syntax::Declaration>(
findChild(syntax::NodeRole::ExplicitTemplateInstantiation_declaration));
}
syntax::Leaf *syntax::ParenDeclarator::lparen() {
- return llvm::cast_or_null<syntax::Leaf>(
- findChild(syntax::NodeRole::OpenParen));
+ return cast_or_null<syntax::Leaf>(findChild(syntax::NodeRole::OpenParen));
}
syntax::Leaf *syntax::ParenDeclarator::rparen() {
- return llvm::cast_or_null<syntax::Leaf>(
- findChild(syntax::NodeRole::CloseParen));
+ return cast_or_null<syntax::Leaf>(findChild(syntax::NodeRole::CloseParen));
}
syntax::Leaf *syntax::ArraySubscript::lbracket() {
- return llvm::cast_or_null<syntax::Leaf>(
- findChild(syntax::NodeRole::OpenParen));
+ return cast_or_null<syntax::Leaf>(findChild(syntax::NodeRole::OpenParen));
}
syntax::Expression *syntax::ArraySubscript::sizeExpression() {
- return llvm::cast_or_null<syntax::Expression>(
+ return cast_or_null<syntax::Expression>(
findChild(syntax::NodeRole::ArraySubscript_sizeExpression));
}
syntax::Leaf *syntax::ArraySubscript::rbracket() {
- return llvm::cast_or_null<syntax::Leaf>(
- findChild(syntax::NodeRole::CloseParen));
+ return cast_or_null<syntax::Leaf>(findChild(syntax::NodeRole::CloseParen));
}
syntax::Leaf *syntax::TrailingReturnType::arrowToken() {
- return llvm::cast_or_null<syntax::Leaf>(
- findChild(syntax::NodeRole::ArrowToken));
+ return cast_or_null<syntax::Leaf>(findChild(syntax::NodeRole::ArrowToken));
}
syntax::SimpleDeclarator *syntax::TrailingReturnType::declarator() {
- return llvm::cast_or_null<syntax::SimpleDeclarator>(
+ return cast_or_null<syntax::SimpleDeclarator>(
findChild(syntax::NodeRole::TrailingReturnType_declarator));
}
syntax::Leaf *syntax::ParametersAndQualifiers::lparen() {
- return llvm::cast_or_null<syntax::Leaf>(
- findChild(syntax::NodeRole::OpenParen));
+ return cast_or_null<syntax::Leaf>(findChild(syntax::NodeRole::OpenParen));
}
std::vector<syntax::SimpleDeclaration *>
@@ -479,17 +467,16 @@ syntax::ParametersAndQualifiers::parameters() {
std::vector<syntax::SimpleDeclaration *> Children;
for (auto *C = firstChild(); C; C = C->nextSibling()) {
if (C->role() == syntax::NodeRole::ParametersAndQualifiers_parameter)
- Children.push_back(llvm::cast<syntax::SimpleDeclaration>(C));
+ Children.push_back(cast<syntax::SimpleDeclaration>(C));
}
return Children;
}
syntax::Leaf *syntax::ParametersAndQualifiers::rparen() {
- return llvm::cast_or_null<syntax::Leaf>(
- findChild(syntax::NodeRole::CloseParen));
+ return cast_or_null<syntax::Leaf>(findChild(syntax::NodeRole::CloseParen));
}
syntax::TrailingReturnType *syntax::ParametersAndQualifiers::trailingReturn() {
- return llvm::cast_or_null<syntax::TrailingReturnType>(
+ return cast_or_null<syntax::TrailingReturnType>(
findChild(syntax::NodeRole::ParametersAndQualifiers_trailingReturn));
}
diff --git a/clang/lib/Tooling/Syntax/Tree.cpp b/clang/lib/Tooling/Syntax/Tree.cpp
index 2944819afc96..6f9ee40a89f2 100644
--- a/clang/lib/Tooling/Syntax/Tree.cpp
+++ b/clang/lib/Tooling/Syntax/Tree.cpp
@@ -36,11 +36,9 @@ syntax::Arena::Arena(SourceManager &SourceMgr, const LangOptions &LangOpts,
const TokenBuffer &Tokens)
: SourceMgr(SourceMgr), LangOpts(LangOpts), Tokens(Tokens) {}
-const clang::syntax::TokenBuffer &syntax::Arena::tokenBuffer() const {
- return Tokens;
-}
+const syntax::TokenBuffer &syntax::Arena::tokenBuffer() const { return Tokens; }
-std::pair<FileID, llvm::ArrayRef<syntax::Token>>
+std::pair<FileID, ArrayRef<syntax::Token>>
syntax::Arena::lexBuffer(std::unique_ptr<llvm::MemoryBuffer> Input) {
auto FID = SourceMgr.createFileID(std::move(Input));
auto It = ExtraTokens.try_emplace(FID, tokenize(FID, SourceMgr, LangOpts));
@@ -135,7 +133,7 @@ void syntax::Tree::replaceChildRangeLowLevel(Node *BeforeBegin, Node *End,
}
namespace {
-static void dumpTokens(llvm::raw_ostream &OS, ArrayRef<syntax::Token> Tokens,
+static void dumpTokens(raw_ostream &OS, ArrayRef<syntax::Token> Tokens,
const SourceManager &SM) {
assert(!Tokens.empty());
bool First = true;
@@ -153,7 +151,7 @@ static void dumpTokens(llvm::raw_ostream &OS, ArrayRef<syntax::Token> Tokens,
}
}
-static void dumpTree(llvm::raw_ostream &OS, const syntax::Node *N,
+static void dumpTree(raw_ostream &OS, const syntax::Node *N,
const syntax::Arena &A, std::vector<bool> IndentMask) {
std::string Marks;
if (!N->isOriginal())
@@ -165,13 +163,13 @@ static void dumpTree(llvm::raw_ostream &OS, const syntax::Node *N,
if (!Marks.empty())
OS << Marks << ": ";
- if (auto *L = llvm::dyn_cast<syntax::Leaf>(N)) {
+ if (auto *L = dyn_cast<syntax::Leaf>(N)) {
dumpTokens(OS, *L->token(), A.sourceManager());
OS << "\n";
return;
}
- auto *T = llvm::cast<syntax::Tree>(N);
+ auto *T = cast<syntax::Tree>(N);
OS << T->kind() << "\n";
for (auto It = T->firstChild(); It != nullptr; It = It->nextSibling()) {
@@ -205,7 +203,7 @@ std::string syntax::Node::dumpTokens(const Arena &A) const {
std::string Storage;
llvm::raw_string_ostream OS(Storage);
traverse(this, [&](const syntax::Node *N) {
- auto *L = llvm::dyn_cast<syntax::Leaf>(N);
+ auto *L = dyn_cast<syntax::Leaf>(N);
if (!L)
return;
::dumpTokens(OS, *L->token(), A.sourceManager());
diff --git a/clang/unittests/Tooling/Syntax/TreeTest.cpp b/clang/unittests/Tooling/Syntax/TreeTest.cpp
index e696be3dae7c..f818959019f5 100644
--- a/clang/unittests/Tooling/Syntax/TreeTest.cpp
+++ b/clang/unittests/Tooling/Syntax/TreeTest.cpp
@@ -40,7 +40,7 @@
using namespace clang;
namespace {
-static llvm::ArrayRef<syntax::Token> tokens(syntax::Node *N) {
+static ArrayRef<syntax::Token> tokens(syntax::Node *N) {
assert(N->isOriginal() && "tokens of modified nodes are not well-defined");
if (auto *L = dyn_cast<syntax::Leaf>(N))
return llvm::makeArrayRef(L->token(), 1);
@@ -53,7 +53,7 @@ class SyntaxTreeTest : public ::testing::Test,
public ::testing::WithParamInterface<TestClangConfig> {
protected:
// Build a syntax tree for the code.
- syntax::TranslationUnit *buildTree(llvm::StringRef Code,
+ syntax::TranslationUnit *buildTree(StringRef Code,
const TestClangConfig &ClangConfig) {
// FIXME: this code is almost the identical to the one in TokensTest. Share
// it.
@@ -169,7 +169,7 @@ class SyntaxTreeTest : public ::testing::Test,
}
// Adds a file to the test VFS.
- void addFile(llvm::StringRef Path, llvm::StringRef Contents) {
+ void addFile(StringRef Path, StringRef Contents) {
if (!FS->addFile(Path, time_t(),
llvm::MemoryBuffer::getMemBufferCopy(Contents))) {
ADD_FAILURE() << "could not add a file to VFS: " << Path;
@@ -179,7 +179,7 @@ class SyntaxTreeTest : public ::testing::Test,
/// Finds the deepest node in the tree that covers exactly \p R.
/// FIXME: implement this efficiently and move to public syntax tree API.
syntax::Node *nodeByRange(llvm::Annotations::Range R, syntax::Node *Root) {
- llvm::ArrayRef<syntax::Token> Toks = tokens(Root);
+ ArrayRef<syntax::Token> Toks = tokens(Root);
if (Toks.front().location().isFileID() &&
Toks.back().location().isFileID() &&
@@ -198,15 +198,14 @@ class SyntaxTreeTest : public ::testing::Test,
}
// Data fields.
- llvm::IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts =
- new DiagnosticOptions();
- llvm::IntrusiveRefCntPtr<DiagnosticsEngine> Diags =
+ IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts = new DiagnosticOptions();
+ IntrusiveRefCntPtr<DiagnosticsEngine> Diags =
new DiagnosticsEngine(new DiagnosticIDs, DiagOpts.get());
IntrusiveRefCntPtr<llvm::vfs::InMemoryFileSystem> FS =
new llvm::vfs::InMemoryFileSystem;
- llvm::IntrusiveRefCntPtr<FileManager> FileMgr =
+ IntrusiveRefCntPtr<FileManager> FileMgr =
new FileManager(FileSystemOptions(), FS);
- llvm::IntrusiveRefCntPtr<SourceManager> SourceMgr =
+ IntrusiveRefCntPtr<SourceManager> SourceMgr =
new SourceManager(*Diags, *FileMgr);
std::shared_ptr<CompilerInvocation> Invocation;
// Set after calling buildTree().
More information about the cfe-commits
mailing list