Initial draft for non-const function objects.

Author: MichaelRFairhurst

cpp/common/src/codingstandards/cpp/exclusions/cpp/RuleMetadata.qll

@@ -61,6 +61,7 @@ import Representation
 import Scope
 import SideEffects1
 import SideEffects2
+import SideEffects6
 import SmartPointers1
 import SmartPointers2
 import Statements
@@ -134,6 +135,7 @@ newtype TCPPQuery =
   TScopePackageQuery(ScopeQuery q) or
   TSideEffects1PackageQuery(SideEffects1Query q) or
   TSideEffects2PackageQuery(SideEffects2Query q) or
+  TSideEffects6PackageQuery(SideEffects6Query q) or
   TSmartPointers1PackageQuery(SmartPointers1Query q) or
   TSmartPointers2PackageQuery(SmartPointers2Query q) or
   TStatementsPackageQuery(StatementsQuery q) or
@@ -207,6 +209,7 @@ predicate isQueryMetadata(Query query, string queryId, string ruleId, string cat
   isScopeQueryMetadata(query, queryId, ruleId, category) or
   isSideEffects1QueryMetadata(query, queryId, ruleId, category) or
   isSideEffects2QueryMetadata(query, queryId, ruleId, category) or
+  isSideEffects6QueryMetadata(query, queryId, ruleId, category) or
   isSmartPointers1QueryMetadata(query, queryId, ruleId, category) or
   isSmartPointers2QueryMetadata(query, queryId, ruleId, category) or
   isStatementsQueryMetadata(query, queryId, ruleId, category) or

cpp/common/src/codingstandards/cpp/exclusions/cpp/SideEffects6.qll

@@ -0,0 +1,44 @@
+//** THIS FILE IS AUTOGENERATED, DO NOT MODIFY DIRECTLY.  **/
+import cpp
+import RuleMetadata
+import codingstandards.cpp.exclusions.RuleMetadata
+
+newtype SideEffects6Query =
+  TPredicateWithPersistentSideEffectsQuery() or
+  TNonConstPredicateFunctionObjectQuery()
+
+predicate isSideEffects6QueryMetadata(Query query, string queryId, string ruleId, string category) {
+  query =
+    // `Query` instance for the `predicateWithPersistentSideEffects` query
+    SideEffects6Package::predicateWithPersistentSideEffectsQuery() and
+  queryId =
+    // `@id` for the `predicateWithPersistentSideEffects` query
+    "cpp/misra/predicate-with-persistent-side-effects" and
+  ruleId = "RULE-28-3-1" and
+  category = "required"
+  or
+  query =
+    // `Query` instance for the `nonConstPredicateFunctionObject` query
+    SideEffects6Package::nonConstPredicateFunctionObjectQuery() and
+  queryId =
+    // `@id` for the `nonConstPredicateFunctionObject` query
+    "cpp/misra/non-const-predicate-function-object" and
+  ruleId = "RULE-28-3-1" and
+  category = "required"
+}
+
+module SideEffects6Package {
+  Query predicateWithPersistentSideEffectsQuery() {
+    //autogenerate `Query` type
+    result =
+      // `Query` type for `predicateWithPersistentSideEffects` query
+      TQueryCPP(TSideEffects6PackageQuery(TPredicateWithPersistentSideEffectsQuery()))
+  }
+
+  Query nonConstPredicateFunctionObjectQuery() {
+    //autogenerate `Query` type
+    result =
+      // `Query` type for `nonConstPredicateFunctionObject` query
+      TQueryCPP(TSideEffects6PackageQuery(TNonConstPredicateFunctionObjectQuery()))
+  }
+}

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

@@ -0,0 +1,66 @@
+import cpp
+private import codingstandards.cpp.StdNamespace
+private import codingstandards.cpp.types.Templates
+private import semmle.code.cpp.dataflow.new.DataFlow
+
+Namespace getTemplateParameterNamespace(TypeTemplateParameter param) {
+  exists(Declaration decl |
+    param = decl.(TemplateClass).getATemplateArgument() or
+    param = decl.(TemplateVariable).getATemplateArgument() or
+    param = decl.(TemplateFunction).getATemplateArgument()
+  |
+    result = decl.getNamespace()
+  )
+}
+
+class PredicateType extends TypeTemplateParameter {
+  PredicateType() {
+    this.getName().matches(["%Compare%", "%Predicate%"]) and
+    getTemplateParameterNamespace(this) instanceof StdNS
+  }
+
+  Type getASubstitutedType(Substitution sub) { result = sub.getSubstitutedTypeForParameter(this) }
+}
+
+class PredicateFunctionObject extends Class {
+  PredicateType pred;
+  Function operator;
+  Substitution sub;
+
+  PredicateFunctionObject() {
+    this = pred.getASubstitutedType(sub) and
+    operator.getDeclaringType() = this and
+    operator.getName() = "operator()"
+  }
+
+  PredicateType getPredicateType() { result = pred }
+
+  Function getCallOperator() { result = operator }
+
+  Substitution getSubstitution() { result = sub }
+}
+
+class PredicateFunctionPointerUse extends FunctionAccess {
+  Expr functionPointerArgument;
+  FunctionCall templateFunctionCall;
+  FunctionTemplateInstantiation instantiation;
+  Substitution sub;
+  PredicateType pred;
+  Parameter parameter;
+  int index;
+
+  PredicateFunctionPointerUse() {
+    functionPointerArgument = templateFunctionCall.getArgument(index) and
+    templateFunctionCall.getTarget() = instantiation and
+    parameter = instantiation.getParameter(index) and
+    sub.asFunctionSubstitution() = instantiation and
+    parameter.getType() = sub.getSubstitutedTypeForParameter(pred) and
+    exists(DataFlow::Node func, DataFlow::Node arg |
+      func.asExpr() = this and
+      arg.asExpr() = functionPointerArgument and
+      DataFlow::localFlow(func, arg)
+    )
+  }
+
+  PredicateType getPredicateType() { result = pred }
+}

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

@@ -0,0 +1,49 @@
+import cpp
+
+private newtype TSubstitution =
+  TClassSubstitution(ClassTemplateInstantiation cti) or
+  TFunctionSubstitution(FunctionTemplateInstantiation fti) or
+  TVariableSubstitution(VariableTemplateInstantiation vti)
+
+class Substitution extends TSubstitution {
+  ClassTemplateInstantiation asClassSubstitution() { this = TClassSubstitution(result) }
+
+  FunctionTemplateInstantiation asFunctionSubstitution() { this = TFunctionSubstitution(result) }
+
+  VariableTemplateInstantiation asVariableSubstitution() { this = TVariableSubstitution(result) }
+
+  TypeTemplateParameter getTemplateParameter(int index) {
+    result = this.asClassSubstitution().getTemplate().getTemplateArgument(index) or
+    result = this.asFunctionSubstitution().getTemplate().getTemplateArgument(index) or
+    result = this.asVariableSubstitution().getTemplate().getTemplateArgument(index)
+  }
+
+  Type getSubstitutedType(int index) {
+    result = this.asClassSubstitution().getTemplateArgument(index) or
+    result = this.asFunctionSubstitution().getTemplateArgument(index) or
+    result = this.asVariableSubstitution().getTemplateArgument(index)
+  }
+
+  Type getSubstitutedTypeForParameter(TypeTemplateParameter param) {
+    exists(int idx |
+      this.getTemplateParameter(idx) = param and
+      result = this.getSubstitutedType(idx)
+    )
+  }
+
+  string toString() {
+    result = this.asClassSubstitution().toString() or
+    result = this.asFunctionSubstitution().toString() or
+    result = this.asVariableSubstitution().toString()
+  }
+
+  Locatable getASubstitutionSite() {
+    result.(TypeMention).getMentionedType() = this.asClassSubstitution()
+    or
+    result.(Call).getTarget() = this.asFunctionSubstitution()
+    or
+    result.(FunctionAccess).getTarget() = this.asFunctionSubstitution()
+    or
+    result.(VariableAccess).getTarget() = this.asVariableSubstitution()
+  }
+}

cpp/misra/src/rules/RULE-28-3-1/NonConstPredicateFunctionObject.ql

@@ -0,0 +1,33 @@
+/**
+ * @id cpp/misra/non-const-predicate-function-object
+ * @name RULE-28-3-1: Predicates shall not have persistent side effects
+ * @description Much of the behavior of predicates is implementation defined, such as how and when
+ *              it is invoked with which argument values, and if it is copied or moved. Therefore,
+ *              predicate function objects should be declared const.
+ * @kind problem
+ * @precision very-high
+ * @problem.severity error
+ * @tags external/misra/id/rule-28-3-1
+ *       scope/system
+ *       correctness
+ *       maintainability
+ *       portability
+ *       external/misra/enforcement/undecidable
+ *       external/misra/obligation/required
+ */
+
+import cpp
+import codingstandards.cpp.misra
+import codingstandards.cpp.SideEffect
+import codingstandards.cpp.types.Predicate
+
+from MemberFunction callOperator, PredicateFunctionObject obj, Locatable usageSite
+where
+  not isExcluded([callOperator, usageSite],
+    SideEffects6Package::nonConstPredicateFunctionObjectQuery()) and
+  obj.getSubstitution().getASubstitutionSite() = usageSite and
+  callOperator = obj.getCallOperator() and
+  not callOperator instanceof ConstMemberFunction
+select usageSite, "Predicate usage of $@ has $@", callOperator.getDeclaringType(),
+  "callable object " + callOperator.getDeclaringType().getName(), callOperator,
+  "non const operator()."

cpp/misra/src/rules/RULE-28-3-1/PredicateWithPersistentSideEffects.ql

@@ -0,0 +1,41 @@
+/**
+ * @id cpp/misra/predicate-with-persistent-side-effects
+ * @name RULE-28-3-1: Predicates shall not have persistent side effects
+ * @description Much of the behavior of predicates is implementation defined, such as how and when
+ *              it is invoked with which argument values, and if it is copied or moved. Therefore,
+ *              persistent side effects in a predicate cannot be relied upon and should not occur.
+ * @kind problem
+ * @precision very-high
+ * @problem.severity error
+ * @tags external/misra/id/rule-28-3-1
+ *       scope/system
+ *       correctness
+ *       maintainability
+ *       portability
+ *       external/misra/enforcement/undecidable
+ *       external/misra/obligation/required
+ */
+
+import cpp
+import codingstandards.cpp.misra
+import codingstandards.cpp.SideEffect
+import codingstandards.cpp.types.Predicate
+
+predicate functionHasSideEffect(Function f) {
+  hasExternalOrGlobalSideEffectInFunction(f)
+}
+
+predicate isPredicateObject(PredicateFunctionObject obj, PredicateType pred, Locatable usageSite, Function callOperator) {
+  obj.getSubstitution().getASubstitutionSite() = usageSite and
+  pred = obj.getPredicateType() and
+  callOperator = obj.getCallOperator()
+}
+
+predicate isPredicateFunctionPointerUse(PredicateFunctionPointerUse predPtrUse, PredicateType pred, Function func) {
+  pred = predPtrUse.getPredicateType() and
+  func = predPtrUse.getTarget()
+}
+
+where
+  not isExcluded(x, SideEffects6Package::predicateWithPersistentSideEffectsQuery()) and
+select

cpp/misra/test/rules/RULE-28-3-1/NonConstPredicateFunctionObject.expected

@@ -0,0 +1 @@
+| test.cpp:21:3:21:11 | call to sort | Predicate usage of $@ has $@ | test.cpp:10:8:10:9 | F1 | callable object F1 | test.cpp:11:8:11:17 | operator() | non const operator(). |

cpp/misra/test/rules/RULE-28-3-1/NonConstPredicateFunctionObject.qlref

@@ -0,0 +1 @@
+rules/RULE-28-3-1/NonConstPredicateFunctionObject.ql

cpp/misra/test/rules/RULE-28-3-1/PredicateWithPersistentSideEffects.expected

@@ -0,0 +1 @@
+No expected results have yet been specified

cpp/misra/test/rules/RULE-28-3-1/PredicateWithPersistentSideEffects.qlref

@@ -0,0 +1 @@
+rules/RULE-28-3-1/PredicateWithPersistentSideEffects.ql