Merge from 'main' to 'sycl-web' (111 commits)

Author: iclsrc

clang-tools-extra/clang-tidy/performance/EnumSizeCheck.cpp

@@ -25,6 +25,17 @@ namespace {
 
 AST_MATCHER(EnumDecl, hasEnumerators) { return !Node.enumerators().empty(); }
 
+AST_MATCHER(EnumDecl, isExternC) {
+  return Node.getDeclContext()->isExternCContext();
+}
+
+AST_MATCHER_P(EnumDecl, hasTypedefNameForAnonDecl,
+              ast_matchers::internal::Matcher<NamedDecl>, InnerMatcher) {
+  if (const TypedefNameDecl *TD = Node.getTypedefNameForAnonDecl())
+    return InnerMatcher.matches(*TD, Finder, Builder);
+  return false;
+}
+
 const std::uint64_t Min8 =
     std::imaxabs(std::numeric_limits<std::int8_t>::min());
 const std::uint64_t Max8 = std::numeric_limits<std::int8_t>::max();
@@ -90,8 +101,11 @@ bool EnumSizeCheck::isLanguageVersionSupported(
 void EnumSizeCheck::registerMatchers(MatchFinder *Finder) {
   Finder->addMatcher(
       enumDecl(unless(isExpansionInSystemHeader()), isDefinition(),
-               hasEnumerators(),
-               unless(matchers::matchesAnyListedRegexName(EnumIgnoreList)))
+               hasEnumerators(), unless(isExternC()),
+               unless(anyOf(
+                   matchers::matchesAnyListedRegexName(EnumIgnoreList),
+                   hasTypedefNameForAnonDecl(
+                       matchers::matchesAnyListedRegexName(EnumIgnoreList)))))
           .bind("e"),
       this);
 }

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

@@ -26,11 +26,12 @@ void NonConstParameterCheck::registerMatchers(MatchFinder *Finder) {
   Finder->addMatcher(declRefExpr().bind("Ref"), this);
 
   // Analyse parameter usage in function.
-  Finder->addMatcher(stmt(anyOf(unaryOperator(hasAnyOperatorName("++", "--")),
-                                binaryOperator(), callExpr(), returnStmt(),
-                                cxxConstructExpr()))
-                         .bind("Mark"),
-                     this);
+  Finder->addMatcher(
+      stmt(anyOf(unaryOperator(hasAnyOperatorName("++", "--")),
+                 binaryOperator(), callExpr(), returnStmt(), cxxConstructExpr(),
+                 cxxUnresolvedConstructExpr()))
+          .bind("Mark"),
+      this);
   Finder->addMatcher(varDecl(hasInitializer(anything())).bind("Mark"), this);
 }
 
@@ -93,6 +94,9 @@ void NonConstParameterCheck::check(const MatchFinder::MatchResult &Result) {
           markCanNotBeConst(Arg->IgnoreParenCasts(), false);
         }
       }
