@cookshack/eslint-config 2.0.5 → 4.0.0

package/plugins/fn-args-nl.js

@@ -0,0 +1,47 @@
+function FnArgsNl
+(node, context) {
+  let nameLine, parenLine, nameEnd, i, newlines, parent
+
+  parent = node.parent
+
+  if (parent?.type == 'Property' && (parent.method || parent.kind == 'get' || parent.kind == 'set')) {
+    nameLine = parent.key.loc.start.line
+    nameEnd = parent.key.range[1]
+  }
+  else if (parent?.type == 'MethodDefinition') {
+    nameLine = parent.key.loc.start.line
+    nameEnd = parent.key.range[1]
+  }
+  else {
+    nameLine = node.loc.start.line
+    nameEnd = node.range[0]
+  }
+
+  i = nameEnd
+  newlines = 0
+  while (i < context.sourceCode.text.length) {
+    if (context.sourceCode.text[i] == '(')
+      break
+    if (context.sourceCode.text[i] == '\n')
+      newlines++
+    i++
+  }
+
+  parenLine = nameLine + newlines
+
+  if (parenLine - nameLine == 1)
+    return
+  context.report({ node, messageId: 'fnArgsNl' })
+}
+
+function create
+(context) {
+  return { FunctionDeclaration: node => FnArgsNl(node, context),
+           FunctionExpression: node => FnArgsNl(node, context) }
+}
+
+export default { meta: { type: 'suggestion',
+                         docs: { description: 'Require function args on the line immediately after the function name.' },
+                         messages: { fnArgsNl: 'Fn args must be on the line immediately after the function name.' },
+                         schema: [] },
+                 create }

package/plugins/fn-decl-block-start.js

@@ -0,0 +1,37 @@
+function FunctionDeclaration
+(context, node) {
+  let parent
+
+  for (parent = node.parent; parent; parent = parent.parent)
+    if (parent.type == 'BlockStatement')
+      break
+
+  if (parent) {
+    let idx
+
+    if (parent.parent?.type == 'CatchClause')
+      return
+
+    idx = parent.body.indexOf(node)
+    for (let i = 0; i < idx; i++) {
+      if (parent.body[i].type == 'VariableDeclaration'
+          || parent.body[i].type == 'FunctionDeclaration'
+          || parent.body[i].type == 'EmptyStatement')
+        continue
+      context.report({ node, messageId: 'fnDeclBlockStart' })
+      return
+    }
+  }
+}
+
+function create
+(context) {
+  return { FunctionDeclaration: node => FunctionDeclaration(context, node) }
+}
+
+export
+default { meta: { type: 'suggestion',
+                  docs: { description: 'Require function declarations to be at the start of the block.' },
+                  messages: { fnDeclBlockStart: 'FnDecl must be the start the block (after VarDecls).' },
+                  schema: [] },
+          create }

package/plugins/indent-struct.js

