checkpoint: attempt to catch unused parameters in lambdaexpr

Author: jeongsoolee09

cpp/common/src/codingstandards/cpp/deadcode/UnusedParameters.qll

@@ -1,40 +1,56 @@
 /**
- * A library for identifying parameters which may be unused.
- */
+* A library for identifying parameters which may be unused.
+*/
 
 import cpp
 
 /**
- * A `Parameter` which is "usable" within the function.
- *
- * For this to be the case, the `Function` must have a definition, and that definition must include
- * a body block, and the parameter must be a named parameter.
- */
+* A `Parameter` which is "usable" within the function.
+*
+* For this to be the case, the `Function` must have a definition, and that definition must include
+* a body block, and the parameter must be a named parameter.
+*/
 class UsableParameter extends Parameter {
   UsableParameter() {
-    // Find the function associated with the parameter
-    exists(Function f | this = f.getAParameter() |
-      // Must have the definition of the function, not just the declaration
-      f.hasDefinition() and
-      // There must be a body block associated with the function, otherwise the parameter cannot
-      // possibly be used
-      exists(f.getBlock())
-    ) and
+    (
+      /* Regular Function */
+      // Find the function associated with the parameter
+     exists(Function f | this = f.getAParameter() |
+        // Must have the definition of the function, not just the declaration
+       f.hasDefinition() and
+        // There must be a body block associated with the function, otherwise the parameter cannot
+        // possibly be used
+       exists(f.getBlock())
+     )
+     or
+      /* Lambda Expression */
+      // Find the function associated with the parameter
+     exists(LambdaExpression lambda, Function f |
+       this = lambda.getLambdaFunction().getParameter(_)
+       |
+        // Must have the definition of the function, not just the declaration
+       lambda.getLambdaFunction() = f and
+       f.hasDefinition() and
+        // There must be a body block associated with the function, otherwise the parameter cannot
+        // possibly be used
+       exists(f.getBlock())
+     )
+     ) and
     // Must be a named parameter, because unnamed parameters cannot be referenced
     isNamed()
   }
 }
 
 /**
- * A `Parameter` which is usable but not directly used in the local context.
- */
+* A `Parameter` which is usable but not directly used in the local context.
+*/
 class UnusedParameter extends UsableParameter {
   UnusedParameter() { not this instanceof UsedParameter }
 }
 
 /**
- * A `Parameter` which is used in the local context.
- */
+* A `Parameter` which is used in the local context.
+*/
 class UsedParameter extends UsableParameter {
   UsedParameter() {
     // An access to the parameter exists in the function body

cpp/common/src/codingstandards/cpp/rules/unusedparameter/UnusedParameter.qll

@@ -1,6 +1,6 @@
 /**
- * Provides a library which includes a `problems` predicate for reporting unused parameters.
- */
+* Provides a library which includes a `problems` predicate for reporting unused parameters.
+*/
 
 import cpp
 import codingstandards.cpp.Customizations
@@ -11,11 +11,31 @@ abstract class UnusedParameterSharedQuery extends Query { }
 
 Query getQuery() { result instanceof UnusedParameterSharedQuery }
 
+predicate isMaybeUnusedParameter(Parameter parameter) {
+  parameter.getAnAttribute().toString() = "maybe_unused"
+}
+
+// query
+predicate isLambdaParameter(Parameter parameter) {
+  exists(LambdaExpression lambda | lambda.getLambdaFunction().getParameter(_) = parameter)
+}
+
+// query
+predicate isLambdaMaybeUnusedParameter(Parameter parameter) {
+  exists(LambdaExpression lambda | lambda.getLambdaFunction().getParameter(_) = parameter) and
+  isMaybeUnusedParameter(parameter)
+}
+
+query predicate lambdaExprParamHasAccess(Parameter parameter) {
+  exists(VariableAccess va | isLambdaParameter(parameter) and parameter.getAnAccess() = va)
+}
+
 query predicate problems(UnusedParameter p, string message, Function f, string fName) {
   not isExcluded(p, getQuery()) and
-  f = p.getFunction() and
+  (not isMaybeUnusedParameter(p) and
+   f = p.getFunction() and
   // Virtual functions are covered by a different rule
-  not f.isVirtual() and
+   not f.isVirtual()) and
   message = "Unused parameter '" + p.getName() + "' for function $@." and
   fName = f.getQualifiedName()
 }