Add support for templates to base class detection

Detect template base classes through class template instantiations.

Author: rvermeulen

cpp/autosar/test/rules/A12-8-6/CopyAndMoveNotDeclaredProtected.expected

@@ -12,3 +12,11 @@
 | test.cpp:76:3:76:12 | declaration of BaseClass6 | Move constructor for base class BaseClass6 (the class is abstract) is not declared protected or deleted. |
 | test.cpp:77:15:77:23 | declaration of operator= | Copy assignment operator for base class BaseClass6 (the class is abstract) is not declared protected or deleted. |
 | test.cpp:78:15:78:23 | declaration of operator= | Move assignment operator for base class BaseClass6 (the class is abstract) is not declared protected or deleted. |
+| test.cpp:85:3:85:12 | declaration of BaseClass7 | Copy constructor for base class BaseClass7<T1> (a derived class exists) is not declared protected or deleted. |
+| test.cpp:86:3:86:12 | declaration of BaseClass7 | Move constructor for base class BaseClass7<T1> (a derived class exists) is not declared protected or deleted. |
+| test.cpp:87:15:87:23 | declaration of operator= | Copy assignment operator for base class BaseClass7<T1> (a derived class exists) is not declared protected or deleted. |
+| test.cpp:88:15:88:23 | declaration of operator= | Move assignment operator for base class BaseClass7<T1> (a derived class exists) is not declared protected or deleted. |
+| test.cpp:108:3:108:12 | declaration of BaseClass8 | Copy constructor for base class BaseClass8 (a derived class exists) is not declared protected or deleted. |
+| test.cpp:109:3:109:12 | declaration of BaseClass8 | Move constructor for base class BaseClass8 (a derived class exists) is not declared protected or deleted. |
+| test.cpp:110:15:110:23 | declaration of operator= | Copy assignment operator for base class BaseClass8 (a derived class exists) is not declared protected or deleted. |
+| test.cpp:111:15:111:23 | declaration of operator= | Move assignment operator for base class BaseClass8 (a derived class exists) is not declared protected or deleted. |

cpp/autosar/test/rules/A12-8-6/test.cpp

@@ -77,4 +77,52 @@ class BaseClass6 {
   BaseClass6 &operator=(BaseClass6 const &) = default; // NON_COMPLIANT
   BaseClass6 &operator=(BaseClass6 &&) = default;      // NON_COMPLIANT
   virtual void test() = 0; // pure virtual function, making this abstract
-};
+};
+
+template <class T1> class BaseClass7 {
+public:
+  BaseClass7() {}
+  BaseClass7(BaseClass7 const &) = default;            // NON_COMPLIANT
+  BaseClass7(BaseClass7 &&) = default;                 // NON_COMPLIANT
+  BaseClass7 &operator=(BaseClass7 const &) = default; // NON_COMPLIANT
+  BaseClass7 &operator=(BaseClass7 &&) = default;      // NON_COMPLIANT
+  int operator=(int i); // COMPLIANT - not an assignment operator
+};                      // COMPLIANT
+
+template <class T>
+class DerivedClass7 // COMPLIANT - not a base class itself
+    : public BaseClass7<T> {
+public:
+  DerivedClass7() {}
+};
+
+class DerivedClass8 // COMPLIANT - not a base class itself
+    : public BaseClass7<int> {
+public:
+  DerivedClass8() {}
+};
+
+class BaseClass8 {
+public:
+  BaseClass8() {}
+  BaseClass8(BaseClass8 const &) = default;            // NON_COMPLIANT
+  BaseClass8(BaseClass8 &&) = default;                 // NON_COMPLIANT
+  BaseClass8 &operator=(BaseClass8 const &) = default; // NON_COMPLIANT
+  BaseClass8 &operator=(BaseClass8 &&) = default;      // NON_COMPLIANT
+};
+
+template <class T>
+class DerivedClass9 // COMPLIANT - not a base class itself
+    : public BaseClass8 {
+public:
+  DerivedClass9() {}
+
+private:
+  T t;
+};
+
+void test() {
+  BaseClass7<int> b;
+  DerivedClass7<int> d;
+  DerivedClass9<int> e;
+}

cpp/common/src/codingstandards/cpp/Class.qll

@@ -10,7 +10,19 @@ import codingstandards.cpp.Expr
  */
 predicate isPossibleBaseClass(Class c, string reason) {
   // There exists a derivation in this database
-  exists(c.getADerivedClass()) and reason = "a derived class exists"
+  (
+    // We make a distinction between class template instantiations, regular classes and template classes.
+    // For template classes we do have derived classes, because derived classes would derive from a 
+    // class template instantiation. 
+    // Therefore, we check for derived classes for regular classes
+    not c instanceof ClassTemplateInstantiation and not c instanceof TemplateClass and exists(c.getADerivedClass())
+    or
+    // and use template instantiations to check for derived classes for template classes
+    exists(ClassTemplateInstantiation instantiation |
+      exists(instantiation.getADerivedClass()) and c = instantiation.getTemplate()
+    )
+  ) and
+  reason = "a derived class exists"
   or
   // The class must be extended at some point
   c.isAbstract() and reason = "the class is abstract"