@@ -0,0 +1,145 @@
+function trace
+(...args) {
+  if (0)
+    console.log(...args)
+}
+
+function unit
+(context) {
+  return context.options[0] ?? 2
+}
+
+function checkObjectExpressionProperties
+(properties, node, context) {
+  let firstProp, sourceCode, lastProp, lastPropEnd, closingBrace, firstPropLine, firstPropCol, afterLastProp, closingLine, lastPropValueEndLine
+
+  sourceCode = context.sourceCode.text
+  firstProp = properties[0]
+  lastProp = properties[properties.length - 1]
+  firstPropLine = firstProp.loc.start.line
+  firstPropCol = firstProp.loc.start.column
+  lastPropEnd = lastProp.range[1]
+  closingBrace = sourceCode.indexOf('}', lastPropEnd)
+  closingLine = sourceCode.slice(0, closingBrace).split('\n').length
+  afterLastProp = sourceCode.slice(lastPropEnd, closingBrace)
+  lastPropValueEndLine = sourceCode.slice(0, lastPropEnd).split('\n').length
+
+  trace('ALGORITHM 1: Single-line objects: always valid (no check needed)')
+  trace('CHECK POINT 1: is single-line? firstPropLine=%d, braceLine=%d, closingLine=%d', firstPropLine, node.loc.start.line, closingLine)
+  if (firstPropLine == node.loc.start.line && closingLine == firstPropLine)
+    return
+
+  trace('ALGORITHM 2: When first property is on a line after {: must use 1 indent unit from the column where { appears')
+  trace('CHECK POINT 2: is firstPropLine (%d) != braceLine (%d)?', firstPropLine, node.loc.start.line)
+  if (firstPropLine == node.loc.start.line) {
+    // first property is on brace line
+  }
+  else if (firstPropCol == node.loc.start.column + unit(context)) {
+    // ok
+  }
+  else {
+    trace('CHECK 2 FAIL')
+    context.report({ node: firstProp, messageId: 'indentStruct' })
+  }
+
+  trace('ALGORITHM 3: Multi-line: all properties must align to first propertys column')
+  trace('CHECK POINT 3: checking property alignment, firstPropCol=%d', firstPropCol)
+  for (let i = 1; i < properties.length; i++) {
+    let prop
+
+    prop = properties[i]
+    if (prop.loc.start.column == firstPropCol) {
+      // ok
+    }
+    else {
+      trace('CHECK 3 FAIL')
+      context.report({ node: prop, messageId: 'indentStruct' })
+    }
+  }
+
+  trace('ALGORITHM 4: } on a line following the last prop value must align with {')
+  trace('CHECK POINT 4: is closing on a line following last prop value? closingLine=%d, lastPropValueEndLine=%d', closingLine, lastPropValueEndLine)
+  if (closingLine > lastPropValueEndLine) {
+    let braceCol, closingCol
+
+    braceCol = node.loc.start.column
+    closingCol = node.loc.end.column - 1
+    trace('CHECK 4: braceCol=%d, closingCol=%d', braceCol, closingCol)
+    if (closingCol == braceCol) {
+      // ok
+    }
+    else {
+      trace('CHECK 4 FAIL')
+      context.report({ node, messageId: 'indentStruct' })
+    }
+  }
+
+  trace('ALGORITHM 5: } on same line as last prop value must have a space before it')
+  trace('CHECK POINT 5: is closing on same line as last prop value? closingLine=%d, lastPropValueEndLine=%d', closingLine, lastPropValueEndLine)
+  if (closingLine == lastPropValueEndLine) {
+    trace('CHECK 5: lastPropEnd=%d, closingBrace=%d, afterLastProp=%j', lastPropEnd, closingBrace, afterLastProp)
+    if (afterLastProp == ' ') {
+      // ok
+    }
+    else {
+      trace('CHECK 5 FAIL')
+      context.report({ node, messageId: 'indentStruct' })
+    }
+  }
+
+  trace('ALGORITHM 6: When a param list is on a line after the field name, it must align with the field name')
+  trace('CHECK POINT 6: checking method param alignment')
+  for (let prop of properties)
+    if (prop.method) {
+      let keyLine, keyEnd, i, newlines, parenLine
+
+      keyLine = prop.key.loc.start.line
+      keyEnd = prop.key.range[1]
+      i = keyEnd
+      newlines = 0
+
+      while (i < sourceCode.length) {
+        if (sourceCode[i] == '(')
+          break
+        if (sourceCode[i] == '\n')
+          newlines++
+        i++
+      }
+      parenLine = keyLine + newlines
+      if (parenLine > keyLine) {
+        let parenCol
+
+        parenCol = i - sourceCode.lastIndexOf('\n', i)
+        if (prop.value.type == 'FunctionExpression' && prop.value.async) {
+          // async methods can have whitespace between key and paren
+        }
+        else if (parenCol - 1 == prop.key.loc.start.column) {
+          // ok
+        }
+        else {
+          trace('CHECK 6 FAIL')
+          context.report({ node: prop, messageId: 'indentStruct' })
+        }
+      }
+    }
+}
+
+function checkObjectExpression
+(node, context) {
+  let properties
+
+  properties = node.properties
+  if (properties.length)
+    checkObjectExpressionProperties(properties, node, context)
+}
+
+function create
+(context) {
+  return { ObjectExpression: node => checkObjectExpression(node, context) }
+}
+
+export default { meta: { type: 'suggestion',
+                         docs: { description: 'Struct alignment rules.' },
+                         messages: { indentStruct: 'Indent structure' },
+                         schema: [] },
+                 create }

