Merge pull request github#1261 from geoffw0/autoformat

CPP: Autoformat the Critical queries directory

Author: jbj

cpp/ql/src/Critical/DeadCodeCondition.ql

@@ -26,9 +26,9 @@ predicate choice(LocalScopeVariable v, Stmt branch, string value) {
   exists(AnalysedExpr e |
     testAndBranch(e, branch) and
     (
-      (e.getNullSuccessor(v) = branch and value = "null")
+      e.getNullSuccessor(v) = branch and value = "null"
       or
-      (e.getNonNullSuccessor(v) = branch and value = "non-null")
+      e.getNonNullSuccessor(v) = branch and value = "non-null"
     )
   )
 }
@@ -60,9 +60,9 @@ where
   exists(cond.getNullSuccessor(v)) and
   not addressLeak(v, branch.getChildStmt*()) and
   (
-    (cond.isNullCheck(v) and test = "null")
+    cond.isNullCheck(v) and test = "null"
     or
-    (cond.isValidCheck(v) and test = "non-null")
+    cond.isValidCheck(v) and test = "non-null"
   ) and
   (if context = test then testresult = "succeed" else testresult = "fail")
 select cond,

cpp/ql/src/Critical/DeadCodeFunction.ql

@@ -7,28 +7,30 @@
  * @tags maintainability
  *       external/cwe/cwe-561
  */
+
 import cpp
 
