2nd try, performance fix that preserves test results.

Author: MichaelRFairhurst

cpp/common/src/codingstandards/cpp/types/Compatible.qll

@@ -486,45 +486,70 @@ signature predicate interestedInFunctionDeclarations(
 );
 
 module FunctionDeclarationTypeEquivalence<
-  TypeEquivalenceSig Config, interestedInFunctionDeclarations/2 interestedInFunctions>
+  TypeEquivalenceSig Config, interestedInFunctionDeclarations/2 interestedInFunDecls>
 {
   private predicate interestedInReturnTypes(Type a, Type b) {
     exists(FunctionDeclarationEntry aFun, FunctionDeclarationEntry bFun |
-      interestedInFunctions(pragma[only_bind_into](aFun), pragma[only_bind_into](bFun)) and
+      interestedInFunDecls(pragma[only_bind_into](aFun), pragma[only_bind_into](bFun)) and
       a = aFun.getType() and
       b = bFun.getType()
     )
   }
 
   private predicate interestedInParameterTypes(Type a, Type b) {
     exists(FunctionDeclarationEntry aFun, FunctionDeclarationEntry bFun, int i |
-      interestedInFunctions(pragma[only_bind_into](aFun), pragma[only_bind_into](bFun)) and
+      interestedInFunDecls(pragma[only_bind_into](aFun), pragma[only_bind_into](bFun)) and
       a = aFun.getParameterDeclarationEntry(i).getType() and
       b = bFun.getParameterDeclarationEntry(i).getType()
     )
   }
 
   predicate equalReturnTypes(FunctionDeclarationEntry f1, FunctionDeclarationEntry f2) {
-    interestedInFunctions(f1, f2) and
+    interestedInFunDecls(f1, f2) and
     TypeEquivalence<Config, interestedInReturnTypes/2>::equalTypes(f1.getType(), f2.getType())
   }
 
   predicate equalParameterTypes(FunctionDeclarationEntry f1, FunctionDeclarationEntry f2) {
-    interestedInFunctions(f1, f2) and
+    interestedInFunDecls(f1, f2) and
     f1.getDeclaration() = f2.getDeclaration() and
     forall(int i | exists([f1, f2].getParameterDeclarationEntry(i)) |
       equalParameterTypesAt(f1, f2, pragma[only_bind_into](i))
     )
   }
 
   predicate equalParameterTypesAt(FunctionDeclarationEntry f1, FunctionDeclarationEntry f2, int i) {
-    interestedInFunctions(f1, f2) and
+    interestedInFunDecls(f1, f2) and
     f1.getDeclaration() = f2.getDeclaration() and
     TypeEquivalence<Config, interestedInParameterTypes/2>::equalTypes(f1.getParameterDeclarationEntry(pragma[only_bind_into](i))
           .getType(), f2.getParameterDeclarationEntry(pragma[only_bind_into](i)).getType())
   }
 }
 
+signature predicate interestedInFunctions(Function f1, Function f2);
+
+module FunctionEquivalence<TypeEquivalenceSig Config, interestedInFunctions/2 interestedInFuncs> {
+  private predicate interestedInParameterTypes(Type a, Type b) {
+    exists(Function aFun, Function bFun, int i |
+      interestedInFuncs(pragma[only_bind_into](aFun), pragma[only_bind_into](bFun)) and
+      a = aFun.getParameter(i).getType() and
+      b = bFun.getParameter(i).getType()
+    )
+  }
+
+  predicate equalParameterTypes(Function f1, Function f2) {
+    interestedInFuncs(f1, f2) and
+    forall(int i | exists([f1, f2].getParameter(i)) |
+      equalParameterTypesAt(f1, f2, pragma[only_bind_into](i))
+    )
+  }
+
+  predicate equalParameterTypesAt(Function f1, Function f2, int i) {
+    interestedInFuncs(f1, f2) and
+    TypeEquivalence<Config, interestedInParameterTypes/2>::equalTypes(f1.getParameter(pragma[only_bind_into](i))
+          .getType(), f2.getParameter(pragma[only_bind_into](i)).getType())
+  }
+}
+
 private class LeafType extends Type {
   LeafType() {
     not this instanceof DerivedType and

cpp/misra/src/rules/RULE-6-8-4/MemberFunctionsRefqualified.ql

@@ -67,17 +67,12 @@ class MembersReturningSubObject extends MembersReturningObjectOrSubobject {
   }
 }
 
-predicate relevantTypes(Type a, Type b) {
-  exists(MembersReturningObjectOrSubobject f, MemberFunction overload |
-    f.getAnOverload() = overload and
-    exists(int i |
-      f.getParameter(i).getType() = a and
-      overload.getParameter(i).getType() = b
-    )
-  )
+predicate relevantFunctions(Function a, Function b) {
+  a instanceof MembersReturningObjectOrSubobject and
+  a.getAnOverload() = b
 }
 
-class AppropriatelyQualified extends MembersReturningObjectOrSubobject {
+class AppropriatelyQualified extends MemberFunction {
   AppropriatelyQualified() {
     //non-const-lvalue-ref-qualified
     this.isLValueRefQualified() and
@@ -91,10 +86,8 @@ class AppropriatelyQualified extends MembersReturningObjectOrSubobject {
       this.getAnOverload() = overload and
       overload.isRValueRefQualified() and
       //and has same param list
-      forall(int i | exists([this, overload].getParameter(i)) |
-        TypeEquivalence<TypesCompatibleConfig, relevantTypes/2>::equalTypes(this.getParameter(i)
-              .getType(), overload.getParameter(i).getType())
-      )
+      FunctionEquivalence<TypesCompatibleConfig, relevantFunctions/2>::equalParameterTypes(this,
+        overload)
     )
   }
 }