merge main into amd-staging

Author: z1.cciauto

clang-tools-extra/clang-tidy/cppcoreguidelines/ProBoundsPointerArithmeticCheck.cpp

@@ -14,6 +14,18 @@ using namespace clang::ast_matchers;
 
 namespace clang::tidy::cppcoreguidelines {
 
+ProBoundsPointerArithmeticCheck::ProBoundsPointerArithmeticCheck(
+    StringRef Name, ClangTidyContext *Context)
+    : ClangTidyCheck(Name, Context),
+      AllowIncrementDecrementOperators(
+          Options.get("AllowIncrementDecrementOperators", false)) {}
+
+void ProBoundsPointerArithmeticCheck::storeOptions(
+    ClangTidyOptions::OptionMap &Opts) {
+  Options.store(Opts, "AllowIncrementDecrementOperators",
+                AllowIncrementDecrementOperators);
+}
+
 void ProBoundsPointerArithmeticCheck::registerMatchers(MatchFinder *Finder) {
   const auto AllPointerTypes =
       anyOf(hasType(hasUnqualifiedDesugaredType(pointerType())),
@@ -30,13 +42,14 @@ void ProBoundsPointerArithmeticCheck::registerMatchers(MatchFinder *Finder) {
       this);
 
   // Flag all operators ++, -- that result in a pointer
-  Finder->addMatcher(
-      unaryOperator(hasAnyOperatorName("++", "--"),
-                    hasType(hasUnqualifiedDesugaredType(pointerType())),
-                    unless(hasUnaryOperand(
-                        ignoringImpCasts(declRefExpr(to(isImplicit()))))))
-          .bind("expr"),
-      this);
+  if (!AllowIncrementDecrementOperators)
+    Finder->addMatcher(
+        unaryOperator(hasAnyOperatorName("++", "--"),
+                      hasType(hasUnqualifiedDesugaredType(pointerType())),
+                      unless(hasUnaryOperand(
+                          ignoringImpCasts(declRefExpr(to(isImplicit()))))))
+            .bind("expr"),
+        this);
 
   // Array subscript on a pointer (not an array) is also pointer arithmetic
   Finder->addMatcher(

clang-tools-extra/clang-tidy/cppcoreguidelines/ProBoundsPointerArithmeticCheck.h

@@ -21,13 +21,16 @@ namespace clang::tidy::cppcoreguidelines {
 /// http://clang.llvm.org/extra/clang-tidy/checks/cppcoreguidelines/pro-bounds-pointer-arithmetic.html
 class ProBoundsPointerArithmeticCheck : public ClangTidyCheck {
 public:
-  ProBoundsPointerArithmeticCheck(StringRef Name, ClangTidyContext *Context)
-      : ClangTidyCheck(Name, Context) {}
+  ProBoundsPointerArithmeticCheck(StringRef Name, ClangTidyContext *Context);
   bool isLanguageVersionSupported(const LangOptions &LangOpts) const override {
     return LangOpts.CPlusPlus;
   }
   void registerMatchers(ast_matchers::MatchFinder *Finder) override;
+  void storeOptions(ClangTidyOptions::OptionMap &Opts) override;
   void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
+
+private:
+  const bool AllowIncrementDecrementOperators;
 };
 
 } // namespace clang::tidy::cppcoreguidelines

clang-tools-extra/clang-tidy/modernize/UseConstraintsCheck.cpp

@@ -8,6 +8,7 @@
 
 #include "UseConstraintsCheck.h"
 #include "clang/AST/ASTContext.h"
+#include "clang/AST/DeclTemplate.h"
 #include "clang/ASTMatchers/ASTMatchFinder.h"
 #include "clang/Lex/Lexer.h"
 
@@ -80,6 +81,13 @@ matchEnableIfSpecializationImplTypename(TypeLoc TheType) {
     if (!TD || TD->getName() != "enable_if")
       return std::nullopt;
 
+    assert(!TD->getTemplateParameters()->empty() &&
+           "found template with no template parameters?");
+    const auto *FirstParam = dyn_cast<NonTypeTemplateParmDecl>(
+        TD->getTemplateParameters()->getParam(0));
+    if (!FirstParam || !FirstParam->getType()->isBooleanType())
+      return std::nullopt;
+
     int NumArgs = SpecializationLoc.getNumArgs();
     if (NumArgs != 1 && NumArgs != 2)
       return std::nullopt;
@@ -107,6 +115,13 @@ matchEnableIfSpecializationImplTrait(TypeLoc TheType) {
     if (!Specialization->isTypeAlias())
       return std::nullopt;
 
+    assert(!TD->getTemplateParameters()->empty() &&
+           "found template with no template parameters?");
+    const auto *FirstParam = dyn_cast<NonTypeTemplateParmDecl>(
+        TD->getTemplateParameters()->getParam(0));
+    if (!FirstParam || !FirstParam->getType()->isBooleanType())
+      return std::nullopt;
+
     if (const auto *AliasedType =
             dyn_cast<DependentNameType>(Specialization->getAliasedType())) {
       ElaboratedTypeKeyword Keyword = AliasedType->getKeyword();

clang-tools-extra/docs/ReleaseNotes.rst

@@ -104,6 +104,10 @@ Improvements to clang-query
 Improvements to clang-tidy
 --------------------------
 
+- The :program:`check_clang_tidy.py` tool now recognizes the ``-std`` argument
+  when run over C files. If ``-std`` is not specified, it defaults to
+  ``c99-or-later``.
+
 - :program:`clang-tidy` no longer attemps to analyze code from system headers
   by default, greatly improving performance. This behavior is disabled if the
   `SystemHeaders` option is enabled.
@@ -180,9 +184,19 @@ Changes in existing checks
   <clang-tidy/checks/cppcoreguidelines/prefer-member-initializer>` check to
   avoid false positives on inherited members in class templates.
 
+- Improved :doc:`cppcoreguidelines-pro-bounds-pointer-arithmetic
+  <clang-tidy/checks/cppcoreguidelines/pro-bounds-pointer-arithmetic>` check
+  adding an option to allow pointer arithmetic via prefix/postfix increment or
+  decrement operators.
+
 - Improved :doc:`misc-header-include-cycle
   <clang-tidy/checks/misc/header-include-cycle>` check performance.
 
+- Improved :doc:`modernize-use-constraints
+  <clang-tidy/checks/modernize/use-constraints>` check by fixing a crash on
+  uses of non-standard ``enable_if`` with a signature different from
+  ``std::enable_if`` (such as ``boost::enable_if``).
+
 - Improved :doc:`modernize-use-designated-initializers
   <clang-tidy/checks/modernize/use-designated-initializers>` check to
   suggest using designated initializers for aliased aggregate types.

clang-tools-extra/docs/clang-tidy/checks/cppcoreguidelines/pro-bounds-pointer-arithmetic.rst

@@ -13,3 +13,11 @@ arrays of data.
 This rule is part of the `Bounds safety (Bounds 1)
 <https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#Pro-bounds-arithmetic>`_
 profile from the C++ Core Guidelines.
+
+Options
+-------
+
+.. option:: AllowIncrementDecrementOperators
+
+   When enabled, the check will allow using the prefix/postfix increment or
+   decrement operators on pointers. Default is ``false``.

clang-tools-extra/test/clang-tidy/check_clang_tidy.py

@@ -135,8 +135,7 @@ def __init__(self, args: argparse.Namespace, extra_args: List[str]) -> None:
                 "-fblocks",
             ] + self.clang_extra_args
 
-        if extension in [".cpp", ".hpp", ".mm"]:
-            self.clang_extra_args.append("-std=" + self.std)
+        self.clang_extra_args.append("-std=" + self.std)
 
         # Tests should not rely on STL being available, and instead provide mock
         # implementations of relevant APIs.
@@ -374,15 +373,23 @@ def parse_arguments() -> Tuple[argparse.Namespace, List[str]]:
     parser.add_argument(
         "-std",
         type=csv,
-        default=["c++11-or-later"],
+        default=None,
         help="Passed to clang. Special -or-later values are expanded.",
     )
     parser.add_argument(
         "--match-partial-fixes",
         action="store_true",
         help="allow partial line matches for fixes",
     )
-    return parser.parse_known_args()
+
+    args, extra_args = parser.parse_known_args()
+    if args.std is None:
+        _, extension = os.path.splitext(args.assume_filename or args.input_file_name)
+        args.std = [
+            "c++11-or-later" if extension in [".cpp", ".hpp", ".mm"] else "c99-or-later"
+        ]
+
+    return (args, extra_args)
 
 
 def main() -> None:

clang-tools-extra/test/clang-tidy/checkers/Inputs/Headers/system-other.h

@@ -11,6 +11,8 @@
 
 // Special system calls.
 
+#if __STDC_VERSION__ < 202311L
 void other_call();
+#endif
 
 #endif // _SYSTEM_OTHER_H_

clang-tools-extra/test/clang-tidy/checkers/android/comparison-in-temp-failure-retry-custom-macro.c

@@ -2,7 +2,7 @@
 
 #define MY_TEMP_FAILURE_RETRY(x) \
   ({                             \
-    typeof(x) __z;               \
+    __typeof__(x) __z;           \
     do                           \
       __z = (x);                 \
     while (__z == -1);           \
@@ -11,7 +11,7 @@
 
 #define MY_OTHER_TEMP_FAILURE_RETRY(x) \
   ({                                   \
-    typeof(x) __z;                     \
+    __typeof__(x) __z;                 \
     do                                 \
       __z = (x);                       \
     while (__z == -1);                 \

clang-tools-extra/test/clang-tidy/checkers/android/comparison-in-temp-failure-retry.c

@@ -2,7 +2,7 @@
 
 #define TEMP_FAILURE_RETRY(x)                                                  \
   ({                                                                           \
-    typeof(x) __z;                                                             \
+    __typeof__(x) __z;                                                         \
     do                                                                         \
       __z = (x);                                                               \
     while (__z == -1);                                                         \
@@ -130,7 +130,7 @@ void obscured_temp_failure_retry(void) {
 #undef TEMP_FAILURE_RETRY
 #define IMPL(x)                                                                \
   ({                                                                           \
-    typeof(x) __z;                                                             \
+    __typeof__(x) __z;                                                         \
     do                                                                         \
       __z = (x);                                                               \
     while (__z == -1);                                                         \

clang-tools-extra/test/clang-tidy/checkers/bugprone/branch-clone-macro-crash.c

@@ -1,11 +1,11 @@
 // RUN: %check_clang_tidy %s bugprone-branch-clone %t
 int x = 0;
 int y = 1;
-#define a(b, c) \
-  typeof(b) d;  \
-  if (b)        \
-    d = b;      \
-  else if (c)   \
+#define a(b, c)    \
+  __typeof__(b) d; \
+  if (b)           \
+    d = b;         \
+  else if (c)      \
     d = b;
 
 void f(void) {