updated documentation, changed options

Author: balazske

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

@@ -17,42 +17,31 @@ namespace clang::tidy::bugprone {
 
 CastToStructCheck::CastToStructCheck(StringRef Name, ClangTidyContext *Context)
     : ClangTidyCheck(Name, Context),
-      IgnoredFunctions(
-          utils::options::parseStringList(Options.get("IgnoredFunctions", ""))),
-      IgnoredFromTypes(
-          utils::options::parseStringList(Options.get("IgnoredFromTypes", ""))),
-      IgnoredToTypes(
-          utils::options::parseStringList(Options.get("IgnoredToTypes", ""))) {}
+      IgnoredCasts(
+          utils::options::parseStringList(Options.get("IgnoredCasts", ""))) {}
 
 void CastToStructCheck::storeOptions(ClangTidyOptions::OptionMap &Opts) {
-  Options.store(Opts, "IgnoredFunctions",
-                utils::options::serializeStringList(IgnoredFunctions));
-  Options.store(Opts, "IgnoredFromTypes",
-                utils::options::serializeStringList(IgnoredFromTypes));
-  Options.store(Opts, "IgnoredToTypes",
-                utils::options::serializeStringList(IgnoredToTypes));
+  Options.store(Opts, "IgnoredCasts",
+                utils::options::serializeStringList(IgnoredCasts));
 }
 
 void CastToStructCheck::registerMatchers(MatchFinder *Finder) {
   auto FromPointee =
       qualType(hasUnqualifiedDesugaredType(type().bind("FromType")),
-               unless(qualType(matchers::matchesAnyListedTypeName(
-                   IgnoredFromTypes, false))))
+               unless(voidType()),
+               unless(hasDeclaration(recordDecl(isUnion()))))
           .bind("FromPointee");
   auto ToPointee =
-      qualType(hasUnqualifiedDesugaredType(recordType().bind("ToType")),
-               unless(qualType(
-                   matchers::matchesAnyListedTypeName(IgnoredToTypes, false))))
+      qualType(hasUnqualifiedDesugaredType(
+                   recordType(unless(hasDeclaration(recordDecl(isUnion()))))
+                       .bind("ToType")))
           .bind("ToPointee");
   auto FromPtrType = qualType(pointsTo(FromPointee)).bind("FromPtr");
   auto ToPtrType = qualType(pointsTo(ToPointee)).bind("ToPtr");
-  Finder->addMatcher(
-      cStyleCastExpr(hasSourceExpression(hasType(FromPtrType)),
-                     hasType(ToPtrType),
-                     unless(hasAncestor(functionDecl(
-                         matchers::matchesAnyListedName(IgnoredFunctions)))))
-          .bind("CastExpr"),
-      this);
+  Finder->addMatcher(cStyleCastExpr(hasSourceExpression(hasType(FromPtrType)),
+                                    hasType(ToPtrType))
+                         .bind("CastExpr"),
+                     this);
 }
 
 void CastToStructCheck::check(const MatchFinder::MatchResult &Result) {
@@ -65,13 +54,24 @@ void CastToStructCheck::check(const MatchFinder::MatchResult &Result) {
   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 (!FromPointee || !ToPointee)
-    return;
-  if (FromType->isVoidType() || FromType->isUnionType() ||
-      ToType->isUnionType())
-    return;
+
   if (FromType == ToType)
     return;
+
+  const std::string FromName = FromPointee->getAsString();
+  const std::string ToName = ToPointee->getAsString();
+  llvm::Regex FromR;
+  llvm::Regex ToR;
+  for (auto [Idx, Str] : llvm::enumerate(IgnoredCasts)) {
+    if (Idx % 2 == 0) {
+      FromR = llvm::Regex(Str);
+    } else {
+      ToR = llvm::Regex(Str);
+      if (FromR.match(FromName) && ToR.match(ToName))
+        return;
+    }
+  }
+
   diag(FoundCastExpr->getExprLoc(),
        "casting a %0 pointer to a "
        "%1 pointer and accessing a field can lead to memory "

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

@@ -29,9 +29,7 @@ class CastToStructCheck : public ClangTidyCheck {
   }
 
 private:
-  std::vector<llvm::StringRef> IgnoredFunctions;
-  std::vector<llvm::StringRef> IgnoredFromTypes;
-  std::vector<llvm::StringRef> IgnoredToTypes;
+  std::vector<llvm::StringRef> IgnoredCasts;
 };
 
 } // namespace clang::tidy::bugprone

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

@@ -6,15 +6,15 @@ bugprone-cast-to-struct
 Finds casts from pointers to struct or scalar type to pointers to struct type.
 
 Casts between pointers to different structs can be unsafe because it is possible
-to access uninitialized or undefined data after the cast. There may be issues
-with type compatibility or data alignment. Cast from a pointer to a scalar type
-(which points often to an array or memory block) to a `struct` type pointer can
-be unsafe for similar reasons. This check warns at 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). It is
-possible to specify additional types to ignore by the check. In addition,
-`union` types are completely excluded from the check. The check does not take
-into account type compatibility or data layout, only the names of the types.
+to access uninitialized or undefined data after the cast. Cast from a
+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
+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
 
