Code format & package description fixes

Author: MichaelRFairhurst

c/common/test/library/identifierlinkage/identifierlinkage.c

@@ -25,6 +25,4 @@ struct s {
 };
 
 // Enums and enum constants are not variables and have no linkage.
-enum e {
-  E1
-};
+enum e { E1 };

c/misra/src/rules/RULE-22-14/MutexInitializedInsideThread.ql

@@ -2,7 +2,7 @@
  * @id c/misra/mutex-initialized-inside-thread
  * @name RULE-22-14: Thread synchronization objects shall be initialized deterministically
  * @description Mutex and condition objects initialized inside of threads may result in
- *              indeterministic state
+ *              indeterministic state.
  * @kind problem
  * @precision high
  * @problem.severity recommendation

c/misra/test/rules/RULE-22-13/test.c

@@ -47,7 +47,7 @@ void f1(void) {
   has_ptr_mtx_t l12; // COMPLIANT
   has_mtx_t l13[10]; // NON-COMPLIANT
 
-  l10 = &g1; // COMPLIANT
-  l10 = malloc(sizeof(mtx_t)); // NON-COMPLIANT
+  l10 = &g1;                       // COMPLIANT
+  l10 = malloc(sizeof(mtx_t));     // NON-COMPLIANT
   l10 = malloc(sizeof(mtx_t) * 4); // NON-COMPLIANT
 }

c/misra/test/rules/RULE-22-16/test.c

@@ -41,7 +41,7 @@ void f6(int p) {
     goto skipped;
   }
   mtx_unlock(&m);
