M14-6-1: Restrict to templates with dependent base

The query didn't explicitly enforce this condition, and instead relied
on the fact that NameQualifiableElement's without any qualifier would
only point to the "wrong" element within templates. However, there are
some edge cases (static member functions with overrides) where non-class
templates could be flagged.

This commit restricts the output to the set of template classes with
dependent base types, therefore avoiding the sort of false positives
seen above. In addition, this improves performance for this query
because the set of template classes with dependent base types is much
much much smaller than the overall set of base types.

Author: lcartey

cpp/autosar/src/rules/M14-6-1/NameInDependentBase.qll

@@ -2,9 +2,20 @@ import cpp
 import codingstandards.cpp.autosar
 
 /**
- * Just the reverse of `Class.getABaseClass()`
+ * Gets a dependent base type of the given template class.
+ *
+ * This returns the `TemplateClass` for the base type, rather than the `ClassTemplateInstantiation`,
+ * as the instantiation does not appear to include any member declarations.
  */
-Class getParent(Class child) { child.getABaseClass() = result }
+TemplateClass getADependentBaseType(TemplateClass t) {
+  exists(ClassTemplateInstantiation baseType |
+    baseType = t.getABaseClass() and
+    // Base type depends on at least one of the template parameters of class t
+    baseType.getATemplateArgument() = t.getATemplateArgument() and
+    // Return the template itself
+    result = baseType.getTemplate()
+  )
+}
 
 /**
  * There is a `MemberFunction` in parent class with same name

cpp/autosar/src/rules/M14-6-1/NameNotReferredUsingAQualifiedIdOrThis.ql

@@ -18,23 +18,23 @@ import cpp
 import codingstandards.cpp.autosar
 import NameInDependentBase
 
-from Class c, Class p, NameQualifiableElement fn
+from TemplateClass c, TemplateClass dependentBaseType, NameQualifiableElement fn
 where
   not isExcluded(fn, TemplatesPackage::nameNotReferredUsingAQualifiedIdOrThisQuery()) and
   not isCustomExcluded(fn) and
-  p = getParent(c) and
+  dependentBaseType = getADependentBaseType(c) and
   missingNameQualifier(fn) and
   (
     fn instanceof FunctionAccess and
-    fn = parentMemberFunctionAccess(c, p)
+    fn = parentMemberFunctionAccess(c, dependentBaseType)
     or
     fn instanceof FunctionCall and
-    fn = parentMemberFunctionCall(c, p) and
+    fn = parentMemberFunctionCall(c, dependentBaseType) and
     not exists(Expr e | e = fn.(FunctionCall).getQualifier())
     or
     fn instanceof VariableAccess and
     not fn.(VariableAccess).getTarget() instanceof Parameter and
-    fn = parentMemberAccess(c, p) and
+    fn = parentMemberAccess(c, dependentBaseType) and
     not exists(Expr e | e = fn.(VariableAccess).getQualifier())
   ) and
   not fn.isAffectedByMacro()

cpp/autosar/src/rules/M14-6-1/NameNotReferredUsingAQualifiedIdOrThisAudit.ql

@@ -18,23 +18,23 @@ import cpp
 import codingstandards.cpp.autosar
 import NameInDependentBase
 
-from Class c, Class p, NameQualifiableElement fn
+from TemplateClass c, TemplateClass dependentBaseType, NameQualifiableElement fn
 where
   not isExcluded(fn, TemplatesPackage::nameNotReferredUsingAQualifiedIdOrThisAuditQuery()) and
   not isCustomExcluded(fn) and
-  p = getParent(c) and
+  dependentBaseType = getADependentBaseType(c) and
   missingNameQualifier(fn) and
   (
     fn instanceof FunctionAccess and
-    fn = parentMemberFunctionAccess(c, p)
+    fn = parentMemberFunctionAccess(c, dependentBaseType)
     or
     fn instanceof FunctionCall and
-    fn = parentMemberFunctionCall(c, p) and
+    fn = parentMemberFunctionCall(c, dependentBaseType) and
     not exists(Expr e | e = fn.(FunctionCall).getQualifier())
     or
     fn instanceof VariableAccess and
     not fn.(VariableAccess).getTarget() instanceof Parameter and
-    fn = parentMemberAccess(c, p) and
+    fn = parentMemberAccess(c, dependentBaseType) and
     not exists(Expr e | e = fn.(VariableAccess).getQualifier())
   )
 select fn, "Use of identifier that also exists in a base class that is not fully qualified."