Fix RULE-7-11-3 false positives for callees in templates

Inside class and function templates, an unqualified call to a member or
free function can be modelled as a FunctionAccess that is the called
expression of an ExprCall. Such an access is the callee of a call, not an
implicit conversion to a function pointer, but it has function pointer
type and was reported by FunctionPointerConversionContext.

Exclude function accesses that are the called expression of an ExprCall,
and add test cases for member, static member and free function calls
inside templates.

Author: castler

change_notes/2026-10-26-fix-fp-rule-7-11-3-template-callee.md

@@ -0,0 +1,2 @@
+- `RULE-7-11-3` - `FunctionPointerConversionContext.ql`:
+   - Fixed false positives on unqualified calls to member and free functions inside class and function templates, where the callee is modelled as a function access that is the called expression of a call rather than a conversion to a function pointer.

cpp/misra/src/rules/RULE-7-11-3/FunctionPointerConversionContext.ql

@@ -33,7 +33,10 @@ class FunctionAccessConversionToFunctionPointer extends FunctionAccess,
   FunctionToFunctionPointerConversion
 {
   FunctionAccessConversionToFunctionPointer() {
-    this.getType().getUnspecifiedType() instanceof FunctionPointerIshType
+    this.getType().getUnspecifiedType() instanceof FunctionPointerIshType and
+    // In templates, the callee of a dependent call is modelled as a function access that is the
+    // called expression of an ExprCall. This is a function call, not a conversion.
+    not any(ExprCall call).getExpr() = this
   }
 }
 

cpp/misra/test/rules/RULE-7-11-3/test.cpp

@@ -95,4 +95,33 @@ void test_logical_expressions() {
   // Lambda used in logical OR expression
   if (lam || false) { // NON_COMPLIANT
   }
-}
+}
+template <typename T> class TemplateWithMemberCalls {
+public:
+  void callMembers() {
+    helper();       // COMPLIANT: callee of a call, not a conversion
+    this->helper(); // COMPLIANT
+    staticHelper(); // COMPLIANT
+    TemplateWithMemberCalls::staticHelper(); // COMPLIANT
+  }
+
+  auto takeAddress() {
+    return &TemplateWithMemberCalls::helper; // COMPLIANT: member pointer, not a
+                                             // function pointer
+  }
+
+private:
+  void helper() {}
+  static void staticHelper() {}
+};
+
+template <typename T> void templateCallsFree() {
+  f(); // COMPLIANT
+}
+
+void instantiate() {
+  TemplateWithMemberCalls<int> t;
+  t.callMembers();
+  t.takeAddress();
+  templateCallsFree<int>();
+}