Merge branch 'main' into rvermeulen/fix-issue-#311

Author: rvermeulen

.vscode/tasks.json

@@ -140,6 +140,28 @@
             },
             "problemMatcher": []
         },
+        {
+            "label": "🧪 Standards Automation: Build Case Test DB from test file",
+            "type": "shell",
+            "windows": {
+                "command": ".${pathSeparator}scripts${pathSeparator}.venv${pathSeparator}Scripts${pathSeparator}python.exe scripts${pathSeparator}build_test_database.py ${file}"
+            },
+            "linux": {
+                "command": ".${pathSeparator}scripts${pathSeparator}.venv${pathSeparator}bin${pathSeparator}python3 scripts${pathSeparator}build_test_database.py ${file}"
+            },
+            "osx": {
+                "command": ".${pathSeparator}scripts${pathSeparator}.venv${pathSeparator}bin${pathSeparator}python3 scripts${pathSeparator}build_test_database.py ${file}"
+            },
+            "presentation": {
+                "reveal": "always",
+                "panel": "new",
+                "focus": true
+            },
+            "runOptions": {
+                "reevaluateOnRerun": false
+            },
+            "problemMatcher": []
+        },
         {
             "label": "📝 Standards Automation: Format CodeQL",
             "type": "shell",

change_notes/2023-10-04-aggregate-literals-from-variadic-templates.md

@@ -0,0 +1,2 @@
+ `M8-5-2` - `AggregateLiteralEnhancements.qll`:
+   - recognise aggregate literals initialized with parameters from variadic templates.

change_notes/2023-11-03-identifier-hiding-improvements.md

@@ -0,0 +1,3 @@
+ - `A2-10-1`, `RULE-5-3`:
+   - Reduce false positives by considering point of declaration for local variables.
+   - Reduce false negatives by considering catch block parameters to be in scope in the catch block.

change_notes/2023-11-05-m6-5-5-const-refs.md

@@ -0,0 +1,3 @@
+ - `M6-5-5`:
+   - Reduce false positives by no longer considering the taking of a const reference as a modification.
+   - Improve detection of non-local modification of loop iteration variables to reduce false positives.

change_notes/2023-11-24-a2-7-3-remove-function-scope.md

@@ -0,0 +1,3 @@
+ * `A2-7-3` - `UndocumentedUserDefinedType.ql`:
+   - Excluding declarations in function scope. The rationale is that these declarations are not exposed outside the scope of the function.
+   

change_notes/2024-01-14-m5-3-3-exclude-binary.md

@@ -0,0 +1,2 @@
+`M5-3-3` - `UnaryOperatorOverloaded.ql`:
+  - Exclude binary user defined `operator&` from this rule.

change_notes/2024-01-16-m5-2-10-arith-only.md

@@ -0,0 +1,2 @@
+ `M5-2-10` - `IncrementAndDecrementOperatorsMixedWithOtherOperatorsInExpression.ql`:
+   - only report use of the increment and decrement operations in conjunction with arithmetic operators, as specified by the rule. Notably we no longer report the expressions of the form `*p++`, which combine increment and dereferencing operations.

change_notes/2024-01-17-a4-7-1-exclude-pointers.md

@@ -0,0 +1 @@
+ * `A4-7-1` - exclude pointer increment and decrement operators from this rule.

change_notes/2024-01-24-throwing-functions-exclude-noexcept.md

@@ -0,0 +1,6 @@
+ * Exceptions are no longer propagated from calls to `noexcept` functions, or calls functions with dynamic exception specifications where the exception is not permitted. This is consistent with the default behaviour specified in `[expect.spec]` which indicates that `std::terminate` is called. This has the following impact:
+   - `A15-4-2`, `ERR55-CPP` - reduce false positives for `noexcept` functions which call other `noexcept` function which may throw.
+   - `A15-2-2` - reduce false positives for constructors which call `noexcept` functions.
+   - `A15-4-5` - reduce false positives for checked exceptions that are thrown from `noexcept` functions called by the original function.
+   - `DCL57-CPP` - do not report exceptions thrown from `noexcept` functions called by deallocation functions or destructors.
+   - `A15-5-1`, `M15-3-1` - do not report exceptions thrown from `noexcept` functions called by special functions.

change_notes/2024-01-30-fix-fp-for-a4-7-1.md

@@ -0,0 +1,2 @@
+`A4-7-1`: `IntegerExpressionLeadToDataLoss.ql`
+ - Fix #368: Incorrectly reporting `/=` as a cause for data loss.

change_notes/2024-01-31-exclusion-a16-0-1.md

@@ -0,0 +1,2 @@
+`A16-0-1` - `PreProcessorShallOnlyBeUsedForCertainDirectivesPatterns.ql`:
+    - Exclude all preprocessor elses and also consider elifs separately (ie do not affect valid ifs) but not valid if not meeting the same criteria as an ifdef etc.

change_notes/2024-01-31-fix-fp-a4-5-1.md

@@ -0,0 +1,4 @@
+`A4-5-1`: `EnumUsedInArithmeticContexts.ql`:
+    - Address incorrect exclusion of the binary operator `&`.
+    - Address incorrect inclusion of the unary operator `&`.
+    - Fix FP reported in #366.

change_notes/2024-01-31-fix-fp-a7-1-2.md

@@ -0,0 +1,2 @@
+`A7-1-2` - `VariableMissingConstexpr.ql`:
+    - Fix FP reported in #466. Addresses incorrect assumption that calls to `constexpr` functions are always compile-time evaluated.

change_notes/2024-02-12-exclusion-A2-10-4.md

@@ -0,0 +1,2 @@
+- `A2-10-4` - `IdentifierNameOfStaticNonMemberObjectReusedInNamespace.ql`:
+    - Fix FP reported in #385. Addresses incorrect detection of partially specialized template variables as conflicting reuses.

change_notes/2024-02-13-fix-fn-M7-3-6.md

@@ -0,0 +1,2 @@
+- `M7-3-6` - `UsingDeclarationsUsedInHeaderFiles.ql`:
+  - Address FN reported in #400. Only using-declarations are exempted from class- and function-scope.

change_notes/2024-02-13-fix-fp-a15-4-4.md

@@ -0,0 +1,2 @@
+-`A15-4-4` - `MissingNoExcept.ql`:
+    - Fix FP reported in #424. Exclude functions calling `std::string::reserve` or `std::string::append` that may throw even if their signatures don't specify it.

cpp/autosar/src/rules/A16-0-1/PreProcessorShallOnlyBeUsedForCertainDirectivesPatterns.ql

@@ -21,13 +21,26 @@ import cpp
 import codingstandards.cpp.autosar
 import codingstandards.cpp.FunctionLikeMacro
 
+class PermittedInnerDirectiveType extends PreprocessorDirective {
+  PermittedInnerDirectiveType() {
+    //permissive listing for directives that can be used in a valid wrapper
+    this instanceof MacroWrapper or
+    this instanceof PreprocessorEndif or
+    this instanceof Include or
+    this instanceof PermittedMacro or
+    this instanceof PreprocessorElif or
+    this instanceof PreprocessorElse
+  }
+}
+
 class PermittedDirectiveType extends PreprocessorDirective {
   PermittedDirectiveType() {
     //permissive listing in case directive types modelled in ql ever expands (example non valid directives)
     this instanceof MacroWrapper or
     this instanceof PreprocessorEndif or
     this instanceof Include or
-    this instanceof PermittedMacro
+    this instanceof PermittedMacro or
+    this instanceof PreprocessorElse
   }
 }
 
@@ -40,9 +53,9 @@ pragma[noinline]
 predicate isPreprocConditionalRange(
   PreprocessorBranch pb, string filepath, int startLine, int endLine
 ) {
-  exists(PreprocessorEndif end | pb.getEndIf() = end |
-    isPreprocFileAndLine(pb, filepath, startLine) and
-    isPreprocFileAndLine(end, filepath, endLine)
+  isPreprocFileAndLine(pb, filepath, startLine) and
+  exists(PreprocessorDirective end |
+    pb.getNext() = end and isPreprocFileAndLine(end, filepath, endLine)
   )
 }
 
@@ -73,7 +86,7 @@ class MacroWrapper extends PreprocessorIfndef {
 class AcceptableWrapper extends PreprocessorBranch {
   AcceptableWrapper() {
     forall(Element inner | not inner instanceof Comment and this = getAGuard(inner) |
-      inner instanceof PermittedDirectiveType
+      inner instanceof PermittedInnerDirectiveType
     )
   }
 }

cpp/autosar/src/rules/A2-10-4/IdentifierNameOfStaticNonMemberObjectReusedInNamespace.ql

@@ -20,7 +20,9 @@ class CandidateVariable extends Variable {
   CandidateVariable() {
     hasDefinition() and
     isStatic() and
-    not this instanceof MemberVariable
+    not this instanceof MemberVariable and
+    //exclude partially specialized template variables
+    not exists(TemplateVariable v | this = v.getAnInstantiation())
   }
 }
 

cpp/autosar/src/rules/A2-7-3/UndocumentedUserDefinedType.ql

@@ -17,6 +17,14 @@
 import cpp
 import codingstandards.cpp.autosar
 
+private predicate isInFunctionScope(Declaration d) {
+  // Type declared in function
+  exists(d.(UserType).getEnclosingFunction())
+  or
+  // Member declared in type which is in function scope
+  isInFunctionScope(d.getDeclaringType())
+}
+
 /**
  * A declaration which is required to be preceded by documentation by AUTOSAR A2-7-3.
  */
@@ -42,10 +50,8 @@ class DocumentableDeclaration extends Declaration {
     declarationType = "member variable" and
     // Exclude memeber variables in instantiated templates, which cannot reasonably be documented.
     not this.(MemberVariable).isFromTemplateInstantiation(_) and
-    // Exclude anonymous lambda functions.
-    // TODO: replace with the following when support is added.
-    // not this.(MemberVariable).isCompilerGenerated()
-    not exists(LambdaExpression lc | lc.getACapture().getField() = this)
+    // Exclude compiler generated variables, such as those for anonymous lambda functions
+    not this.(MemberVariable).isCompilerGenerated()
   }
 
   /** Gets a `DeclarationEntry` for this declaration that should be documented. */
@@ -96,6 +102,7 @@ from DocumentableDeclaration d, DeclarationEntry de
 where
   not isExcluded(de, CommentsPackage::undocumentedUserDefinedTypeQuery()) and
   not isExcluded(d, CommentsPackage::undocumentedUserDefinedTypeQuery()) and
+  not isInFunctionScope(d) and
   d.getAnUndocumentedDeclarationEntry() = de
 select de,
   "Declaration entry for " + d.getDeclarationType() + " " + d.getName() +

cpp/autosar/src/rules/A4-5-1/EnumUsedInArithmeticContexts.ql

@@ -18,44 +18,26 @@
 
 import cpp
 import codingstandards.cpp.autosar
+import codingstandards.cpp.Operator
+import codingstandards.cpp.Type
 
-/*
- * Get an operand to all overloaded operator member functions, except:
- *   operator[]
- *   operator=
- *   operator==
- *   operator!=
- *   operator&
- *   operator<
- *   operator<=
- *   operator>
- *   operator>=
- */
-
-Expr getAnOperandOfAllowedOverloadedOperator(FunctionCall fc) {
-  fc.getAnArgument() = result and
-  fc.getTarget().getName().regexpMatch("operator(?!\\[]$|=$|==$|!=$|&$|<$|<=$|>$|>=$).+")
-}
-
-Expr getAnOperandOfAllowedOperation(Operation o) {
-  o.getAnOperand() = result and
-  not (
-    o instanceof AssignExpr or
-    o instanceof BitwiseAndExpr or
-    o instanceof ComparisonOperation
-  )
+class AllowedOperatorUse extends OperatorUse {
+  AllowedOperatorUse() {
+    this.getOperator() in ["[]", "=", "==", "!=", "<", "<=", ">", ">="]
+    or
+    this.(UnaryOperatorUse).getOperator() = "&"
+  }
 }
 
-from Expr e, Expr operand
+from OperatorUse operatorUse, Access access, Enum enum
 where
-  not isExcluded(e, ExpressionsPackage::enumUsedInArithmeticContextsQuery()) and
+  not isExcluded(access, ExpressionsPackage::enumUsedInArithmeticContextsQuery()) and
+  operatorUse.getAnOperand() = access and
   (
-    operand = getAnOperandOfAllowedOverloadedOperator(e)
-    or
-    operand = getAnOperandOfAllowedOperation(e)
+    access.(EnumConstantAccess).getTarget().getDeclaringEnum() = enum or
+    access.(VariableAccess).getType() = enum
   ) and
-  (
-    operand instanceof EnumConstantAccess or
-    operand.(VariableAccess).getType() instanceof Enum
-  )
-select e, "Enum $@ is used as an operand of arithmetic operation.", operand, "expression"
+  not operatorUse instanceof AllowedOperatorUse and
+  // Enums that implement the BitmaskType trait are an exception.
+  not enum instanceof BitmaskType
+select access, "Enum $@ is used as an operand of arithmetic operation.", enum, enum.getName()

cpp/autosar/src/rules/A4-7-1/IntegerExpressionLeadToDataLoss.ql

@@ -30,5 +30,7 @@ where
   not e instanceof MulExpr and
   // Not covered by this query - overflow/underflow in division is rare
   not e instanceof DivExpr and
-  not e instanceof RemExpr
+  not e instanceof AssignDivExpr and
+  not e instanceof RemExpr and
+  not e instanceof AssignRemExpr
 select e, "Binary expression ..." + e.getOperator() + "... may overflow."

cpp/autosar/src/rules/A7-1-2/VariableMissingConstexpr.ql

@@ -17,6 +17,7 @@ import cpp
 import codingstandards.cpp.autosar
 import codingstandards.cpp.TrivialType
 import codingstandards.cpp.SideEffect
+import semmle.code.cpp.controlflow.SSA
 
 predicate isZeroInitializable(Variable v) {
   not exists(v.getInitializer().getExpr()) and
@@ -33,6 +34,78 @@ predicate isTypeZeroInitializable(Type t) {
   t.getUnderlyingType() instanceof ArrayType
 }
 
+/**
+ * An optimized set of expressions used to determine the flow through constexpr variables.
+ */
+class VariableAccessOrCallOrLiteral extends Expr {
+  VariableAccessOrCallOrLiteral() {
+    this instanceof VariableAccess or
+    this instanceof Call or
+    this instanceof Literal
+  }
+}
+
+/**
+ * Holds if the value of source flows through compile time evaluated variables to target.
+ */
+predicate flowsThroughConstExprVariables(
+  VariableAccessOrCallOrLiteral source, VariableAccessOrCallOrLiteral target
+) {
+  (
+    source = target
+    or
+    source != target and
+    exists(SsaDefinition intermediateDef, StackVariable intermediate |
+      intermediateDef.getAVariable().getFunction() = source.getEnclosingFunction() and
+      intermediateDef.getAVariable().getFunction() = target.getEnclosingFunction() and
+      intermediateDef.getAVariable() = intermediate and
+      intermediate.isConstexpr()
+    |
+      DataFlow::localExprFlow(source, intermediateDef.getDefiningValue(intermediate)) and
+      flowsThroughConstExprVariables(intermediateDef.getAUse(intermediate), target)
+    )
+  )
+}
+
+/*
+ * Returns true if the given call may be evaluated at compile time and is compile time evaluated because
+ * all its arguments are compile time evaluated and its default values are compile time evaluated.
+ */
+
+predicate isCompileTimeEvaluated(Call call) {
+  // 1. The call may be evaluated at compile time, because it is constexpr, and
+  call.getTarget().isConstexpr() and
+  // 2. all its arguments are compile time evaluated, and
+  forall(DataFlow::Node ultimateArgSource, DataFlow::Node argSource |
+    argSource = DataFlow::exprNode(call.getAnArgument()) and
+    DataFlow::localFlow(ultimateArgSource, argSource) and
+    not DataFlow::localFlowStep(_, ultimateArgSource)
+  |
+    (
+      ultimateArgSource.asExpr() instanceof Literal
+      or
+      any(Call c | isCompileTimeEvaluated(c)) = ultimateArgSource.asExpr()
+    ) and
+    // If the ultimate argument source is not the same as the argument source, then it must flow through
+    // constexpr variables.
+    (
+      ultimateArgSource != argSource
+      implies
+      flowsThroughConstExprVariables(ultimateArgSource.asExpr(), argSource.asExpr())
+    )
+  ) and
+  // 3. all the default values used are compile time evaluated.
+  forall(Expr defaultValue, Parameter parameterUsingDefaultValue, int idx |
+    parameterUsingDefaultValue = call.getTarget().getParameter(idx) and
+    not exists(call.getArgument(idx)) and
+    parameterUsingDefaultValue.getAnAssignedValue() = defaultValue
+  |
+    defaultValue instanceof Literal
+    or
+    any(Call c | isCompileTimeEvaluated(c)) = defaultValue
+  )
+}
+
 from Variable v
 where
   not isExcluded(v, ConstPackage::variableMissingConstexprQuery()) and
@@ -46,7 +119,7 @@ where
   (
     v.getInitializer().getExpr().isConstant()
     or
-    v.getInitializer().getExpr().(Call).getTarget().isConstexpr()
+    any(Call call | isCompileTimeEvaluated(call)) = v.getInitializer().getExpr()
     or
     isZeroInitializable(v)
     or

cpp/autosar/src/rules/M3-9-1/TypesNotIdenticalInReturnDeclarations.ql

@@ -15,8 +15,6 @@
 
 import cpp
 import codingstandards.cpp.autosar
-import cpp
-import codingstandards.cpp.autosar
 
 from FunctionDeclarationEntry f1, FunctionDeclarationEntry f2
 where

cpp/autosar/src/rules/M5-2-10/IncrementAndDecrementOperatorsMixedWithOtherOperatorsInExpression.ql

@@ -16,8 +16,9 @@
 
 import cpp
 import codingstandards.cpp.autosar
+import codingstandards.cpp.Expr
 
-from CrementOperation cop, Operation op, string name
+from CrementOperation cop, ArithmeticOperation op, string name
 where
   not isExcluded(cop) and
   not isExcluded(op,

cpp/autosar/src/rules/M5-3-3/UnaryOperatorOverloaded.ql

@@ -13,7 +13,8 @@
 
 import cpp
 import codingstandards.cpp.autosar
+import codingstandards.cpp.Operator
 
-from Operator o
-where not isExcluded(o, OperatorsPackage::unaryOperatorOverloadedQuery()) and o.hasName("operator&")
+from UnaryAddressOfOperator o
+where not isExcluded(o, OperatorsPackage::unaryOperatorOverloadedQuery())
 select o, "The unary & operator overloaded."