Merge remote-tracking branch 'origin/main' into vplan-all-regions-as-transform

Author: fhahn

clang-tools-extra/clangd/ConfigCompile.cpp

@@ -535,7 +535,7 @@ struct FragmentCompiler {
     }
     if (Filters->empty())
       return std::nullopt;
-    auto Filter = [Filters](llvm::StringRef Path) {
+    auto Filter = [Filters = std::move(Filters)](llvm::StringRef Path) {
       for (auto &Regex : *Filters)
         if (Regex.match(Path))
           return true;

clang-tools-extra/clangd/Headers.cpp

@@ -305,14 +305,14 @@ IncludeInserter::calculateIncludePath(const HeaderFile &InsertedHeader,
   if (llvm::sys::path::is_absolute(Suggested))
     return std::nullopt;
   bool IsAngled = false;
-  for (auto Filter : AngledHeaders) {
+  for (auto &Filter : AngledHeaders) {
     if (Filter(Suggested)) {
       IsAngled = true;
       break;
     }
   }
   bool IsQuoted = false;
-  for (auto Filter : QuotedHeaders) {
+  for (auto &Filter : QuotedHeaders) {
     if (Filter(Suggested)) {
       IsQuoted = true;
       break;

clang-tools-extra/docs/clang-tidy/checks/android/comparison-in-temp-failure-retry.rst

@@ -41,3 +41,4 @@ Options
 .. option:: RetryMacros
 
    A comma-separated list of the names of retry macros to be checked.
+   Default is `TEMP_FAILURE_RETRY`.

clang-tools-extra/docs/clang-tidy/checks/cert/msc51-cpp.rst

@@ -37,4 +37,4 @@ Options
 .. option:: DisallowedSeedTypes
 
    A comma-separated list of the type names which are disallowed.
-   Default values are ``time_t``, ``std::time_t``.
+   Default value is `time_t,std::time_t`.

clang-tools-extra/docs/clang-tidy/checks/concurrency/mt-unsafe.rst

@@ -32,6 +32,9 @@ Examples:
 
     sleep(1); // implementation may use SIGALRM
 
+Options
+-------
+
 .. option:: FunctionSet
 
   Specifies which functions in libc should be considered thread-safe,

clang-tools-extra/docs/clang-tidy/checks/cppcoreguidelines/no-malloc.rst

@@ -35,14 +35,14 @@ Options
 .. option:: Allocations
 
    Semicolon-separated list of fully qualified names of memory allocation functions.
-   Defaults to ``::malloc;::calloc``.
+   Defaults to `::malloc;::calloc`.
 
 .. option:: Deallocations
 
    Semicolon-separated list of fully qualified names of memory allocation functions.
-   Defaults to ``::free``.
+   Defaults to `::free`.
 
 .. option:: Reallocations
 
    Semicolon-separated list of fully qualified names of memory allocation functions.
-   Defaults to ``::realloc``.
+   Defaults to `::realloc`.

clang-tools-extra/docs/clang-tidy/checks/cppcoreguidelines/owning-memory.rst

@@ -95,14 +95,14 @@ Options
 
    Semicolon-separated list of fully qualified names of legacy functions that create
    resources but cannot introduce ``gsl::owner<>``.
-   Defaults to ``::malloc;::aligned_alloc;::realloc;::calloc;::fopen;::freopen;::tmpfile``.
+   Defaults to `::malloc;::aligned_alloc;::realloc;::calloc;::fopen;::freopen;::tmpfile`.
 
 
 .. option:: LegacyResourceConsumers
 
    Semicolon-separated list of fully qualified names of legacy functions expecting
    resource owners as pointer arguments but cannot introduce ``gsl::owner<>``.
-   Defaults to ``::free;::realloc;::freopen;::fclose``.
+   Defaults to `::free;::realloc;::freopen;::fclose`.
 
 
 Limitations

clang-tools-extra/docs/clang-tidy/checks/cppcoreguidelines/pro-bounds-constant-array-index.rst

@@ -21,6 +21,7 @@ Options
 
    The check can generate fixes after this option has been set to the name of
    the include file that contains ``gsl::at()``, e.g. `"gsl/gsl.h"`.
+   Default is an empty string.
 
 .. option:: IncludeStyle
 

clang-tools-extra/docs/clang-tidy/checks/cppcoreguidelines/pro-type-member-init.rst

@@ -37,6 +37,7 @@ Options
 
    If set to `true`, the check will provide fix-its with literal initializers
    \( ``int i = 0;`` \) instead of curly braces \( ``int i{};`` \).
+   Default is `false`.
 
 This rule is part of the `Type safety (Type.6)
 <https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#Pro-type-memberinit>`_

clang-tools-extra/docs/clang-tidy/checks/misc/coroutine-hostile-raii.rst

@@ -45,8 +45,8 @@ Options
 
     A semicolon-separated list of qualified types which should not be allowed to
     persist across suspension points.
-    Eg: ``my::lockable; a::b;::my::other::lockable;``
-    The default value of this option is `"std::lock_guard;std::scoped_lock"`.
+    Eg: `my::lockable;a::b;::my::other::lockable`
+    The default value of this option is `std::lock_guard;std::scoped_lock`.
 
 .. option:: AllowedAwaitablesList
 
@@ -78,6 +78,6 @@ Options
         co_await wait();
       }
 
-    Eg: ``my::safe::awaitable;other::awaitable``
-    The default value of this option is empty string `""`.
+    Eg: `my::safe::awaitable;other::awaitable`
+    Default is an empty string.
 

clang-tools-extra/docs/clang-tidy/checks/misc/include-cleaner.rst

@@ -31,8 +31,8 @@ Options
 
    A semicolon-separated list of regexes to disable insertion/removal of header
    files that match this regex as a suffix.  E.g., `foo/.*` disables
-   insertion/removal for all headers under the directory `foo`. By default, no 
-   headers will be ignored.
+   insertion/removal for all headers under the directory `foo`. Default is an
+   empty string, no headers will be ignored.
 
 .. option:: DeduplicateFindings
 

clang-tools-extra/docs/clang-tidy/checks/misc/non-private-member-variables-in-classes.rst

@@ -17,10 +17,11 @@ Options
 
 .. option:: IgnoreClassesWithAllMemberVariablesBeingPublic
 
-   Allows to completely ignore classes if **all** the member variables in that
-   class a declared with a ``public`` access specifier.
+   When `true`, allows to completely ignore classes if **all** the member
+   variables in that class declared with a ``public`` access specifier.
+   Default is `false`.
 
 .. option:: IgnorePublicMemberVariables
 
-   Allows to ignore (not diagnose) **all** the member variables declared with
-   a ``public`` access specifier.
+   When `true`, allows to ignore (not diagnose) **all** the member variables
+   declared with a ``public`` access specifier. Default is `false`.

clang-tools-extra/docs/clang-tidy/checks/readability/container-data-pointer.rst

@@ -18,4 +18,4 @@ Options
 .. option:: IgnoredContainers
 
    Semicolon-separated list of containers regexp for which this check won't be
-   enforced. Default is `empty`.
+   enforced. Default is an empty string.

clang-tools-extra/docs/clang-tidy/checks/readability/container-size-empty.rst

@@ -25,6 +25,9 @@ The check issues warning if a container has ``empty()`` and ``size()`` or
 
 `size_type` can be any kind of integer type.
 
+Options
+-------
+
 .. option:: ExcludedComparisonTypes
 
     A semicolon-separated list of class names for which the check will ignore

clang-tools-extra/docs/clang-tidy/checks/readability/inconsistent-declaration-parameter-name.rst

@@ -52,6 +52,9 @@ In the case of multiple redeclarations or function template specializations,
 a warning is issued for every redeclaration or specialization inconsistent with
 the definition or the first declaration seen in a translation unit.
 
+Options
+-------
+
 .. option:: IgnoreMacros
 
    If this option is set to `true` (default is `true`), the check will not warn

clang-tools-extra/docs/clang-tidy/checks/readability/redundant-inline-specifier.rst

@@ -29,4 +29,4 @@ Options
 .. option:: StrictMode
 
    If set to `true`, the check will also flag functions and variables that
-   already have internal linkage as redundant.
+   already have internal linkage as redundant. Default is `false`.

clang-tools-extra/docs/clang-tidy/checks/readability/redundant-smartptr-get.rst

@@ -14,6 +14,8 @@ Examples:
   *ptr->get()  ==>  **ptr
   if (ptr.get() == nullptr) ... => if (ptr == nullptr) ...
 
+Options
+-------
 
 .. option:: IgnoreMacros
 

clang/include/clang/AST/DeclCXX.h

@@ -2878,7 +2878,7 @@ class CXXDestructorDecl : public CXXMethodDecl {
   static CXXDestructorDecl *CreateDeserialized(ASTContext &C, GlobalDeclID ID);
 
   void setOperatorDelete(FunctionDecl *OD, Expr *ThisArg);
-  void setOperatorArrayDelete(FunctionDecl *OD, Expr *ThisArg);
+  void setOperatorArrayDelete(FunctionDecl *OD);
 
   const FunctionDecl *getOperatorDelete() const {
     return getCanonicalDecl()->OperatorDelete;

clang/include/clang/ASTMatchers/ASTMatchers.h

@@ -71,6 +71,7 @@
 #include "clang/AST/TypeLoc.h"
 #include "clang/ASTMatchers/ASTMatchersInternal.h"
 #include "clang/ASTMatchers/ASTMatchersMacros.h"
+#include "clang/ASTMatchers/LowLevelHelpers.h"
 #include "clang/Basic/AttrKinds.h"
 #include "clang/Basic/ExceptionSpecificationType.h"
 #include "clang/Basic/FileManager.h"
@@ -5211,72 +5212,25 @@ AST_POLYMORPHIC_MATCHER_P2(forEachArgumentWithParamType,
                            internal::Matcher<Expr>, ArgMatcher,
                            internal::Matcher<QualType>, ParamMatcher) {
   BoundNodesTreeBuilder Result;
-  // The first argument of an overloaded member operator is the implicit object
-  // argument of the method which should not be matched against a parameter, so
-  // we skip over it here.
-  BoundNodesTreeBuilder Matches;
-  unsigned ArgIndex =
-      cxxOperatorCallExpr(
-          callee(cxxMethodDecl(unless(isExplicitObjectMemberFunction()))))
-              .matches(Node, Finder, &Matches)
-          ? 1
-          : 0;
-  const FunctionProtoType *FProto = nullptr;
-
-  if (const auto *Call = dyn_cast<CallExpr>(&Node)) {
-    if (const auto *Value =
-            dyn_cast_or_null<ValueDecl>(Call->getCalleeDecl())) {
-      QualType QT = Value->getType().getCanonicalType();
-
-      // This does not necessarily lead to a `FunctionProtoType`,
-      // e.g. K&R functions do not have a function prototype.
-      if (QT->isFunctionPointerType())
-        FProto = QT->getPointeeType()->getAs<FunctionProtoType>();
-
-      if (QT->isMemberFunctionPointerType()) {
-        const auto *MP = QT->getAs<MemberPointerType>();
-        assert(MP && "Must be member-pointer if its a memberfunctionpointer");
-        FProto = MP->getPointeeType()->getAs<FunctionProtoType>();
-        assert(FProto &&
-               "The call must have happened through a member function "
-               "pointer");
-      }
-    }
-  }
-
-  unsigned ParamIndex = 0;
   bool Matched = false;
-  unsigned NumArgs = Node.getNumArgs();
-  if (FProto && FProto->isVariadic())
-    NumArgs = std::min(NumArgs, FProto->getNumParams());
-
-  for (; ArgIndex < NumArgs; ++ArgIndex, ++ParamIndex) {
+  auto ProcessParamAndArg = [&](QualType ParamType, const Expr *Arg) {
     BoundNodesTreeBuilder ArgMatches(*Builder);
-    if (ArgMatcher.matches(*(Node.getArg(ArgIndex)->IgnoreParenCasts()), Finder,
-                           &ArgMatches)) {
-      BoundNodesTreeBuilder ParamMatches(ArgMatches);
+    if (!ArgMatcher.matches(*Arg, Finder, &ArgMatches))
+      return;
+    BoundNodesTreeBuilder ParamMatches(std::move(ArgMatches));
+    if (!ParamMatcher.matches(ParamType, Finder, &ParamMatches))
+      return;
+    Result.addMatch(ParamMatches);
+    Matched = true;
+    return;
+  };
+  if (auto *Call = llvm::dyn_cast<CallExpr>(&Node))
+    matchEachArgumentWithParamType(*Call, ProcessParamAndArg);
+  else if (auto *Construct = llvm::dyn_cast<CXXConstructExpr>(&Node))
+    matchEachArgumentWithParamType(*Construct, ProcessParamAndArg);
+  else
+    llvm_unreachable("expected CallExpr or CXXConstructExpr");
 
-      // This test is cheaper compared to the big matcher in the next if.
-      // Therefore, please keep this order.
-      if (FProto && FProto->getNumParams() > ParamIndex) {
-        QualType ParamType = FProto->getParamType(ParamIndex);
-        if (ParamMatcher.matches(ParamType, Finder, &ParamMatches)) {
-          Result.addMatch(ParamMatches);
-          Matched = true;
-          continue;
-        }
-      }
-      if (expr(anyOf(cxxConstructExpr(hasDeclaration(cxxConstructorDecl(
-                         hasParameter(ParamIndex, hasType(ParamMatcher))))),
-                     callExpr(callee(functionDecl(
-                         hasParameter(ParamIndex, hasType(ParamMatcher)))))))
-              .matches(Node, Finder, &ParamMatches)) {
-        Result.addMatch(ParamMatches);
-        Matched = true;
-        continue;
-      }
-    }
-  }
   *Builder = std::move(Result);
   return Matched;
 }

clang/include/clang/ASTMatchers/LowLevelHelpers.h

@@ -0,0 +1,37 @@
+//===- LowLevelHelpers.h - helpers with pure AST interface ---- *- C++ -*-===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+// Collects a number of helpers that are used by matchers, but can be reused
+// outside of them, e.g. when corresponding matchers cannot be used due to
+// performance constraints.
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_CLANG_ASTMATCHERS_LOWLEVELHELPERS_H
+#define LLVM_CLANG_ASTMATCHERS_LOWLEVELHELPERS_H
+
+#include "clang/AST/Expr.h"
+#include "clang/AST/ExprCXX.h"
+#include "clang/AST/Type.h"
+#include "llvm/ADT/STLFunctionalExtras.h"
+
+namespace clang {
+namespace ast_matchers {
+
+void matchEachArgumentWithParamType(
+    const CallExpr &Node,
+    llvm::function_ref<void(QualType /*Param*/, const Expr * /*Arg*/)>
+        OnParamAndArg);
+
+void matchEachArgumentWithParamType(
+    const CXXConstructExpr &Node,
+    llvm::function_ref<void(QualType /*Param*/, const Expr * /*Arg*/)>
+        OnParamAndArg);
+
+} // namespace ast_matchers
+} // namespace clang
+
+#endif

clang/include/clang/Sema/Sema.h

@@ -8336,7 +8336,8 @@ class Sema final : public SemaBase {
                                               DeclarationName Name);
   FunctionDecl *FindDeallocationFunctionForDestructor(SourceLocation StartLoc,
                                                       CXXRecordDecl *RD,
-                                                      DeclarationName Name);
+                                                      DeclarationName Name,
+                                                      bool Diagnose = true);
 
   /// ActOnCXXDelete - Parsed a C++ 'delete' expression (C++ 5.3.5), as in:
   /// @code ::delete ptr; @endcode

clang/lib/AST/DeclCXX.cpp

@@ -3031,8 +3031,7 @@ void CXXDestructorDecl::setOperatorDelete(FunctionDecl *OD, Expr *ThisArg) {
   }
 }
 
-void CXXDestructorDecl::setOperatorArrayDelete(FunctionDecl *OD,
-                                               Expr *ThisArg) {
+void CXXDestructorDecl::setOperatorArrayDelete(FunctionDecl *OD) {
   auto *First = cast<CXXDestructorDecl>(getFirstDecl());
   if (OD && !First->OperatorArrayDelete)
     First->OperatorArrayDelete = OD;

clang/lib/ASTMatchers/CMakeLists.txt

@@ -9,6 +9,7 @@ add_clang_library(clangASTMatchers
   ASTMatchFinder.cpp
   ASTMatchersInternal.cpp
   GtestMatchers.cpp
+  LowLevelHelpers.cpp
 
   LINK_LIBS
   clangAST