LLVM and LLVM-SPIRV-Translator pulldown

LLVM: 4b8632e
LLVM-SPIRV-Translator: KhronosGroup/SPIRV-LLVM-Translator@1b546773

Author: vladimirlaz

clang-tools-extra/clang-query/Query.cpp

@@ -43,6 +43,15 @@ bool HelpQuery::run(llvm::raw_ostream &OS, QuerySession &QS) const {
         "Set whether to bind the root matcher to \"root\".\n"
         "  set print-matcher (true|false)    "
         "Set whether to print the current matcher,\n"
+        "  set traversal <kind>              "
+        "Set traversal kind of clang-query session. Available kinds are:\n"
+        "    AsIs                            "
+        "Print and match the AST as clang sees it.\n"
+        "    IgnoreImplicitCastsAndParentheses  "
+        "Omit implicit casts and parens in matching and dumping.\n"
+        "    IgnoreUnlessSpelledInSource     "
+        "Omit AST nodes unless spelled in the source.  This mode is the "
+        "default.\n"
         "  set output <feature>              "
         "Set whether to output only <feature> content.\n"
         "  enable output <feature>           "
@@ -98,6 +107,8 @@ bool MatchQuery::run(llvm::raw_ostream &OS, QuerySession &QS) const {
       OS << "Not a valid top-level matcher.\n";
       return false;
     }
+
+    AST->getASTContext().getParentMapContext().setTraversalKind(QS.TK);
     Finder.matchAST(AST->getASTContext());
 
     if (QS.PrintMatcher) {
@@ -148,6 +159,7 @@ bool MatchQuery::run(llvm::raw_ostream &OS, QuerySession &QS) const {
           const SourceManager &SM = Ctx.getSourceManager();
           ASTDumper Dumper(OS, &Ctx.getCommentCommandTraits(), &SM,
                 SM.getDiagnostics().getShowColors(), Ctx.getPrintingPolicy());
+          Dumper.SetTraversalKind(QS.TK);
           Dumper.Visit(BI->second);
           OS << "\n";
         }

clang-tools-extra/clang-query/Query.h

@@ -28,6 +28,7 @@ enum QueryKind {
   QK_Match,
   QK_SetBool,
   QK_SetOutputKind,
+  QK_SetTraversalKind,
   QK_EnableOutputKind,
   QK_DisableOutputKind,
   QK_Quit
@@ -119,6 +120,10 @@ template <> struct SetQueryKind<OutputKind> {
   static const QueryKind value = QK_SetOutputKind;
 };
 
+template <> struct SetQueryKind<ast_type_traits::TraversalKind> {
+  static const QueryKind value = QK_SetTraversalKind;
+};
+
 /// Query for "set VAR VALUE".
 template <typename T> struct SetQuery : Query {
   SetQuery(T QuerySession::*Var, T Value)

clang-tools-extra/clang-query/QueryParser.cpp

@@ -128,6 +128,24 @@ template <typename QueryType> QueryRef QueryParser::parseSetOutputKind() {
   llvm_unreachable("Invalid output kind");
 }
 
+QueryRef QueryParser::parseSetTraversalKind(
+    ast_type_traits::TraversalKind QuerySession::*Var) {
+  StringRef ValStr;
+  unsigned Value =
+      LexOrCompleteWord<unsigned>(this, ValStr)
+          .Case("AsIs", ast_type_traits::TK_AsIs)
+          .Case("IgnoreImplicitCastsAndParentheses",
+                ast_type_traits::TK_IgnoreImplicitCastsAndParentheses)
+          .Case("IgnoreUnlessSpelledInSource",
+                ast_type_traits::TK_IgnoreUnlessSpelledInSource)
+          .Default(~0u);
+  if (Value == ~0u) {
+    return new InvalidQuery("expected traversal kind, got '" + ValStr + "'");
+  }
+  return new SetQuery<ast_type_traits::TraversalKind>(
+      Var, static_cast<ast_type_traits::TraversalKind>(Value));
+}
+
 QueryRef QueryParser::endQuery(QueryRef Q) {
   StringRef Extra = Line;
   StringRef ExtraTrimmed = Extra.drop_while(
@@ -171,7 +189,8 @@ enum ParsedQueryVariable {
   PQV_Invalid,
   PQV_Output,
   PQV_BindRoot,
-  PQV_PrintMatcher
+  PQV_PrintMatcher,
+  PQV_Traversal
 };
 
 QueryRef makeInvalidQueryFromDiagnostics(const Diagnostics &Diag) {
@@ -272,6 +291,7 @@ QueryRef QueryParser::doParse() {
             .Case("output", PQV_Output)
             .Case("bind-root", PQV_BindRoot)
             .Case("print-matcher", PQV_PrintMatcher)
+            .Case("traversal", PQV_Traversal)
             .Default(PQV_Invalid);
     if (VarStr.empty())
       return new InvalidQuery("expected variable name");
@@ -289,6 +309,9 @@ QueryRef QueryParser::doParse() {
     case PQV_PrintMatcher:
       Q = parseSetBool(&QuerySession::PrintMatcher);
       break;
+    case PQV_Traversal:
+      Q = parseSetTraversalKind(&QuerySession::TK);
+      break;
     case PQV_Invalid:
       llvm_unreachable("Invalid query kind");
     }

clang-tools-extra/clang-query/QueryParser.h

@@ -43,6 +43,8 @@ class QueryParser {
   template <typename T> struct LexOrCompleteWord;
 
   QueryRef parseSetBool(bool QuerySession::*Var);
+  QueryRef
+  parseSetTraversalKind(ast_type_traits::TraversalKind QuerySession::*Var);
   template <typename QueryType> QueryRef parseSetOutputKind();
   QueryRef completeMatcherExpression();
 

clang-tools-extra/clang-query/QuerySession.h

@@ -9,6 +9,7 @@
 #ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_QUERY_QUERY_SESSION_H
 #define LLVM_CLANG_TOOLS_EXTRA_CLANG_QUERY_QUERY_SESSION_H
 
+#include "clang/AST/ASTTypeTraits.h"
 #include "clang/ASTMatchers/Dynamic/VariantValue.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/StringMap.h"
@@ -25,7 +26,7 @@ class QuerySession {
   QuerySession(llvm::ArrayRef<std::unique_ptr<ASTUnit>> ASTs)
       : ASTs(ASTs), PrintOutput(false), DiagOutput(true),
         DetailedASTOutput(false), BindRoot(true), PrintMatcher(false),
-        Terminate(false) {}
+        Terminate(false), TK(ast_type_traits::TK_IgnoreUnlessSpelledInSource) {}
 
   llvm::ArrayRef<std::unique_ptr<ASTUnit>> ASTs;
 
@@ -36,6 +37,8 @@ class QuerySession {
   bool BindRoot;
   bool PrintMatcher;
   bool Terminate;
+
+  ast_type_traits::TraversalKind TK;
   llvm::StringMap<ast_matchers::dynamic::VariantValue> NamedValues;
 };
 

clang-tools-extra/clang-reorder-fields/ReorderFieldsAction.cpp

@@ -104,9 +104,11 @@ findMembersUsedInInitExpr(const CXXCtorInitializer *Initializer,
   // for those accesses Sema::PerformObjectMemberConversion always inserts an
   // UncheckedDerivedToBase ImplicitCastExpr between the this expr and the
   // object expression
-  auto FoundExprs =
-      match(findAll(memberExpr(hasObjectExpression(cxxThisExpr())).bind("ME")),
-            *Initializer->getInit(), Context);
+  auto FoundExprs = match(
+      traverse(
+          TK_AsIs,
+          findAll(memberExpr(hasObjectExpression(cxxThisExpr())).bind("ME"))),
+      *Initializer->getInit(), Context);
   for (BoundNodes &BN : FoundExprs)
     if (auto *MemExpr = BN.getNodeAs<MemberExpr>("ME"))
       if (auto *FD = dyn_cast<FieldDecl>(MemExpr->getMemberDecl()))

clang-tools-extra/clang-tidy/abseil/DurationDivisionCheck.cpp

@@ -20,16 +20,17 @@ void DurationDivisionCheck::registerMatchers(MatchFinder *finder) {
   const auto DurationExpr =
       expr(hasType(cxxRecordDecl(hasName("::absl::Duration"))));
   finder->addMatcher(
-      implicitCastExpr(
-          hasSourceExpression(ignoringParenCasts(
-              cxxOperatorCallExpr(hasOverloadedOperatorName("/"),
-                                  hasArgument(0, DurationExpr),
-                                  hasArgument(1, DurationExpr))
-                  .bind("OpCall"))),
-          hasImplicitDestinationType(qualType(unless(isInteger()))),
-          unless(hasParent(cxxStaticCastExpr())),
-          unless(hasParent(cStyleCastExpr())),
-          unless(isInTemplateInstantiation())),
+      traverse(ast_type_traits::TK_AsIs,
+               implicitCastExpr(
+                   hasSourceExpression(ignoringParenCasts(
+                       cxxOperatorCallExpr(hasOverloadedOperatorName("/"),
+                                           hasArgument(0, DurationExpr),
+                                           hasArgument(1, DurationExpr))
+                           .bind("OpCall"))),
+                   hasImplicitDestinationType(qualType(unless(isInteger()))),
+                   unless(hasParent(cxxStaticCastExpr())),
+                   unless(hasParent(cStyleCastExpr())),
+                   unless(isInTemplateInstantiation()))),
       this);
 }
 

clang-tools-extra/clang-tidy/abseil/FasterStrsplitDelimiterCheck.cpp

@@ -78,20 +78,23 @@ void FasterStrsplitDelimiterCheck::registerMatchers(MatchFinder *Finder) {
 
   // Find uses of absl::StrSplit(..., "x") and absl::StrSplit(...,
   // absl::ByAnyChar("x")) to transform them into absl::StrSplit(..., 'x').
-  Finder->addMatcher(callExpr(callee(functionDecl(hasName("::absl::StrSplit"))),
-                              hasArgument(1, anyOf(ByAnyCharArg, SingleChar)),
-                              unless(isInTemplateInstantiation()))
-                         .bind("StrSplit"),
-                     this);
+  Finder->addMatcher(
+      traverse(ast_type_traits::TK_AsIs,
+               callExpr(callee(functionDecl(hasName("::absl::StrSplit"))),
+                        hasArgument(1, anyOf(ByAnyCharArg, SingleChar)),
+                        unless(isInTemplateInstantiation()))
+                   .bind("StrSplit")),
+      this);
 
   // Find uses of absl::MaxSplits("x", N) and
   // absl::MaxSplits(absl::ByAnyChar("x"), N) to transform them into
   // absl::MaxSplits('x', N).
   Finder->addMatcher(
-      callExpr(
-          callee(functionDecl(hasName("::absl::MaxSplits"))),
-          hasArgument(0, anyOf(ByAnyCharArg, ignoringParenCasts(SingleChar))),
-          unless(isInTemplateInstantiation())),
+      traverse(ast_type_traits::TK_AsIs,
+               callExpr(callee(functionDecl(hasName("::absl::MaxSplits"))),
+                        hasArgument(0, anyOf(ByAnyCharArg,
+                                             ignoringParenCasts(SingleChar))),
+                        unless(isInTemplateInstantiation()))),
       this);
 }
 

clang-tools-extra/clang-tidy/abseil/RedundantStrcatCallsCheck.cpp

@@ -64,11 +64,12 @@ const clang::CallExpr* ProcessArgument(const Expr* Arg,
   static const auto* const Strcat = new auto(hasName("::absl::StrCat"));
   const auto IsStrcat = cxxBindTemporaryExpr(
       has(callExpr(callee(functionDecl(*Strcat))).bind("StrCat")));
-  if (const auto* SubStrcatCall = selectFirst<const CallExpr>(
+  if (const auto *SubStrcatCall = selectFirst<const CallExpr>(
           "StrCat",
-          match(stmt(anyOf(
-                    cxxConstructExpr(IsAlphanum, hasArgument(0, IsStrcat)),
-                    IsStrcat)),
+          match(stmt(traverse(ast_type_traits::TK_AsIs,
+                              anyOf(cxxConstructExpr(IsAlphanum,
+                                                     hasArgument(0, IsStrcat)),
+                                    IsStrcat))),
                 *Arg->IgnoreParenImpCasts(), *Result.Context))) {
     RemoveCallLeaveArgs(SubStrcatCall, CheckResult);
     return SubStrcatCall;

clang-tools-extra/clang-tidy/abseil/StrCatAppendCheck.cpp

@@ -58,14 +58,17 @@ void StrCatAppendCheck::registerMatchers(MatchFinder *Finder) {
   // StrCat on the RHS. The first argument of the StrCat call should be the same
   // as the LHS. Ignore calls from template instantiations.
   Finder->addMatcher(
-      cxxOperatorCallExpr(
-          unless(isInTemplateInstantiation()), hasOverloadedOperatorName("="),
-          hasArgument(0, declRefExpr(to(decl().bind("LHS")))),
-          hasArgument(1, IgnoringTemporaries(
-                             callExpr(callee(StrCat), hasArgument(0, AlphaNum),
-                                      unless(HasAnotherReferenceToLhs))
-                                 .bind("Call"))))
-          .bind("Op"),
+      traverse(ast_type_traits::TK_AsIs,
+               cxxOperatorCallExpr(
+                   unless(isInTemplateInstantiation()),
+                   hasOverloadedOperatorName("="),
+                   hasArgument(0, declRefExpr(to(decl().bind("LHS")))),
+                   hasArgument(
+                       1, IgnoringTemporaries(
+                              callExpr(callee(StrCat), hasArgument(0, AlphaNum),
+                                       unless(HasAnotherReferenceToLhs))
+                                  .bind("Call"))))
+                   .bind("Op")),
       this);
 }
 

clang-tools-extra/clang-tidy/abseil/StringFindStartswithCheck.cpp

@@ -52,8 +52,8 @@ void StringFindStartswithCheck::registerMatchers(MatchFinder *Finder) {
       // Match [=!]= with a zero on one side and a string.find on the other.
       binaryOperator(
           hasAnyOperatorName("==", "!="),
-          hasEitherOperand(ignoringParenImpCasts(ZeroLiteral)),
-          hasEitherOperand(ignoringParenImpCasts(StringFind.bind("findexpr"))))
+          hasOperands(ignoringParenImpCasts(ZeroLiteral),
+                      ignoringParenImpCasts(StringFind.bind("findexpr"))))
           .bind("expr"),
       this);
 }

clang-tools-extra/clang-tidy/abseil/UpgradeDurationConversionsCheck.cpp

@@ -99,14 +99,17 @@ void UpgradeDurationConversionsCheck::registerMatchers(MatchFinder *Finder) {
   //   `absl::Hours(x)`
   // where `x` is not of a built-in type.
   Finder->addMatcher(
-      implicitCastExpr(
-          anyOf(hasCastKind(CK_UserDefinedConversion),
-                has(implicitCastExpr(hasCastKind(CK_UserDefinedConversion)))),
-          hasParent(callExpr(
-              callee(functionDecl(DurationFactoryFunction(),
-                                  unless(hasParent(functionTemplateDecl())))),
-              hasArgument(0, expr().bind("arg")))))
-          .bind("OuterExpr"),
+      traverse(
+          ast_type_traits::TK_AsIs,
+          implicitCastExpr(anyOf(hasCastKind(CK_UserDefinedConversion),
+                                 has(implicitCastExpr(
+                                     hasCastKind(CK_UserDefinedConversion)))),
+                           hasParent(callExpr(
+                               callee(functionDecl(
+                                   DurationFactoryFunction(),
+                                   unless(hasParent(functionTemplateDecl())))),
+                               hasArgument(0, expr().bind("arg")))))
+              .bind("OuterExpr")),
       this);
 }
 
@@ -116,6 +119,8 @@ void UpgradeDurationConversionsCheck::check(
       "implicit conversion to 'int64_t' is deprecated in this context; use an "
       "explicit cast instead";
 
+  TraversalKindScope RAII(*Result.Context, ast_type_traits::TK_AsIs);
+
   const auto *ArgExpr = Result.Nodes.getNodeAs<Expr>("arg");
   SourceLocation Loc = ArgExpr->getBeginLoc();
 

clang-tools-extra/clang-tidy/add_new_check.py

@@ -1,12 +1,12 @@
 #!/usr/bin/env python
 #
-#===- add_new_check.py - clang-tidy check generator ----------*- python -*--===#
+#===- add_new_check.py - clang-tidy check generator ---------*- python -*--===#
 #
 # 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
 #
-#===------------------------------------------------------------------------===#
+#===-----------------------------------------------------------------------===#
 
 from __future__ import print_function
 
@@ -15,8 +15,9 @@
 import re
 import sys
 
-# Adapts the module's CMakelist file. Returns 'True' if it could add a new entry
-# and 'False' if the entry already existed.
+
+# Adapts the module's CMakelist file. Returns 'True' if it could add a new
+# entry and 'False' if the entry already existed.
 def adapt_cmake(module_path, check_name_camel):
   filename = os.path.join(module_path, 'CMakeLists.txt')
   with open(filename, 'r') as f:
@@ -227,7 +228,6 @@ def add_release_notes(module_path, module, check_name):
   with open(filename, 'w') as f:
     note_added = False
     header_found = False
-    next_header_found = False
     add_note_here = False
 
     for line in lines:
@@ -241,7 +241,6 @@ def add_release_notes(module_path, module, check_name):
             add_note_here = True
 
         if match_next:
-          next_header_found = True
           add_note_here = True
 
         if match:

clang-tools-extra/clang-tidy/bugprone/AssertSideEffectCheck.cpp

@@ -84,7 +84,8 @@ void AssertSideEffectCheck::storeOptions(ClangTidyOptions::OptionMap &Opts) {
 
 void AssertSideEffectCheck::registerMatchers(MatchFinder *Finder) {
   auto DescendantWithSideEffect =
-      hasDescendant(expr(hasSideEffect(CheckFunctionCalls)));
+      traverse(ast_type_traits::TK_AsIs,
+               hasDescendant(expr(hasSideEffect(CheckFunctionCalls))));
   auto ConditionWithSideEffect = hasCondition(DescendantWithSideEffect);
   Finder->addMatcher(
       stmt(

clang-tools-extra/clang-tidy/bugprone/BoolPointerImplicitConversionCheck.cpp

@@ -18,14 +18,16 @@ void BoolPointerImplicitConversionCheck::registerMatchers(MatchFinder *Finder) {
   // Look for ifs that have an implicit bool* to bool conversion in the
   // condition. Filter negations.
   Finder->addMatcher(
-      ifStmt(hasCondition(findAll(implicitCastExpr(
-                 unless(hasParent(unaryOperator(hasOperatorName("!")))),
-                 hasSourceExpression(
-                     expr(hasType(pointerType(pointee(booleanType()))),
-                          ignoringParenImpCasts(declRefExpr().bind("expr")))),
-                 hasCastKind(CK_PointerToBoolean)))),
-             unless(isInTemplateInstantiation()))
-          .bind("if"),
+      traverse(
+          ast_type_traits::TK_AsIs,
+          ifStmt(hasCondition(findAll(implicitCastExpr(
+                     unless(hasParent(unaryOperator(hasOperatorName("!")))),
+                     hasSourceExpression(expr(
+                         hasType(pointerType(pointee(booleanType()))),
+                         ignoringParenImpCasts(declRefExpr().bind("expr")))),
+                     hasCastKind(CK_PointerToBoolean)))),
+                 unless(isInTemplateInstantiation()))
+              .bind("if")),
       this);
 }