@@ -33,22 +33,28 @@ into account type compatibility or data layout, only the names of the types.
      s = (struct S1 *)calloc(1, sizeof(struct S1)); // no warning
    }
 
-Options
--------
-
-.. option:: IgnoredFromTypes
+Limitations
+-----------
 
-   Semicolon-separated list of types for which the checker should not warn if
-   encountered at cast source. Can contain regular expressions. The `*`
-   character (for pointer type) is not needed in the type names.
+The check does run only on `C` code.
 
-.. option:: IgnoredToTypes
+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
+indicates by itself a potentially dangerous operation. Additionally, inheritance
+and dynamic types would make such a check less useful.
 
-   Semicolon-separated list of types for which the checker should not warn if
-   encountered at cast destination. Can contain regular expressions. The `*`
-   character (for pointer type) is not needed in the type names.
-
-.. option:: IgnoredFunctions
+Options
+-------
 
-   List of function names from which the checker should produce no warnings. Can
-   contain regular expressions.
+.. option:: IgnoredCasts
+
+   Can contain a semicolon-separated list of type names that specify cast
+   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;Type1;char;Type2`` specifies that the
+   check does not produce warning for casts from ``char *`` to ``Type1 *`` and
+   casts from ``char *`` to ``Type2 *``. The list entries can be regular
+   expressions. The type name in the cast expression is matched without
+   resolution of type aliases like ``typedef``. Default value is empty list.
+   (Casts from ``void *`` are ignored always regardless of this list.)

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

@@ -1,40 +1,33 @@
-// RUN: %check_clang_tidy -check-suffixes=FUNC %s bugprone-cast-to-struct %t -- \
-// RUN:   -config="{CheckOptions: {bugprone-cast-to-struct.IgnoredFunctions: 'ignored_f$'}}"
-// RUN: %check_clang_tidy -check-suffixes=FROM-TY %s bugprone-cast-to-struct %t -- \
-// RUN:   -config="{CheckOptions: {bugprone-cast-to-struct.IgnoredFromTypes: 'int'}}"
-// RUN: %check_clang_tidy -check-suffixes=TO-TY %s bugprone-cast-to-struct %t -- \
-// RUN:   -config="{CheckOptions: {bugprone-cast-to-struct.IgnoredToTypes: 'IgnoredType'}}"
+// RUN: %check_clang_tidy %s bugprone-cast-to-struct %t -- \
+// RUN:   -config="{CheckOptions: {bugprone-cast-to-struct.IgnoredCasts: 'char;S1;int;Other*'}}"
 
-struct IgnoredType {
+struct S1 {
   int a;
 };
 
-struct OtherType {
+struct S2 {
+  char a;
+};
+
+struct OtherS {
   int a;
   int b;
 };
 
-void ignored_f(char *p) {
-  struct OtherType *p1;
-  p1 = (struct OtherType *)p;
-  // CHECK-MESSAGES-FROM-TY: :[[@LINE-1]]:8: warning: casting a 'char *' pointer to a 'struct OtherType *' pointer and accessing a field can lead to memory access errors or data corruption
-  // CHECK-MESSAGES-TO-TY: :[[@LINE-2]]:8: warning: casting a 'char *' pointer to a 'struct OtherType *' pointer and accessing a field can lead to memory access errors or data corruption
-}
-
-void ignored_from_type(int *p) {
-  struct OtherType *p1;
-  p1 = (struct OtherType *)p;
-  // CHECK-MESSAGES-FUNC: :[[@LINE-1]]:8: warning: casting a 'int *' pointer to a 'struct OtherType *' pointer and accessing a field can lead to memory access errors or data corruption
-  // CHECK-MESSAGES-TO-TY: :[[@LINE-2]]:8: warning: casting a 'int *' pointer to a 'struct OtherType *' pointer and accessing a field can lead to memory access errors or data corruption
-}
-
-void ignored_to_type(char *p) {
-  struct IgnoredType *p1;
-  p1 = (struct IgnoredType *)p;
-  // CHECK-MESSAGES-FUNC: :[[@LINE-1]]:8: warning: casting a 'char *' pointer to a 'struct IgnoredType *' pointer and accessing a field can lead to memory access errors or data corruption
-  // CHECK-MESSAGES-FROM-TY: :[[@LINE-2]]:8: warning: casting a 'char *' pointer to a 'struct IgnoredType *' pointer and accessing a field can lead to memory access errors or data corruption
+void test1(char *p1, int *p2) {
+  struct S1 *s1;
+  s1 = (struct S1 *)p1;
+  struct S2 *s2;
+  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 OtherS *s3;
+  s3 = (struct OtherS *)p2;
+  s3 = (struct OtherS *)p1;
+  // CHECK-MESSAGES: :[[@LINE-1]]:8: warning: casting a 'char *' pointer to a 'struct OtherS *'
 }
 
-struct OtherType *test_void_is_always_ignored(void *p) {
-  return (struct OtherType *)p;
+struct S2 *test_void_is_always_ignored(void *p) {
+  return (struct S2 *)p;
 }