new behavior of ignore list

Author: balazske

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

@@ -15,13 +15,30 @@ using namespace clang::ast_matchers;
 
 namespace clang::tidy::bugprone {
 
+namespace {
+
+AST_MATCHER(Type, charType) {
+  return Node.isCharType();
+}
+AST_MATCHER(Type, unionType) {
+  return Node.isUnionType();
+}
+
+}
+
 CastToStructCheck::CastToStructCheck(StringRef Name, ClangTidyContext *Context)
     : ClangTidyCheck(Name, Context),
       IgnoredCasts(
           utils::options::parseStringList(Options.get("IgnoredCasts", ""))) {
   IgnoredCastsRegex.reserve(IgnoredCasts.size());
-  for (const auto &Str : IgnoredCasts)
-    IgnoredCastsRegex.emplace_back(Str);
+  for (const auto &Str : IgnoredCasts) {
+    std::string WholeWordRegex;
+    WholeWordRegex.reserve(Str.size() + 2);
+    WholeWordRegex.push_back('^');
+    WholeWordRegex.append(Str);
+    WholeWordRegex.push_back('$');
+    IgnoredCastsRegex.emplace_back(WholeWordRegex);
+  }
 }
 
 void CastToStructCheck::storeOptions(ClangTidyOptions::OptionMap &Opts) {
@@ -33,7 +50,8 @@ void CastToStructCheck::registerMatchers(MatchFinder *Finder) {
   auto FromPointee =
       qualType(hasUnqualifiedDesugaredType(type().bind("FromType")),
                unless(voidType()),
-               unless(hasDeclaration(recordDecl(isUnion()))))
+               unless(charType()),
+               unless(unionType()))
           .bind("FromPointee");
   auto ToPointee =
       qualType(hasUnqualifiedDesugaredType(
@@ -53,26 +71,27 @@ void CastToStructCheck::check(const MatchFinder::MatchResult &Result) {
       Result.Nodes.getNodeAs<CStyleCastExpr>("CastExpr");
   const auto *const FromPtr = Result.Nodes.getNodeAs<QualType>("FromPtr");
   const auto *const ToPtr = Result.Nodes.getNodeAs<QualType>("ToPtr");
-  const auto *const FromPointee =
-      Result.Nodes.getNodeAs<QualType>("FromPointee");
-  const auto *const ToPointee = Result.Nodes.getNodeAs<QualType>("ToPointee");
   const auto *const FromType = Result.Nodes.getNodeAs<Type>("FromType");
   const auto *const ToType = Result.Nodes.getNodeAs<RecordType>("ToType");
 
   if (FromType == ToType)
     return;
 
-  const std::string FromName = FromPointee->getAsString();
-  const std::string ToName = ToPointee->getAsString();
-  bool FromMatch = false;
-  for (auto [Idx, Regex] : llvm::enumerate(IgnoredCastsRegex)) {
-    if (Idx % 2 == 0) {
-      FromMatch = Regex.match(FromName);
-    } else {
-      if (FromMatch && Regex.match(ToName))
-        return;
+  auto CheckNameIgnore = [this](const std::string &FromName, const std::string &ToName) {
+    bool FromMatch = false;
+    for (auto [Idx, Regex] : llvm::enumerate(IgnoredCastsRegex)) {
+      if (Idx % 2 == 0) {
+        FromMatch = Regex.match(FromName);
+      } else {
+        if (FromMatch && Regex.match(ToName))
+          return true;
+      }
     }
-  }
+    return false;
+  };
+
+  if (CheckNameIgnore(FromPtr->getAsString(), ToPtr->getAsString()))
+    return;
 
   diag(FoundCastExpr->getExprLoc(),
        "casting a %0 pointer to a "

clang-tools-extra/clang-tidy/bugprone/CastToStructCheck.h

@@ -25,7 +25,7 @@ class CastToStructCheck : public ClangTidyCheck {
   void registerMatchers(ast_matchers::MatchFinder *Finder) override;
   void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
   bool isLanguageVersionSupported(const LangOptions &LangOpts) const override {
-    return LangOpts.C99;
+    return !LangOpts.CPlusPlus;
   }
 
 private:

clang-tools-extra/docs/clang-tidy/checks/bugprone/cast-to-struct.rst

@@ -11,16 +11,17 @@ scalar-type pointer (which points often to an array or memory block) to a
 ``struct`` type pointer can be unsafe for similar reasons. This check warns at
 pointer casts from any non-struct type to a struct type. No warning is produced
 at cast from type ``void *`` (this is the usual way of allocating memory with
-``malloc``-like functions). In addition, ``union`` types are excluded from the
+``malloc``-like functions) and ``char *`` types (which are used often as
+pointers into data buffers). In addition, ``union`` types are excluded from the
 check. It is possible to specify additional types to ignore. The check does not
 take into account type compatibility or data layout, only the names of the
 types.
 
 .. code-block:: c
 
-   void test1(char *p) {
+   void test1(int *p) {
      struct S1 *s;
-     s = (struct S1 *)p; // warn: 'char *' is converted to 'struct S1 *'
+     s = (struct S1 *)p; // warn: 'int *' is converted to 'struct S1 *'
    }
 
    void test2(struct S1 *p) {
@@ -36,7 +37,7 @@ types.
 Limitations
 -----------
 
-The check does run only on `C` code.
+The check does not run on `C++` code.
 
 C-style casts are discouraged in C++ and should be converted to more type-safe
 casts. The ``reinterpreted_cast`` is used for the most unsafe cases and
@@ -52,16 +53,12 @@ Options
    types to ignore. The list should contain pairs of type names in a way that
    the first type is the "from" type, the second is the "to" type in a cast
    expression. The types in a pair and the pairs itself are separated by
-   `;` characters. For example `char;struct Type1;char;struct Type2` specifies
-   that the check does not produce warning for casts from ``char *`` to
-   ``struct Type1 *`` and casts from ``char *`` to ``struct Type2 *`` (the `*`
-   character to indicate pointer should not be used in the list). The type name
-   in the cast expression is matched without resolution of type aliases like
-   ``typedef``.
+   `;` characters. The parts between `;` characters are matched as regular
+   expressions over the whole type name. For example
+   `struct S1 \*;struct T1 \*;short \*;struct T1 \*` specifies that the check
+   does not produce warning for casts from ``struct S1 *`` to ``struct T1 *``
+   and casts from ``short *`` to ``struct T1 *`` (the `*` character needs to be
+   escaped). The type name in the cast expression is matched without resolution
+   of ``typedef`` types.
 
-   The list entries are matched as substring regular expressions. For example
-   `char` would match `unsigned char` too. This problem can be avoided by using
-   anchor characters (`^char$`).
-   
-   Default value of the option is an empty list. (Casts from ``void *`` are
-   ignored always regardless of this list.)
+   Default value of the option is an empty list.

clang-tools-extra/test/clang-tidy/checkers/bugprone/cast-to-struct-ignore.c

@@ -1,33 +1,63 @@
 // RUN: %check_clang_tidy %s bugprone-cast-to-struct %t -- \
-// RUN:   -config="{CheckOptions: {bugprone-cast-to-struct.IgnoredCasts: '^char$;^struct S1$;^int$;Other'}}"
+// RUN:   -config="{CheckOptions: {bugprone-cast-to-struct.IgnoredCasts: 'int \*;struct S1 \*;TYPE \*;struct S2 \*;TYPE_P;struct S3 \*;struct S4 \*;struct S. \*'}}"
 
 struct S1 {
-  int a;
 };
 
 struct S2 {
-  char a;
 };
 
-struct SomeOtherS {
-  int a;
-  int b;
+struct S3 {
 };
 
-void test1(char *p1, int *p2) {
+struct S4 {
+};
+
+typedef int TYPE;
+typedef int * TYPE_P;
+typedef unsigned char uchar;
+
+void test1(int *p0, TYPE *p1, TYPE_P p2) {
+  struct S1 *s1;
+  struct S4 *s4;
+
+  s1 = (struct S1 *)p0; // no warning
+  s1 = (struct S1 *)p1; // CHECK-MESSAGES: warning: casting a 'TYPE *' (aka 'int *') pointer to a 'struct S1 *'
+  s1 = (struct S1 *)p2; // CHECK-MESSAGES: warning: casting a 'TYPE_P' (aka 'int *') pointer to a 'struct S1 *'
+  s4 = (struct S4 *)p0; // CHECK-MESSAGES: warning: casting a 'int *' pointer to a 'struct S4 *'
+}
+
+void test2(int *p0, TYPE *p1, TYPE_P p2) {
+  struct S2 *s2;
+  struct S4 *s4;
+
+  s2 = (struct S2 *)p0; // CHECK-MESSAGES: warning: casting a 'int *' pointer to a 'struct S2 *'
+  s2 = (struct S2 *)p1; // no warning
+  s2 = (struct S2 *)p2; // CHECK-MESSAGES: warning: casting a 'TYPE_P' (aka 'int *') pointer to a 'struct S2 *'
+  s4 = (struct S4 *)p1; // CHECK-MESSAGES: warning: casting a 'TYPE *' (aka 'int *') pointer to a 'struct S4 *'
+}
+
+void test3(int *p0, TYPE *p1, TYPE_P p2) {
+  struct S3 *s3;
+  struct S4 *s4;
+
+  s3 = (struct S3 *)p0; // CHECK-MESSAGES: warning: casting a 'int *' pointer to a 'struct S3 *'
+  s3 = (struct S3 *)p1; // CHECK-MESSAGES: warning: casting a 'TYPE *' (aka 'int *') pointer to a 'struct S3 *'
+  s3 = (struct S3 *)p2; // no warning
+  s4 = (struct S4 *)p2; // CHECK-MESSAGES: warning: casting a 'TYPE_P' (aka 'int *') pointer to a 'struct S4 *'
+}
+
+void test_wildcard(struct S4 *p1, struct S1 *p2) {
   struct S1 *s1;
-  s1 = (struct S1 *)p1;
   struct S2 *s2;
+  s1 = (struct S1 *)p1;
   s2 = (struct S2 *)p1;
-  // CHECK-MESSAGES: :[[@LINE-1]]:8: warning: casting a 'char *' pointer to a 'struct S2 *'
-  s2 = (struct S2 *)p2;
-  // CHECK-MESSAGES: :[[@LINE-1]]:8: warning: casting a 'int *' pointer to a 'struct S2 *'
-  struct SomeOtherS *s3;
-  s3 = (struct SomeOtherS *)p2;
-  s3 = (struct SomeOtherS *)p1;
-  // CHECK-MESSAGES: :[[@LINE-1]]:8: warning: casting a 'char *' pointer to a 'struct SomeOtherS *'
+  s2 = (struct S2 *)p2; // CHECK-MESSAGES: warning: casting a 'struct S1 *' pointer to a 'struct S2 *'
 }
 
-struct S2 *test_void_is_always_ignored(void *p) {
-  return (struct S2 *)p;
+void test_default_ignore(void *p1, char *p2, uchar *p3) {
+  struct S4 *s4;
+  s4 = (struct S4 *)p1;
+  s4 = (struct S4 *)p2;
+  s4 = (struct S4 *)p3;
 }

clang-tools-extra/test/clang-tidy/checkers/bugprone/cast-to-struct.c

@@ -26,9 +26,9 @@ typedef union U1 *TyPU1;
 typedef int int_t;
 typedef int * int_ptr_t;
 
-struct S1 *test_simple(char *p) {
+struct S1 *test_simple(short *p) {
   return (struct S1 *)p;
-  // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: casting a 'char *' pointer to a 'struct S1 *' pointer and accessing a field can lead to memory access errors or data corruption [bugprone-cast-to-struct]
+  // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: casting a 'short *' pointer to a 'struct S1 *' pointer and accessing a field can lead to memory access errors or data corruption [bugprone-cast-to-struct]
   struct S1 *s;
   int i;
   s = (struct S1 *)&i;
@@ -48,18 +48,18 @@ TyPS1 test_cast_from_similar(struct S1 *p) {
   return (TyPS1)p;
 }
 
-void test_typedef(char *p1, int_t *p2, int_ptr_t p3) {
+void test_typedef(short *p1, int_t *p2, int_ptr_t p3) {
   TyS1 *a = (TyS1 *)p1;
-  // CHECK-MESSAGES: :[[@LINE-1]]:13: warning: casting a 'char *' pointer to a 'TyS1 *' (aka 'struct S1 *') pointer and accessing a field can lead to memory access errors or data corruption [bugprone-cast-to-struct]
+  // CHECK-MESSAGES: :[[@LINE-1]]:13: warning: casting a 'short *' pointer to a 'TyS1 *' (aka 'struct S1 *') pointer and accessing a field can lead to memory access errors or data corruption [bugprone-cast-to-struct]
   TyPS1 b = (TyPS1)p1;
-  // CHECK-MESSAGES: :[[@LINE-1]]:13: warning: casting a 'char *' pointer to a 'TyPS1' (aka 'struct S1 *') pointer and accessing a field can lead to memory access errors or data corruption [bugprone-cast-to-struct]
+  // CHECK-MESSAGES: :[[@LINE-1]]:13: warning: casting a 'short *' pointer to a 'TyPS1' (aka 'struct S1 *') pointer and accessing a field can lead to memory access errors or data corruption [bugprone-cast-to-struct]
   struct S1 *c = (struct S1 *)p2;
   // CHECK-MESSAGES: :[[@LINE-1]]:18: warning: casting a 'int_t *' (aka 'int *') pointer to a 'struct S1 *' pointer and accessing a field can lead to memory access errors or data corruption [bugprone-cast-to-struct]
   struct S1 *d = (struct S1 *)p3;
   // CHECK-MESSAGES: :[[@LINE-1]]:18: warning: casting a 'int_ptr_t' (aka 'int *') pointer to a 'struct S1 *' pointer and accessing a field can lead to memory access errors or data corruption [bugprone-cast-to-struct]
 }
 
-void test_union(char *p1, union U1 *p2, TyPU1 p3) {
+void test_union(short *p1, union U1 *p2, TyPU1 p3) {
   union U1 *a = (union U1 *)p1;
   struct S1 *b = (struct S1 *)p2;
   struct S1 *c = (struct S1 *)p3;