@cookshack/eslint-config 2.0.5 → 3.0.0

package/test/rules/init-before-use.js

@@ -0,0 +1,192 @@
+import { Linter } from 'eslint'
+import { plugins } from '../../index.js'
+import { lastOst, ostString } from '../../plugins/init-before-use.js'
+
+let linter, validCases, invalidCases, config
+
+linter = new Linter()
+validCases = []
+invalidCases = []
+
+config = [ { languageOptions: { ecmaVersion: 2025,
+                                sourceType: 'module' },
+             plugins,
+             rules: { 'cookshack/init-before-use': 'error' } } ]
+
+function tree
+() {
+  let out
+
+  out = ostString(lastOst())
+  if (out.length)
+    return '=== Ordered Syntax Tree ===\n' + out
+  return ''
+}
+
+function _pass(tc) {
+  let messages
+
+  messages = linter.verify(tc.code, config)
+  if (messages.length > 0)
+    throw new Error('unexpected errors: ' + JSON.stringify(messages, null, 2) + '\n' + tree())
+}
+
+function _fail(tc) {
+  let messages
+
+  messages = linter.verify(tc.code, config)
+  if (messages.length == tc.errors.length)
+    return
+  throw new Error('expected ' + tc.errors.length + ' errors, got ' + messages.length + '\n' + JSON.stringify(messages, null, 2) + '\n' + tree())
+}
+
+function fail(message, code) {
+  let errors
+
+  if (Array.isArray(message))
+    errors = message.map(m => ({ messageId: m }))
+  else
+    errors = [ { messageId: message } ]
+
+  invalidCases.push({ code, errors })
+}
+
+function pass(code) {
+  validCases.push({ code })
+}
+
+pass('let x; x = 1')
+
+pass('let x = 1; x')
+
+pass('function f() { let x = 1; return x }')
+
+pass('let x; function shadow() { let x = 2; return x } function shadow2() { let x = 3; return x } x = 1')
+
+pass('for (let x in [1,2,3]) {}; let x = 1')
+
+pass(`for (let tc of validCases)
+    globalThis.it(tc.code, () => _valid(tc))
+`)
+
+pass(`for (let tc of validCases)
+    globalThis.it(tc.code, () => _valid(tc))
+  for (let tc of invalidCases)
+    globalThis.it(tc.code, () => _invalid(tc))
+`)
+
+pass('let x; let y = { x: 1 }; x = 2')
+
+pass('function x() { }')
+
+pass(`function a1
+() {
+  let p
+
+  function a2
+  () {
+    return p[p.length - 1]
+  }
+
+  p = []
+  return a2(0)
+}`)
+
+pass('let x = 1; --x')
+
+pass('let x = 1; x++')
+
+pass('let x = 1; x += 2')
+
+pass("import globals from 'globals'")
+
+pass('let x, y; y = () => { return x }; x = 1')
+
+// it's actually an err, but we'd have to track assignments
+pass('let x, y; y = () => { return x }; y(); x = 1')
+
+pass('let i; for (i = addr; i < end; i++) {}')
+
+pass('for (let i = 0; i < 16; i++) { }')
+
+pass(`
+  for (let count = 0, i = 0; i < Ed.ctags.length; i++)
+    if (Ed.ctags[i].name.startsWith(word.text)) {
+      options.push({ label: Ed.ctags[i].name, type: Ed.ctags[i].kind })
+      if (count++ > 10)
+        break
+    }
+`)
+
+pass(`
+function equal
+() {
+  let two
+
+  function run
+  () {
+    console.log(two)
+  }
+
+  function open
+  () {
+    // the point is to test if this will accidentally be first write of two
+    two = 0
+  }
+
+  if (globalThis.x) {
+    two = 1
+    run()
+  }
+}`)
+
+fail('mustInit', 'let x')
+
+fail('initBeforeUse', 'x; let x = 1')
+
+fail('initBeforeUse', 'f(); let f = () => {}')
+
+fail('mustInit', 'console.log(x); let x')
+
+fail([ 'initBeforeUse', 'initBeforeUse' ], 'x; y; let x = 1; let y = 2')
+
+fail('initBeforeUse', 'for (x in [1,2,3]) {}; let x = 1')
+
+fail('mustInit', 'for (x in [1,2,3]) {}; let x')
+
+fail('initBeforeUse', 'let x = f(); function f() { return x }')
+
+fail('initBeforeUse', `function outer
+(arg) {
+  let p
+
+  function inner
+  () {
+    p.focus()
+  }
+
+  if (arg) {
+    inner()
+    return
+  }
+
+  p = get()
+  inner()
+}`)
+
+fail('initBeforeUse', 'let x; x = f(x)')
+
+fail('initBeforeUse', 'let x = 0; function shadow(y) { let x; x = shadow2(x) + y; return x } function shadow2(y) { let x = 3 + y; return x } shadow(x)')
+
+fail('initBeforeUse', 'let x; --x')
+
+fail('initBeforeUse', 'let x; x++')
+
+fail('initBeforeUse', 'let x; x += 2')
+
+globalThis.describe('init-before-use', () => {
+  for (let tc of validCases)
+    globalThis.it(tc.code, () => _pass(tc))
+  for (let tc of invalidCases)
+    globalThis.it(tc.code, () => _fail(tc))
+})

package/test/rules/narrowest-scope.js

