@cookshack/eslint-config 2.0.5 → 3.0.0

package/index.js

@@ -1,471 +1,24 @@
 import globals from 'globals'
+import narrowestScopePlugin from './plugins/narrowest-scope.js'
+import { getPrintBuffer } from './plugins/narrowest-scope.js'
+import positiveVibesPlugin from './plugins/positive-vibes.js'
+import useRiskyEqualPlugin from './plugins/use-risky-equal.js'
+import alwaysLetPlugin from './plugins/always-let.js'
+import initBeforeUsePlugin from './plugins/init-before-use.js'
+import varDeclBlockStartPlugin from './plugins/var-decl-block-start.js'
+import fnDeclBlockStartPlugin from './plugins/fn-decl-block-start.js'
 
-export let rules, languageOptions, plugins
-
-let printBuffer
-
-printBuffer = []
-
-function print
-(...args) {
-  //console.log(args.join(' '))
-  printBuffer.push(args.join(' '))
-}
-
-function trace
-(...args) {
-  if (0)
-    console.log('TRACE', ...args)
-}
-
-export
-function getPrintBuffer
-() {
-  return printBuffer.join('\n')
-}
-
-function clearPrintBuffer
-() {
-  printBuffer = []
-}
-
-function getNarrowestScope
-(variable) {
-  let common
-
-  common = null
-  for (let ref of variable.references) {
-    if (variable.defs.some(def => def.name === ref.identifier))
-      continue
-    if (ref.from)
-      if (common)
-        common = getCommonAncestor(common, ref.from)
-      else
-        common = ref.from
-  }
-  return common
-}
-
-function getCommonAncestor
-(scope1, scope2) {
-  let ancestors, s
-
-  ancestors = []
-  s = scope1
-  while (s) {
-    if (s.type == 'global')
-      break
-    ancestors.push(s)
-    s = s.upper
-  }
-  s = scope2
-  while (s) {
-    if (s.type == 'global')
-      break
-    if (ancestors.includes(s))
-      return s
-    s = s.upper
-  }
-  return scope1
-}
-
-function getDefinitionScope
-(variable) {
-  return variable.scope
-}
-
-function isWriteRef
-(ref) {
-  let parent
-
-  parent = ref.identifier.parent
-  if (parent) {
-    if (parent.type == 'AssignmentExpression' && parent.left == ref.identifier)
-      return 1
-    if (parent.type == 'UpdateExpression')
-      return 1
-    if (parent.type == 'VariableDeclarator' && parent.id == ref.identifier)
-      return 1
-  }
-  return 0
-}
-
-function isReadRef
-(ref) {
-  if (isWriteRef(ref))
-    return 0
-  return 1
-}
-
-function getConditionalContext
-(ref) {
-  let node, prevNode, scopeBlock
-
-  scopeBlock = ref.from.block
-  prevNode = ref.identifier
-  node = ref.identifier.parent
-  while (node) {
-    if (node === scopeBlock)
-      break
-    if (node.type === 'IfStatement')
-      if (prevNode === node.test || nodeContains(node.test, prevNode))
-        prevNode = node
-      else
-        return 'B'
-    else if ([ 'WhileStatement', 'DoWhileStatement', 'ForStatement', 'ForInStatement', 'ForOfStatement', 'SwitchStatement' ].includes(node.type))
-      if (prevNode === node.test || nodeContains(node.test, prevNode))
-        prevNode = node
-      else
-        return 'B'
-    else
-      prevNode = node
-    node = node.parent
-  }
-  return ''
-}
-
-function nodeContains(node, target) {
-  if (node === target)
-    return true
-  if (node && typeof node === 'object')
-    for (let key in node)
-      if (nodeHas(node[key], target))
-        return true
-  return false
-}
-
-function nodeHas(value, target) {
-  if (value === target)
-    return true
-  if (Array.isArray(value))
-    return value.some(v => nodeContains(v, target))
-  return false
-}
-
-function hasReadBeforeWriteInNestedScope(variable, defScope) {
-  let nestedFunctions
-
-  nestedFunctions = new Set(variable.references
-    .filter(ref => {
-      let refScope
-
-      refScope = ref.from
-      if (refScope == defScope)
-        return 0
-      return isProperAncestor(defScope, refScope) && (refScope.type == 'function' || refScope.type == 'arrow')
-    })
-    .map(ref => ref.from))
-  for (let fnScope of nestedFunctions) {
-    let fnRefs, hasRead, hasWrite
-
-    fnRefs = variable.references.filter(ref => ref.from === fnScope || isProperAncestor(fnScope, ref.from))
-    hasRead = fnRefs.some(ref => isReadRef(ref))
-    hasWrite = fnRefs.some(ref => isWriteRef(ref))
-    if (hasRead && hasWrite)
-      return 1
-  }
-  return 0
-}
-
-function isConditionalRef
-(ref, narrowestScope) {
-  let node
-
-  node = ref.identifier.parent
-
-  while (node) {
-    if (node === narrowestScope.block)
-      break
-    if (node.type === 'BlockStatement') {
-      let parent
-
-      parent = node.parent
-      if (parent?.type === 'IfStatement' && (parent.consequent === node || parent.alternate === node))
-        return true
-      if ([ 'WhileStatement', 'DoWhileStatement', 'ForStatement', 'ForInStatement', 'ForOfStatement' ].includes(parent?.type) && parent.body === node)
-        return true
-    }
-    node = node.parent
-  }
-  return false
-}
-
-function markConditionalRefs
-(variable, scopeToNode, narrowestScope) {
-  for (let ref of variable.references) {
-    let refNode, rItems, item
-
-    refNode = scopeToNode.get(ref.from)
-    rItems = refNode.items.filter(i => i.ref == ref)
-    item = rItems[0]
-    if (item && (item.ctx == 'B' || isConditionalRef(ref, narrowestScope)))
-      item.isConditional = true
-  }
-}
-
-function mayBeReadBeforeAnyWrite
-(variable, scopeToNode, narrowestScope) {
-  let refs
-
-  refs = [ ...variable.references ]
-  refs.sort((a, b) => (a.cookshackNarrowestScopeItem?.pos ?? a.identifier.range[0]) - (b.cookshackNarrowestScopeItem?.pos ?? b.identifier.range[0]))
-
-  for (let ref of refs) {
-    let item
-
-    if (isReadRef(ref))
-      // a possible read
-      return 1
+export { getPrintBuffer }
 
-    item = ref.cookshackNarrowestScopeItem
-    if (item.ctx == 'B' || isConditionalRef(ref, narrowestScope))
-      // a conditional write
-      continue
-    // A guaranteed write before any possible read.
-    return 0
-  }
-}
-
-function isProperAncestor(ancestor, descendant) {
-  let s
-
-  s = descendant.upper
-  while (s) {
-    if (s == ancestor)
-      return 1
-    s = s.upper
-  }
-  return 0
-}
-
-function scopeStart(scope) {
-  if (scope.block == null)
-    return Infinity
-  if (scope.type == 'function' && scope.block.id)
-    return scope.block.id.range[1]
-  if (scope.type == 'class' && scope.block.id)
-    return scope.block.id.range[0]
-  return scope.block.range[0]
-}
-
-function buildScopeTree(scope, prefix, scopeToNode) {
-  let node, siblingNum
-
-  node = {
-    scope,
-    prefix,
-    items: [],
-    children: []
-  }
-  scopeToNode.set(scope, node)
-
-  siblingNum = 0
-  for (let child of scope.childScopes) {
-    siblingNum++
-    node.children.push(buildScopeTree(child, prefix + '.' + siblingNum, scopeToNode))
-  }
-
-  for (let variable of scope.variables) {
-    if (variable.defs.length > 0)
-      node.items.push({ type: 'LET', name: variable.name, pos: variable.defs[0].name.range[0] })
-
-    for (let ref of variable.references) {
-      let targetNode
-
-      targetNode = scopeToNode.get(ref.from)
-      if (targetNode) {
-        let parent, sortPos, ctx, item
-
-        ctx = getConditionalContext(ref)
-        parent = ref.identifier.parent
-
-        if (isWriteRef(ref))
-          if (ref.identifier.parent?.type == 'UpdateExpression') {
-            targetNode.items.push({ type: 'READ', name: ref.identifier.name, ctx, pos: ref.identifier.range[0] })
-            item = { ref, type: 'WRITE', name: ref.identifier.name, pos: ref.identifier.range[0] }
-          }
-          else if (ref.identifier.parent?.type == 'AssignmentExpression') {
-            sortPos = parent.right.range[1] + 0.4
-            item = { ref, type: 'WRITE', name: ref.identifier.name, ctx, pos: sortPos }
-          }
-          else if (ref.identifier.parent?.type == 'VariableDeclarator')
-            item = { ref, type: 'WRITE', name: ref.identifier.name, pos: ref.identifier.range[0] + 0.4 }
-          else
-            item = { ref, type: 'WRITE', name: ref.identifier.name, pos: ref.identifier.range[0] }
-        else {
-          let declarator
-
-          declarator = parent
-          while (declarator)
-            if (declarator.type == 'VariableDeclarator')
-              break
-            else
-              declarator = declarator.parent
-          if (declarator?.type == 'VariableDeclarator' && nodeContains(declarator.init, ref.identifier))
-            sortPos = declarator.id ? declarator.id.range[0] - 0.4 : ref.identifier.range[0]
-          else
-            sortPos = ref.identifier.range[0]
-          item = { ref, type: 'READ', name: ref.identifier.name, ctx, pos: sortPos }
-        }
-        targetNode.items.push(item)
-        ref.cookshackNarrowestScopeItem = item
-      }
-    }
-  }
-
-  node.items.sort((a, b) => a.pos - b.pos)
-
-  return node
-}
-
-function checkScopeNode(context, treeNode, reported, scopeToNode) {
-  let indent
-
-  reported = reported || new Set
-  indent = '  '.repeat(treeNode.prefix.split('.').length - 1)
-
-  for (let variable of treeNode.scope.variables) {
-    let defNode
-
-    if (reported.has(variable))
-      continue
-    if (variable.defs.length === 0)
-      continue
-    if ([ 'Parameter', 'FunctionName', 'ImportBinding', 'CatchClause', 'ClassName' ].includes(variable.defs[0].type))
-      continue
-    if (variable.defs[0].node.parent?.parent?.type === 'ExportNamedDeclaration')
-      continue
-
-    defNode = variable.defs[0]?.name
-    if (defNode) {
-      let defScope, narrowestScope, defNodePrefix
-
-      defScope = getDefinitionScope(variable)
-      defNodePrefix = scopeToNode.get(defScope)?.prefix ?? '?'
-      trace(indent, '1 found decl scope of', variable.name + ':', defNodePrefix + ' ' + defScope.type.toUpperCase())
-
-      narrowestScope = getNarrowestScope(variable)
-      if (narrowestScope) {
-        let narrowestPrefix
-
-        narrowestPrefix = scopeToNode.get(narrowestScope)?.prefix ?? '?'
-        trace(indent, '2 found narrowest scope of', variable.name + ':', narrowestPrefix + ' ' + narrowestScope?.type.toUpperCase())
-
-        markConditionalRefs(variable, scopeToNode, narrowestScope)
-
-        if (defScope == narrowestScope)
-          continue
-        trace(indent, '3', variable.name, 'could be moved to a narrower scope')
-
-        if (defScope.type == 'for') {
-          trace(indent, '4 exception:', variable.name, 'is in a for loop header')
-          continue
-        }
-        if (0 && hasReadBeforeWriteInNestedScope(variable, defScope)) {
-          trace(indent, '4 exception:', variable.name, 'hasReadBeforeWriteInNestedScope')
-          continue
-        }
-        if (mayBeReadBeforeAnyWrite(variable, scopeToNode, narrowestScope)) {
-          trace(indent, '4 exception:', variable.name, 'mayBeReadBeforeAnyWrite')
-          continue
-        }
-
-        trace(indent, '5', variable.name, 'is too broad')
-
-        reported.add(variable)
-        context.report({
-          node: defNode,
-          messageId: 'tooBroad',
-          data: { name: variable.name }
-        })
-      }
-    }
-  }
-
-  for (let child of treeNode.children)
-    checkScopeNode(context, child, reported, scopeToNode)
-}
-
-function printTree(node, siblingNum) {
-  let prefix, all, indent
-
-  prefix = siblingNum === 0 ? node.prefix : node.prefix.split('.').slice(0, -1).join('.') + '.' + siblingNum
-  indent = '  '.repeat(prefix.split('.').length - 1)
-  {
-    let name
-
-    name = node.scope.block?.id?.name ?? node.scope.block?.parent?.key?.name
-    print(indent + 'SCOPE ' + prefix + ' ' + node.scope.type.toUpperCase() + ' pos ' + scopeStart(node.scope) + (name ? ' name ' + name : ''))
-  }
-
-  all = [ ...node.items.map(i => ({ pos: i.pos, type: 'item', data: i })),
-          ...node.children.map((c, i) => ({ pos: scopeStart(c.scope), type: 'scope', data: c, sibling: i + 1 })) ]
-  all.sort((a, b) => a.pos - b.pos)
-
-  for (let entry of all)
-    if (entry.type === 'item')
-      print(indent
-            + '  ' + entry.data.type.padEnd(5)
-            + ' ' + entry.data.name
-            // B: is the ref conditional within the scope that "owns" the ref (for single statement `if`)
-            + (entry.data.ctx ? ' ' + entry.data.ctx : '').padEnd(3)
-            // C: is the ref conditional within the variable's narrowestScope?
-            + (entry.data.isConditional ? 'C' : ' ').padEnd(2)
-            + 'pos ' + entry.data.pos)
-    else
-      printTree(entry.data, entry.sibling)
-}
-
-function createNarrowestScope
-(context) {
-  let scopeManager
-
-  clearPrintBuffer()
-  scopeManager = context.sourceCode.scopeManager
-  if (scopeManager)
-    return {
-      'Program:exit'() {
-        let tree, scopeToNode
-
-        scopeToNode = new Map
-        tree = buildScopeTree(scopeManager.scopes[0], '1', scopeToNode)
-        checkScopeNode(context, tree, null, scopeToNode)
-        printTree(tree, 0)
-      }
-    }
-}
-
-function createPositiveVibes
-(context) {
-  return {
-    UnaryExpression(node) {
-      if (node.operator == '!')
-        context.report({ node,
-                         messageId: 'positiveVibes' })
-    },
-    BinaryExpression(node) {
-      if (node.operator == '!=')
-        context.report({ node,
-                         messageId: 'equality' })
-      else if (node.operator == '!==')
-        context.report({ node,
-                         messageId: 'strictEquality' })
-    }
-  }
-}
+export let rules, languageOptions, plugins
 
