JS: Autoformat everything

javascript/ql/src/Expressions/ExprHasNoEffect.ql

@@ -16,7 +16,6 @@ import javascript
 import ExprHasNoEffect
 import semmle.javascript.RestrictedLocations
 
-
 from Expr e
 where hasNoEffect(e)
 select e.(FirstLineOf), "This expression has no effect."

javascript/ql/src/Expressions/HeterogeneousComparison.ql

@@ -200,10 +200,12 @@ where
   rightExprDescription = getDescription(right.asExpr(), "an expression") and
   leftTypeCount = strictcount(left.getAType()) and
   rightTypeCount = strictcount(right.getAType()) and
-  leftTypeDescription = getTypeDescription("is of type " + leftTypes,
-      "cannot be of type " + rightTypes, leftTypeCount, rightTypeCount) and
-  rightTypeDescription = getTypeDescription("of type " + rightTypes,
-      ", which cannot be of type " + leftTypes, rightTypeCount, leftTypeCount)
+  leftTypeDescription =
+    getTypeDescription("is of type " + leftTypes, "cannot be of type " + rightTypes, leftTypeCount,
+      rightTypeCount) and
+  rightTypeDescription =
+    getTypeDescription("of type " + rightTypes, ", which cannot be of type " + leftTypes,
+      rightTypeCount, leftTypeCount)
 select left,
   leftExprDescription + " " + leftTypeDescription + ", but it is compared to $@ " +
     rightTypeDescription + ".", right, rightExprDescription

javascript/ql/src/Expressions/MissingSpaceInAppend.ql

@@ -23,48 +23,40 @@ Expr leftChild(Expr e) {
 }
 
 predicate isInConcat(Expr e) {
-    exists(ParExpr par | isInConcat(par) and par.getExpression() = e)
-    or 
-    exists(AddExpr a | a.getAnOperand() = e)
+  exists(ParExpr par | isInConcat(par) and par.getExpression() = e)
+  or
+  exists(AddExpr a | a.getAnOperand() = e)
 }
 
 class ConcatenationLiteral extends Expr {
   ConcatenationLiteral() {
     (
-      this instanceof TemplateLiteral 
+      this instanceof TemplateLiteral
       or
       this instanceof Literal
-    )
-    and isInConcat(this)
+    ) and
+    isInConcat(this)
   }
 }
 
 Expr getConcatChild(Expr e) {
-    result = rightChild(e) or 
-    result = leftChild(e)
+  result = rightChild(e) or
+  result = leftChild(e)
 }
 
-Expr getConcatParent(Expr e) {
-    e = getConcatChild(result)
-}
+Expr getConcatParent(Expr e) { e = getConcatChild(result) }
 
 predicate isWordLike(ConcatenationLiteral lit) {
-    lit.getStringValue().regexpMatch("(?i).*[a-z]{3,}.*")
+  lit.getStringValue().regexpMatch("(?i).*[a-z]{3,}.*")
 }
 
 class ConcatRoot extends AddExpr {
-    ConcatRoot() {
-        not isInConcat(this)
-    }
+  ConcatRoot() { not isInConcat(this) }
 }
 
-ConcatRoot getAddRoot(AddExpr e) {
-    result = getConcatParent*(e)
-}
+ConcatRoot getAddRoot(AddExpr e) { result = getConcatParent*(e) }
 
-predicate hasWordLikeFragment(AddExpr e) {
-    isWordLike(getConcatChild*(getAddRoot(e)))
-}
+predicate hasWordLikeFragment(AddExpr e) { isWordLike(getConcatChild*(getAddRoot(e))) }
 
 from AddExpr e, ConcatenationLiteral l, ConcatenationLiteral r, string word
 where
@@ -79,7 +71,6 @@ where
   word = l.getStringValue().regexpCapture(".* (([-A-Za-z/'\\.:,]*[a-zA-Z]|[0-9]+)[\\.:,!?']*)", 1) and
   r.getStringValue().regexpMatch("[a-zA-Z].*") and
   not word.regexpMatch(".*[,\\.:].*[a-zA-Z].*[^a-zA-Z]") and
-  
   // There must be a constant-string in the concatenation that looks like a word.
   hasWordLikeFragment(e)
 select l, "This string appears to be missing a space after '" + word + "'."

javascript/ql/src/Expressions/Misspelling.qll

@@ -91,7 +91,8 @@ private string replaceATypoAndLowerCase(Identifier wrong) {
     idPart(wrong, wrongPart, offset)
   |
     normalized_typos(wrongPart, rightPart, _, _, _, _) and
-    rightName = wrong.getName().substring(0, offset) + rightPart +
+    rightName =
+      wrong.getName().substring(0, offset) + rightPart +
         wrong.getName().suffix(offset + wrongPart.length()) and
     result = rightName.toLowerCase()
   )

javascript/ql/src/Expressions/UnboundEventHandlerReceiver.ql

@@ -36,7 +36,8 @@ private predicate isBoundInMethod(MethodDeclaration method) {
       mod = "react-autobind"
     |
       thiz.flowsTo(DataFlow::moduleImport(mod).getACall().getArgument(0))
-    ) or
+    )
+    or
     // heuristic reflective binders
     exists(DataFlow::CallNode binder, string calleeName |
       (
@@ -92,8 +93,8 @@ private DOM::AttributeDefinition getAnEventHandlerAttribute() {
 from MethodDeclaration callback, DOM::AttributeDefinition attribute, ThisExpr unbound
 where
   attribute = getAnEventHandlerAttribute() and
-  attribute.getValueNode().analyze().getAValue().(AbstractFunction).getFunction() = callback
-        .getBody() and
+  attribute.getValueNode().analyze().getAValue().(AbstractFunction).getFunction() =
+    callback.getBody() and
   unbound.getBinder() = callback.getBody() and
   not isBoundInMethod(callback)
 select attribute,