Add test case for handle overloaded operator-> for CallExpression

cpg-language-cxx/src/test/kotlin/de/fraunhofer/aisec/cpg/frontends/cxx/CXXDeclarationTest.kt

@@ -306,4 +306,41 @@ class CXXDeclarationTest {
         assertEquals(p, opCall.base)
         assertInvokes(opCall, op)
     }
+
+    @Test
+    fun testCallExpressionOperator() {
+        val file = File("src/test/resources/cxx/operators/call_expression.cpp")
+        val result =
+            analyze(listOf(file), file.parentFile.toPath(), true) {
+                it.registerLanguage<CPPLanguage>()
+            }
+        assertNotNull(result)
+
+        var proxy = result.records["Proxy"]
+        assertNotNull(proxy)
+
+        var op = proxy.operators["operator->"]
+        assertNotNull(op)
+
+        var data = result.records["Data"]
+        assertNotNull(data)
+
+        var funcFoo = data.functions["foo"]
+        assertNotNull(funcFoo)
+
+        val p = result.refs["p"]
+        assertNotNull(p)
+        assertEquals(proxy.toType(), p.type)
+
+        var funcFooRef = result.memberExpressions["foo"]
+        assertNotNull(funcFooRef)
+        assertRefersTo(funcFooRef, funcFoo)
+
+        // we should now have an implicit call to our operator in-between "p" and "foo"
+        val opCall = funcFooRef.base
+        assertNotNull(opCall)
+        assertIs<OperatorCallExpression>(opCall)
+        assertEquals(p, opCall.base)
+        assertInvokes(opCall, op)
+    }
 }

cpg-language-cxx/src/test/resources/cxx/operators/call_expression.cpp

@@ -0,0 +1,23 @@
+struct Data {
+    int foo() {
+        return 1;
+    }
+};
+
+struct Proxy {
+    Data *data;
+    Proxy() {
+        data = new Data;
+    }
+    Data* operator->() {
+        return data;
+    }
+};
+
+int main() {
+    Proxy p;
+
+    int i = p->foo();
+    return 1;
+}
+