-predicate limitedScope(Function f)
-{
-  (f.isStatic() and not (f instanceof MemberFunction))
+predicate limitedScope(Function f) {
+  f.isStatic() and not f instanceof MemberFunction
   or
   f.(MemberFunction).isPrivate()
 }
 
-predicate uncalled(Function f)
-{
-  limitedScope(f)
-  and not exists(Function g |
-                 g = f or g = f.(VirtualFunction).getAnOverriddenFunction+() |
-                 exists(g.getACallToThisFunction()) or
-                 exists(FunctionAccess fa | fa.getTarget() = g))
+predicate uncalled(Function f) {
+  limitedScope(f) and
+  not exists(Function g | g = f or g = f.(VirtualFunction).getAnOverriddenFunction+() |
+    exists(g.getACallToThisFunction()) or
+    exists(FunctionAccess fa | fa.getTarget() = g)
+  )
 }
 
 from Function f
-where uncalled(f)
-  and forall(Function instance | f.(TemplateFunction).getAnInstantiation() = instance | uncalled(instance))
+where
+  uncalled(f) and
+  forall(Function instance | f.(TemplateFunction).getAnInstantiation() = instance |
+    uncalled(instance)
+  ) and
   // tweaks for good results:
-  and exists(f.getBlock())
-  and not(f instanceof Constructor or f instanceof Destructor or f.hasName("operator="))
+  exists(f.getBlock()) and
+  not (f instanceof Constructor or f instanceof Destructor or f.hasName("operator="))
 select f, "Dead Code: this function is never called."

cpp/ql/src/Critical/DeadCodeGoto.ql

@@ -1,6 +1,6 @@
 /**
  * @name Dead code due to goto or break statement
- * @description A goto or break statement is followed by unreachable code. 
+ * @description A goto or break statement is followed by unreachable code.
  * @kind problem
  * @problem.severity warning
  * @precision high
@@ -21,16 +21,17 @@ Stmt getNextRealStmt(Block b, int i) {
 }
 
 from JumpStmt js, Block b, int i, Stmt s
-where b.getStmt(i) = js
-  and s = getNextRealStmt(b, i)
+where
+  b.getStmt(i) = js and
+  s = getNextRealStmt(b, i) and
   // the next statement isn't jumped to
-  and not s instanceof LabelStmt
-  and not s instanceof SwitchCase
+  not s instanceof LabelStmt and
+  not s instanceof SwitchCase and
   // the next statement isn't breaking out of a switch
-  and not s.(BreakStmt).getBreakable() instanceof SwitchStmt
+  not s.(BreakStmt).getBreakable() instanceof SwitchStmt and
   // the next statement isn't a loop that can be jumped into
-  and not exists (LabelStmt ls | s.(Loop).getStmt().getAChild*() = ls)
-  and not exists (SwitchCase sc | s.(Loop).getStmt().getAChild*() = sc)
+  not exists(LabelStmt ls | s.(Loop).getStmt().getAChild*() = ls) and
+  not exists(SwitchCase sc | s.(Loop).getStmt().getAChild*() = sc) and
   // no preprocessor logic applies
-  and not functionContainsPreprocCode(js.getEnclosingFunction())
+  not functionContainsPreprocCode(js.getEnclosingFunction())
 select js, "This statement makes $@ unreachable.", s, s.toString()

cpp/ql/src/Critical/DescriptorMayNotBeClosed.ql

@@ -8,54 +8,53 @@
  *       security
  *       external/cwe/cwe-775
  */
+
 import semmle.code.cpp.pointsto.PointsTo
 import Negativity
 
-predicate closeCall(FunctionCall fc, Variable v)
-{
-  (fc.getTarget().hasQualifiedName("close") and v.getAnAccess() = fc.getArgument(0))
+predicate closeCall(FunctionCall fc, Variable v) {
+  fc.getTarget().hasQualifiedName("close") and v.getAnAccess() = fc.getArgument(0)
   or
   exists(FunctionCall midcall, Function mid, int arg |
     fc.getArgument(arg) = v.getAnAccess() and
     fc.getTarget() = mid and
     midcall.getEnclosingFunction() = mid and
-    closeCall(midcall, mid.getParameter(arg)))
+    closeCall(midcall, mid.getParameter(arg))
+  )
 }
 
-predicate openDefinition(LocalScopeVariable v, ControlFlowNode def)
-{
-  exists(Expr expr |
-      exprDefinition(v, def, expr) and allocateDescriptorCall(expr))
+predicate openDefinition(LocalScopeVariable v, ControlFlowNode def) {
+  exists(Expr expr | exprDefinition(v, def, expr) and allocateDescriptorCall(expr))
 }
 
-predicate openReaches(ControlFlowNode def, ControlFlowNode node)
-{
-  exists(LocalScopeVariable v |
-    openDefinition(v, def) and node = def.getASuccessor())
+predicate openReaches(ControlFlowNode def, ControlFlowNode node) {
+  exists(LocalScopeVariable v | openDefinition(v, def) and node = def.getASuccessor())
   or
   exists(LocalScopeVariable v, ControlFlowNode mid |
     openDefinition(v, def) and
     openReaches(def, mid) and
-    not(errorSuccessor(v, mid)) and
-    not(closeCall(mid, v)) and
-    not(assignedToFieldOrGlobal(v, mid)) and
-    node = mid.getASuccessor())
+    not errorSuccessor(v, mid) and
+    not closeCall(mid, v) and
+    not assignedToFieldOrGlobal(v, mid) and
+    node = mid.getASuccessor()
+  )
 }
 
-predicate assignedToFieldOrGlobal(LocalScopeVariable v, Assignment assign)
-{
+predicate assignedToFieldOrGlobal(LocalScopeVariable v, Assignment assign) {
   exists(Variable external |
     assign.getRValue() = v.getAnAccess() and
     assign.getLValue().(VariableAccess).getTarget() = external and
-    (external instanceof Field or external instanceof GlobalVariable))
+    (external instanceof Field or external instanceof GlobalVariable)
+  )
 }
 
 from LocalScopeVariable v, ControlFlowNode def, ReturnStmt ret
-where openDefinition(v, def)
-  and openReaches(def, ret)
-  and checkedSuccess(v, ret)
-  and not(ret.getExpr().getAChild*() = v.getAnAccess())
-  and exists(ReturnStmt other | other.getExpr() = v.getAnAccess())
+where
+  openDefinition(v, def) and
+  openReaches(def, ret) and
+  checkedSuccess(v, ret) and
+  not ret.getExpr().getAChild*() = v.getAnAccess() and
+  exists(ReturnStmt other | other.getExpr() = v.getAnAccess())
 select ret,
   "Descriptor assigned to '" + v.getName().toString() + "' (line " +
-  def.getLocation().getStartLine().toString() + ") may not be closed."
+    def.getLocation().getStartLine().toString() + ") may not be closed."

cpp/ql/src/Critical/DescriptorNeverClosed.ql

@@ -8,22 +8,24 @@
  *       security
  *       external/cwe/cwe-775
  */
+
 import semmle.code.cpp.pointsto.PointsTo
 
-predicate closed(Expr e)
-{
+predicate closed(Expr e) {
   exists(FunctionCall fc |
     fc.getTarget().hasQualifiedName("close") and
-    fc.getArgument(0) = e)
+    fc.getArgument(0) = e
+  )
 }
 
-class ClosedExpr extends PointsToExpr
-{
+class ClosedExpr extends PointsToExpr {
   ClosedExpr() { closed(this) }
+
   override predicate interesting() { closed(this) }
 }
 
 from Expr alloc
-where allocateDescriptorCall(alloc)
-  and not exists(ClosedExpr closed | closed.pointsTo() = alloc)
+where
+  allocateDescriptorCall(alloc) and
+  not exists(ClosedExpr closed | closed.pointsTo() = alloc)
 select alloc, "This file descriptor is never closed"

cpp/ql/src/Critical/FileClosed.qll

@@ -1,18 +1,17 @@
 import semmle.code.cpp.pointsto.PointsTo
 
 predicate closed(Expr e) {
-    fcloseCall(_, e) or
-    exists(ExprCall c |
-        // cautiously assume that any ExprCall could be a call to fclose.
-        c.getAnArgument() = e
-    )
+  fcloseCall(_, e) or
+  exists(ExprCall c |
+    // cautiously assume that any ExprCall could be a call to fclose.
+    c.getAnArgument() = e
+  )
 }
 
 class ClosedExpr extends PointsToExpr {
-    ClosedExpr() { closed(this) }
-    override predicate interesting() { closed(this) }
-}
+  ClosedExpr() { closed(this) }
 
-predicate fopenCallMayBeClosed(FunctionCall fc) {
-    fopenCall(fc) and anythingPointsTo(fc)
+  override predicate interesting() { closed(this) }
 }
+
+predicate fopenCallMayBeClosed(FunctionCall fc) { fopenCall(fc) and anythingPointsTo(fc) }