C++: Introduce a new base class for template parameters

This will enable us to support non-type template parameters, which we
currently do not support, and error template parameters, which might
become relevant in the `build-mode: none` context.

cpp/ql/lib/change-notes/2024-12-17-template-parameter-base.md

@@ -0,0 +1,4 @@
+---
+category: feature
+---
+* A new class `TemplateParameterBase` was introduced, which represents C++ non-type template parameters, type template parameters, and template template parameters.

cpp/ql/lib/change-notes/2024-12-17-template-parameter.md

@@ -0,0 +1,4 @@
+---
+category: deprecated
+---
+* The `TemplateParameter` class, representing C++ type template parameters has been deprecated. Use `TypeTemplateParameter` instead.

cpp/ql/lib/semmle/code/cpp/Class.qll

@@ -952,7 +952,7 @@ class ClassTemplateSpecialization extends Class {
     result.getNamespace() = this.getNamespace() and
     // It is distinguished by the fact that each of its template arguments
     // is a distinct template parameter.
-    count(TemplateParameter tp | tp = result.getATemplateArgument()) =
+    count(TemplateParameterBase tp | tp = result.getATemplateArgument()) =
       count(int i | exists(result.getTemplateArgument(i)))
   }
 
@@ -1006,7 +1006,7 @@ private predicate isPartialClassTemplateSpecialization(Class c) {
    */
 
   exists(Type ta | ta = c.getATemplateArgument() and ta.involvesTemplateParameter()) and
-  count(TemplateParameter tp | tp = c.getATemplateArgument()) !=
+  count(TemplateParameterBase tp | tp = c.getATemplateArgument()) !=
     count(int i | exists(c.getTemplateArgument(i)))
 }
 
@@ -1091,7 +1091,7 @@ class ProxyClass extends UserType {
   override Location getLocation() { result = this.getTemplateParameter().getDefinitionLocation() }
 
   /** Gets the template parameter for which this is the proxy class. */
-  TemplateParameter getTemplateParameter() {
+  TypeTemplateParameter getTemplateParameter() {
     is_proxy_class_for(underlyingElement(this), unresolveElement(result))
   }
 }

cpp/ql/lib/semmle/code/cpp/Declaration.qll

@@ -187,7 +187,7 @@ class Declaration extends Locatable, @declaration {
       this instanceof Parameter or
       this instanceof ProxyClass or
       this instanceof LocalVariable or
-      this instanceof TemplateParameter or
+      this instanceof TypeTemplateParameter or
       this.(UserType).isLocal()
     )
   }

cpp/ql/lib/semmle/code/cpp/Print.qll

@@ -33,7 +33,7 @@ private string getScopePrefix(Declaration decl) {
     result = "(" + type.getEnclosingFunction().(DumpFunction).getIdentityString() + ")::"
   )
   or
-  decl instanceof TemplateParameter and result = ""
+  decl instanceof TypeTemplateParameter and result = ""
 }
 
 /**

cpp/ql/lib/semmle/code/cpp/Type.qll

@@ -1666,6 +1666,28 @@ class RoutineType extends Type, @routinetype {
   }
 }
 
+abstract private class TemplateParameterImpl extends Locatable {
+  override string getAPrimaryQlClass() { result = "TemplateParameterImpl" }
+}
+
+/**
+ * A C++ template parameter.
+ *
+ * In the example below, `T` and `I` are template parameters:
+ * ```
+ * template <class T, int I>
+ * class C { };
+ * ```
+ */
+final class TemplateParameterBase = TemplateParameterImpl;
+
+/**
+ * A C++ `typename` (or `class`) template parameter.
+ *
+ * DEPRECATED: Use `TypeTemplateParameter` instead.
+ */
+deprecated class TemplateParameter = TypeTemplateParameter;
+
 /**
  * A C++ `typename` (or `class`) template parameter.
  *
@@ -1675,12 +1697,12 @@ class RoutineType extends Type, @routinetype {
  * class C { };
  * ```
  */