+    } else if (const auto *CE = dyn_cast<CXXUnresolvedConstructExpr>(S)) {
+      for (const auto *Arg : CE->arguments())
+        markCanNotBeConst(Arg->IgnoreParenCasts(), true);
     } else if (const auto *R = dyn_cast<ReturnStmt>(S)) {
       markCanNotBeConst(R->getRetValue(), true);
     } else if (const auto *U = dyn_cast<UnaryOperator>(S)) {

clang-tools-extra/clangd/index/Background.cpp

@@ -309,10 +309,7 @@ llvm::Error BackgroundIndex::index(tooling::CompileCommand Cmd) {
 
   IndexFileIn Index;
   auto Action = createStaticIndexingAction(
-      IndexOpts, [&](SymbolSlab S) { Index.Symbols = std::move(S); },
-      [&](RefSlab R) { Index.Refs = std::move(R); },
-      [&](RelationSlab R) { Index.Relations = std::move(R); },
-      [&](IncludeGraph IG) { Index.Sources = std::move(IG); });
+      IndexOpts, [&](IndexFileIn Result) { Index = std::move(Result); });
 
   // We're going to run clang here, and it could potentially crash.
   // We could use CrashRecoveryContext to try to make indexing crashes nonfatal,

clang-tools-extra/clangd/index/IndexAction.cpp

@@ -11,6 +11,7 @@
 #include "Headers.h"
 #include "clang-include-cleaner/Record.h"
 #include "index/Relation.h"
+#include "index/Serialization.h"
 #include "index/SymbolCollector.h"
 #include "index/SymbolOrigin.h"
 #include "clang/AST/ASTConsumer.h"
@@ -130,13 +131,8 @@ class IndexAction : public ASTFrontendAction {
   IndexAction(std::shared_ptr<SymbolCollector> C,
               std::unique_ptr<include_cleaner::PragmaIncludes> PI,
               const index::IndexingOptions &Opts,
-              std::function<void(SymbolSlab)> SymbolsCallback,
-              std::function<void(RefSlab)> RefsCallback,
-              std::function<void(RelationSlab)> RelationsCallback,
-              std::function<void(IncludeGraph)> IncludeGraphCallback)
-      : SymbolsCallback(SymbolsCallback), RefsCallback(RefsCallback),
-        RelationsCallback(RelationsCallback),
-        IncludeGraphCallback(IncludeGraphCallback), Collector(C),
+              std::function<void(IndexFileIn)> IndexContentsCallback)
+      : IndexContentsCallback(IndexContentsCallback), Collector(C),
         PI(std::move(PI)), Opts(Opts) {
     this->Opts.ShouldTraverseDecl = [this](const Decl *D) {
       // Many operations performed during indexing is linear in terms of depth
@@ -161,9 +157,8 @@ class IndexAction : public ASTFrontendAction {
   std::unique_ptr<ASTConsumer>
   CreateASTConsumer(CompilerInstance &CI, llvm::StringRef InFile) override {
     PI->record(CI.getPreprocessor());
-    if (IncludeGraphCallback != nullptr)
-      CI.getPreprocessor().addPPCallbacks(
-          std::make_unique<IncludeGraphCollector>(CI.getSourceManager(), IG));
+    CI.getPreprocessor().addPPCallbacks(
+        std::make_unique<IncludeGraphCollector>(CI.getSourceManager(), IG));
 
     return index::createIndexingASTConsumer(Collector, Opts,
                                             CI.getPreprocessorPtr());
@@ -185,26 +180,21 @@ class IndexAction : public ASTFrontendAction {
   }
 
   void EndSourceFileAction() override {
-    SymbolsCallback(Collector->takeSymbols());
-    if (RefsCallback != nullptr)
-      RefsCallback(Collector->takeRefs());
-    if (RelationsCallback != nullptr)
-      RelationsCallback(Collector->takeRelations());
-    if (IncludeGraphCallback != nullptr) {
+    IndexFileIn Result;
+    Result.Symbols = Collector->takeSymbols();
+    Result.Refs = Collector->takeRefs();
+    Result.Relations = Collector->takeRelations();
 #ifndef NDEBUG
       // This checks if all nodes are initialized.
       for (const auto &Node : IG)
         assert(Node.getKeyData() == Node.getValue().URI.data());
 #endif
-      IncludeGraphCallback(std::move(IG));
-    }
+      Result.Sources = std::move(IG);
+      IndexContentsCallback(std::move(Result));
   }
 
 private:
-  std::function<void(SymbolSlab)> SymbolsCallback;
-  std::function<void(RefSlab)> RefsCallback;
-  std::function<void(RelationSlab)> RelationsCallback;
-  std::function<void(IncludeGraph)> IncludeGraphCallback;
+  std::function<void(IndexFileIn)> IndexContentsCallback;
   std::shared_ptr<SymbolCollector> Collector;
   std::unique_ptr<include_cleaner::PragmaIncludes> PI;
   index::IndexingOptions Opts;
@@ -215,10 +205,7 @@ class IndexAction : public ASTFrontendAction {
 
 std::unique_ptr<FrontendAction> createStaticIndexingAction(
     SymbolCollector::Options Opts,
-    std::function<void(SymbolSlab)> SymbolsCallback,
-    std::function<void(RefSlab)> RefsCallback,
-    std::function<void(RelationSlab)> RelationsCallback,
-    std::function<void(IncludeGraph)> IncludeGraphCallback) {
+    std::function<void(IndexFileIn)> IndexContentsCallback) {
   index::IndexingOptions IndexOpts;
   IndexOpts.SystemSymbolFilter =
       index::IndexingOptions::SystemSymbolFilterKind::All;
@@ -231,16 +218,13 @@ std::unique_ptr<FrontendAction> createStaticIndexingAction(
   if (Opts.Origin == SymbolOrigin::Unknown)
     Opts.Origin = SymbolOrigin::Static;
   Opts.StoreAllDocumentation = false;
-  if (RefsCallback != nullptr) {
-    Opts.RefFilter = RefKind::All;
-    Opts.RefsInHeaders = true;
-  }
+  Opts.RefFilter = RefKind::All;
+  Opts.RefsInHeaders = true;
   auto PragmaIncludes = std::make_unique<include_cleaner::PragmaIncludes>();
   Opts.PragmaIncludes = PragmaIncludes.get();
   return std::make_unique<IndexAction>(std::make_shared<SymbolCollector>(Opts),
                                        std::move(PragmaIncludes), IndexOpts,
-                                       SymbolsCallback, RefsCallback,
-                                       RelationsCallback, IncludeGraphCallback);
+                                       IndexContentsCallback);
 }
 
 } // namespace clangd

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

@@ -8,15 +8,16 @@
 
 #ifndef LLVM_CLANG_TOOLS_EXTRA_CLANGD_INDEX_INDEXACTION_H
 #define LLVM_CLANG_TOOLS_EXTRA_CLANGD_INDEX_INDEXACTION_H
-#include "Headers.h"
 #include "index/SymbolCollector.h"
 #include "clang/Frontend/FrontendAction.h"
 
 namespace clang {
 namespace clangd {
 
+struct IndexFileIn;
+
 // Creates an action that indexes translation units and delivers the results
-// for SymbolsCallback (each slab corresponds to one TU).
+// for IndexContentsCallback (each call corresponds to one TU).
 //
 // Only a subset of SymbolCollector::Options are respected:
 //   - include paths are always collected, and canonicalized appropriately
@@ -25,10 +26,7 @@ namespace clangd {
 //   - the symbol origin is set to Static if not specified by caller
 std::unique_ptr<FrontendAction> createStaticIndexingAction(
     SymbolCollector::Options Opts,
-    std::function<void(SymbolSlab)> SymbolsCallback,
-    std::function<void(RefSlab)> RefsCallback,
-    std::function<void(RelationSlab)> RelationsCallback,
-    std::function<void(IncludeGraph)> IncludeGraphCallback);
+    std::function<void(IndexFileIn)> IndexContentsCallback);
 
 } // namespace clangd
 } // namespace clang

clang-tools-extra/clangd/indexer/IndexerMain.cpp

@@ -65,33 +65,33 @@ class IndexActionFactory : public tooling::FrontendActionFactory {
       std::lock_guard<std::mutex> Lock(FilesMu);
       return Files.insert(*AbsPath).second; // Skip already processed files.
     };
-    return createStaticIndexingAction(
-        Opts,
-        [&](SymbolSlab S) {
-          // Merge as we go.
-          std::lock_guard<std::mutex> Lock(SymbolsMu);
-          for (const auto &Sym : S) {
-            if (const auto *Existing = Symbols.find(Sym.ID))
-              Symbols.insert(mergeSymbol(*Existing, Sym));
-            else
-              Symbols.insert(Sym);
-          }
-        },
-        [&](RefSlab S) {
-          std::lock_guard<std::mutex> Lock(RefsMu);
-          for (const auto &Sym : S) {
-            // Deduplication happens during insertion.
-            for (const auto &Ref : Sym.second)
-              Refs.insert(Sym.first, Ref);
-          }
-        },
-        [&](RelationSlab S) {
-          std::lock_guard<std::mutex> Lock(RelsMu);
-          for (const auto &R : S) {
-            Relations.insert(R);
-          }
-        },
-        /*IncludeGraphCallback=*/nullptr);
+    return createStaticIndexingAction(Opts, [&](IndexFileIn Result) {
+      {
+        // Merge as we go.
+        std::lock_guard<std::mutex> Lock(SymbolsMu);
+        for (const auto &Sym : *Result.Symbols) {
+          if (const auto *Existing = Symbols.find(Sym.ID))
+            Symbols.insert(mergeSymbol(*Existing, Sym));
+          else
+            Symbols.insert(Sym);
+        }
+      }
+      {
+        std::lock_guard<std::mutex> Lock(RefsMu);
+        for (const auto &Sym : *Result.Refs) {
+          // Deduplication happens during insertion.
+          for (const auto &Ref : Sym.second)
+            Refs.insert(Sym.first, Ref);
+        }
+      }
+      {
+        std::lock_guard<std::mutex> Lock(RelsMu);
+        for (const auto &R : *Result.Relations) {
+          Relations.insert(R);
+        }
+      }
+      // FIXME: Handle Result.Sources?
+    });
   }
 
   bool runInvocation(std::shared_ptr<CompilerInvocation> Invocation,

clang-tools-extra/clangd/unittests/IndexActionTests.cpp

@@ -86,10 +86,7 @@ class IndexActionTest : public ::testing::Test {
         new FileManager(FileSystemOptions(), InMemoryFileSystem));
 
     auto Action = createStaticIndexingAction(
-        Opts, [&](SymbolSlab S) { IndexFile.Symbols = std::move(S); },
-        [&](RefSlab R) { IndexFile.Refs = std::move(R); },
-        [&](RelationSlab R) { IndexFile.Relations = std::move(R); },
-        [&](IncludeGraph IG) { IndexFile.Sources = std::move(IG); });
+        Opts, [&](IndexFileIn Result) { IndexFile = std::move(Result); });
 
     std::vector<std::string> Args = {"index_action", "-fsyntax-only",
                                      "-xc++",        "-std=c++11",

clang-tools-extra/docs/ReleaseNotes.rst

@@ -155,6 +155,13 @@ Changes in existing checks
   <clang-tidy/checks/modernize/use-using>` check by avoiding the generation
   of invalid code for function types with redundant parentheses.
 
+- Improved :doc:`performance-enum-size
+  <clang-tidy/checks/performance/enum-size>` check:
+
+  - Exclude ``enum`` in ``extern "C"`` blocks.
+
+  - Improved the ignore list to correctly handle ``typedef`` and  ``enum``.
+
 - Improved :doc:`performance-move-const-arg
   <clang-tidy/checks/performance/move-const-arg>` check by avoiding false
   positives on trivially copyable types with a non-public copy constructor.
@@ -164,6 +171,10 @@ Changes in existing checks
   now uses separate note diagnostics for each uninitialized enumerator, making
   it easier to see which specific enumerators need explicit initialization.
 
+- Improved :doc:`readability-non-const-parameter
+  <clang-tidy/checks/readability/non-const-parameter>` check by avoiding false
+  positives on parameters used in dependent expressions.
+
 Removed checks
 ^^^^^^^^^^^^^^
 

clang-tools-extra/test/clang-tidy/checkers/performance/enum-size.cpp

@@ -1,5 +1,5 @@
 // RUN: %check_clang_tidy -std=c++17-or-later %s performance-enum-size %t -- \
-// RUN:   -config="{CheckOptions: {performance-enum-size.EnumIgnoreList: '::IgnoredEnum;IgnoredSecondEnum'}}"
+// RUN:   -config="{CheckOptions: {performance-enum-size.EnumIgnoreList: '::IgnoredEnum;IgnoredSecondEnum;IgnoredTypedefEnum'}}"
 
 namespace std
 {
@@ -106,3 +106,15 @@ enum class EnumClassWithoutValues : int {};
 enum EnumWithoutValues {};
 
 }
+
+extern "C" {
+enum ExternCEnum {
+    ec1,
+    ec2
+};
+
+typedef enum {
+    tec1,
+    tec2
+} IgnoredTypedefEnum;
+} // extern "C"

clang-tools-extra/test/clang-tidy/checkers/readability/non-const-parameter.cpp

@@ -341,3 +341,25 @@ void constructLVRef(int *p) {
   // CHECK-MESSAGES-NOT: warning: pointer parameter 'p' can be
   Temp1 t(*p);
 }
+
+template<bool>
+class A final {
+    char* sz_ = {};
+
+public:
+    explicit A(char* sz) noexcept : sz_(sz) {}
+    void f() { sz_ = {}; }
+};
+
+class B final {
+    char* sz_ = {};
+
+public:
+    explicit B(char* sz) noexcept : sz_(sz) {}
+    void f() { sz_ = {}; }
+};
+
+void gh176623() {
+    auto const V1 = []<bool tc>(char* p) { auto X = A<tc>(p); };
+    auto const V2 = []<bool tc>(char* p) { auto Y = B(p); };
+}