-  skipped:
+skipped:
 }
 
 void f7(int p) {
@@ -84,24 +84,24 @@ void f13() {
     mtx_t m;
   } s;
   mtx_lock(&s.m); // COMPLIANT
-  mtx_unlock(&s.m); 
+  mtx_unlock(&s.m);
 }
 
 void f14() {
-  for(;;) {
+  for (;;) {
     mtx_t m;
     mtx_lock(&m); // COMPLIANT
-    mtx_unlock(&m); 
+    mtx_unlock(&m);
   }
 }
 
 void f15(int p) {
-  for(;;) {
+  for (;;) {
     mtx_t m;
     mtx_lock(&m); // NON-COMPLIANT
     if (p) {
       break;
     }
-    mtx_unlock(&m); 
+    mtx_unlock(&m);
   }
 }

cpp/common/src/codingstandards/cpp/Concurrency.qll

@@ -70,27 +70,19 @@ class C11ThreadCreateCall extends ThreadCreationFunction {
 }
 
 class C11MutexType extends TypedefType {
-  C11MutexType() {
-    this.hasName("mtx_t")
-  }
+  C11MutexType() { this.hasName("mtx_t") }
 }
 
 class C11ThreadType extends TypedefType {
-  C11ThreadType() {
-    this.hasName("thrd_t")
-  }
+  C11ThreadType() { this.hasName("thrd_t") }
 }
 
 class C11ConditionType extends TypedefType {
-  C11ConditionType() {
-    this.hasName("cnd_t")
-  }
+  C11ConditionType() { this.hasName("cnd_t") }
 }
 
 class C11ThreadStorageType extends TypedefType {
-  C11ThreadStorageType() {
-    this.hasName("tss_t")
-  }
+  C11ThreadStorageType() { this.hasName("tss_t") }
 }
 
 class C11ThreadingObjectType extends TypedefType {
@@ -100,7 +92,7 @@ class C11ThreadingObjectType extends TypedefType {
     this instanceof C11ThreadType
     or
     this instanceof C11ConditionType
-    or 
+    or
     this instanceof C11ThreadStorageType
   }
 }
@@ -506,13 +498,9 @@ class CConditionOperation extends FunctionCall {
     getTarget().hasName(["cnd_broadcast", "cnd_signal", "cnd_timedwait", "cnd_wait", "cnd_init"])
   }
 
-  predicate isInit() {
-    getTarget().hasName("cnd_init")
-  }
+  predicate isInit() { getTarget().hasName("cnd_init") }
 
-  predicate isUse() {
-    not isInit()
-  }
+  predicate isUse() { not isInit() }
 
   Expr getConditionExpr() { result = getArgument(0) }
 

cpp/common/src/codingstandards/cpp/Type.qll

@@ -64,21 +64,21 @@ signature class PossiblySpecifiedBaseType extends Type;
 
 /**
  * This module defines a class `Type` which holds for types `T` and `const/volatile T` etc.
- * 
+ *
  * Similar to `getUnspecifiedType()`, but does not resolve typedefs. Useful for matching
  * potentially qualified versions of standard typedef types, such as `const mtx_t`.
- * 
+ *
  * Example usage: `someType.(PossiblySpecified<PointerType>::Type).strip()`
  */
 module PossiblySpecified<PossiblySpecifiedBaseType BaseType> {
   import cpp as cpp
+
   final class CppType = cpp::Type;
 
   class Type extends CppType {
     BaseType baseType;
-    Type() {
-      baseType = stripSpecifiers(this)
-    }
+
+    Type() { baseType = stripSpecifiers(this) }
 
     BaseType strip() { result = baseType }
   }
@@ -93,4 +93,4 @@ int getPrecision(IntegralType type) {
   type.isExplicitlyUnsigned() and result = type.getSize() * 8
   or
   type.isExplicitlySigned() and result = type.getSize() * 8 - 1
-}
+}

cpp/common/src/codingstandards/cpp/resources/ResourceLeakAnalysis.qll

@@ -6,32 +6,32 @@ import codeql.util.Boolean
 
 /**
  * A library for detecting leaked resources.
- * 
+ *
  * To use this library, implement `ResourceLeakConfigSig`:
- * 
+ *
  * ```
  * class UnjoinedThreadConfig implements ResourceLeakConfigSig {
  *   predicate isResource(DataFlow::Node node) {
  *     node.asExpr().isThreadCreate()
  *   }
- * 
+ *
  *   predicate isFree(ControlFlowNode node, DataFlow::Node resource) {
  *     node.asExpr().isThreadJoin(resource.asExpr())
  *   }
  * }
  * ```
- * 
+ *
  * You can now check if a resource is leaked through the module predicate
  * `ResourceLeak<UnjoinedThreadConfig>::isLeaked(resource)`.
- * 
+ *
  * The leak analysis finds the exit point of the function in which the resource is is declared, and
  * then reverses execution from there using `getAPredecessor()`. When this backwards walk discovers
  * a control flow node that frees the resource, that exploration stops. If any exploration reaches
  * a resource, that resource may be leaked via that path.
- * 
+ *
  * Uses `DataFlow::Node` in order to track aliases of the resource to better detect when the
  * resource is freed.
- * 
+ *
  * This library by default assumes that resources are expression nodes. To use it with other kinds
  * of nodes requires overriding `resourceInitPoint`.
  */
@@ -41,7 +41,8 @@ signature module ResourceLeakConfigSig {
   predicate isFree(ControlFlowNode node, DataFlow::Node resource);
 
   default DataFlow::Node getAnAlias(DataFlow::Node node) {
-    DataFlow::localFlow(node, result) or
+    DataFlow::localFlow(node, result)
+    or
     exists(Expr current, Expr after |
       current in [node.asExpr(), node.asDefiningArgument()] and
       after in [result.asExpr(), result.asDefiningArgument()] and
@@ -57,9 +58,10 @@ signature module ResourceLeakConfigSig {
 }
 
 module ResourceLeak<ResourceLeakConfigSig Config> {
-  private newtype TResource = TJustResource(DataFlow::Node resource, ControlFlowNode cfgNode) {
-    Config::isAllocate(cfgNode, resource)
-  }
+  private newtype TResource =
+    TJustResource(DataFlow::Node resource, ControlFlowNode cfgNode) {
+      Config::isAllocate(cfgNode, resource)
+    }
 
   /**
    * Get an alias of a resource, and aliases of nodes that are aliased by a resource.
@@ -98,4 +100,4 @@ module ResourceLeak<ResourceLeakConfigSig Config> {
       isLeakedAtControlPoint(resourceWrapper, result)
     )
   }
-}
+}

cpp/common/src/codingstandards/cpp/resources/ResourceManagement.qll

@@ -11,9 +11,9 @@ module ResourceLeakConfig implements ResourceLeakConfigSig {
     )
     or
     exists(FunctionCall f |
-      f.getTarget().hasQualifiedName("std", "basic_fstream", "open")
-      and allocPoint = f
-      and node.asDefiningArgument() = f.getQualifier()
+      f.getTarget().hasQualifiedName("std", "basic_fstream", "open") and
+      allocPoint = f and
+      node.asDefiningArgument() = f.getQualifier()
     )
     or
     exists(FunctionCall f |
@@ -24,22 +24,22 @@ module ResourceLeakConfig implements ResourceLeakConfigSig {
   }
 
   predicate isFree(ControlFlowNode node, DataFlow::Node resource) {
-    exists(DeallocationExpr d, Expr freedExpr|
+    exists(DeallocationExpr d, Expr freedExpr |
       freedExpr = d.getFreedExpr() and
       node = d and
       resource.asExpr() = freedExpr
     )
     or
     exists(FunctionCall f |
-      f.getTarget().hasQualifiedName("std", "basic_fstream", "close")
-      and node = f and
+      f.getTarget().hasQualifiedName("std", "basic_fstream", "close") and
+      node = f and
       resource.asExpr() = f.getQualifier()
     )
     or
     exists(FunctionCall f |
-      f.getTarget().hasQualifiedName("std", "mutex", "unlock")
-      and node = f and
+      f.getTarget().hasQualifiedName("std", "mutex", "unlock") and
+      node = f and
       resource.asExpr() = f.getQualifier()
     )
   }
-}
+}

cpp/common/src/codingstandards/cpp/rules/exceptionsafetyvalidstate/ExceptionSafetyValidState.qll

@@ -15,7 +15,6 @@ abstract class ExceptionSafetyValidStateSharedQuery extends Query { }
 
 Query getQuery() { result instanceof ExceptionSafetyValidStateSharedQuery }
 
-
 /**
  * `UncaughtThrowExpr` models a `throw` expression that is not handled
  */
@@ -24,38 +23,23 @@ class UncaughtThrowExpr extends ThrowExpr {
 }
 
 module ThrowLeakConfig implements ResourceLeakConfigSig {
-
   predicate isAllocate(ControlFlowNode node, DataFlow::Node resource) {
-    //exists(ResourceAcquisitionExpr rae |
-    //  node = rae and resource.asExpr() = rae
-    //)
     ResourceLeakConfig::isAllocate(node, resource)
   }
 
   predicate isFree(ControlFlowNode node, DataFlow::Node resource) {
-    //exists(ResourceAcquisitionExpr rae |
-    //  node = rae.getReleaseExpr() and resource.asExpr() = rae
-    //)
     ResourceLeakConfig::isFree(node, resource)
   }
 
   ControlFlowNode outOfScope(ControlFlowNode allocPoint) {
     result.(UncaughtThrowExpr).getEnclosingFunction() = allocPoint.(Expr).getEnclosingFunction()
   }
 
-  DataFlow::Node getAnAlias(DataFlow::Node node) {
-    DataFlow::localFlow(node, result)
-  }
+  DataFlow::Node getAnAlias(DataFlow::Node node) { DataFlow::localFlow(node, result) }
 }
 
-query predicate problems(
-  UncaughtThrowExpr te, string message, Element e, string eDescription
-) {
+query predicate problems(UncaughtThrowExpr te, string message, Element e, string eDescription) {
   not isExcluded(te, getQuery()) and
-  //exists(SubBasicBlock sbb |
-  //  sbb.getANode() = e and
-  //  te = followsInitialized(sbb)
-  //) and
   te = ResourceLeak<ThrowLeakConfig>::getALeak(e) and
   message = "The $@ is not released explicitly before throwing an exception." and
   eDescription = "allocated resource"

rule_packages/c/Concurrency8.json

@@ -61,7 +61,7 @@
           ]
         },
         {
-          "description": "Mutex and condition objects initialized inside of threads may result in indeterministic state",
+          "description": "Mutex and condition objects initialized inside of threads may result in indeterministic state.",
           "kind": "problem",
           "name": "Thread synchronization objects shall be initialized deterministically",
           "precision": "high",