-plugins = { 'cookshack': { rules: { 'positive-vibes': { meta: { type: 'problem',
-                                                                docs: { description: 'Prefer positive expressions.' },
-                                                                messages: { positiveVibes: 'Be positive!',
-                                                                            equality: 'Use ==.',
-                                                                            strictEquality: 'Use ===.' },
-                                                                schema: [] },
-                                                        create: createPositiveVibes },
-                                    'narrowest-scope': { meta: { type: 'suggestion',
-                                                                 docs: { description: 'Enforce variables are declared in their narrowest possible scope.' },
-                                                                 messages: { tooBroad: 'Variable "{{ name }}" is declared in a broader scope than necessary.' },
-                                                                 schema: [] },
-                                                         create: createNarrowestScope } } } }
+plugins = { 'cookshack': { rules: { 'positive-vibes': positiveVibesPlugin,
+                                    'narrowest-scope': narrowestScopePlugin,
+                                    'use-risky-equal': useRiskyEqualPlugin,
+                                    'always-let': alwaysLetPlugin,
+                                    'init-before-use': initBeforeUsePlugin,
+                                    'var-decl-block-start': varDeclBlockStartPlugin,
+                                    'fn-decl-block-start': fnDeclBlockStartPlugin } } }
 
 rules = {
   'array-bracket-newline': [ 'error', 'never' ],
@@ -496,8 +49,14 @@ rules = {
                                        { blankLine: 'never', prev: 'let', next: 'let' } ],
   'no-case-declarations': 'error',
   'no-global-assign': 'error',
-  'cookshack/narrowest-scope': 'error',
   'cookshack/positive-vibes': 'error',
+  'cookshack/narrowest-scope': 'error',
+  'cookshack/use-risky-equal': 'error',
+  'cookshack/always-let': 'error',
+  // using the implicit inititialization to undefined fits better
+  //'cookshack/init-before-use': 'error',
+  'cookshack/var-decl-block-start': 'error',
+  'cookshack/fn-decl-block-start': 'error',
   'no-mixed-operators': 'error',
   'no-multi-spaces': 'error',
   'no-multiple-empty-lines': [ 'error', { max: 1, maxEOF: 0 } ],

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "@cookshack/eslint-config",
-  "version": "2.0.5",
+  "version": "3.0.0",
   "description": "ESLint config for Cookshack projects",
   "homepage": "https://git.sr.ht/~mattmundell/eslint-config",
   "type": "module",
   "scripts": {
-    "check": "npx eslint --no-warn-ignored -f ./formatter.js -c ./index.js *.js test/rules/*.js",
+    "check": "npx eslint --no-warn-ignored -f ./formatter.js -c ./index.js *.js test/rules/*.js plugins/*.js",
     "test": "mocha test/**/*.js",
     "prepare": "husky && rollup -c"
   },

package/plugins/always-let.js

@@ -0,0 +1,14 @@
+function create
+(context) {
+  return { VariableDeclaration(node) {
+    if (node.kind == 'const' || node.kind == 'var')
+      context.report({ node, messageId: 'useLet' })
+  } }
+}
+
+export
+default { meta: { type: 'problem',
+                  docs: { description: 'Enforce use of let instead of const or var.' },
+                  messages: { useLet: 'Use let.' },
+                  schema: [] },
+          create }

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

@@ -0,0 +1,38 @@
+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 }