more review suggestion fixes

Author: balazske

clang-tools-extra/docs/ReleaseNotes.rst

@@ -109,6 +109,12 @@ New checks
   Finds lambda captures that capture the ``this`` pointer and store it as class
   members without handle the copy and move constructors and the assignments.
 
+- New :doc:`bugprone-misleading-setter-of-reference
+  <clang-tidy/checks/bugprone/misleading-setter-of-reference>` check.
+
+  Finds setter-like member functions that take a pointer parameter and set a
+  reference member of the same class with the pointed value.
+
 - New :doc:`bugprone-unintended-char-ostream-output
   <clang-tidy/checks/bugprone/unintended-char-ostream-output>` check.
 

clang-tools-extra/docs/clang-tidy/checks/bugprone/misleading-setter-of-reference.rst

@@ -4,12 +4,11 @@ bugprone-misleading-setter-of-reference
 =======================================
 
 Finds setter-like member functions that take a pointer parameter and set a
-(non-const) reference member of the same class with the pointed value.
+reference member of the same class with the pointed value.
 
-The checker detects public member functions that have a single parameter (which
-is a pointer) and contain a single (maybe overloaded) assignment operator call.
-The assignment should set a member variable with the dereference of the
-parameter pointer. The member variable can have any visibility.
+The check detects public member functions that take a single pointer parameter,
+and contain a single expression statement that dereferences the parameter and
+assigns the result to a data member with a reference type.
 
 The fact that a setter function takes a pointer might cause the belief that an
 internal reference (if it would be a pointer) is changed instead of the
@@ -26,22 +25,22 @@ Example:
 
     // Warning: This setter could lead to unintended behaviour.
     void setRef(int *Value) {
-      InternalRef = *Value;  // This assigns to the referenced value, not changing what ref_ references.
+      InternalRef = *Value;  // This assigns to the referenced value, not changing what InternalRef references.
     }
   };
 
   int main() {
     int Value1 = 42;
     int Value2 = 100;
     MyClass X(Value1);
-    
+
     // This might look like it changes what InternalRef references to,
     // but it actually modifies Value1 to be 100.
     X.setRef(&Value2);
   }
 
 Possible fixes:
-  - Change the parameter type of the "set" function to non-pointer or const reference
-    type.
+  - Change the parameter type of the "set" function to non-pointer type (for
+    example, a const reference).
   - Change the type of the member variable to a pointer and in the "set"
     function assign a value to the pointer (without dereference).

clang-tools-extra/docs/clang-tidy/checks/list.rst

@@ -109,6 +109,7 @@ Clang-Tidy Checks
    :doc:`bugprone-lambda-function-name <bugprone/lambda-function-name>`,
    :doc:`bugprone-macro-parentheses <bugprone/macro-parentheses>`, "Yes"
    :doc:`bugprone-macro-repeated-side-effects <bugprone/macro-repeated-side-effects>`,
+   :doc:`bugprone-misleading-setter-of-reference <bugprone/misleading-setter-of-reference>`,
    :doc:`bugprone-misplaced-operator-in-strlen-in-alloc <bugprone/misplaced-operator-in-strlen-in-alloc>`, "Yes"
    :doc:`bugprone-misplaced-pointer-arithmetic-in-alloc <bugprone/misplaced-pointer-arithmetic-in-alloc>`, "Yes"
    :doc:`bugprone-misplaced-widening-cast <bugprone/misplaced-widening-cast>`,

clang-tools-extra/test/clang-tidy/checkers/bugprone/misleading-setter-of-reference.cpp

@@ -99,8 +99,11 @@ class TemplateTest {
   }
 };
 
-char CharValue;
-TemplateTest<char> TTChar{CharValue};
+void f_TemplateTest(char *Value) {
+  char CharValue;
+  TemplateTest<char> TTChar{CharValue};
+  TTChar.setValue(Value);
+}
 
 template <typename T>
 class AddMember {