LLVM and SPIRV-LLVM-Translator pulldown (WW14-15) #3488

LLVM: llvm/llvm-project@9711118
SPIRV-LLVM-Translator: KhronosGroup/SPIRV-LLVM-Translator@56988bb

Author: vladimirlaz

clang-tools-extra/clang-tidy/readability/BracesAroundStatementsCheck.cpp

@@ -105,10 +105,7 @@ void BracesAroundStatementsCheck::storeOptions(
 }
 
 void BracesAroundStatementsCheck::registerMatchers(MatchFinder *Finder) {
-  Finder->addMatcher(
-      ifStmt(unless(allOf(isConstexpr(), isInTemplateInstantiation())))
-          .bind("if"),
-      this);
+  Finder->addMatcher(ifStmt().bind("if"), this);
   Finder->addMatcher(whileStmt().bind("while"), this);
   Finder->addMatcher(doStmt().bind("do"), this);
   Finder->addMatcher(forStmt().bind("for"), this);

clang-tools-extra/clang-tidy/readability/BracesAroundStatementsCheck.h

@@ -55,6 +55,9 @@ class BracesAroundStatementsCheck : public ClangTidyCheck {
   template <typename IfOrWhileStmt>
   SourceLocation findRParenLoc(const IfOrWhileStmt *S, const SourceManager &SM,
                                const ASTContext *Context);
+  llvm::Optional<TraversalKind> getCheckTraversalKind() const override {
+    return TK_IgnoreUnlessSpelledInSource;
+  }
 
 private:
   std::set<const Stmt *> ForceBracesStmts;

clang-tools-extra/clang-tidy/readability/ElseAfterReturnCheck.cpp

@@ -171,8 +171,7 @@ void ElseAfterReturnCheck::registerPPCallbacks(const SourceManager &SM,
 void ElseAfterReturnCheck::registerMatchers(MatchFinder *Finder) {
   const auto InterruptsControlFlow = stmt(anyOf(
       returnStmt().bind(InterruptingStr), continueStmt().bind(InterruptingStr),
-      breakStmt().bind(InterruptingStr),
-      expr(ignoringImplicit(cxxThrowExpr().bind(InterruptingStr)))));
+      breakStmt().bind(InterruptingStr), cxxThrowExpr().bind(InterruptingStr)));
   Finder->addMatcher(
       compoundStmt(
           forEach(ifStmt(unless(isConstexpr()),

clang-tools-extra/clang-tidy/readability/ElseAfterReturnCheck.h

@@ -28,6 +28,9 @@ class ElseAfterReturnCheck : public ClangTidyCheck {
                            Preprocessor *ModuleExpanderPP) override;
   void registerMatchers(ast_matchers::MatchFinder *Finder) override;
   void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
+  llvm::Optional<TraversalKind> getCheckTraversalKind() const override {
+    return TK_IgnoreUnlessSpelledInSource;
+  }
 
   using ConditionalBranchMap =
       llvm::DenseMap<FileID, SmallVector<SourceRange, 1>>;

clang-tools-extra/clang-tidy/readability/InconsistentDeclarationParameterNameCheck.cpp

@@ -294,8 +294,7 @@ void InconsistentDeclarationParameterNameCheck::storeOptions(
 
 void InconsistentDeclarationParameterNameCheck::registerMatchers(
     MatchFinder *Finder) {
-  Finder->addMatcher(functionDecl(unless(isImplicit()), hasOtherDeclarations())
-                         .bind("functionDecl"),
+  Finder->addMatcher(functionDecl(hasOtherDeclarations()).bind("functionDecl"),
                      this);
 }
 

clang-tools-extra/clang-tidy/readability/InconsistentDeclarationParameterNameCheck.h

@@ -33,6 +33,9 @@ class InconsistentDeclarationParameterNameCheck : public ClangTidyCheck {
   void storeOptions(ClangTidyOptions::OptionMap &Opts) override;
   void registerMatchers(ast_matchers::MatchFinder *Finder) override;
   void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
+  llvm::Optional<TraversalKind> getCheckTraversalKind() const override {
+    return TK_IgnoreUnlessSpelledInSource;
+  }
 
 private:
   void markRedeclarationsAsVisited(const FunctionDecl *FunctionDeclaration);

clang-tools-extra/clang-tidy/readability/MisleadingIndentationCheck.cpp

@@ -106,11 +106,7 @@ void MisleadingIndentationCheck::missingBracesCheck(const SourceManager &SM,
 }
 
 void MisleadingIndentationCheck::registerMatchers(MatchFinder *Finder) {
-  Finder->addMatcher(
-      ifStmt(allOf(hasElse(stmt()),
-                   unless(allOf(isConstexpr(), isInTemplateInstantiation()))))
-          .bind("if"),
-      this);
+  Finder->addMatcher(ifStmt(hasElse(stmt())).bind("if"), this);
   Finder->addMatcher(
       compoundStmt(has(stmt(anyOf(ifStmt(), forStmt(), whileStmt()))))
           .bind("compound"),

clang-tools-extra/clang-tidy/readability/MisleadingIndentationCheck.h

@@ -27,6 +27,9 @@ class MisleadingIndentationCheck : public ClangTidyCheck {
       : ClangTidyCheck(Name, Context) {}
   void registerMatchers(ast_matchers::MatchFinder *Finder) override;
   void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
+  llvm::Optional<TraversalKind> getCheckTraversalKind() const override {
+    return TK_IgnoreUnlessSpelledInSource;
+  }
 
 private:
   void danglingElseCheck(const SourceManager &SM, ASTContext *Context,

clang-tools-extra/clang-tidy/readability/NamedParameterCheck.cpp

@@ -18,18 +18,14 @@ namespace tidy {
 namespace readability {
 
 void NamedParameterCheck::registerMatchers(ast_matchers::MatchFinder *Finder) {
-  Finder->addMatcher(functionDecl(unless(isInstantiated())).bind("decl"), this);
+  Finder->addMatcher(functionDecl().bind("decl"), this);
 }
 
 void NamedParameterCheck::check(const MatchFinder::MatchResult &Result) {
   const SourceManager &SM = *Result.SourceManager;
   const auto *Function = Result.Nodes.getNodeAs<FunctionDecl>("decl");
   SmallVector<std::pair<const FunctionDecl *, unsigned>, 4> UnnamedParams;
 
-  // Ignore implicitly generated members.
-  if (Function->isImplicit())
-    return;
-
   // Ignore declarations without a definition if we're not dealing with an
   // overriden method.
   const FunctionDecl *Definition = nullptr;

clang-tools-extra/clang-tidy/readability/NamedParameterCheck.h

@@ -32,6 +32,9 @@ class NamedParameterCheck : public ClangTidyCheck {
       : ClangTidyCheck(Name, Context) {}
   void registerMatchers(ast_matchers::MatchFinder *Finder) override;
   void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
+  llvm::Optional<TraversalKind> getCheckTraversalKind() const override {
+    return TK_IgnoreUnlessSpelledInSource;
+  }
 };
 
 } // namespace readability

clang-tools-extra/clang-tidy/readability/NonConstParameterCheck.cpp

@@ -18,7 +18,7 @@ namespace readability {
 
 void NonConstParameterCheck::registerMatchers(MatchFinder *Finder) {
   // Add parameters to Parameters.
-  Finder->addMatcher(parmVarDecl(unless(isInstantiated())).bind("Parm"), this);
+  Finder->addMatcher(parmVarDecl().bind("Parm"), this);
 
   // C++ constructor.
   Finder->addMatcher(cxxConstructorDecl().bind("Ctor"), this);
@@ -28,13 +28,11 @@ void NonConstParameterCheck::registerMatchers(MatchFinder *Finder) {
   Finder->addMatcher(declRefExpr().bind("Ref"), this);
 
   // Analyse parameter usage in function.
-  Finder->addMatcher(
-      traverse(TK_AsIs,
-               stmt(anyOf(unaryOperator(hasAnyOperatorName("++", "--")),
-                          binaryOperator(), callExpr(), returnStmt(),
-                          cxxConstructExpr()))
-                   .bind("Mark")),
-      this);
+  Finder->addMatcher(stmt(anyOf(unaryOperator(hasAnyOperatorName("++", "--")),
+                                binaryOperator(), callExpr(), returnStmt(),
+                                cxxConstructExpr()))
+                         .bind("Mark"),
+                     this);
   Finder->addMatcher(varDecl(hasInitializer(anything())).bind("Mark"), this);
 }
 

clang-tools-extra/clang-tidy/readability/NonConstParameterCheck.h

@@ -26,6 +26,9 @@ class NonConstParameterCheck : public ClangTidyCheck {
   void registerMatchers(ast_matchers::MatchFinder *Finder) override;
   void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
   void onEndOfTranslationUnit() override;
+  llvm::Optional<TraversalKind> getCheckTraversalKind() const override {
+    return TK_IgnoreUnlessSpelledInSource;
+  }
 
 private:
   /// Parameter info.

clang-tools-extra/clang-tidy/readability/RedundantControlFlowCheck.cpp

@@ -32,10 +32,10 @@ bool isLocationInMacroExpansion(const SourceManager &SM, SourceLocation Loc) {
 
 void RedundantControlFlowCheck::registerMatchers(MatchFinder *Finder) {
   Finder->addMatcher(
-      functionDecl(
-          isDefinition(), returns(voidType()),
-          has(compoundStmt(hasAnySubstatement(returnStmt(unless(has(expr())))))
-                  .bind("return"))),
+      functionDecl(isDefinition(), returns(voidType()),
+                   hasBody(compoundStmt(hasAnySubstatement(
+                                            returnStmt(unless(has(expr())))))
+                               .bind("return"))),
       this);
   Finder->addMatcher(
       mapAnyOf(forStmt, cxxForRangeStmt, whileStmt, doStmt)

clang-tools-extra/clang-tidy/readability/RedundantControlFlowCheck.h

@@ -29,6 +29,10 @@ class RedundantControlFlowCheck : public ClangTidyCheck {
   void registerMatchers(ast_matchers::MatchFinder *Finder) override;
   void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
 
+  llvm::Optional<TraversalKind> getCheckTraversalKind() const override {
+    return TK_IgnoreUnlessSpelledInSource;
+  }
+
 private:
   void
   checkRedundantReturn(const ast_matchers::MatchFinder::MatchResult &Result,

clang-tools-extra/clang-tidy/readability/SimplifySubscriptExprCheck.cpp

@@ -32,15 +32,15 @@ void SimplifySubscriptExprCheck::registerMatchers(MatchFinder *Finder) {
           llvm::SmallVector<StringRef, 8>(Types.begin(), Types.end()))))));
 
   Finder->addMatcher(
-      arraySubscriptExpr(hasBase(ignoringParenImpCasts(
+      arraySubscriptExpr(hasBase(
           cxxMemberCallExpr(
               has(memberExpr().bind("member")),
               on(hasType(qualType(
                   unless(anyOf(substTemplateTypeParmType(),
                                hasDescendant(substTemplateTypeParmType()))),
                   anyOf(TypesMatcher, pointerType(pointee(TypesMatcher)))))),
               callee(namedDecl(hasName("data"))))
-              .bind("call")))),
+              .bind("call"))),
       this);
 }
 

clang-tools-extra/clang-tidy/readability/SimplifySubscriptExprCheck.h

@@ -28,6 +28,9 @@ class SimplifySubscriptExprCheck : public ClangTidyCheck {
   void registerMatchers(ast_matchers::MatchFinder *Finder) override;
   void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
   void storeOptions(ClangTidyOptions::OptionMap& Opts) override;
+  llvm::Optional<TraversalKind> getCheckTraversalKind() const override {
+    return TK_IgnoreUnlessSpelledInSource;
+  }
 
 private:
   const std::vector<std::string> Types;

clang-tools-extra/clang-tidy/readability/StaticAccessedThroughInstanceCheck.cpp

@@ -39,8 +39,7 @@ void StaticAccessedThroughInstanceCheck::storeOptions(
 void StaticAccessedThroughInstanceCheck::registerMatchers(MatchFinder *Finder) {
   Finder->addMatcher(
       memberExpr(hasDeclaration(anyOf(cxxMethodDecl(isStaticStorageClass()),
-                                      varDecl(hasStaticStorageDuration()))),
-                 unless(isInTemplateInstantiation()))
+                                      varDecl(hasStaticStorageDuration()))))
           .bind("memberExpression"),
       this);
 }

clang-tools-extra/clang-tidy/readability/StaticAccessedThroughInstanceCheck.h

@@ -30,6 +30,9 @@ class StaticAccessedThroughInstanceCheck : public ClangTidyCheck {
   void storeOptions(ClangTidyOptions::OptionMap &Opts) override;
   void registerMatchers(ast_matchers::MatchFinder *Finder) override;
   void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
+  llvm::Optional<TraversalKind> getCheckTraversalKind() const override {
+    return TK_IgnoreUnlessSpelledInSource;
+  }
 
 private:
   const unsigned NameSpecifierNestingThreshold;

clang-tools-extra/clang-tidy/readability/UniqueptrDeleteReleaseCheck.cpp

@@ -39,17 +39,14 @@ void UniqueptrDeleteReleaseCheck::registerMatchers(MatchFinder *Finder) {
   Finder->addMatcher(
       cxxDeleteExpr(
           unless(isInTemplateInstantiation()),
-          has(expr(ignoringParenImpCasts(
-              cxxMemberCallExpr(
-                  callee(
-                      memberExpr(hasObjectExpression(allOf(
-                                     unless(isTypeDependent()),
-                                     anyOf(hasType(UniquePtrWithDefaultDelete),
-                                           hasType(pointsTo(
-                                               UniquePtrWithDefaultDelete))))),
-                                 member(cxxMethodDecl(hasName("release"))))
-                          .bind("release_expr")))
-                  .bind("release_call")))))
+          has(cxxMemberCallExpr(
+                  callee(memberExpr(hasObjectExpression(anyOf(
+                                        hasType(UniquePtrWithDefaultDelete),
+                                        hasType(pointsTo(
+                                            UniquePtrWithDefaultDelete)))),
+                                    member(cxxMethodDecl(hasName("release"))))
+                             .bind("release_expr")))
+                  .bind("release_call")))
           .bind("delete"),
       this);
 }

clang-tools-extra/clang-tidy/readability/UniqueptrDeleteReleaseCheck.h

@@ -26,6 +26,9 @@ class UniqueptrDeleteReleaseCheck : public ClangTidyCheck {
   void registerMatchers(ast_matchers::MatchFinder *Finder) override;
   void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
   void storeOptions(ClangTidyOptions::OptionMap &Opts) override;
+  llvm::Optional<TraversalKind> getCheckTraversalKind() const override {
+    return TK_IgnoreUnlessSpelledInSource;
+  }
 
 private:
   const bool PreferResetCall;

clang-tools-extra/clang-tidy/readability/UppercaseLiteralSuffixCheck.cpp

@@ -196,12 +196,11 @@ void UppercaseLiteralSuffixCheck::registerMatchers(MatchFinder *Finder) {
   // Sadly, we can't check whether the literal has suffix or not.
   // E.g. i32 suffix still results in 'BuiltinType::Kind::Int'.
   // And such an info is not stored in the *Literal itself.
-  Finder->addMatcher(traverse(TK_AsIs,
+  Finder->addMatcher(
       stmt(eachOf(integerLiteral().bind(IntegerLiteralCheck::Name),
                   floatLiteral().bind(FloatingLiteralCheck::Name)),
            unless(anyOf(hasParent(userDefinedLiteral()),
-                        hasAncestor(isImplicit()),
-                        hasAncestor(substNonTypeTemplateParmExpr()))))),
+                        hasAncestor(substNonTypeTemplateParmExpr())))),
       this);
 }
 

clang-tools-extra/clang-tidy/readability/UppercaseLiteralSuffixCheck.h

@@ -28,6 +28,9 @@ class UppercaseLiteralSuffixCheck : public ClangTidyCheck {
   void registerMatchers(ast_matchers::MatchFinder *Finder) override;
   void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
   void storeOptions(ClangTidyOptions::OptionMap &Opts) override;
+  llvm::Optional<TraversalKind> getCheckTraversalKind() const override {
+    return TK_IgnoreUnlessSpelledInSource;
+  }
 
 private:
   template <typename LiteralType>

clang-tools-extra/clangd/index/Index.h

@@ -149,8 +149,9 @@ class SymbolIndex {
 
   /// Returns function which checks if the specified file was used to build this
   /// index or not. The function must only be called while the index is alive.
-  virtual llvm::unique_function<IndexContents(llvm::StringRef) const>
-  indexedFiles() const = 0;
+  using IndexedFiles =
+      llvm::unique_function<IndexContents(llvm::StringRef) const>;
+  virtual IndexedFiles indexedFiles() const = 0;
 
   /// Returns estimated size of index (in bytes).
   virtual size_t estimateMemoryUsage() const = 0;