================ @@ -0,0 +1,403 @@ +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include "UseStructuredBindingCheck.h" +#include "../utils/DeclRefExprUtils.h" +#include "clang/Lex/Lexer.h" + +using namespace clang::ast_matchers; + +namespace clang::tidy::modernize { + +static constexpr StringRef PairDeclName = "PairVarD"; +static constexpr StringRef PairVarTypeName = "PairVarType"; +static constexpr StringRef FirstVarDeclName = "FirstVarDecl"; +static constexpr StringRef SecondVarDeclName = "SecondVarDecl"; +static constexpr StringRef BeginDeclStmtName = "BeginDeclStmt"; +static constexpr StringRef EndDeclStmtName = "EndDeclStmt"; +static constexpr StringRef FirstTypeName = "FirstType"; +static constexpr StringRef SecondTypeName = "SecondType"; +static constexpr StringRef ScopeBlockName = "ScopeBlock"; +static constexpr StringRef StdTieAssignStmtName = "StdTieAssign"; +static constexpr StringRef StdTieExprName = "StdTieExpr"; +static constexpr StringRef ForRangeStmtName = "ForRangeStmt"; +static constexpr StringRef InitExprName = "init_expr"; + +/// Matches a sequence of VarDecls matching the inner matchers, starting from +/// the \p Iter to \p EndIter and set bindings for the first DeclStmt and the +/// last DeclStmt if matched. +/// +/// \p Backwards indicates whether to match the VarDecls in reverse order. +template <typename Iterator> +static bool matchNVarDeclStartingWith( + Iterator Iter, const Iterator &EndIter, + ArrayRef<ast_matchers::internal::Matcher<VarDecl>> InnerMatchers, + ast_matchers::internal::ASTMatchFinder *Finder, + ast_matchers::internal::BoundNodesTreeBuilder *Builder, + bool Backwards = false) { + const DeclStmt *BeginDS = nullptr; + const DeclStmt *EndDS = nullptr; + const size_t N = InnerMatchers.size(); + size_t Count = 0; + + auto Matches = [&](const Decl *VD) { + // We don't want redundant decls in DeclStmt. + if (Count == N) + return false; + + if (const auto *Var = dyn_cast<VarDecl>(VD); + Var && InnerMatchers[Backwards ? N - Count - 1 : Count].matches( + *Var, Finder, Builder)) { + ++Count; + return true; + } + + return false; + }; + + for (; Iter != EndIter; ++Iter) { + EndDS = dyn_cast<DeclStmt>(*Iter); + if (!EndDS) + break; + + if (!BeginDS) + BeginDS = EndDS; + + for (const auto *VD : + llvm::reverse_conditionally(EndDS->decls(), Backwards)) { + if (!Matches(VD)) + return false; + } + + // All the matchers is satisfied in those DeclStmts. + if (Count == N) { + Builder->setBinding( + BeginDeclStmtName, + clang::DynTypedNode::create(Backwards ? *EndDS : *BeginDS)); + Builder->setBinding(EndDeclStmtName, clang::DynTypedNode::create( + Backwards ? *BeginDS : *EndDS)); + return true; + } + } + + return false; +} + +namespace { +/// What qualifiers and specifiers are used to create structured binding +/// declaration, it only supports the following four cases now. +enum TransferType : uint8_t { + TT_ByVal, + TT_ByConstVal, + TT_ByRef, + TT_ByConstRef +}; + +/// Matches a Stmt whose parent is a CompoundStmt, and which is directly +/// following two VarDecls matching the inner matcher. +AST_MATCHER_P(Stmt, hasPreTwoVarDecl, + llvm::SmallVector<ast_matchers::internal::Matcher<VarDecl>>, + InnerMatchers) { + const DynTypedNodeList Parents = Finder->getASTContext().getParents(Node); + if (Parents.size() != 1) + return false; + + const auto *C = Parents[0].get<CompoundStmt>(); + if (!C) + return false; + + const auto It = llvm::find(llvm::reverse(C->body()), &Node); + assert(It != C->body_rend() && "C is parent of Node"); + return matchNVarDeclStartingWith(It + 1, C->body_rend(), InnerMatchers, + Finder, Builder, true); +} + +/// Matches a Stmt whose parent is a CompoundStmt, and which is directly +/// followed by two VarDecls matching the inner matcher. +AST_MATCHER_P(Stmt, hasNextTwoVarDecl, + llvm::SmallVector<ast_matchers::internal::Matcher<VarDecl>>, + InnerMatchers) { + const DynTypedNodeList Parents = Finder->getASTContext().getParents(Node); + if (Parents.size() != 1) + return false; + + const auto *C = Parents[0].get<CompoundStmt>(); + if (!C) + return false; + + const auto *It = llvm::find(C->body(), &Node); + assert(It != C->body_end() && "C is parent of Node"); + return matchNVarDeclStartingWith(It + 1, C->body_end(), InnerMatchers, Finder, + Builder); +} + +/// Matches a CompoundStmt which has two VarDecls matching the inner matcher in +/// the beginning. +AST_MATCHER_P(CompoundStmt, hasFirstTwoVarDecl, + llvm::SmallVector<ast_matchers::internal::Matcher<VarDecl>>, + InnerMatchers) { + return matchNVarDeclStartingWith(Node.body_begin(), Node.body_end(), + InnerMatchers, Finder, Builder); +} + +/// It's not very common to have specifiers for variables used to decompose a +/// pair, so we ignore these cases. +AST_MATCHER(VarDecl, hasAnySpecifiersShouldBeIgnored) { + return Node.isStaticLocal() || Node.isConstexpr() || Node.hasAttrs() || + Node.isInlineSpecified(); +} + +// Ignore nodes inside macros. +AST_POLYMORPHIC_MATCHER(isInMarco, + AST_POLYMORPHIC_SUPPORTED_TYPES(Stmt, Decl)) { + return Node.getBeginLoc().isMacroID() || Node.getEndLoc().isMacroID(); +} + +AST_MATCHER_P(Expr, ignoringCopyCtorAndImplicitCast, + ast_matchers::internal::Matcher<Expr>, InnerMatcher) { + if (const auto *CtorE = dyn_cast<CXXConstructExpr>(&Node)) { + if (const CXXConstructorDecl *CtorD = CtorE->getConstructor(); + CtorD->isCopyConstructor() && CtorE->getNumArgs() == 1) { + return InnerMatcher.matches(*CtorE->getArg(0)->IgnoreImpCasts(), Finder, + Builder); + } + } + + return InnerMatcher.matches(*Node.IgnoreImpCasts(), Finder, Builder); +} + +AST_MATCHER(CXXRecordDecl, isPairType) { + return llvm::all_of(Node.fields(), [](const FieldDecl *FD) { + return FD->getAccess() == AS_public && + (FD->getName() == "first" || FD->getName() == "second"); + }); +} + +AST_MATCHER(VarDecl, isDirectInitialization) { + return Node.getInitStyle() != VarDecl::InitializationStyle::CInit; +} + +} // namespace + +static auto getVarInitWithMemberMatcher( + StringRef PairName, StringRef MemberName, StringRef TypeName, + StringRef BindingName, + const ast_matchers::internal::Matcher<VarDecl> &ExtraMatcher) { + return varDecl(ExtraMatcher, + hasInitializer(ignoringCopyCtorAndImplicitCast(memberExpr( + hasObjectExpression(ignoringImpCasts(declRefExpr( + to(equalsBoundNode(std::string(PairName)))))), + member(fieldDecl(hasName(MemberName), + hasType(qualType().bind(TypeName)))))))) + .bind(BindingName); +} + +void UseStructuredBindingCheck::registerMatchers(MatchFinder *Finder) { + auto PairType = qualType(unless(isVolatileQualified()), + hasUnqualifiedDesugaredType(recordType( + hasDeclaration(cxxRecordDecl(isPairType()))))); + + auto UnlessShouldBeIgnored = + unless(anyOf(hasAnySpecifiersShouldBeIgnored(), isInMarco())); + + auto VarInitWithFirstMember = + getVarInitWithMemberMatcher(PairDeclName, "first", FirstTypeName, + FirstVarDeclName, UnlessShouldBeIgnored); + auto VarInitWithSecondMember = + getVarInitWithMemberMatcher(PairDeclName, "second", SecondTypeName, + SecondVarDeclName, UnlessShouldBeIgnored); + + auto RefToBindName = [&UnlessShouldBeIgnored](const StringRef &Name) + -> ast_matchers::internal::BindableMatcher<Stmt> { + return declRefExpr(to(varDecl(UnlessShouldBeIgnored).bind(Name))); + }; + + auto HasAnyLambdaCaptureThisVar = + [](const ast_matchers::internal::Matcher<VarDecl> &VDMatcher) + -> ast_matchers::internal::BindableMatcher<Stmt> { + return compoundStmt(hasDescendant( + lambdaExpr(hasAnyCapture(capturesVar(varDecl(VDMatcher)))))); + }; ---------------- zwuis wrote:
It's up to you, but these trailing return types could be removed. https://github.com/llvm/llvm-project/pull/158462 _______________________________________________ cfe-commits mailing list [email protected] https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