package/plugins/init-before-use.js

@@ -0,0 +1,382 @@
+import { buildScopeTree } from './narrowest-scope.js'
+
+let ostIdCounter, errorCount, ost
+
+ostIdCounter = 0
+errorCount = 0
+ost = 0
+
+function trace
+(...args) {
+  if (0)
+    console.log(...args)
+}
+
+export
+function lastOst
+() {
+  return ost
+}
+
+function createInitBeforeUse
+(context) {
+  let scopeManager
+
+  scopeManager = context.sourceCode.scopeManager
+  if (scopeManager)
+    return { 'Program:exit'
+             () {
+               let scopeToNode, astToTree, astToOst
+
+               errorCount = 0
+               scopeToNode = new Map
+               astToTree = new Map
+               astToOst = new Map
+               buildScopeTree(scopeManager.scopes[0], '1', scopeToNode, astToTree)
+
+               ostIdCounter = 0
+               ost = processAst(context.sourceCode.ast, null, astToTree, astToOst, '', new Set())
+
+               ostAnnotate(ost, astToOst, context)
+
+               ostCheck(ost, context)
+
+               trace('ERRORS: ' + errorCount)
+             } }
+}
+
+function isRegularDeclaration
+(item) {
+  if (item.type == 'LET') {
+    if (item.defType == 'FunctionName' || item.defType == 'Parameter')
+      return 0
+    return 1
+  }
+  return 0
+}
+
+function processAst
+(astNode, parentOst, astToTree, astToOst, indent, visited) {
+  if (astNode) {
+    let treeNode, scopeName, lets, reads, writes, ost, children
+
+    if (visited.has(astNode))
+      return
+    visited.add(astNode)
+
+    treeNode = astToTree.get(astNode) ?? parentOst?.treeNode
+
+    scopeName = treeNode?.scope ? `${treeNode.scope.type}` : 'no-scope'
+    if (treeNode?.scope?.block?.id?.name)
+      scopeName += `(${treeNode.scope.block.id.name})`
+    trace(`${indent}${astNode.type}`)
+    trace(`${indent}  | scope: ${scopeName}`)
+
+    lets = []
+    reads = []
+    writes = []
+
+    for (let item of treeNode?.items ?? [])
+      if (isRegularDeclaration(item)) {
+        let scopeCreator
+
+        scopeCreator = treeNode?.scope?.block
+        if (scopeCreator && astNode == scopeCreator) {
+          lets.push({ item })
+          trace(`${indent}  | LET ${item.name}:${item.varId}`)
+        }
+      }
+      else if (item.ref)
+        if (astNode == item.ref.identifier)
+          if (item.type == 'READ') {
+            reads.push({ item })
+            trace(`${indent}  | READ ${item.name}:${item.varId}`)
+          }
+          else if (item.type == 'WRITE') {
+            writes.push({ item })
+            trace(`${indent}  | WRITE ${item.name}:${item.varId}`)
+          }
+
+    ost = { id: ostIdCounter++,
+            astNode,
+            treeNode,
+            scopeItems: treeNode?.items ?? [],
+            lets,
+            reads,
+            writes,
+            children: [],
+            fnDefOst: null }
+
+    astToOst.set(astNode, ost)
+
+    children = []
+
+    if (astNode.type == 'ForOfStatement' || astNode.type == 'ForInStatement') {
+      if (astNode.right)
+        children.push(astNode.right)
+      if (astNode.left)
+        children.push(astNode.left)
+      if (astNode.body)
+        children.push(astNode.body)
+    }
+    else if (astNode.type == 'ForStatement') {
+      if (astNode.init)
+        children.push(astNode.init)
+      if (astNode.test)
+        children.push(astNode.test)
+      if (astNode.update)
+        children.push(astNode.update)
+      if (astNode.body)
+        children.push(astNode.body)
+    }
+    else if (astNode.type == 'AssignmentExpression') {
+      if (astNode.right)
+        children.push(astNode.right)
+      if (astNode.left)
+        children.push(astNode.left)
+    }
+    else {
+      if (astNode.body)
+        if (Array.isArray(astNode.body))
+          children.push(...astNode.body)
+        else
+          children.push(astNode.body)
+      if (astNode.consequent)
+        children.push(astNode.consequent)
+      if (astNode.alternate)
+        children.push(astNode.alternate)
+      if (astNode.block)
+        children.push(astNode.block)
+      if (astNode.expression)
+        children.push(astNode.expression)
+      if (astNode.callee)
+        children.push(astNode.callee)
+      if (astNode.object)
+        children.push(astNode.object)
+      if (astNode.property)
+        children.push(astNode.property)
+      if (astNode.init)
+        children.push(astNode.init)
+      if (astNode.id)
+        children.push(astNode.id)
+      if (astNode.declarations)
+        children.push(...astNode.declarations)
+      if (astNode.test)
+        children.push(astNode.test)
+      if (astNode.update)
+        children.push(astNode.update)
+      if (astNode.left)
+        children.push(astNode.left)
+      if (astNode.right)
+        children.push(astNode.right)
+      if (astNode.argument)
+        children.push(astNode.argument)
+      if (astNode.arguments)
+        children.push(...astNode.arguments)
+      if (astNode.elements)
+        children.push(...astNode.elements)
+      if (astNode.properties)
+        children.push(...astNode.properties)
+    }
+
+    for (let child of children) {
+      let childOst
+
+      childOst = processAst(child, ost, astToTree, astToOst, indent + '  ', visited)
+      if (childOst)
+        ost.children.push(childOst)
+    }
+
+    return ost
+  }
+}
+
+function ostAnnotate
+(ost, astToOst, context) {
+  if (ost) {
+    for (let letInfo of ost.lets) {
+      let writeOst
+
+      writeOst = findFirstWrite(ost, letInfo)
+      letInfo.firstWrite = writeOst
+      if (writeOst)
+        continue
+      if (letInfo.item.defType == 'ImportBinding')
+        continue
+      errorCount++
+      context.report({ node: letInfo.item.identifier,
+                       messageId: 'mustInit',
+                       data: { name: letInfo.item.name } })
+    }
+
+    if (ost.astNode.type == 'CallExpression' && ost.astNode.callee?.type == 'Identifier')
+      for (let child of ost.children)
+        if (child.astNode == ost.astNode.callee && child.reads.length > 0) {
+          let readRef
+
+          readRef = child.reads[0].item.ref
+          if (readRef?.resolved) {
+            let variable
+
+            variable = readRef.resolved
+            if (variable.defs.length > 0) {
+              let fnDefAst
+
+              fnDefAst = variable.defs[0].node
+              if (fnDefAst) {
+                if (fnDefAst.init?.type == 'ArrowFunctionExpression' || fnDefAst.init?.type == 'FunctionExpression')
+                  fnDefAst = fnDefAst.init
+                ost.fnDefOst = astToOst.get(fnDefAst)
+              }
+            }
+          }
+        }
+
+    for (let child of ost.children)
+      ostAnnotate(child, astToOst, context)
+  }
+}
+
+function findFirstWrite
+(ost, letInfo) {
+  if (ost.astNode.type == 'FunctionDeclaration' || ost.astNode.type == 'ArrowFunctionExpression' || ost.astNode.type == 'FunctionExpression')
+    for (let child of ost.children)
+      if (child.astNode.type == 'BlockStatement')
+        return findFirstWriteInSubtree(child, letInfo)
+  return findFirstWriteInSubtree(ost, letInfo)
+}
+
+function findFirstWriteInSubtree
+(ost, letInfo) {
+  if (ost) {
+    if (ost.astNode.type == 'FunctionDeclaration' || ost.astNode.type == 'ArrowFunctionExpression' || ost.astNode.type == 'FunctionExpression')
+      return null
+
+    for (let writeInfo of ost.writes) {
+      let writeVar
+
+      writeVar = writeInfo.item.ref.resolved
+      if (writeVar == letInfo.item.variable)
+        return ost
+    }
+
+    for (let child of ost.children) {
+      let result
+
+      result = findFirstWriteInSubtree(child, letInfo)
+      if (result)
+        return result
+    }
+  }
+
+  return null
+}
+
+function ostCheck
+(ost, context) {
+  if (ost) {
+    for (let letInfo of ost.lets)
+      if (letInfo.firstWrite)
+        walk2Start(ost, letInfo, context)
+
+    for (let child of ost.children)
+      ostCheck(child, context)
+  }
+}
+
+function walk2Start
+(node, letInfo, context) {
+  if (node.astNode.type == 'FunctionDeclaration')
+    for (let child of node.children)
+      if (child.astNode.type == 'BlockStatement')
+        return walk2(child, letInfo, context, new Set())
+  return walk2(node, letInfo, context, new Set())
+}
+
+function walk2
+(node, letInfo, context, visited) {
+  if (node) {
+    if (node.astNode.type == 'FunctionDeclaration' || node.astNode.type == 'ArrowFunctionExpression' || node.astNode.type == 'FunctionExpression')
+      return false
+
+    if (node == letInfo.firstWrite) {
+      for (let readInfo of node.reads)
+        if (readInfo.item.ref.resolved == letInfo.item.variable) {
+          errorCount++
+          context.report({ node: readInfo.item.ref.identifier,
+                           messageId: 'initBeforeUse',
+                           data: { name: letInfo.item.name } })
+        }
+      return true
+    }
+
+    if (node.astNode.type == 'CallExpression' && node.fnDefOst) {
+      let fnType
+
+      fnType = node.fnDefOst.astNode.type
+
+      if (fnType == 'FunctionDeclaration' || fnType == 'ArrowFunctionExpression' || fnType == 'FunctionExpression') {
+        let key
+
+        key = `${letInfo.item.name}:${node.fnDefOst.id}`
+        if (visited.has(key)) {
+        }
+        else {
+          visited.add(key)
+          for (let child of node.fnDefOst.children)
+            if (child.astNode.type == 'BlockStatement' && walk2(child, letInfo, context, visited))
+              return true
+        }
+      }
+    }
+
+    for (let readInfo of node.reads)
+      if (readInfo.item.ref.resolved == letInfo.item.variable) {
+        errorCount++
+        context.report({ node: readInfo.item.ref.identifier,
+                         messageId: 'initBeforeUse',
+                         data: { name: letInfo.item.name } })
+      }
+
+    for (let child of node.children)
+      if (walk2(child, letInfo, context, visited))
+        return true
+  }
+
+  return false
+}
+
+export
+function ostString
+(ost, indent) {
+  if (ost) {
+    let lets, reads, writes, fnDef, extra, scopeName, result
+
+    indent = indent || ''
+
+    lets = ost.lets.length ? ` ${ost.lets.map(l => `LET:${l.item.name}:${l.item.varId}` + (l.firstWrite ? ` (fw:${l.firstWrite.id})` : ' (no fw)')).join(', ')}` : ''
+    reads = ost.reads.length ? ` READ:${ost.reads.map(r => `${r.item.name}:${r.item.varId}`).join(', ')}` : ''
+    writes = ost.writes.length ? ` WRITE:${ost.writes.map(w => `${w.item.name}:${w.item.varId}`).join(', ')}` : ''
+    fnDef = ost.fnDefOst ? ` fnDefOst:${ost.fnDefOst.id}` : ''
+    extra = lets + reads + writes + fnDef
+
+    scopeName = ost.treeNode?.scope ? `${ost.treeNode.scope.type}` : 'no-scope'
+    if (ost.treeNode?.scope?.block?.id?.name)
+      scopeName += `(${ost.treeNode.scope.block.id.name})`
+
+    result = `${indent}${ost.id} ${ost.astNode.type} [${scopeName}]${extra}\n`
+
+    for (let child of ost.children)
+      result += ostString(child, indent + '  ')
+
+    return result
+  }
+  return ''
+}
+
+export default { meta: { type: 'problem',
+                         docs: { description: 'Warn when a variable is used before being explicitly initialized.' },
+                         messages: { initBeforeUse: "'{{name}}' used before initialization.",
+                                     mustInit: "'{{name}}' must be initialized." },
+                         schema: [] },
+                 create: createInitBeforeUse }