[clang-tidy] Skip parentheses in `readability-make-member-function-const`

[Izaron]

Summary

The checker should ignore parentheses when looking whether the
function should be marked as const.

Fixes https://github.com/llvm/llvm-project/issues/52838

[mgehre-amd]

LGTM

[njames93]

Mostly LGTM, just a few nits

clang-tools-extra/clang-tidy/readability/MakeMemberFunctionConstCheck.cpp

69

This change looks unrelated to what this patch is trying to achieve

71

Maybe rename this to getParentExprIgnoreParens to be more explicit in what you are trying to achieve.

113

Ditto

[Izaron]

Fixed as suggested by njames93. Thank you!

clang-tools-extra/clang-tidy/readability/MakeMemberFunctionConstCheck.cpp

public:
   template <class T> const T *getParent(const Expr *E) {
     DynTypedNodeList Parents = Ctxt.getParents(*E);
     if (Parents.size() != 1)
       return nullptr;
 
     return Parents.begin()->get<T>();
   }
 
+  const Expr *getParentExprIgnoreParens(const Expr *E) {
+    const Expr *Parent = getParent<Expr>(E);
+    while (isa_and_nonnull<ParenExpr>(Parent))
+      Parent = getParent<Expr>(Parent);
+    return Parent;
+  }
+
   bool VisitUnresolvedMemberExpr(const UnresolvedMemberExpr *) {
     // An UnresolvedMemberExpr might resolve to a non-const non-static
     // member function.
     Usage = NonConst;
     return false; // Stop traversal.
   }
 
   bool VisitCXXConstCastExpr(const CXXConstCastExpr *) {
bool visitUser(const ImplicitCastExpr *Cast) {
     // Only allow NoOp cast to 'const S' or 'const S *'.
     QualType QT = Cast->getType();
     if (QT->isPointerType())
       QT = QT->getPointeeType();
 
     if (!QT.isConstQualified())
       return false; // Stop traversal.
 
     const auto *Parent = getParent<Stmt>(Cast);
     if (!Parent)
       return false; // Stop traversal.
 
     if (isa<ReturnStmt>(Parent))
       return true; // return (const S*)this;
 
     if (isa<CallExpr>(Parent))
       return true; // use((const S*)this);
if (Member->isBoundMemberFunction(Ctxt)) {
         // get() uses a private const method, but must not be made const
         // itself.
         return false; // Stop traversal.
       }
       // Using a public non-static const member function.
       return true;
     }
 
-    const auto *Parent = getParent<Expr>(Member);
+    const auto *Parent = getParentExprIgnoreParens(Member);
 
     if (const auto *Cast = dyn_cast_or_null<ImplicitCastExpr>(Parent)) {
       // A read access to a member is safe when the member either
       // 1) has builtin type (a 'const int' cannot be modified),
       // 2) or it's a public member (the pointee of a public 'int * const' can
       // can be modified by any user of the class).
       if (Member->getFoundDecl().getAccess() != AS_public &&
           !Cast->getType()->isBuiltinType())
if (const auto *M = dyn_cast_or_null<MemberExpr>(Parent))
       return visitUser(M, /*OnConstObject=*/false);
 
     return false; // Stop traversal.
   }
 
   bool VisitCXXThisExpr(const CXXThisExpr *E) {
     Usage = Const;
 
-    const auto *Parent = getParent<Expr>(E);
+    const auto *Parent = getParentExprIgnoreParens(E);
 
     // Look through deref of this.
     if (const auto *UnOp = dyn_cast_or_null<UnaryOperator>(Parent)) {
       if (UnOp->getOpcode() == UO_Deref) {
-        Parent = getParent<Expr>(UnOp);
+        Parent = getParentExprIgnoreParens(UnOp);
       }
     }
 
     // It's okay to
     //  return (const S*)this;
     //  use((const S*)this);
     //  ((const S*)this)->f()
     // when 'f' is a public member function.

clang-tools-extra/test/clang-tidy/checkers/readability-make-member-function-const.cpp

struct A {
   }
 
   int read_const_field() {
     // CHECK-MESSAGES: :[[@LINE-1]]:7: warning: method 'read_const_field' can be made const
     // CHECK-FIXES: {{^}}  int read_const_field() const {
     return ConstM;
   }
 
+  int read_fields_in_parentheses() {
+    // CHECK-MESSAGES: :[[@LINE-1]]:7: warning: method 'read_fields_in_parentheses' can be made const
+    // CHECK-FIXES: {{^}}  int read_fields_in_parentheses() const {
+    return (this)->M + (((((Struct.M))))) + ((this->ConstM));
+  }
+
   void call_const_member() {
     // CHECK-MESSAGES: :[[@LINE-1]]:8: warning: method 'call_const_member' can be made const
     // CHECK-FIXES: {{^}}  void call_const_member() const {
     already_const();
   }
 
   void call_const_member_on_public_field() {
     // CHECK-MESSAGES: :[[@LINE-1]]:8: warning: method 'call_const_member_on_public_field' can be made const