@@ -472,6 +472,30 @@ function add
       READ  Map     pos 75
       WRITE classCache     pos 80.4`)
 
+pass(`function a1
+() {
+  let p
+
+  function a2
+  () {
+    return p[p.length - 1]
+  }
+
+  p = []
+  return a2(0)
+}`,
+     `SCOPE 1 GLOBAL pos 0
+  SCOPE 1.1 MODULE pos 0
+    LET   a1     pos 9
+    SCOPE 1.1.1 FUNCTION pos 11 name a1
+      LET   p     pos 23
+      LET   a2     pos 37
+      SCOPE 1.1.1.1 FUNCTION pos 39 name a2
+        READ  p     pos 58
+        READ  p     pos 60
+      WRITE p     pos 87.4
+      READ  a2     pos 97`)
+
 fail(1, 'let x = 1; function foo() { return x }',
      `SCOPE 1 GLOBAL pos 0
   SCOPE 1.1 MODULE pos 0
@@ -538,12 +562,14 @@ function f
         READ  b     pos 115
         SCOPE 1.1.1.1.1 FUNCTION pos 125
           LET   d     pos 125
+          READ  c1     pos 138
           READ  d     pos 144
           WRITE c1     pos 145.4
         READ  c1     pos 164
       SCOPE 1.1.1.2 BLOCK pos 174
         READ  ok     pos 185
         WRITE c2     pos 187.4
+        READ  c2     pos 192
         READ  ok     pos 198
         READ  ok     pos 203
         WRITE c2     pos 205.4

package/test/rules/use-risky-equal.js

@@ -0,0 +1,42 @@
+import { RuleTester } from 'eslint'
+import { plugins } from '../../index.js'
+
+let ruleTester, validCases, invalidCases
+
+ruleTester = new RuleTester()
+validCases = []
+invalidCases = []
+
+function pass
+(code) {
+  validCases.push({ code })
+}
+
+function fail
+(count, code) {
+  let errors
+
+  errors = []
+  while (count > 0) {
+    errors.push({ messageId: 'risky' })
+    count--
+  }
+
+  invalidCases.push({ code, errors })
+}
+
+pass('if (x == y) { }')
+
+pass('if (x != y) { }')
+
+pass('if (x !== y) { }')
+
+fail(1, 'if (x === y) { }')
+
+fail(2, 'if (x === y || a === y || a > 4) { }')
+
+globalThis.describe('use-risky-equal',
+                    () => ruleTester.run('use-risky-equal',
+                                         plugins.cookshack.rules['use-risky-equal'],
+                                         { valid: validCases,
+                                           invalid: invalidCases }))

package/test/rules/var-decl-block-start.js

@@ -0,0 +1,108 @@
+import { RuleTester } from 'eslint'
+import { plugins } from '../../index.js'
+
+let ruleTester, validCases, invalidCases
+
+ruleTester = new RuleTester()
+validCases = []
+invalidCases = []
+
+function pass
+(code) {
+  validCases.push({ code })
+}
+
+function fail
+(count, code) {
+  let errors
+
+  errors = []
+  while (count > 0) {
+    errors.push({ messageId: 'varDeclBlockStart' })
+    count--
+  }
+
+  invalidCases.push({ code, errors })
+}
+
+pass('let x = 1')
+
+pass('var x = 1')
+
+pass('const x = 1')
+
+pass('{ let x = 1 }')
+
+pass('{ var x = 1 }')
+
+pass('{ const x = 1 }')
+
+pass('{ let x = 1; let y = 2 }')
+
+pass('{ let x, y }')
+
+pass('{ let x; let y }')
+
+pass('for (let i = 0; i < 10; i++) { }')
+
+pass('for (var i = 0; i < 10; i++) { }')
+
+pass('for (const i = 0; i < 10; i++) { }')
+
+pass('for (let x of arr) { }')
+
+pass('for (let x in obj) { }')
+
+pass('for (var x in obj) { }')
+
+pass('try { } catch (err) { }')
+
+pass('function f() { let x }')
+
+pass('function f() { var x }')
+
+pass('function f() { const x = 1 }')
+
+pass('{ { let x } }')
+
+pass('{ { let x; let y } }')
+
+fail(1, 'if (1) { x = 1; let y = 2 }')
+
+fail(1, 'if (1) { x = 1; var y = 2 }')
+
+fail(1, 'if (1) { x = 1; const y = 2 }')
+
+fail(2, 'if (1) { x = 1; let y = 2; let z = 3 }')
+
+fail(1, '{ x = 1; let y = 2 }')
+
+fail(1, '{ x = 1; var y = 2 }')
+
+fail(1, '{ x = 1; const y = 2 }')
+
+fail(1, 'function f() { x = 1; let y = 2 }')
+
+fail(1, 'function f() { x = 1; var y = 2 }')
+
+fail(1, 'function f() { x = 1; const y = 2 }')
+
+fail(1, '{ { x = 1; let y = 2 } }')
+
+fail(1, 'if (1) { if (2) { x = 1; let y = 2 } }')
+
+fail(1, 'while (1) { x = 1; let y = 2 }')
+
+fail(1, 'for (let i = 0; i < 10; i++) { x = 1; let y = 2 }')
+
+fail(1, '{ function f() {}; let x }')
+
+fail(2, '{ function f() {}; let x; let y }')
+
+fail(1, '{ function f() {}; function g() {}; let x }')
+
+globalThis.describe('var-decl-block-start',
+                    () => ruleTester.run('var-decl-block-start',
+                                         plugins.cookshack.rules['var-decl-block-start'],
+                                         { valid: validCases,
+                                           invalid: invalidCases }))