Author: Marcel Hlopko Date: 2020-03-23T16:22:14+01:00 New Revision: a711a3a46039154c38eade8bef1138b77fdb05ee
URL: https://github.com/llvm/llvm-project/commit/a711a3a46039154c38eade8bef1138b77fdb05ee DIFF: https://github.com/llvm/llvm-project/commit/a711a3a46039154c38eade8bef1138b77fdb05ee.diff LOG: [Syntax] Build mapping from AST to syntax tree nodes Summary: Copy of https://reviews.llvm.org/D72446, submitting with Ilya's permission. Only used to assign roles to child nodes for now. This is more efficient than doing range-based queries. In the future, will be exposed in the public API of syntax trees. Reviewers: gribozavr2 Reviewed By: gribozavr2 Subscribers: cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D76355 Added: Modified: clang/include/clang/Tooling/Syntax/Tree.h clang/lib/Tooling/Syntax/BuildTree.cpp clang/lib/Tooling/Syntax/Mutations.cpp clang/lib/Tooling/Syntax/Tree.cpp Removed: ################################################################################ diff --git a/clang/include/clang/Tooling/Syntax/Tree.h b/clang/include/clang/Tooling/Syntax/Tree.h index 8702fe60ce1b..bc581004c46e 100644 --- a/clang/include/clang/Tooling/Syntax/Tree.h +++ b/clang/include/clang/Tooling/Syntax/Tree.h @@ -126,6 +126,8 @@ class Node { // FactoryImpl sets CanModify flag. friend class FactoryImpl; + void setRole(NodeRole NR); + Tree *Parent; Node *NextSibling; unsigned Kind : 16; @@ -171,8 +173,11 @@ class Tree : public Node { /// Prepend \p Child to the list of children and and sets the parent pointer. /// A very low-level operation that does not check any invariants, only used /// by TreeBuilder and FactoryImpl. - /// EXPECTS: Role != NodeRoleDetached. + /// EXPECTS: Role != Detached. void prependChildLowLevel(Node *Child, NodeRole Role); + /// Like the previous overload, but does not set role for \p Child. + /// EXPECTS: Child->Role != Detached + void prependChildLowLevel(Node *Child); friend class TreeBuilder; friend class FactoryImpl; diff --git a/clang/lib/Tooling/Syntax/BuildTree.cpp b/clang/lib/Tooling/Syntax/BuildTree.cpp index a09ac1c53e34..4103a4d92c7d 100644 --- a/clang/lib/Tooling/Syntax/BuildTree.cpp +++ b/clang/lib/Tooling/Syntax/BuildTree.cpp @@ -25,6 +25,8 @@ #include "clang/Tooling/Syntax/Tokens.h" #include "clang/Tooling/Syntax/Tree.h" #include "llvm/ADT/ArrayRef.h" +#include "llvm/ADT/DenseMap.h" +#include "llvm/ADT/PointerUnion.h" #include "llvm/ADT/STLExtras.h" #include "llvm/ADT/ScopeExit.h" #include "llvm/ADT/SmallVector.h" @@ -34,6 +36,7 @@ #include "llvm/Support/FormatVariadic.h" #include "llvm/Support/MemoryBuffer.h" #include "llvm/Support/raw_ostream.h" +#include <cstddef> #include <map> using namespace clang; @@ -145,6 +148,30 @@ static SourceRange getDeclaratorRange(const SourceManager &SM, TypeLoc T, return SourceRange(Start, End); } +namespace { +/// All AST hierarchy roots that can be represented as pointers. +using ASTPtr = llvm::PointerUnion<Stmt *, Decl *>; +/// Maintains a mapping from AST to syntax tree nodes. This class will get more +/// complicated as we support more kinds of AST nodes, e.g. TypeLocs. +/// FIXME: expose this as public API. +class ASTToSyntaxMapping { +public: + void add(ASTPtr From, syntax::Tree *To) { + assert(To != nullptr); + assert(!From.isNull()); + + bool Added = Nodes.insert({From, To}).second; + (void)Added; + assert(Added && "mapping added twice"); + } + + syntax::Tree *find(ASTPtr P) const { return Nodes.lookup(P); } + +private: + llvm::DenseMap<ASTPtr, syntax::Tree *> Nodes; +}; +} // namespace + /// A helper class for constructing the syntax tree while traversing a clang /// AST. /// @@ -172,7 +199,18 @@ 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); + void foldNode(llvm::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) { + // FIXME: add mapping for TypeLocs + foldNode(Range, New, nullptr); + } /// Must be called with the range of each `DeclaratorDecl`. Ensures the /// corresponding declarator nodes are covered by `SimpleDeclaration`. @@ -195,8 +233,10 @@ class syntax::TreeBuilder { /// Set role for \p T. void markChildToken(const syntax::Token *T, NodeRole R); - /// Set role for the node that spans exactly \p Range. - void markChild(llvm::ArrayRef<syntax::Token> Range, NodeRole R); + /// Set role for \p N. + void markChild(syntax::Node *N, NodeRole R); + /// Set role for the syntax node matching \p N. + void markChild(ASTPtr N, NodeRole R); /// Set role for the delayed node that spans exactly \p Range. void markDelayedChild(llvm::ArrayRef<syntax::Token> Range, NodeRole R); /// Set role for the node that may or may not be delayed. Node must span @@ -221,8 +261,13 @@ class syntax::TreeBuilder { /// Finds a token starting at \p L. The token must exist if \p L is valid. const syntax::Token *findToken(SourceLocation L) const; - /// getRange() finds the syntax tokens corresponding to the passed source - /// locations. + /// Finds the syntax tokens corresponding to the \p SourceRange. + llvm::ArrayRef<syntax::Token> getRange(SourceRange Range) const { + assert(Range.isValid()); + return getRange(Range.getBegin(), Range.getEnd()); + } + + /// 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, @@ -236,8 +281,7 @@ class syntax::TreeBuilder { llvm::ArrayRef<syntax::Token> getTemplateRange(const ClassTemplateSpecializationDecl *D) const { - auto R = D->getSourceRange(); - auto Tokens = getRange(R.getBegin(), R.getEnd()); + auto Tokens = getRange(D->getSourceRange()); return maybeAppendSemicolon(Tokens, D); } @@ -247,16 +291,16 @@ class syntax::TreeBuilder { if (const auto *S = llvm::dyn_cast<TagDecl>(D)) Tokens = getRange(S->TypeDecl::getBeginLoc(), S->getEndLoc()); else - Tokens = getRange(D->getBeginLoc(), D->getEndLoc()); + Tokens = getRange(D->getSourceRange()); return maybeAppendSemicolon(Tokens, D); } llvm::ArrayRef<syntax::Token> getExprRange(const Expr *E) const { - return getRange(E->getBeginLoc(), E->getEndLoc()); + 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 { - auto Tokens = getRange(S->getBeginLoc(), S->getEndLoc()); + auto Tokens = getRange(S->getSourceRange()); if (isa<CompoundStmt>(S)) return Tokens; @@ -290,6 +334,11 @@ class syntax::TreeBuilder { return Tokens; } + void setRole(syntax::Node *N, NodeRole R) { + assert(N->role() == NodeRole::Detached); + N->setRole(R); + } + /// A collection of trees covering the input tokens. /// When created, each tree corresponds to a single token in the file. /// Clients call 'foldChildren' to attach one or more subtrees to a parent @@ -306,7 +355,7 @@ class syntax::TreeBuilder { auto *L = new (A.allocator()) syntax::Leaf(&T); L->Original = true; L->CanModify = A.tokenBuffer().spelledForExpanded(T).hasValue(); - Trees.insert(Trees.end(), {&T, NodeAndRole{L}}); + Trees.insert(Trees.end(), {&T, L}); } } @@ -338,7 +387,9 @@ class syntax::TreeBuilder { assert((std::next(It) == Trees.end() || std::next(It)->first == Range.end()) && "no child with the specified range"); - It->second.Role = Role; + assert(It->second->role() == NodeRole::Detached && + "re-assigning role for a child"); + It->second->setRole(Role); } /// Add \p Node to the forest and attach child nodes based on \p Tokens. @@ -394,7 +445,7 @@ class syntax::TreeBuilder { // EXPECTS: all tokens were consumed and are owned by a single root node. syntax::Node *finalize() && { assert(Trees.size() == 1); - auto *Root = Trees.begin()->second.Node; + auto *Root = Trees.begin()->second; Trees = {}; return Root; } @@ -408,9 +459,9 @@ class syntax::TreeBuilder { : A.tokenBuffer().expandedTokens().end() - It->first; R += std::string(llvm::formatv( - "- '{0}' covers '{1}'+{2} tokens\n", It->second.Node->kind(), + "- '{0}' covers '{1}'+{2} tokens\n", It->second->kind(), It->first->text(A.sourceManager()), CoveredTokens)); - R += It->second.Node->dump(A); + R += It->second->dump(A); } return R; } @@ -434,32 +485,25 @@ class syntax::TreeBuilder { "fold crosses boundaries of existing subtrees"); // We need to go in reverse order, because we can only prepend. - for (auto It = EndChildren; It != BeginChildren; --It) - Node->prependChildLowLevel(std::prev(It)->second.Node, - std::prev(It)->second.Role); + for (auto It = EndChildren; It != BeginChildren; --It) { + auto *C = std::prev(It)->second; + if (C->role() == NodeRole::Detached) + C->setRole(NodeRole::Unknown); + Node->prependChildLowLevel(C); + } // Mark that this node came from the AST and is backed by the source code. Node->Original = true; Node->CanModify = A.tokenBuffer().spelledForExpanded(Tokens).hasValue(); Trees.erase(BeginChildren, EndChildren); - Trees.insert({FirstToken, NodeAndRole(Node)}); + Trees.insert({FirstToken, Node}); } - /// A with a role that should be assigned to it when adding to a parent. - struct NodeAndRole { - explicit NodeAndRole(syntax::Node *Node) - : Node(Node), Role(NodeRole::Unknown) {} - - syntax::Node *Node; - NodeRole Role; - }; /// Maps from the start token to a subtree starting at that token. /// Keys in the map are pointers into the array of expanded tokens, so /// pointer order corresponds to the order of preprocessor tokens. - /// FIXME: storing the end tokens is redundant. - /// FIXME: the key of a map is redundant, it is also stored in NodeForRange. - std::map<const syntax::Token *, NodeAndRole> Trees; + std::map<const syntax::Token *, syntax::Node *> Trees; /// See documentation of `foldChildrenDelayed` for details. struct DelayedFold { @@ -479,6 +523,7 @@ class syntax::TreeBuilder { LocationToToken; Forest Pending; llvm::DenseSet<Decl *> DeclsWithoutSemicolons; + ASTToSyntaxMapping Mapping; }; namespace { @@ -505,10 +550,9 @@ class BuildTreeVisitor : public RecursiveASTVisitor<BuildTreeVisitor> { Builder.sourceManager(), DD->getTypeSourceInfo()->getTypeLoc(), getQualifiedNameStart(DD), Initializer); if (Declarator.isValid()) { - auto Tokens = - Builder.getRange(Declarator.getBegin(), Declarator.getEnd()); - Builder.foldNode(Tokens, new (allocator()) syntax::SimpleDeclarator); - Builder.markChild(Tokens, syntax::NodeRole::SimpleDeclaration_declarator); + auto *N = new (allocator()) syntax::SimpleDeclarator; + Builder.foldNode(Builder.getRange(Declarator), N, DD); + Builder.markChild(N, syntax::NodeRole::SimpleDeclaration_declarator); } return true; @@ -522,9 +566,9 @@ class BuildTreeVisitor : public RecursiveASTVisitor<BuildTreeVisitor> { Builder.sourceManager(), D->getTypeSourceInfo()->getTypeLoc(), /*Name=*/D->getLocation(), /*Initializer=*/SourceRange()); if (R.isValid()) { - auto Tokens = Builder.getRange(R.getBegin(), R.getEnd()); - Builder.foldNode(Tokens, new (allocator()) syntax::SimpleDeclarator); - Builder.markChild(Tokens, syntax::NodeRole::SimpleDeclaration_declarator); + auto *N = new (allocator()) syntax::SimpleDeclarator; + Builder.foldNode(Builder.getRange(R), N, D); + Builder.markChild(N, syntax::NodeRole::SimpleDeclaration_declarator); } return true; } @@ -532,7 +576,7 @@ class BuildTreeVisitor : public RecursiveASTVisitor<BuildTreeVisitor> { bool VisitDecl(Decl *D) { assert(!D->isImplicit()); Builder.foldNode(Builder.getDeclRange(D), - new (allocator()) syntax::UnknownDeclaration()); + new (allocator()) syntax::UnknownDeclaration(), D); return true; } @@ -545,11 +589,11 @@ class BuildTreeVisitor : public RecursiveASTVisitor<BuildTreeVisitor> { return false; if (C->isExplicitSpecialization()) return true; // we are only interested in explicit instantiations. - if (!WalkUpFromClassTemplateSpecializationDecl(C)) - return false; + auto *Declaration = + cast<syntax::SimpleDeclaration>(handleFreeStandingTagDecl(C)); foldExplicitTemplateInstantiation( Builder.getTemplateRange(C), Builder.findToken(C->getExternLoc()), - Builder.findToken(C->getTemplateKeywordLoc()), Builder.getDeclRange(C)); + Builder.findToken(C->getTemplateKeywordLoc()), Declaration, C); return true; } @@ -557,7 +601,7 @@ class BuildTreeVisitor : public RecursiveASTVisitor<BuildTreeVisitor> { foldTemplateDeclaration( Builder.getDeclRange(S), Builder.findToken(S->getTemplateParameters()->getTemplateLoc()), - Builder.getDeclRange(S->getTemplatedDecl())); + Builder.getDeclRange(S->getTemplatedDecl()), S); return true; } @@ -567,24 +611,30 @@ class BuildTreeVisitor : public RecursiveASTVisitor<BuildTreeVisitor> { assert(C->getNumTemplateParameterLists() == 0); return true; } + handleFreeStandingTagDecl(C); + return true; + } + + syntax::Declaration *handleFreeStandingTagDecl(TagDecl *C) { + assert(C->isFreeStanding()); // Class is a declaration specifier and needs a spanning declaration node. auto DeclarationRange = Builder.getDeclRange(C); - Builder.foldNode(DeclarationRange, - new (allocator()) syntax::SimpleDeclaration); + syntax::Declaration *Result = new (allocator()) syntax::SimpleDeclaration; + Builder.foldNode(DeclarationRange, Result, nullptr); // Build TemplateDeclaration nodes if we had template parameters. auto ConsumeTemplateParameters = [&](const TemplateParameterList &L) { const auto *TemplateKW = Builder.findToken(L.getTemplateLoc()); auto R = llvm::makeArrayRef(TemplateKW, DeclarationRange.end()); - foldTemplateDeclaration(R, TemplateKW, DeclarationRange); - + Result = + foldTemplateDeclaration(R, TemplateKW, DeclarationRange, nullptr); DeclarationRange = R; }; if (auto *S = llvm::dyn_cast<ClassTemplatePartialSpecializationDecl>(C)) ConsumeTemplateParameters(*S->getTemplateParameters()); for (unsigned I = C->getNumTemplateParameterLists(); 0 < I; --I) ConsumeTemplateParameters(*C->getTemplateParameterList(I - 1)); - return true; + return Result; } bool WalkUpFromTranslationUnitDecl(TranslationUnitDecl *TU) { @@ -602,14 +652,14 @@ class BuildTreeVisitor : public RecursiveASTVisitor<BuildTreeVisitor> { Builder.markChildToken(S->getRBracLoc(), NodeRole::CloseParen); Builder.foldNode(Builder.getStmtRange(S), - new (allocator()) syntax::CompoundStatement); + new (allocator()) syntax::CompoundStatement, S); return true; } // Some statements are not yet handled by syntax trees. bool WalkUpFromStmt(Stmt *S) { Builder.foldNode(Builder.getStmtRange(S), - new (allocator()) syntax::UnknownStatement); + new (allocator()) syntax::UnknownStatement, S); return true; } @@ -647,7 +697,7 @@ class BuildTreeVisitor : public RecursiveASTVisitor<BuildTreeVisitor> { bool WalkUpFromExpr(Expr *E) { assert(!isImplicitExpr(E) && "should be handled by TraverseStmt"); Builder.foldNode(Builder.getExprRange(E), - new (allocator()) syntax::UnknownExpression); + new (allocator()) syntax::UnknownExpression, E); return true; } @@ -659,7 +709,7 @@ class BuildTreeVisitor : public RecursiveASTVisitor<BuildTreeVisitor> { // FIXME: build corresponding nodes for the name of this namespace. return true; } - Builder.foldNode(Tokens, new (allocator()) syntax::NamespaceDefinition); + Builder.foldNode(Tokens, new (allocator()) syntax::NamespaceDefinition, S); return true; } @@ -674,7 +724,7 @@ class BuildTreeVisitor : public RecursiveASTVisitor<BuildTreeVisitor> { Builder.markChildToken(L.getLParenLoc(), syntax::NodeRole::OpenParen); Builder.markChildToken(L.getRParenLoc(), syntax::NodeRole::CloseParen); Builder.foldNode(Builder.getRange(L.getLParenLoc(), L.getRParenLoc()), - new (allocator()) syntax::ParenDeclarator); + new (allocator()) syntax::ParenDeclarator, L); return true; } @@ -685,7 +735,7 @@ class BuildTreeVisitor : public RecursiveASTVisitor<BuildTreeVisitor> { syntax::NodeRole::ArraySubscript_sizeExpression); Builder.markChildToken(L.getRBracketLoc(), syntax::NodeRole::CloseParen); Builder.foldNode(Builder.getRange(L.getLBracketLoc(), L.getRBracketLoc()), - new (allocator()) syntax::ArraySubscript); + new (allocator()) syntax::ArraySubscript, L); return true; } @@ -697,7 +747,7 @@ class BuildTreeVisitor : public RecursiveASTVisitor<BuildTreeVisitor> { syntax::NodeRole::ParametersAndQualifiers_parameter); Builder.markChildToken(L.getRParenLoc(), syntax::NodeRole::CloseParen); Builder.foldNode(Builder.getRange(L.getLParenLoc(), L.getEndLoc()), - new (allocator()) syntax::ParametersAndQualifiers); + new (allocator()) syntax::ParametersAndQualifiers, L); return true; } @@ -714,8 +764,8 @@ class BuildTreeVisitor : public RecursiveASTVisitor<BuildTreeVisitor> { bool WalkUpFromMemberPointerTypeLoc(MemberPointerTypeLoc L) { auto SR = L.getLocalSourceRange(); - Builder.foldNode(Builder.getRange(SR.getBegin(), SR.getEnd()), - new (allocator()) syntax::MemberPointer); + Builder.foldNode(Builder.getRange(SR), + new (allocator()) syntax::MemberPointer, L); return true; } @@ -724,13 +774,13 @@ class BuildTreeVisitor : public RecursiveASTVisitor<BuildTreeVisitor> { // and fold resulting nodes. bool WalkUpFromDeclStmt(DeclStmt *S) { Builder.foldNode(Builder.getStmtRange(S), - new (allocator()) syntax::DeclarationStatement); + new (allocator()) syntax::DeclarationStatement, S); return true; } bool WalkUpFromNullStmt(NullStmt *S) { Builder.foldNode(Builder.getStmtRange(S), - new (allocator()) syntax::EmptyStatement); + new (allocator()) syntax::EmptyStatement, S); return true; } @@ -739,7 +789,7 @@ class BuildTreeVisitor : public RecursiveASTVisitor<BuildTreeVisitor> { syntax::NodeRole::IntroducerKeyword); Builder.markStmtChild(S->getBody(), syntax::NodeRole::BodyStatement); Builder.foldNode(Builder.getStmtRange(S), - new (allocator()) syntax::SwitchStatement); + new (allocator()) syntax::SwitchStatement, S); return true; } @@ -749,7 +799,7 @@ class BuildTreeVisitor : public RecursiveASTVisitor<BuildTreeVisitor> { Builder.markExprChild(S->getLHS(), syntax::NodeRole::CaseStatement_value); Builder.markStmtChild(S->getSubStmt(), syntax::NodeRole::BodyStatement); Builder.foldNode(Builder.getStmtRange(S), - new (allocator()) syntax::CaseStatement); + new (allocator()) syntax::CaseStatement, S); return true; } @@ -758,7 +808,7 @@ class BuildTreeVisitor : public RecursiveASTVisitor<BuildTreeVisitor> { syntax::NodeRole::IntroducerKeyword); Builder.markStmtChild(S->getSubStmt(), syntax::NodeRole::BodyStatement); Builder.foldNode(Builder.getStmtRange(S), - new (allocator()) syntax::DefaultStatement); + new (allocator()) syntax::DefaultStatement, S); return true; } @@ -771,7 +821,7 @@ class BuildTreeVisitor : public RecursiveASTVisitor<BuildTreeVisitor> { Builder.markStmtChild(S->getElse(), syntax::NodeRole::IfStatement_elseStatement); Builder.foldNode(Builder.getStmtRange(S), - new (allocator()) syntax::IfStatement); + new (allocator()) syntax::IfStatement, S); return true; } @@ -779,7 +829,7 @@ class BuildTreeVisitor : public RecursiveASTVisitor<BuildTreeVisitor> { Builder.markChildToken(S->getForLoc(), syntax::NodeRole::IntroducerKeyword); Builder.markStmtChild(S->getBody(), syntax::NodeRole::BodyStatement); Builder.foldNode(Builder.getStmtRange(S), - new (allocator()) syntax::ForStatement); + new (allocator()) syntax::ForStatement, S); return true; } @@ -788,7 +838,7 @@ class BuildTreeVisitor : public RecursiveASTVisitor<BuildTreeVisitor> { syntax::NodeRole::IntroducerKeyword); Builder.markStmtChild(S->getBody(), syntax::NodeRole::BodyStatement); Builder.foldNode(Builder.getStmtRange(S), - new (allocator()) syntax::WhileStatement); + new (allocator()) syntax::WhileStatement, S); return true; } @@ -796,7 +846,7 @@ class BuildTreeVisitor : public RecursiveASTVisitor<BuildTreeVisitor> { Builder.markChildToken(S->getContinueLoc(), syntax::NodeRole::IntroducerKeyword); Builder.foldNode(Builder.getStmtRange(S), - new (allocator()) syntax::ContinueStatement); + new (allocator()) syntax::ContinueStatement, S); return true; } @@ -804,7 +854,7 @@ class BuildTreeVisitor : public RecursiveASTVisitor<BuildTreeVisitor> { Builder.markChildToken(S->getBreakLoc(), syntax::NodeRole::IntroducerKeyword); Builder.foldNode(Builder.getStmtRange(S), - new (allocator()) syntax::BreakStatement); + new (allocator()) syntax::BreakStatement, S); return true; } @@ -814,7 +864,7 @@ class BuildTreeVisitor : public RecursiveASTVisitor<BuildTreeVisitor> { Builder.markExprChild(S->getRetValue(), syntax::NodeRole::ReturnStatement_value); Builder.foldNode(Builder.getStmtRange(S), - new (allocator()) syntax::ReturnStatement); + new (allocator()) syntax::ReturnStatement, S); return true; } @@ -822,13 +872,13 @@ class BuildTreeVisitor : public RecursiveASTVisitor<BuildTreeVisitor> { Builder.markChildToken(S->getForLoc(), syntax::NodeRole::IntroducerKeyword); Builder.markStmtChild(S->getBody(), syntax::NodeRole::BodyStatement); Builder.foldNode(Builder.getStmtRange(S), - new (allocator()) syntax::RangeBasedForStatement); + new (allocator()) syntax::RangeBasedForStatement, S); return true; } bool WalkUpFromEmptyDecl(EmptyDecl *S) { Builder.foldNode(Builder.getDeclRange(S), - new (allocator()) syntax::EmptyDeclaration); + new (allocator()) syntax::EmptyDeclaration, S); return true; } @@ -838,55 +888,56 @@ class BuildTreeVisitor : public RecursiveASTVisitor<BuildTreeVisitor> { Builder.markExprChild(S->getMessage(), syntax::NodeRole::StaticAssertDeclaration_message); Builder.foldNode(Builder.getDeclRange(S), - new (allocator()) syntax::StaticAssertDeclaration); + new (allocator()) syntax::StaticAssertDeclaration, S); return true; } bool WalkUpFromLinkageSpecDecl(LinkageSpecDecl *S) { Builder.foldNode(Builder.getDeclRange(S), - new (allocator()) syntax::LinkageSpecificationDeclaration); + new (allocator()) syntax::LinkageSpecificationDeclaration, + S); return true; } bool WalkUpFromNamespaceAliasDecl(NamespaceAliasDecl *S) { Builder.foldNode(Builder.getDeclRange(S), - new (allocator()) syntax::NamespaceAliasDefinition); + new (allocator()) syntax::NamespaceAliasDefinition, S); return true; } bool WalkUpFromUsingDirectiveDecl(UsingDirectiveDecl *S) { Builder.foldNode(Builder.getDeclRange(S), - new (allocator()) syntax::UsingNamespaceDirective); + new (allocator()) syntax::UsingNamespaceDirective, S); return true; } bool WalkUpFromUsingDecl(UsingDecl *S) { Builder.foldNode(Builder.getDeclRange(S), - new (allocator()) syntax::UsingDeclaration); + new (allocator()) syntax::UsingDeclaration, S); return true; } bool WalkUpFromUnresolvedUsingValueDecl(UnresolvedUsingValueDecl *S) { Builder.foldNode(Builder.getDeclRange(S), - new (allocator()) syntax::UsingDeclaration); + new (allocator()) syntax::UsingDeclaration, S); return true; } bool WalkUpFromUnresolvedUsingTypenameDecl(UnresolvedUsingTypenameDecl *S) { Builder.foldNode(Builder.getDeclRange(S), - new (allocator()) syntax::UsingDeclaration); + new (allocator()) syntax::UsingDeclaration, S); return true; } bool WalkUpFromTypeAliasDecl(TypeAliasDecl *S) { Builder.foldNode(Builder.getDeclRange(S), - new (allocator()) syntax::TypeAliasDeclaration); + new (allocator()) syntax::TypeAliasDeclaration, S); return true; } private: /// Returns the range of the built node. - llvm::ArrayRef<syntax::Token> BuildTrailingReturn(FunctionProtoTypeLoc L) { + syntax::TrailingReturnType *BuildTrailingReturn(FunctionProtoTypeLoc L) { assert(L.getTypePtr()->hasTrailingReturn()); auto ReturnedType = L.getReturnLoc(); @@ -895,33 +946,31 @@ class BuildTreeVisitor : public RecursiveASTVisitor<BuildTreeVisitor> { getDeclaratorRange(this->Builder.sourceManager(), ReturnedType, /*Name=*/SourceLocation(), /*Initializer=*/SourceLocation()); - llvm::ArrayRef<syntax::Token> ReturnDeclaratorTokens; + syntax::SimpleDeclarator *ReturnDeclarator = nullptr; if (ReturnDeclaratorRange.isValid()) { - ReturnDeclaratorTokens = Builder.getRange( - ReturnDeclaratorRange.getBegin(), ReturnDeclaratorRange.getEnd()); - Builder.foldNode(ReturnDeclaratorTokens, - new (allocator()) syntax::SimpleDeclarator); + ReturnDeclarator = new (allocator()) syntax::SimpleDeclarator; + Builder.foldNode(Builder.getRange(ReturnDeclaratorRange), + ReturnDeclarator, nullptr); } // Build node for trailing return type. - auto Return = - Builder.getRange(ReturnedType.getBeginLoc(), ReturnedType.getEndLoc()); + auto Return = Builder.getRange(ReturnedType.getSourceRange()); const auto *Arrow = Return.begin() - 1; assert(Arrow->kind() == tok::arrow); auto Tokens = llvm::makeArrayRef(Arrow, Return.end()); Builder.markChildToken(Arrow, syntax::NodeRole::TrailingReturnType_arrow); - if (!ReturnDeclaratorTokens.empty()) - Builder.markChild(ReturnDeclaratorTokens, + if (ReturnDeclarator) + Builder.markChild(ReturnDeclarator, syntax::NodeRole::TrailingReturnType_declarator); - Builder.foldNode(Tokens, new (allocator()) syntax::TrailingReturnType); - return Tokens; + auto *R = new (allocator()) syntax::TrailingReturnType; + Builder.foldNode(Tokens, R, nullptr); + return R; } - void - foldExplicitTemplateInstantiation(ArrayRef<syntax::Token> Range, - const syntax::Token *ExternKW, - const syntax::Token *TemplateKW, - ArrayRef<syntax::Token> InnerDeclaration) { + void foldExplicitTemplateInstantiation( + ArrayRef<syntax::Token> Range, const syntax::Token *ExternKW, + const syntax::Token *TemplateKW, + syntax::SimpleDeclaration *InnerDeclaration, Decl *From) { assert(!ExternKW || ExternKW->kind() == tok::kw_extern); assert(TemplateKW && TemplateKW->kind() == tok::kw_template); Builder.markChildToken( @@ -931,19 +980,22 @@ class BuildTreeVisitor : public RecursiveASTVisitor<BuildTreeVisitor> { Builder.markChild( InnerDeclaration, syntax::NodeRole::ExplicitTemplateInstantiation_declaration); - Builder.foldNode(Range, - new (allocator()) syntax::ExplicitTemplateInstantiation); + Builder.foldNode( + Range, new (allocator()) syntax::ExplicitTemplateInstantiation, From); } - void foldTemplateDeclaration(ArrayRef<syntax::Token> Range, - const syntax::Token *TemplateKW, - ArrayRef<syntax::Token> TemplatedDeclaration) { + syntax::TemplateDeclaration *foldTemplateDeclaration( + ArrayRef<syntax::Token> Range, const syntax::Token *TemplateKW, + ArrayRef<syntax::Token> TemplatedDeclaration, Decl *From) { assert(TemplateKW && TemplateKW->kind() == tok::kw_template); Builder.markChildToken(TemplateKW, syntax::NodeRole::IntroducerKeyword); Builder.markMaybeDelayedChild( TemplatedDeclaration, syntax::NodeRole::TemplateDeclaration_declaration); - Builder.foldNode(Range, new (allocator()) syntax::TemplateDeclaration); + + auto *N = new (allocator()) syntax::TemplateDeclaration; + Builder.foldNode(Range, N, From); + return N; } /// A small helper to save some typing. @@ -954,11 +1006,6 @@ class BuildTreeVisitor : public RecursiveASTVisitor<BuildTreeVisitor> { }; } // namespace -void syntax::TreeBuilder::foldNode(llvm::ArrayRef<syntax::Token> Range, - syntax::Tree *New) { - Pending.foldChildren(Arena, Range, New); -} - void syntax::TreeBuilder::noticeDeclRange(llvm::ArrayRef<syntax::Token> Range) { if (Pending.extendDelayedFold(Range)) return; @@ -982,9 +1029,15 @@ void syntax::TreeBuilder::markChildToken(const syntax::Token *T, NodeRole R) { Pending.assignRole(*T, R); } -void syntax::TreeBuilder::markChild(llvm::ArrayRef<syntax::Token> Range, - NodeRole R) { - Pending.assignRole(Range, R); +void syntax::TreeBuilder::markChild(syntax::Node *N, NodeRole R) { + assert(N); + setRole(N, R); +} + +void syntax::TreeBuilder::markChild(ASTPtr N, NodeRole R) { + auto *SN = Mapping.find(N); + assert(SN != nullptr); + setRole(SN, R); } void syntax::TreeBuilder::markDelayedChild(llvm::ArrayRef<syntax::Token> Range, @@ -1001,24 +1054,28 @@ void syntax::TreeBuilder::markStmtChild(Stmt *Child, NodeRole Role) { if (!Child) return; - auto Range = getStmtRange(Child); + syntax::Tree *ChildNode = Mapping.find(Child); + assert(ChildNode != nullptr); + // This is an expression in a statement position, consume the trailing // semicolon and form an 'ExpressionStatement' node. if (auto *E = dyn_cast<Expr>(Child)) { - Pending.assignRole(getExprRange(E), - NodeRole::ExpressionStatement_expression); - // 'getRange(Stmt)' ensures this already covers a trailing semicolon. - Pending.foldChildren(Arena, Range, - new (allocator()) syntax::ExpressionStatement); + setRole(ChildNode, NodeRole::ExpressionStatement_expression); + ChildNode = new (allocator()) syntax::ExpressionStatement; + // (!) 'getStmtRange()' ensures this covers a trailing semicolon. + Pending.foldChildren(Arena, getStmtRange(Child), ChildNode); } - Pending.assignRole(Range, Role); + setRole(ChildNode, Role); } void syntax::TreeBuilder::markExprChild(Expr *Child, NodeRole Role) { if (!Child) return; + Child = Child->IgnoreImplicit(); - Pending.assignRole(getExprRange(Child), Role); + syntax::Tree *ChildNode = Mapping.find(Child); + assert(ChildNode != nullptr); + setRole(ChildNode, Role); } const syntax::Token *syntax::TreeBuilder::findToken(SourceLocation L) const { diff --git a/clang/lib/Tooling/Syntax/Mutations.cpp b/clang/lib/Tooling/Syntax/Mutations.cpp index 72458528202e..24048b297a11 100644 --- a/clang/lib/Tooling/Syntax/Mutations.cpp +++ b/clang/lib/Tooling/Syntax/Mutations.cpp @@ -35,7 +35,7 @@ class syntax::MutationsImpl { assert(!New->isDetached()); assert(Role != NodeRole::Detached); - New->Role = static_cast<unsigned>(Role); + New->setRole(Role); auto *P = Anchor->parent(); P->replaceChildRangeLowLevel(Anchor, Anchor, New); diff --git a/clang/lib/Tooling/Syntax/Tree.cpp b/clang/lib/Tooling/Syntax/Tree.cpp index 9a6270ec4cce..37579e6145b6 100644 --- a/clang/lib/Tooling/Syntax/Tree.cpp +++ b/clang/lib/Tooling/Syntax/Tree.cpp @@ -58,22 +58,33 @@ bool syntax::Leaf::classof(const Node *N) { syntax::Node::Node(NodeKind Kind) : Parent(nullptr), NextSibling(nullptr), Kind(static_cast<unsigned>(Kind)), - Role(static_cast<unsigned>(NodeRole::Detached)), Original(false), - CanModify(false) {} + Role(0), Original(false), CanModify(false) { + this->setRole(NodeRole::Detached); +} bool syntax::Node::isDetached() const { return role() == NodeRole::Detached; } +void syntax::Node::setRole(NodeRole NR) { + this->Role = static_cast<unsigned>(NR); +} + bool syntax::Tree::classof(const Node *N) { return N->kind() > NodeKind::Leaf; } void syntax::Tree::prependChildLowLevel(Node *Child, NodeRole Role) { - assert(Child->Parent == nullptr); - assert(Child->NextSibling == nullptr); assert(Child->role() == NodeRole::Detached); assert(Role != NodeRole::Detached); + Child->setRole(Role); + prependChildLowLevel(Child); +} + +void syntax::Tree::prependChildLowLevel(Node *Child) { + assert(Child->Parent == nullptr); + assert(Child->NextSibling == nullptr); + assert(Child->role() != NodeRole::Detached); + Child->Parent = this; Child->NextSibling = this->FirstChild; - Child->Role = static_cast<unsigned>(Role); this->FirstChild = Child; } @@ -94,7 +105,7 @@ void syntax::Tree::replaceChildRangeLowLevel(Node *BeforeBegin, Node *End, N != End;) { auto *Next = N->NextSibling; - N->Role = static_cast<unsigned>(NodeRole::Detached); + N->setRole(NodeRole::Detached); N->Parent = nullptr; N->NextSibling = nullptr; if (N->Original) _______________________________________________ cfe-commits mailing list cfe-commits@lists.llvm.org https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits