misc: Rename the new option to an even better version, as per review request

Author: whisperity

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

@@ -71,8 +71,8 @@ SizeofExpressionCheck::SizeofExpressionCheck(StringRef Name,
       WarnOnSizeOfPointerToAggregate(
           Options.get("WarnOnSizeOfPointerToAggregate", true)),
       WarnOnSizeOfPointer(Options.get("WarnOnSizeOfPointer", false)),
-      WarnOnArithmeticWithDivisionBySizeOf(
-          Options.get("WarnOnArithmeticWithDivisionBySizeOf", true)) {}
+      WarnOnOffsetDividedBySizeOf(
+          Options.get("WarnOnOffsetDividedBySizeOf", true)) {}
 
 void SizeofExpressionCheck::storeOptions(ClangTidyOptions::OptionMap &Opts) {
   Options.store(Opts, "WarnOnSizeOfConstant", WarnOnSizeOfConstant);
@@ -84,8 +84,8 @@ void SizeofExpressionCheck::storeOptions(ClangTidyOptions::OptionMap &Opts) {
   Options.store(Opts, "WarnOnSizeOfPointerToAggregate",
                 WarnOnSizeOfPointerToAggregate);
   Options.store(Opts, "WarnOnSizeOfPointer", WarnOnSizeOfPointer);
-  Options.store(Opts, "WarnOnArithmeticWithDivisionBySizeOf",
-                WarnOnArithmeticWithDivisionBySizeOf);
+  Options.store(Opts, "WarnOnOffsetDividedBySizeOf",
+                WarnOnOffsetDividedBySizeOf);
 }
 
 void SizeofExpressionCheck::registerMatchers(MatchFinder *Finder) {
@@ -311,9 +311,8 @@ void SizeofExpressionCheck::registerMatchers(MatchFinder *Finder) {
                  offsetOfExpr()))
           .bind("sizeof-in-ptr-arithmetic-scale-expr");
   const auto PtrArithmeticIntegerScaleExpr = binaryOperator(
-      WarnOnArithmeticWithDivisionBySizeOf
-          ? binaryOperator(hasAnyOperatorName("*", "/"))
-          : binaryOperator(hasOperatorName("*")),
+      WarnOnOffsetDividedBySizeOf ? binaryOperator(hasAnyOperatorName("*", "/"))
+                                  : binaryOperator(hasOperatorName("*")),
       // sizeof(...) * sizeof(...) and sizeof(...) / sizeof(...) is handled
       // by this check on another path.
       hasOperands(expr(hasType(isInteger()), unless(SizeofLikeScaleExpr)),

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

@@ -31,7 +31,7 @@ class SizeofExpressionCheck : public ClangTidyCheck {
   const bool WarnOnSizeOfCompareToConstant;
   const bool WarnOnSizeOfPointerToAggregate;
   const bool WarnOnSizeOfPointer;
-  const bool WarnOnArithmeticWithDivisionBySizeOf;
+  const bool WarnOnOffsetDividedBySizeOf;
 };
 
 } // namespace clang::tidy::bugprone

clang-tools-extra/docs/clang-tidy/checks/bugprone/sizeof-expression.rst

@@ -221,15 +221,15 @@ and the result is typically unintended, often out of bounds.
 ``Ptr + sizeof(T)`` will offset the pointer by ``sizeof(T)`` elements,
 effectively exponentiating the scaling factor to the power of 2.
 
-Similarly, multiplying or dividing a numeric value with the ``sizeof`` an
+Similarly, multiplying or dividing a numeric value with the ``sizeof`` of an
 element or the whole buffer is suspicious, because the dimensional connection
 between the numeric value and the actual ``sizeof`` result can not always be
 deduced.
 While scaling an integer up (multiplying) with ``sizeof`` is likely **always**
 an issue, a scaling down (division) is not always inherently dangerous, in case
 the developer is aware that the division happens between an appropriate number
 of _bytes_ and a ``sizeof`` value.
-Turning :option:`WarnOnArithmeticWithDivisionBySizeOf` off will restrict the
+Turning :option:`WarnOnOffsetDividedBySizeOf` off will restrict the
 warnings to the multiplication case.
 
 This case also checks suspicious ``alignof`` and ``offsetof`` usages in
@@ -311,7 +311,7 @@ Options
    idiomatic expressions that are probably intentional and correct).
    This detects occurrences of CWE 467. Default is `false`.
 
-.. option:: WarnOnArithmeticWithDivisionBySizeOf
+.. option:: WarnOnOffsetDividedBySizeOf
 
    When `true`, the check will warn on pointer arithmetic where the
    element count is obtained from a division with ``sizeof(...)``,

clang-tools-extra/test/clang-tidy/checkers/bugprone/sizeof-expression-pointer-arithmetics-no-division.c

@@ -1,6 +1,6 @@
 // RUN: %check_clang_tidy %s bugprone-sizeof-expression %t -- \
 // RUN:   -config='{CheckOptions: { \
-// RUN:     bugprone-sizeof-expression.WarnOnArithmeticWithDivisionBySizeOf: false \
+// RUN:     bugprone-sizeof-expression.WarnOnOffsetDividedBySizeOf: false \
 // RUN:   }}'
 
 typedef __SIZE_TYPE__ size_t;