-class TemplateParameter extends UserType {
-  TemplateParameter() {
+class TypeTemplateParameter extends UserType, TemplateParameterImpl {
+  TypeTemplateParameter() {
     usertypes(underlyingElement(this), _, 7) or usertypes(underlyingElement(this), _, 8)
   }
 
-  override string getAPrimaryQlClass() { result = "TemplateParameter" }
+  override string getAPrimaryQlClass() { result = "TypeTemplateParameter" }
 
   override predicate involvesTemplateParameter() { any() }
 }
@@ -1695,7 +1717,7 @@ class TemplateParameter extends UserType {
  * void foo(const Container<Elem> &value) { }
  * ```
  */
-class TemplateTemplateParameter extends TemplateParameter {
+class TemplateTemplateParameter extends TypeTemplateParameter {
   TemplateTemplateParameter() { usertypes(underlyingElement(this), _, 8) }
 
   override string getAPrimaryQlClass() { result = "TemplateTemplateParameter" }
@@ -1707,7 +1729,7 @@ class TemplateTemplateParameter extends TemplateParameter {
  * auto val = some_typed_expr();
  * ```
  */
-class AutoType extends TemplateParameter {
+class AutoType extends TypeTemplateParameter {
   AutoType() { usertypes(underlyingElement(this), "auto", 7) }
 
   override string getAPrimaryQlClass() { result = "AutoType" }

cpp/ql/lib/semmle/code/cpp/commons/Dependency.qll

@@ -66,7 +66,7 @@ class Symbol extends DependsSource {
       not this.(TypeDeclarationEntry).getType() instanceof LocalEnum and
       not this.(TypeDeclarationEntry).getType() instanceof LocalClass and
       not this.(TypeDeclarationEntry).getType() instanceof LocalTypedefType and
-      not this.(TypeDeclarationEntry).getType() instanceof TemplateParameter
+      not this.(TypeDeclarationEntry).getType() instanceof TypeTemplateParameter
       or
       this instanceof NamespaceDeclarationEntry
     )

cpp/ql/lib/semmle/code/cpp/dataflow/ExternalFlow.qll

@@ -504,7 +504,7 @@ private string getTypeNameWithoutFunctionTemplates(Function f, int n, int remain
     result = getParameterTypeWithoutTemplateArguments(templateFunction, n)
   )
   or
-  exists(string mid, TemplateParameter tp, Function templateFunction |
+  exists(string mid, TypeTemplateParameter tp, Function templateFunction |
     mid = getTypeNameWithoutFunctionTemplates(f, n, remaining + 1) and
     templateFunction = getFullyTemplatedFunction(f) and
     tp = templateFunction.getTemplateArgument(remaining) and
@@ -529,7 +529,7 @@ private string getTypeNameWithoutClassTemplates(Function f, int n, int remaining
   remaining = 0 and
   result = getTypeNameWithoutFunctionTemplates(f, n, 0)
   or
-  exists(string mid, TemplateParameter tp, Class template |
+  exists(string mid, TypeTemplateParameter tp, Class template |
     mid = getTypeNameWithoutClassTemplates(f, n, remaining + 1) and
     isClassConstructedFrom(f.getDeclaringType(), template) and
     tp = template.getTemplateArgument(remaining) and

cpp/ql/lib/semmle/code/cpp/internal/QualifiedName.qll

@@ -130,7 +130,7 @@ class Declaration extends @declaration {
       this instanceof Parameter or
       this instanceof ProxyClass or
       this instanceof LocalVariable or
-      this instanceof TemplateParameter or
+      this instanceof TypeTemplateParameter or
       this.(UserType).isLocal()
     )
   }
@@ -226,8 +226,8 @@ class ProxyClass extends UserType {
   ProxyClass() { usertypes(this, _, 9) }
 }
 
-class TemplateParameter extends UserType {
-  TemplateParameter() { usertypes(this, _, 7) or usertypes(this, _, 8) }
+class TypeTemplateParameter extends UserType {
+  TypeTemplateParameter() { usertypes(this, _, 7) or usertypes(this, _, 8) }
 }
 
 class TemplateClass extends UserType {