[clang] [alpha.webkit.UnretainedCallArgsChecker] Emit a warning for a non-const RetainPtr member (PR #184243)

[Balázs Benics via cfe-commits]

================
@@ -440,3 +440,45 @@ namespace call_with_adopt_ref {
     adoptRef(new Obj)->method();
   }
 }
+
+namespace call_on_member {
+
+  class SomeObj {
+  public:
+    static Ref<SomeObj> create() { return adoptRef(*new SomeObj); }
+
+    void ref() const;
+    void deref() const;
+
+    void doWork() {
+      m_obj->method();
+      // expected-warning at -1{{Call argument for 'this' parameter is uncounted and unsafe}}
+      m_obj.get()->method();
+      // expected-warning at -1{{Call argument for 'this' parameter is uncounted and unsafe}}
+      m_constObj->method();
----------------
steakhal wrote:

This actually demonstrate a case I had in mind.
The `method` CXXMethodDecl has 2 overloads. One is const, the other one is non-const.
Because of the const-rules of C++, calling `method` on a mutable object will resolve to the non-const overload - while it could have also bind to the `const` overload instead.

This would mean unnecessary constifying casts that is alien for C++ code, just for the sake of suppressing this diagnostics.

Now, the solution for this for sensible code would be to see if there would be a similar overload in the set that would bind if `this` was `const`. (and also assuming that the overload set elements share their semantics, so any of those could be substituted for the other).

Checking this would be somewhat complicated but let's keep this limitation in mind and if it occurs often enough, then we should think about solving this somehow.

https://github.com/llvm/llvm-project/pull/184243